The example of this paper describes the implementation of Aes encryption and decryption by java using Hex encoding and decoding. I will share it with you for your reference as follows:

The Aes encryption and decryption method here is encoded and decoded using Hex

package com.baidu.wallet.bdwallet.utils;
import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.SecretKeySpec;
import org.apache.commons.codec.DecoderException;
import org.apache.commons.codec.binary.Hex;
public class Test {
   private static final String AES="AES";
   private static final String UTF8="UTF-8";
    /**
    * AES encryption
    * @param content
    * @param pkey
    * @return
    * @throws DecoderException
    */
    private static byte[] encrypt(String content, String pkey) throws DecoderException {
      try {
        String private_key=pkey;
        byte[] encodeFormat=null;
        try {
          // The secret key  Hex Decoding why should the secret key be decoded, because the secret key is some secret key that is in clear text Hex The encoded value, so it should be decoded when used
          encodeFormat = Hex.decodeHex(private_key.toCharArray());
        } catch (DecoderException e) {
          e.printStackTrace();
        }
        SecretKeySpec key = new SecretKeySpec(encodeFormat, AES);
        // Cipher The object actually does the encryption
        Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
        //  Encrypted content is encoded
        byte[] byteContent = content.getBytes(UTF8);
        //  Initialize with a key Cipher object
        cipher.init(Cipher.ENCRYPT_MODE, key);
        //  Formally perform the encryption operation
        byte[] result = cipher.doFinal(byteContent);
        return result;
      } catch (NoSuchAlgorithmException e) {
        e.printStackTrace();
      } catch (NoSuchPaddingException e) {
        e.printStackTrace();
      } catch (InvalidKeyException e) {
        e.printStackTrace();
      } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
      } catch (IllegalBlockSizeException e) {
        e.printStackTrace();
      } catch (BadPaddingException e) {
        e.printStackTrace();
      }
      return null;
    }
    /**
     * AES decryption
     * @param contents
     * @param password
     * @return
     * @throws DecoderException
     */
    private static byte[] decrypt(String contents, String password) throws DecoderException {
      try {
        // Cipher using Hex decoding
        byte[]content = Hex.decodeHex(contents.toCharArray());
        // The secret key  Hex Decoding why should the secret key be decoded, because the secret key is some secret key that is in clear text Hex The encoded value, so it should be decoded when used
        byte[] encodeFormat = Hex.decodeHex(password.toCharArray());
        SecretKeySpec key = new SecretKeySpec(encodeFormat, AES);
        // Cipher The object actually does the encryption
        Cipher cipher = Cipher.getInstance(AES);
        //  Initialize with a key Cipher object
        cipher.init(Cipher.DECRYPT_MODE, key);
        //  Officially execute the decryption operation
        byte[] result = cipher.doFinal(content);
        return result;
      } catch (NoSuchAlgorithmException e) {
        e.printStackTrace();
      } catch (NoSuchPaddingException e) {
        e.printStackTrace();
      } catch (InvalidKeyException e) {
        e.printStackTrace();
      } catch (IllegalBlockSizeException e) {
        e.printStackTrace();
      } catch (BadPaddingException e) {
        e.printStackTrace();
      }
      return null;
    }
    /**
     * Aes encryption
     * @param context  clear
     * @param private_key  The secret key
     * @return
     * @throws DecoderException
     */
    public static String encryption(String context,String private_key) throws DecoderException{
      // The encrypted plaintext becomes ciphertext
      byte[] encryptResult = encrypt(context, private_key);
      // Password, Hex coding
      String encryptResultStr = Hex.encodeHexString(encryptResult);
      return encryptResultStr;
    }
    /**
    * Aes decryption
    * @param context  cipher
    * @param private_key  The secret key
    * @return
    * @throws DecoderException
    * @throws UnsupportedEncodingException
    */
    public static String decryption(String context,String private_key) throws DecoderException, UnsupportedEncodingException{
     // The ciphertext here was decrypted before it was decrypted Hex decoding
      byte[] decryptResult = decrypt(context, private_key);
      String result = new String(decryptResult, UTF8);
      return result;
    }
    public static void main(String[] args) throws UnsupportedEncodingException, DecoderException {
      // Encrypted content
      String content = "123456787654321";
      //AES Encrypt the decryption key
      String password = " This value 1 General are given, double hair know ";
      //  encryption
      System.out.println(" Encrypted before: " + content);
      //  Call the encryption method
      String encryptResultStr = encryption(content, password);
      System.out.println(" After the encryption: " + encryptResultStr);
      //  Call the decryption method
      String result = decryption(encryptResultStr, password);
      //  Decrypted content is decoded
      System.out.println(" After decryption: " + result);
    }
}

This method is already in use in formal projects, no problem, note that the AES encryption and decryption here you have to be right…

Used above is org. apache. commons. codec. binary. Hex methods of this class, in maven configuration is as follows:

<dependency>
  <groupId>commons-codec</groupId>
  <artifactId>commons-codec</artifactId>
  <version>1.4</version>
</dependency>

Note: version 1.4 and above should be used here, because there is no Hex.encodeHexString (byte[]) method below 1.4!

PS: about encryption and decryption interested friends can also refer to the website online tools:

Password security online detection: http://tools.ofstack.com/password/my\_password\_safe

High strength password generator: http://tools.ofstack.com/password/CreateStrongPassword

Thunderbolt, express, whirlwind URL encryption/decryption tools: http://tools.ofstack.com/password/urlrethunder

Online hash/hash algorithm encryption tool: http://tools.ofstack.com/password/hash\_encrypt

MD5/hash/ SHA-1 / SHA-2 / es538en-256 / SHA-512 / SHA-3 / RIPEMD-160 encryption tools: http://tools.ofstack.com/password/hash\_md5\_sha

Online sha1 sha224 / sha256 sha384 / sha512 encryption tools: http://tools.ofstack.com/password/sha\_encode

I hope this article is helpful to you java programming.