AES 加密 java版本 Demo，密钥可以保存字符串，也可以输出文件保存本地

package com.fingerchar.core.util;

import org.apache.commons.lang3.StringUtils;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Base64;

public class AESUtil {

    private static final String ALGORITHM_NAME = "AES";//加密因子，可根据您的需要自定义

    private static final String DEFAULT_ENCRYPT_RULE = "AES/CBC/PKCS5Padding";
    private static final String RANDOM_KEY_ALGORITHM = "SHA1PRNG";
    private static final String RANDOM_KEY_ALGORITHM_PROVIDER = "SUN";


    /**
     * 生成密钥 并且保存文件  没有加密因子（无盐）
     * @return
     * @throws Exception
     */
    public SecretKey geneKey( String keyFilePath) throws Exception {
        //获取一个密钥生成器实例
        KeyGenerator keyGenerator = KeyGenerator.getInstance(ALGORITHM_NAME);
        SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
        random.setSeed("123456".getBytes());//设置加密用的种子，密钥，这个可不操作，固定了的话每次出来的密钥时一样的
        keyGenerator.init(random);
        SecretKey secretKey = keyGenerator.generateKey();
        //把上面的密钥存起来
        Path keyPath = Paths.get(keyFilePath);
        Files.write(keyPath, secretKey.getEncoded());
        return secretKey;
    }

    /**
     * 生成密钥  并且返回密钥   有加密因子（有盐）
     * @param password
     * @return
     * @throws Exception
     */
    public String geneKeyString(String password) throws Exception {
        //获取一个密钥生成器实例
        KeyGenerator keyGenerator = KeyGenerator.getInstance(ALGORITHM_NAME);
        SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
        if(null!=password&&!"".equals(password)){
              random.setSeed(password.getBytes());//设置加密用的种子，密钥，这个可不操作，固定了的话每次出来的密钥时一样的
        }
        keyGenerator.init(random);
        SecretKey secretKey = keyGenerator.generateKey();
        //把上面的密钥存起来
        return Base64Utils.encode(secretKey.getEncoded());
    }

