java DES和AES加密解密

import org.bouncycastle.jce.provider.BouncyCastleProvider;

import javax.crypto.*;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;

import java.security.*;
import java.security.spec.InvalidKeySpecException;
import java.util.Base64;

/**
 * DES/AES 加密解密方式
 */
public class DesCipherUtil {

    private DesCipherUtil() {
        throw new AssertionError("您没有实例!");
    }

    static {
        // 添加 BC
        Security.addProvider(new BouncyCastleProvider());
    }

    /**
     * 加密
     *
     * @param encryptText 需要加密的信息
     * @param key 加密密钥
     * @return 加密后Base64编码的字符串
     */
    public static String encryptDES(String encryptText, String key) {
        if (encryptText == null || key == null) {
            throw new IllegalArgumentException("加密文本不能为空!");
        }
        try {
            DESKeySpec desKeySpec = new DESKeySpec(key.getBytes());
            SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance("DES");
            SecretKey secretKey = secretKeyFactory.generateSecret(desKeySpec);

            Cipher cipher = Cipher.getInstance("DES/ECB/PKCS7Padding", "BC");
            cipher.init(Cipher.ENCRYPT_MODE, secretKey);
            byte[] bytes = cipher.doFinal(encryptText.getBytes(Charset.forName("UTF-8")));
//            String fina=new String(bytes);
            return byteToHexString(bytes);
            //Base64二次加密
//            return Base64.getEncoder().encodeToString(bytes);

        } catch (NoSuchAlgorithmException | InvalidKeyException | InvalidKeySpecException | NoSuchPaddingException
                | BadPaddingException | NoSuchProviderException | IllegalBlockSizeException e) {
            throw new RuntimeException("加密失败", e);
        }

    }
    /**
     * 接口描述:解密
     * @param encryptText 需要解密的信息
     * @param key 加密密钥
     * @return java.lang.String 解密后的字符串
     **/
    public static String decryptDES(String encryptText,String key){
        try{
            // 创建一个DESKeySpec对象，PASSWORD可任意指定
            DESKeySpec desKey = new DESKeySpec(key.getBytes());
            // 创建一个密匙工厂
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
            // 生成密钥
            SecretKey secretkey = keyFactory.generateSecret(desKey);
            // 指定获取DES的Cipher对象
            Cipher cipher = Cipher.getInstance("DES");
            // 用密匙初始化Cipher对象
            cipher.init(Cipher.DECRYPT_MODE, secretkey, new SecureRandom());
            // 真正开始解密操作
            return new String(cipher.doFinal(parseHexStr2Byte(encryptText)));
        }catch(Throwable e){
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 加密
     * @param encryptText 待加密内容
     * @param key 加密使用的 AES 密钥，BASE64 编码后的字符串
     * @return 加密后的密文,进行 BASE64 处理之后返回
     */
    public static String encryptAES(String encryptText, String key) {

        try {
            // 获得一个加密规则 SecretKeySpec
            byte[] content=encryptText.getBytes();
            SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(), "AES");
            // 获得加密算法实例对象 Cipher
            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS7Padding"); //"算法/模式/补码方式"
            // 获得一个 IvParameterSpec
            IvParameterSpec ivParameterSpec = new IvParameterSpec(key.getBytes());  // 使用 CBC 模式，需要一个向量 iv, 可增加加密算法的强度
            // 根据参数初始化算法
            cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec, ivParameterSpec);
            // 执行加密并返回经 BASE64 处助理之后的密文
            return Base64.getEncoder().encodeToString(cipher.doFinal(content));
        } catch (NoSuchAlgorithmException | InvalidKeyException | InvalidAlgorithmParameterException | NoSuchPaddingException
                | BadPaddingException | IllegalBlockSizeException e) {
            throw new RuntimeException("加密失败", e);
        }
    }
    /**
     * 解密
     * @param encryptText: 待解密内容，是 BASE64 编码后的字节数组
     * @param key: 解密使用的 AES 密钥，BASE64 编码后的字符串
     * @return 解密后的明文，直接返回经 UTF-8 编码转换后的明文
     */
    public static String decryptAES(String encryptText, String key)  {
        try {
            byte[] content=encryptText.getBytes();
            // 密文进行 BASE64 解密处理
            byte[] contentDecByBase64 = Base64.getDecoder().decode(content);
            // 获得一个 SecretKeySpec
            // SecretKeySpec secretKeySpec = new SecretKeySpec(Base64.getDecoder().decode(secretKeyStr), "AES");
            SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(), "AES");
            // 获得加密算法实例对象 Cipher
            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS7Padding"); //"算法/模式/补码方式"
            // 获得一个初始化 IvParameterSpec
            IvParameterSpec ivParameterSpec = new IvParameterSpec(key.getBytes());
            // 根据参数初始化算法
            cipher.init(Cipher.DECRYPT_MODE, secretKeySpec, ivParameterSpec);
            // 解密
            return new String(cipher.doFinal(contentDecByBase64), "utf8");
        } catch (NoSuchAlgorithmException | InvalidKeyException | InvalidAlgorithmParameterException | NoSuchPaddingException
                    | BadPaddingException | IllegalBlockSizeException | UnsupportedEncodingException e) {
            throw new RuntimeException("加密失败", e);
        }
    }
    /**
     * 将byte转换为16进制字符串
     * @param src
     * @return
     */
    public static String byteToHexString(byte[] src) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < src.length; i++) {
            int v = src[i] & 0xff;
            String hv = Integer.toHexString(v);
            if (hv.length() < 2) {
                sb.append("0");
            }
            sb.append(hv);
        }
        return sb.toString();
    }

    /**将16进制转换为二进制
     * @param hexStr
     * @return
     */
    public static byte[] parseHexStr2Byte(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;
    }

}