Java DES 加密工具类

package com;

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

import javax.crypto.Cipher;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.IvParameterSpec;
import java.security.Key;
import java.util.HashMap;
import java.util.Map;

/**
 * 加密
 *
 * @author 
 * @since 2021-08-30 14:14
 **/
public class DesPlus {

    private static final String strDefaultKey = "dhyPksiF";

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

    private final Map<String, Cipher> encryptMap = new HashMap<String, Cipher>();

    private final Map<String, Cipher> decryptMap = new HashMap<String, Cipher>();

    private static final ThreadLocal<DesPlus> localDesPlus = new ThreadLocal<DesPlus>() {

        @Override
        protected DesPlus initialValue() {
            return new DesPlus();
        }
    };

    private DesPlus() {
    }

    public static DesPlus getInstance() {

        return localDesPlus.get();
    }

    public static final String ALGORITHM_DES = "DES/CBC/PKCS5Padding";

    /**
     * DES算法，加密
     *
     * @param data 待加密字符串
     * @return 加密后的字节数组，一般结合Base64编码使用
     * @throws Exception 异常
     */
    public String encode(String data) throws Exception {
        return encode(strDefaultKey, data.getBytes());
    }

    /**
     * DES算法，加密
     *
     * @param data 待加密字符串
     * @param key  加密私钥，长度不能够小于8位
     * @return 加密后的字节数组，一般结合Base64编码使用
     * @throws Exception 异常
     */
    public String encode(String key, String data) throws Exception {
        logger.info("key:{}|data:{}|start", key, data);
        String encode = encode(key, data.getBytes());
        logger.info("key:{}|data:{}|end。{}", key, data, encode);
        return encode;
    }

    /**
     * DES算法，加密
     *
     * @param data 待加密字符串
     * @param key  加密私钥，长度不能够小于8位
     * @return 加密后的字节数组，一般结合Base64编码使用
     * @throws Exception 异常
     */
    public String encode(String key, byte[] data) throws Exception {
        try {
            DESKeySpec dks = new DESKeySpec(key.getBytes());

            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
            //key的长度不能够小于8位字节
            Key secretKey = keyFactory.generateSecret(dks);
            Cipher cipher = Cipher.getInstance(ALGORITHM_DES);
            IvParameterSpec iv = new IvParameterSpec(key.getBytes());
            cipher.init(Cipher.ENCRYPT_MODE, secretKey, iv);

            byte[] bytes = cipher.doFinal(data);

            return byteArrayToHexString(bytes);
        } catch (Exception e) {
            logger.error("key:{}|data:{}|encode error", key, new String(data), e);
        }
        return "";
    }
    
	public String byteArrayToHexString(byte b[]) {
        StringBuffer resultSb = new StringBuffer();
        for (int i = 0; i < b.length; i++)
            resultSb.append(byteToHexString(b[i]));

        return resultSb.toString();
    }
    
    private static String byteToHexString(byte b) {
        int n = b;
        if (n < 0)
            n += 256;
        int d1 = n / 16;
        int d2 = n % 16;
        return hexDigits[d1] + hexDigits[d2];
    }

    /**
     * DES算法，解密
     *
     * @param data 待解密字符串
     * @param key  解密私钥，长度不能够小于8位
     * @return 解密后的字节数组
     */
    public byte[] decode(String key, byte[] data) {
        try {
            DESKeySpec dks = new DESKeySpec(key.getBytes());
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
            //key的长度不能够小于8位字节
            Key secretKey = keyFactory.generateSecret(dks);
            Cipher cipher = Cipher.getInstance(ALGORITHM_DES);
            IvParameterSpec iv = new IvParameterSpec(key.getBytes());
            cipher.init(Cipher.DECRYPT_MODE, secretKey, iv);
            return cipher.doFinal(data);
        } catch (Exception e) {
            logger.error("key:{}|data:{}|decode error", key, new String(data), e);
        }
        return new byte[0];
    }

    /**
     * 获取编码后的值
     *
     * @param data 解码数据
     * @return 解码后的数据
     */
    public String decodeValue(String data) {
        return decodeValue(strDefaultKey, data);
    }

    /**
     * 获取编码后的值
     *
     * @param key
     * @param data
     * @return
     * @throws Exception
     */
    public String decodeValue(String key, String data) {
        byte[] datas;
        String value = null;
        try {
            datas = decode(key, hexStr2ByteArr(data));
            value = new String(datas);
        } catch (Exception e) {
            value = "";
        }
        return value;
    }
    
    public byte[] hexStr2ByteArr(String strIn) {

        byte[] arrB = strIn.getBytes();

        int iLen = arrB.length;
        // 两个字符表示一个字节，所以字节数组长度是字符串长度除以2
        byte[] arrOut = new byte[iLen / 2];

        for (int i = 0; i < iLen; i = i + 2) {

            String strTmp = new String(arrB, i, 2);

            arrOut[i / 2] = (byte) Integer.parseInt(strTmp, 16);

        }

        return arrOut;

    }

    public static void main(String[] args) throws Exception {
        DesPlus instance = getInstance();
        String encode = instance.encode("18000000000");
        System.out.println(encode);
        System.out.println(instance.decodeValue(encode));
    }
}