AES加密算法

在系统开发的或城中，为了安全性的考虑，我会们对一些数据进行加密的处理，这边提供了AES加密算法的java实现，有自己的一些理解，也有网上的一些代码，算是一个综合吧，有不足之处，望大家指教，话不多少，直接上代码：

package ice.snow.util;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.security.SecureRandom;

/**
 * AES加密解密
 * @author Binbin.Yang
 * @date 2018-06-06
 */
public class AESUtil {

    private final static Logger logger = LoggerFactory.getLogger(AESUtil.class);

    private static final String DEFAULT_ENCRYPT_TYPE = "AES"; // 默认加密方式
    private static final String DEFAULT_ENCRYPT_METHOD = "AES/ECB/PKCS5Padding"; // 默认加密算法
    private static final String ENCODING_TYPE = "UTF-8";// 编码类型
    private static final String DEFAULT_METHOD = "SHA1PRNG";//默认算法实现

    private AESUtil(){

    }
    /**
     * 加密算法
     * @param content 需要被加密的对象
     * @param key 加密秘钥
     * @return
     */
    public static String encrypt(String content,String key){
        try{
            // 创建密码器
            Cipher cipher = Cipher.getInstance(DEFAULT_ENCRYPT_METHOD);
            // 密码器初始化为加密模式
            cipher.init(Cipher.ENCRYPT_MODE,createSecretKey(key));
            // 进行数据加密，获得相应的字节数组
            byte[] result = cipher.doFinal(content.getBytes(ENCODING_TYPE));
            // 使用base64加密返回字符串
            return paresByte2HexString(result);
        }catch (Exception e){
            logger.error("对 " +content+ " 加密出现异常",e);
        }
        return null;
    }

    /**
     * 解密算法
     * @param content 需要被解密的对象
     * @param key 解密秘钥，需和加密秘钥相同
     * @return
     */
    public static String decrypt(String content,String key){
        try{
            // 创建密码器
            Cipher cipher = Cipher.getInstance(DEFAULT_ENCRYPT_METHOD);
            // 密码器初始化为解密模式
            cipher.init(Cipher.DECRYPT_MODE,createSecretKey(key));
            // 先使用base64对内容进行解密获得字节数组，然后在进行aes解密
            byte[] result = cipher.doFinal(paresHexString2Byte(content));
            return new String(result,ENCODING_TYPE);
        }catch (Exception e){
            logger.error("对 "+content+ " 解密出现异常",e);
        }
        return null;
    }

    /**
     * 生成对应的秘钥
     * @param key
     * @return
     */
    private static SecretKeySpec createSecretKey(String key){
        try{
            // 获得指定算法加密生成器
            KeyGenerator generator = KeyGenerator.getInstance(DEFAULT_ENCRYPT_TYPE);
            // 获得随机秘钥信息，通过Instancef方法和setSeed方法进行处理，保证在不同的操作系统下生成的结果一致
            // 如果直接使用 generator.init(128,new SecureRandom(key.getBytes(ENCODING_TYPE)))，会出现在linux系统下每次加密的结果不一致，
            // 这是因为SecureRandom 实现完全随操作系统本身的内部状态
            SecureRandom random = SecureRandom.getInstance(DEFAULT_METHOD);
            random.setSeed(key.getBytes(ENCODING_TYPE));
            // 指定秘钥长度，以及秘钥信息
            generator.init(128,random);
            // 生成秘钥
            SecretKey secretKey = generator.generateKey();
            // 返回AES专用秘钥
            return new SecretKeySpec(secretKey.getEncoded(),DEFAULT_ENCRYPT_TYPE);
        } catch (Exception e){
            logger.error("通过 "+key+" 获取秘钥出现异常",e);
        }
        return null;
    }

    /**
     * 二进进制转为十六进制
     * @param buf
     * @return
     */
    private static String paresByte2HexString(byte[] buf){
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < buf.length; i++) {
            String hex = Integer.toHexString(buf[i] & 0xFF);
            if (hex.length() == 1) {
                hex = '0' + hex;
            }
            sb.append(hex.toUpperCase());
        }
        return sb.toString();
    }

    /**
     * 十六进制转为二进制
     * @param hexStr 必须为十六进制字符串
     * @return
     */
    private static byte[] paresHexString2Byte(String hexStr){
        if (hexStr.length() < 1)
            return null;
        byte[] result = new byte[hexStr.length()/2];
        for (int i = 0;i< hexStr.length()/2; i++) {
            int high = Integer.parseInt(hexStr.substring(i*2, i*2+1), 16);
            int low = Integer.parseInt(hexStr.substring(i*2+1, i*2+2), 16);
            result[i] = (byte) (high * 16 + low);
        }
        return result;
    }

}