    /**
     * AES加密
     * * keyFilePath  .key 文件
     * @param content 待加密的内容，为空时为回空
     * @return 加密后的base64格式的结果，出现异常时返回null
     */
    public  String encryptString(String keyString,String content) {
        if (StringUtils.isEmpty(content)) {
            return null;
        }
        try {
            SecretKeySpec keySpec = new SecretKeySpec(keyString.getBytes(), ALGORITHM_NAME);

            SecretKey secretKey =  keySpec;
            Cipher cipher = Cipher.getInstance(ALGORITHM_NAME);
            cipher.init(Cipher.ENCRYPT_MODE, secretKey);
            byte[] encrypted = cipher.doFinal(content.getBytes("utf-8"));
            String result = new String(Base64.getEncoder().encodeToString(encrypted));
            return  result;
        } catch (Exception e) {
            e.printStackTrace();
             return null;
        }
    }
    /**
     * AES加密
     * * keyFilePath  .key 文件
     * @param content 待加密的内容，为空时为回空
     * @return 加密后的base64格式的结果，出现异常时返回null
     */
    public  String encrypt(String keyFilePath,String content) {
        if (StringUtils.isEmpty(content)) {
            return null;
        }
        try {
            Path keyPath = Paths.get(keyFilePath);
            SecretKey secretKey =  this.readKey(keyPath);
            Cipher cipher = Cipher.getInstance(ALGORITHM_NAME);
            cipher.init(Cipher.ENCRYPT_MODE, secretKey);
            byte[] encrypted = cipher.doFinal(content.getBytes("utf-8"));
            String result = new String(Base64.getEncoder().encodeToString(encrypted));
            return  result;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 解密
     *    keyString
     * @param encrypted 加密后的base64格式的密文
     * @return 解密后的原文，出现异常时返回null
     */
    public  String decryptString(String keyString,String encrypted) {
        if (StringUtils.isEmpty(encrypted)) {
            return null;
        }
        try {
//            KeyGenerator keyGenerator = KeyGenerator.getInstance(ALGORITHM_NAME);
//            SecureRandom secureRandom = SecureRandom.getInstance(RANDOM_KEY_ALGORITHM, RANDOM_KEY_ALGORITHM_PROVIDER);
//            secureRandom.setSeed(DEFAULT_ENCRYPT_RULE.getBytes());
//            keyGenerator.init(128, secureRandom);
//            SecretKey originalKey = keyGenerator.generateKey();
            // SecretKey secretKey = new SecretKeySpec(originalKey.getEncoded(), ALGORITHM_NAME);
            SecretKey secretKey = new SecretKeySpec(keyString.getBytes(),ALGORITHM_NAME);
            Cipher cipher = Cipher.getInstance(ALGORITHM_NAME);
            cipher.init(Cipher.DECRYPT_MODE, secretKey);
            byte[] decrypted = cipher.doFinal(Base64.getDecoder().decode(encrypted));
            return new String(decrypted, "utf-8");
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 解密
     * keyFilePath  .key 文件
     * @param encrypted 加密后的base64格式的密文
     * @return 解密后的原文，出现异常时返回null
     */
    public  String decrypt(String keyFilePath,String encrypted) {
        if (StringUtils.isEmpty(encrypted)) {
            return null;
        }
        try {
//            KeyGenerator keyGenerator = KeyGenerator.getInstance(ALGORITHM_NAME);
//            SecureRandom secureRandom = SecureRandom.getInstance(RANDOM_KEY_ALGORITHM, RANDOM_KEY_ALGORITHM_PROVIDER);
//            secureRandom.setSeed(DEFAULT_ENCRYPT_RULE.getBytes());
//            keyGenerator.init(128, secureRandom);
//            SecretKey originalKey = keyGenerator.generateKey();
            // SecretKey secretKey = new SecretKeySpec(originalKey.getEncoded(), ALGORITHM_NAME);
            Path keyPath = Paths.get(keyFilePath);
            SecretKey secretKey = this.readKey(keyPath);
            Cipher cipher = Cipher.getInstance(ALGORITHM_NAME);
            cipher.init(Cipher.DECRYPT_MODE, secretKey);
            byte[] decrypted = cipher.doFinal(Base64.getDecoder().decode(encrypted));
            return new String(decrypted, "utf-8");
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }


    /**
     * 读取存储的密钥
     * @param keyPath
     * @return
     * @throws Exception
     */
    public SecretKey readKey(Path keyPath) throws Exception {
        //读取存起来的密钥
        byte[] keyBytes = Files.readAllBytes(keyPath);
        SecretKeySpec keySpec = new SecretKeySpec(keyBytes, ALGORITHM_NAME);
        return keySpec;
    }


    public static void main(String[] args) {

////////&************************************案例1  生成密钥并且保存 文件 satrt
        /**
         *        //获取一个密钥生成器实例
         *         KeyGenerator keyGenerator = KeyGenerator.getInstance(ALGORITHM_NAME);
         *         SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
         *         random.setSeed("123456".getBytes());//设置加密用的种子，密钥，这个可不操作，固定了的话每次出来的密钥时一样的
         *         keyGenerator.init(random);
         *         SecretKey secretKey = keyGenerator.generateKey();
         *         //把上面的密钥存起来
         *         Path keyPath = Paths.get(keyFilePath);
         *         Files.write(keyPath, secretKey.getEncoded());
         *         return secretKey;
         */
////////&************************************案例1  生成密钥并且保存 文件 end

////////&************************************案例2  生成密钥并且保存 字符串 start

        try{
            AESUtil aesUtil=new AESUtil();

            String keyString=aesUtil.geneKeyString("langjunnan");
            String result= aesUtil.encryptString(keyString,"顶顶顶顶的点点滴滴");
            System.out.println("加密后的数据= "+result);
            String data=aesUtil.decryptString(keyString,result);
            System.out.println("解密后的数据= "+data);

            // a7SDfrdDKRBe5FaN2n3Gfg==
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    ////////&************************************案例2  生成密钥并且保存 字符串 end


}