java 加密解密工具类（实用！！！）

最近发现了一个加密解密的好例子，很方便使用，可以作为平时开发的工具集，记录一下。

 package com.sh.springboottdemo2.util;

 import com.sun.org.apache.xerces.internal.impl.dv.util.Base64;

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

 public class EncryptUtil {
     public static final String MD5 = "MD5";
     public static final String SHA1 = "SHA1";
     public static final String HmacMD5 = "HmacMD5";
     public static final String HmacSHA1 = "HmacSHA1";
     public static final String DES = "DES";
     public static final String AES = "AES";

     /**编码格式；默认使用uft-8*/
     public String charset = "utf-8";
     /**DES*/
     public int keysizeDES = 0;
     /**AES*/
     public int keysizeAES = 128;

     public static EncryptUtil me;

     private EncryptUtil(){
         //单例
     }
     //双重锁
     public static EncryptUtil getInstance(){
         if (me==null) {
            synchronized (EncryptUtil.class) {
                if(me == null){
                    me = new EncryptUtil();
                }
            }
         }
         return me;
     }

     /**
      * 使用MessageDigest进行单向加密（无密码）
      * @param res 被加密的文本
      * @param algorithm 加密算法名称
      * @return
      */
     private String messageDigest(String res,String algorithm){
         try {
             MessageDigest md = MessageDigest.getInstance(algorithm);
             byte[] resBytes = charset==null?res.getBytes():res.getBytes(charset);
             return base64(md.digest(resBytes));
         } catch (Exception e) {
             e.printStackTrace();
         }
         return null;
     }

     /**
      * 使用KeyGenerator进行单向/双向加密（可设密码）
      * @param res 被加密的原文
      * @param algorithm  加密使用的算法名称
      * @param key 加密使用的秘钥
      * @return
      */
     private String keyGeneratorMac(String res,String algorithm,String key){
         try {
             SecretKey sk = null;
             if (key==null) {
                 KeyGenerator kg = KeyGenerator.getInstance(algorithm);
                 sk = kg.generateKey();
             }else {
                 byte[] keyBytes = charset==null?key.getBytes():key.getBytes(charset);
                 sk = new SecretKeySpec(keyBytes, algorithm);
             }
             Mac mac = Mac.getInstance(algorithm);
             mac.init(sk);
             byte[] result = mac.doFinal(res.getBytes());
             return base64(result);
         } catch (Exception e) {
             e.printStackTrace();
         }
         return null;
     }

     /**
      * 使用KeyGenerator双向加密，DES/AES，注意这里转化为字符串的时候是将2进制转为16进制格式的字符串，不是直接转，因为会出错
      * @param res 加密的原文
      * @param algorithm 加密使用的算法名称
      * @param key  加密的秘钥
      * @param keysize
      * @param isEncode
      * @return
      */
     private String keyGeneratorES(String res,String algorithm,String key,int keysize,boolean isEncode){
         try {
             KeyGenerator kg = KeyGenerator.getInstance(algorithm);
             if (keysize == 0) {
                 byte[] keyBytes = charset==null?key.getBytes():key.getBytes(charset);
                 kg.init(new SecureRandom(keyBytes));
             }else if (key==null) {
                 kg.init(keysize);
             }else {
                 byte[] keyBytes = charset==null?key.getBytes():key.getBytes(charset);
                 kg.init(keysize, new SecureRandom(keyBytes));
             }
             SecretKey sk = kg.generateKey();
             SecretKeySpec sks = new SecretKeySpec(sk.getEncoded(), algorithm);
             Cipher cipher = Cipher.getInstance(algorithm);
             if (isEncode) {
                 cipher.init(Cipher.ENCRYPT_MODE, sks);
                 byte[] resBytes = charset==null?res.getBytes():res.getBytes(charset);
                 return parseByte2HexStr(cipher.doFinal(resBytes));
             }else {
                 cipher.init(Cipher.DECRYPT_MODE, sks);
                 return new String(cipher.doFinal(parseHexStr2Byte(res)));
             }
         } catch (Exception e) {
             e.printStackTrace();
         }
         return null;
     }

     private String base64(byte[] res){
         return Base64.encode(res);
     }

     /**将二进制转换成16进制 */
     public static String parseByte2HexStr(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();
     }
     /**将16进制转换为二进制*/
     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;
     }

     /**
      * md5加密算法进行加密（不可逆）
      * @param res 需要加密的原文
      * @return
      */
     public String MD5(String res) {
         return messageDigest(res, MD5);
     }

     /**
      * md5加密算法进行加密（不可逆）
      * @param res  需要加密的原文
      * @param key  秘钥
      * @return
      */
     public String MD5(String res, String key) {
         return keyGeneratorMac(res, HmacMD5, key);
     }

     /**
      * 使用SHA1加密算法进行加密（不可逆）
      * @param res 需要加密的原文
      * @return
      */
     public String SHA1(String res) {
         return messageDigest(res, SHA1);
     }

     /**
      * 使用SHA1加密算法进行加密（不可逆）
      * @param res 需要加密的原文
      * @param key 秘钥
      * @return
      */
     public String SHA1(String res, String key) {
         return keyGeneratorMac(res, HmacSHA1, key);
     }

     /**
      * 使用DES加密算法进行加密（可逆）
      * @param res 需要加密的原文
      * @param key 秘钥
      * @return
      */
     public String DESencode(String res, String key) {
         return keyGeneratorES(res, DES, key, keysizeDES, true);
     }

     /**
      * 对使用DES加密算法的密文进行解密（可逆）
      * @param res 需要解密的密文
      * @param key 秘钥
      * @return
      */
     public String DESdecode(String res, String key) {
         return keyGeneratorES(res, DES, key, keysizeDES, false);
     }

     /**
      * 使用AES加密算法经行加密（可逆）
      * @param res 需要加密的密文
      * @param key 秘钥
      * @return
      */
     public String AESencode(String res, String key) {
         return keyGeneratorES(res, AES, key, keysizeAES, true);
     }

     /**
      * 对使用AES加密算法的密文进行解密
      * @param res 需要解密的密文
      * @param key 秘钥
      * @return
      */
     public String AESdecode(String res, String key) {
         return keyGeneratorES(res, AES, key, keysizeAES, false);
     }

     /**
      * 使用异或进行加密
      * @param res 需要加密的密文
      * @param key 秘钥
      * @return
      */
     public String XORencode(String res, String key) {
         byte[] bs = res.getBytes();
         for (int i = 0; i < bs.length; i++) {
             bs[i] = (byte) ((bs[i]) ^ key.hashCode());
         }
         return parseByte2HexStr(bs);
     }

     /**
      * 使用异或进行解密
      * @param res 需要解密的密文
      * @param key 秘钥
      * @return
      */
     public String XORdecode(String res, String key) {
         byte[] bs = parseHexStr2Byte(res);
         for (int i = 0; i < bs.length; i++) {
             bs[i] = (byte) ((bs[i]) ^ key.hashCode());
         }
         return new String(bs);
     }

     /**
      * 直接使用异或（第一调用加密，第二次调用解密）
      * @param res 密文
      * @param key 秘钥
      * @return
      */
     public int XOR(int res, String key) {
         return res ^ key.hashCode();
     }

     /**
      * 使用Base64进行加密
      * @param res 密文
      * @return
      */
     public String Base64Encode(String res) {
         return Base64.encode(res.getBytes());
     }

     /**
      * 使用Base64进行解密
      * @param res
      * @return
      */
     public String Base64Decode(String res) {
         return new String(Base64.decode(res));
     }
 }