Java的MD5盐值加密，Des加密解密和base64加密解密使用方法

java支持md5盐值加密和des加密。
做项目时，某些模块添加加密功能可以提高用户个人信息安全性，防止信息泄露，其中des支持加密解密，MD5目前只支持加密（多用于用户登录密码验证，所以无需解密展示）。

一、MD5盐值加密
1.在pom文件中导入相关jar包

                <dependency>
                        <groupId>org.apache.shiro</groupId>
                        <artifactId>shiro-core</artifactId>
                        <version>1.3.2</version>
                </dependency>

2.编写MD5类

import org.apache.shiro.crypto.hash.SimpleHash;

/**
 * 加密工具类
 * @author john
 *
 */
public class MD5 {
        //加密类型
        private static String hashName="MD5";
        //加密次数
        private static int hashNum=1024;
        //pwd是需要加密的字符，salt是盐值（自定义），hashNum是加密次数，次数越多越安全
        public static Object getMD5(String pwd,String salt){
                Object obj=new SimpleHash(hashName, pwd, salt, hashNum);
                return obj;
                
        }

}

加密方法是静态方法，使用时直接MD5.getMD5（pwd,salt）.toString();即可。暂无解密方法。

二、Base64加密
1.同样第一步也是导入base相关jar包

<!-- Base64 -->
                <dependency>
                <groupId>commons-codec</groupId>
                <artifactId>commons-codec</artifactId>
                <version>1.14</version>
                </dependency>

2.编写base64类

import org.apache.commons.codec.binary.Base64;

public class Base64Utils {
    /**
     * 加密
     *
     * @param plainText
     * @return
     */
    public static String encodeStr(String plainText) {
        byte[] b = plainText.getBytes();
        Base64 base64 = new Base64();
        b = base64.encode(b);
        return new String(b);
    }

    /**
     * 解密
     *
     * @param encodeStr
     * @return
     */
    public static String decodeStr(String encodeStr) {
        byte[] b = encodeStr.getBytes();
        Base64 base64 = new Base64();
        b = base64.decode(b);
        return new String(b);
    }
    
}

加密解密的方法同样是静态方法，直接类名.方法名调用即可。

三、des加密
这个不需要导jar包，直接使用即可，但代码量较多

import java.io.IOException;
import java.security.SecureRandom;

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

/**
 * DES加密 解密算法
 * 
 */
public class DesUtil {

    private final static String DES = "DES";
    private final static String ENCODE = "GBK"; //设置编码形式,防止乱码
    private final static String defaultKey = "test1234";

    /**
     * 使用 默认key 加密
     * 
     */
    public static String encrypt(String data) throws Exception {
        byte[] bt = encrypt(data.getBytes(ENCODE), defaultKey.getBytes(ENCODE));
        String strs = new BASE64Encoder().encode(bt);
        return strs;
    }

    /**
     * 使用 默认key 解密
     * 
     */
    public static String decrypt(String data) throws IOException, Exception {
        if (data == null)
            return null;
        BASE64Decoder decoder = new BASE64Decoder();
        byte[] buf = decoder.decodeBuffer(data);
        byte[] bt = decrypt(buf, defaultKey.getBytes(ENCODE));
        return new String(bt, ENCODE);
    }

    /**
     * Description 根据键值进行加密
     *
     */
    public static String encrypt(String data, String key) throws Exception {
        byte[] bt = encrypt(data.getBytes(ENCODE), defaultKey.getBytes(ENCODE));
        String strs = new BASE64Encoder().encode(bt);
        return strs;
    }

    /**
     * Description 根据键值进行解密
     * 
     */
    public static String decrypt(String data, String key) throws IOException,
            Exception {
        if (data == null)
            return null;
        BASE64Decoder decoder = new BASE64Decoder();
        byte[] buf = decoder.decodeBuffer(data);
        byte[] bt = decrypt(buf, key.getBytes(ENCODE));
        return new String(bt, ENCODE);
    }

    /**
     * Description 根据键值进行加密
     * 
     */
    private static byte[] encrypt(byte[] data, byte[] key) throws Exception {
        // 生成一个可信任的随机数源
        SecureRandom sr = new SecureRandom();

        // 从原始密钥数据创建DESKeySpec对象
        DESKeySpec dks = new DESKeySpec(key);

        // 创建一个密钥工厂，然后用它把DESKeySpec转换成SecretKey对象
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);
        SecretKey securekey = keyFactory.generateSecret(dks);

        // Cipher对象实际完成加密操作
        Cipher cipher = Cipher.getInstance(DES);

        // 用密钥初始化Cipher对象
        cipher.init(Cipher.ENCRYPT_MODE, securekey, sr);

        return cipher.doFinal(data);
    }

    /**
     * Description 根据键值进行解密
     * 
     */
    private static byte[] decrypt(byte[] data, byte[] key) throws Exception {
        // 生成一个可信任的随机数源
        SecureRandom sr = new SecureRandom();

        // 从原始密钥数据创建DESKeySpec对象
        DESKeySpec dks = new DESKeySpec(key);

        // 创建一个密钥工厂，然后用它把DESKeySpec转换成SecretKey对象
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);
        SecretKey securekey = keyFactory.generateSecret(dks);

        // Cipher对象实际完成解密操作
        Cipher cipher = Cipher.getInstance(DES);

        // 用密钥初始化Cipher对象
        cipher.init(Cipher.DECRYPT_MODE, securekey, sr);

        return cipher.doFinal(data);
    }
    

    public static void main(String[] args) throws Exception {
        String test = "今晚打老虎5.11ca";
        //加密解密
        System.out.println(encrypt(test));
        System.out.println(decrypt(encrypt(test)));

    }
}


静态方法，直接调用