该系列为java工具类系列，主要展示100个常用的java工具类。

此文重点讲述：常见的8种加解密算法。

一、加解密算法应用场景

加解密是什么？为什么要加密？加密类型都有哪些？有万能加密么？

1，加密，顾名思义，添加密码，密码的作用是加密保护和安全认证。

如果没有加密，即明文显示，那么很容易导致信息泄露；加密之后，未经授权的用户即使获得了信息，但不知秘钥，仍然无法了解信息的具体内容。

2，加密算法大体上分为单向加密和双向加密，双向加密又可分为对称加密和非对称加密。

单向加密就是非可逆加密，就是不可解密的加密方法。如：MD5、SHA、HMAC。

双向加密是可逆加密，采用秘钥进行加密和解密。

对称加密是使用同样的秘钥进行加密和解密。如：DES、IDEA、RC2、RC4、SKIPJACK、RC5、AES

非对称加密一般用两个秘钥完成加密解密，这两个秘钥是公开秘钥（公钥）和私有秘钥（私钥）。如：RSA、DSA

3，世界上没有万能加密算法，只有相对安全的加密算法，加密算法会越来越安全，但任何加密算法都可以被破解，听起来好像很矛盾。

二、个性化字符串工具类（本文重点）

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";
public static String charset = "utf-8";
public static int keysizeDES = 0;
public static int keysizeAES = 128;	
 //1.Base64算法
 /**
     * 使用Base64进行加密
     * @param res 密文
     */
    public static String Base64Encode(String res) {
        return Base64.encode(res.getBytes());
    }
    /**
     * 使用Base64进行解密
     */
    public static String Base64Decode(String res) {
        return new String(Base64.decode(res));
    }
 
 //2.AES算法
 /**
     * 使用AES加密算法经行加密（可逆）
     * @param res 需要加密的密文
     * @param key 秘钥
     * @return
     * @return
     */
    public static String AESencode(String res, String key) {
        return keyGeneratorES(res, AES, key, keysizeAES, true);
    }
    /**
     * 对使用AES加密算法的密文进行解密
     * @param res 需要解密的密文
     * @param key 秘钥
     */
    public static String AESdecode(String res, String key) {
        return keyGeneratorES(res, AES, key, keysizeAES, false);
    }
 //3.DES算法
 /**
     * 使用DES加密算法进行加密（可逆）
     * @param res 需要加密的原文
     * @param key 秘钥
     */
    public static String DESencode(String res, String key) {
        return keyGeneratorES(res, DES, key, keysizeDES, true);
    }
    /**
     * 对使用DES加密算法的密文进行解密（可逆）
     * @param res 需要解密的密文
     * @param key 秘钥
     */
    public static String DESdecode(String res, String key) {
        return keyGeneratorES(res, DES, key, keysizeDES, false);
    }
 //4.md5算法
 /**
     * md5加密算法进行加密（不可逆）
     * @param res 需要加密的原文
     */
    public static String MD5(String res) {
        return messageDigest(res, MD5);
    }
 
    /**
     * md5加密算法进行加密（不可逆）
     * @param res  需要加密的原文
     * @param key  秘钥
     */
    public static String MD5(String res, String key) {
        return keyGeneratorMac(res, HmacMD5, key);
    }
 //5.SHA1算法
 /**
     * 使用SHA1加密算法进行加密（不可逆）
     * @param res 需要加密的原文
     */
    public static String SHA1(String res) {
        return messageDigest(res, SHA1);
    }
    /**
     * 使用SHA1加密算法进行加密（不可逆）
     * @param res 需要加密的原文
     * @param key 秘钥
     * @return
     */
    public static String SHA1(String res, String key) {
        return keyGeneratorMac(res, HmacSHA1, key);
    }
 //6.MessageDigest算法
  /**
     * 使用MessageDigest进行单向加密（无密码）
     * @param res 被加密的文本
     * @param algorithm 加密算法名称
     */
    private static 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 加密使用的秘钥
     */
    private static 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;
    }
 //7.KeyGenerator算法 
 /**
     * 使用KeyGenerator双向加密，DES/AES，注意这里转化为字符串的时候是将2进制转为16进制格式的字符串，不是直接转，因为会出错
     * @param res 加密的原文
     * @param algorithm 加密使用的算法名称
     * @param key  加密的秘钥
     * @param keysize
     * @param isEncode
     * @return
     */
    private static 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 static String base64(byte[] res){
        return Base64.encode(res);
    }
 //8.异或
 /**
     * 使用异或进行加密
     * @param res 需要加密的密文
     * @param key 秘钥
     */
    public static 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 秘钥
     */
    public static 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);
    }

本文仅供个人记录，大家可以借鉴，每行代码都是自己手打，亲测可直接粘贴执行，如有任何问题可在评论区提问，欢迎大家交流。

编辑人：程序幻境

码字不易，不喜勿踩