java AES實現字符串的加密、解密(配合二進制、十六進制轉換的工具使用)

import javax.crypto.*;
import javax.crypto.spec.SecretKeySpec;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Arrays;
import java.util.Base64;

//import org.apache.commons.codec.binary.Base64;

public class EncryptStrUtil {

    /**
     * KeyGenerator的方式，通過傳入種子串生成key，進行加密
     * @param seed 生成key傳入的種子串
     * @param toEncryptStr 要加密的字節數組
     * @return 返回 Base64 的加密字符串
     */
    public static String encrypt(String seed, byte[] toEncryptStr) {
        try {
            return Base64.getEncoder().encodeToString(getCipher(seed, Cipher.ENCRYPT_MODE).doFinal(toEncryptStr));  //此時使用的 Base64 編碼
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 根據傳入的二進制 key數組，返回AES的十六進制加密串
     * @param keyBytes
     * @param toEncryptStr
     * @return
     */
    public static String encrypt(byte[] keyBytes, byte[] toEncryptStr) {
        try {
           return BinHexSwitchUtil.bytesToHexString(getCipher(keyBytes, Cipher.ENCRYPT_MODE).doFinal(toEncryptStr));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * KeyGenerator的方式，通過傳入種子串生成key，進行解密
     * @param seed 生成key傳入的種子串
     * @param encryptedStr 要解密的字節數組，Base64加密的
     * @return 返回 解密的字節數組
     */
    public static byte[] decrypt(String seed, byte[] encryptedStr) {
        try {
            return getCipher(seed, Cipher.DECRYPT_MODE).doFinal(Base64.getDecoder().decode(encryptedStr));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 根據傳入的 二進制 key數組，將16進制加密串 解密
     * @param keyBytes
     * @param encryptedStr 要解密的字符串
     * @return 已解密的二進制數組
     */
    public static byte[] decrypt(byte[] keyBytes, String encryptedStr) {
        try {
            return getCipher(keyBytes, Cipher.DECRYPT_MODE).doFinal(BinHexSwitchUtil.hexStringTobytes(encryptedStr));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * KeyGenerator 的方式生成key，獲取密碼生成器
     * @param seed 傳入的種子 字符串
     * @param encryptMode 傳入加密模式、解密模式
     * @return 返回密碼生成器
     * @throws Exception
     */
    private static Cipher getCipher(String seed, int encryptMode) throws Exception {
        //生成加密隨機數
        SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
        //並設置seed
        random.setSeed(seed.getBytes());
        //創建AES生產者
        KeyGenerator generator = KeyGenerator.getInstance("AES");
        //初始化生產者，128位
        generator.init(128, random);

        Key key=generator.generateKey();
        // 返回基本編碼格式的密鑰(初始key)，如果此密鑰不支持編碼，則返回null。
//        byte[] enCodeFormat = generator.generateKey().getEncoded();
//
//        SecretKey key = new SecretKeySpec(enCodeFormat, "AES");//應該沒有必要再次生成一次 SecretKey
        // 創建密碼器
        Cipher cipher = Cipher.getInstance("AES");
        //初始化解碼器,這里根據是加密模式還是解碼模式
        cipher.init(encryptMode, key);
        return cipher;
    }

    /**
     * SecretKey的方式生成key，根據傳入的二進制數組 獲取密碼生成器
     * @param keyBytes
     * @param encryptMode
     * @return
     * @throws Exception
     */
    private static Cipher getCipher(byte[] keyBytes, int encryptMode) throws Exception {

        SecretKey key = new SecretKeySpec(keyBytes, "AES");//根據傳入的二進制數組 生成SecretKey
        // 創建密碼器
        Cipher cipher = Cipher.getInstance("AES");
        //初始化解碼器,這里根據是加密模式還是解碼模式
        cipher.init(encryptMode, key);
        return cipher;
    }




    public static void main(String[] args) {
        String key="1234567890123456";
        String str="nihaoma";
        String miStr=EncryptStrUtil.encrypt(key.getBytes(),str.getBytes());
        System.out.println(miStr);

        byte[] noMiStr=EncryptStrUtil.decrypt(key.getBytes(),miStr);
        System.out.println(Arrays.toString(noMiStr));
        System.out.println(new String(noMiStr));

    }
}