DES加密 Base64编码工具类

package cn.youzule.demo.utils.encrypt;

import cn.youzule.demo.utils.encrypt.des.DesUtils;
import org.apache.commons.codec.digest.DigestUtils;

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.IvParameterSpec;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Field;
import java.util.*;

/**
 * @title:加密工具类
 * @description:加密、签名等
 * @date:2018/5/2 13:33
 **/

public class EncryptUtil {
    //des加密key
    public static final String DES_KEY = "key";
    //des加密
    public static final String DES_INSTANCE = "DES/CBC/PKCS5Padding";
    //base64编码解码
    public static Base64.Decoder decoder = Base64.getDecoder();
    public static Base64.Encoder encoder = Base64.getEncoder();


    /**
     * @Description: map按照key排序
     * @Param: map
     * @Date: 2018/5/2
     */
    public static void sortMap(Map<String, Object> map) {
        //使用list排序实现
        List<Map.Entry<String, Object>> list = new ArrayList<>(map.entrySet());
        //使用增强Collections
        Collections.sort(list, Comparator.comparing(Map.Entry<String, Object>::getKey));
    }

    /**
     * @Description: 获取签名
     * @Param: map
     * @return: String
     * @Date: 2018/5/2
     */
    public static String getSign(Map<String, Object> map) {
        //将map排序
        sortMap(map);
        StringBuilder result = new StringBuilder();
        //遍历map，拼接字符串
        for (Map.Entry<String, Object> item : map.entrySet()) {
            result.append(item.getKey())
                    .append("=")
                    .append(item.getValue())
                    .append("&");
        }
        //追加key
        result.append("singKey=")
                .append(DES_KEY);
        //sha1加密
        return DigestUtils.sha1Hex(result.toString());
    }

    /**
     * @Description: 获取签名
     * @Param: object
     * @return: String
     * @Date: 2018/5/2
     */
    public static String getSign(Object o) {
        //获取对象属性List
        Field[] fields = o.getClass().getDeclaredFields();
        //对象属性名list
        List<String> list = new ArrayList<>();
        //遍历属性放入list
        for (Field item : fields) {
            list.add(item.getName());
        }
        //将属性名list排序
        Collections.sort(list);
        //拼接
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < list.size(); i++) {
            try {
                Field field = o.getClass().getDeclaredField(list.get(i));
                field.setAccessible(true);
                String value = (String) field.get(o);
                result.append(field.getName())
                        .append("=")
                        .append(value)
                        .append("&");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        //追加signKek
        result.append("signKey=")
                .append(DES_KEY);

        return result.toString();
    }

    /**
     * @Description: des加密
     * @Param: byte[]
     * @return: byte[]
     * @Date: 2018/5/2
     */
    public static byte[] desEncrypt(byte[] data, byte[] key) {
        try {
            // 初始化向量
            IvParameterSpec iv = new IvParameterSpec(key);
            //获取密钥
            DESKeySpec desKeySpec = new DESKeySpec(key);
            // 创建一个密匙工厂，然后用它把DESKeySpec转换成securekey
            SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance("DES");
            SecretKey secretKey = secretKeyFactory.generateSecret(desKeySpec);
            // Cipher对象实际完成加密操作
            Cipher cipher = Cipher.getInstance(DES_INSTANCE);
            cipher.init(Cipher.ENCRYPT_MODE, secretKey, iv);
            byte[] result = cipher.doFinal(data);
            return result;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * @Description: 解密
     * @Param: byte[]
     * @return: byte[]
     * @Date: 2018/5/2
     */
    public static byte[] desDecrypt(byte[] data, byte[] key) {
        try {
            // 初始化向量
            IvParameterSpec iv = new IvParameterSpec(key);
            DESKeySpec desKeySpec = new DESKeySpec(key);
            SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance("DES");
            SecretKey secretKey = secretKeyFactory.generateSecret(desKeySpec);
            // Cipher对象实际完成解密操作
            Cipher cipher = Cipher.getInstance(DES_INSTANCE);
            cipher.init(Cipher.DECRYPT_MODE, secretKey, iv);
            byte[] result = cipher.doFinal(data);
            return result;

        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * @Description: des加密 base64编码
     * @Param:
     * @return:
     * @Date: 2018/5/2
     */
    public static String encodeBase64(String src, String key) {
        byte[] bytes = desEncrypt(src.getBytes(), key.getBytes());
        return encoder.encodeToString(bytes);
    }
    /** 
    * @Description: base64解码，des解密
    * @Param:
    * @return:  
    * @Date: 2018/5/2 
    */
    public static String decodeBase64(String src,String key){
        //base64解码
        byte[] bytes = decoder.decode(src.getBytes());
        //des解密
        byte[] bytes1 = desDecrypt(bytes,key.getBytes());
        try {
            return new String(bytes1,"utf-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return "";
    }

}