Java加密解密工具类详解

一、MD5加密解密工具类

MD5加密算法是一种常见的加密算法，通常用于对密码、数字签名等敏感信息进行加密处理，以确保数据的安全性。在Java编程中，我们可以使用如下的工具类来实现MD5加密解密功能：

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class EncryptUtil {
    
    public static final String KEY_MD5 = "MD5";
 
    public static String encryptMD5(String data) {
        byte[] inputData = data.getBytes();
        MessageDigest md;
        String md5Str = "";
        try {
            md = MessageDigest.getInstance(KEY_MD5);
            byte[] md5Bytes = md.digest(inputData);
            md5Str = toHexString(md5Bytes);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return md5Str;
    }
    
    private static String toHexString(byte[] byteArray) {
        StringBuilder hexString = new StringBuilder();
        for (byte b : byteArray) {
            String hex = Integer.toHexString(0xFF & b);
            if (hex.length() == 1) {
                hexString.append('0');
            }
            hexString.append(hex);
        }
        return hexString.toString();
    }
}

首先，我们定义了一个常量KEY_MD5，表示使用MD5算法进行加密；然后，通过encryptMD5()方法，传入需要加密的数据进行处理；toHexString()方法将加密后的字节数组以十六进制的形式返回。

在使用时，只需要将需要加密的原始数据传入encryptMD5()方法中即可：

String encryptedStr = EncryptUtil.encryptMD5("password");

以上代码将会把字符串"password"进行MD5加密，并返回加密后的字符串。

二、Base64编码解码工具类

Base64编码是一种用于将任意二进制数据编码成纯文本的方法，通常用于在HTTP协议传输中发送明文字符串。在Java编程中，我们可以使用如下的Base64工具类来实现编码解码功能：

import java.util.Base64;

public class EncodeUtil {
    
    public static String encode(String data) {
        return Base64.getEncoder().encodeToString(data.getBytes());
    }
    
    public static String decode(String encodedStr) {
        byte[] decodedBytes = Base64.getDecoder().decode(encodedStr);
        return new String(decodedBytes);
    }
}

以上代码通过调用Java 8提供的Base64 API实现了编码解码功能。在encode()方法中，我们将字符串转换为二进制数据后通过Base64.getEncoder()进行编码，并将结果以字符串形式返回；在decode()方法中，对Base64编码后的字符串进行解码，并将结果转换为字符串返回。以下是使用示例：

String encodedStr = EncodeUtil.encode("hello world");
String decodedStr = EncodeUtil.decode(encodedStr);

以上代码将会对字符串"hello world"进行Base64编码，并将结果转换为字符串。接着再对编码后的字符串进行解码，得到原始的字符串。

三、AES加密解密工具类

AES（Advanced Encryption Standard）是一种常用的对称加密算法，通常用于加密敏感信息以保证数据的安全性。在Java编程中，我们可以使用如下的AES工具类来实现加密解密功能：

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

public class AESUtil {
    
    private static final String AES = "AES";
    
    private static SecretKeySpec generateKey(String password) throws Exception {
        KeyGenerator keyGenerator = KeyGenerator.getInstance(AES);
        keyGenerator.init(128);
        SecretKey secretKey = keyGenerator.generateKey();
        byte[] enCodeFormat = secretKey.getEncoded();
        return new SecretKeySpec(enCodeFormat, AES);
    }

    public static String encrypt(String data, String password) throws Exception {
        SecretKeySpec secretKeySpec = generateKey(password);
        Cipher cipher = Cipher.getInstance(AES);// 创建密码器  
        cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);// 初始化  
        byte[] result = cipher.doFinal(data.getBytes("UTF-8")); 
        return toHexString(result); // 加密  
    }
  
    public static String decrypt(String data, String password) throws Exception {
        SecretKeySpec secretKeySpec = generateKey(password);
        Cipher cipher = Cipher.getInstance(AES);// 创建密码器  
        cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);// 初始化  
        byte[] result = cipher.doFinal(hexStringToBytes(data)); // 加密  
        return new String(result,"UTF-8"); // 解密  
    }
    
    private static byte[] hexStringToBytes(String hexString) {
        if (hexString == null || hexString.equals("")) {
            return null;
        }
        hexString = hexString.toUpperCase();
        int length = hexString.length() / 2;
        char[] hexChars = hexString.toCharArray();
        byte[] d = new byte[length];
        for (int i = 0; i < length; i++) {
            int pos = i * 2;
            d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));
        }
        return d;
    }
    
    private static byte charToByte(char c) {
        return (byte) "0123456789ABCDEF".indexOf(c);
    }
    
    private static String toHexString(byte[] byteArray) {
        StringBuilder hexString = new StringBuilder();
        for (byte b : byteArray) {
            String hex = Integer.toHexString(0xFF & b);
            if (hex.length() == 1) {
                hexString.append('0');
            }
            hexString.append(hex);
        }
        return hexString.toString();
    }
}

在AESUtil类中，我们定义了一个常量AES表示使用AES加密算法进行加密；generateKey()方法用于生成加密密钥；encrypt()方法将原始数据进行AES加密后返回加密结果；decrypt()方法用于将加密后的数据进行解密。使用示例：

String encryptedStr = AESUtil.encrypt("Hello World", "password");
String decryptedStr = AESUtil.decrypt(encryptedStr, "password");

这里的encrypt()和decrypt()方法分别用于加密和解密原始数据。首先，我们将需要加密的数据和密钥传入encrypt()方法中，得到加密后的字符串；然后再将加密后的字符串和密钥传入decrypt()方法中，得到原始字符串。

四、RSA加密解密工具类

RSA（Rivest-Shamir-Adleman）是一种非对称加密算法，通常用于加密较小长度的文本或数据传输中的密钥。在Java编程中，我们可以使用如下的RSA工具类来实现加密解密功能：

import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import javax.crypto.Cipher;

public class RSAUtil {
    
    private static final String RSA = "RSA";
    
    /**
     * 生成密钥对
     */
    public static KeyPair generateKeyPair() throws NoSuchAlgorithmException {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(RSA);
        keyPairGenerator.initialize(1024);
        return keyPairGenerator.generateKeyPair();
    }
    
    /**
     * 从公钥中获取公钥对象
     */
    public static PublicKey getPublicKey(byte[] publicKey) throws NoSuchAlgorithmException, InvalidKeySpecException {
        X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(publicKey);
        KeyFactory keyFactory = KeyFactory.getInstance(RSA);
        return keyFactory.generatePublic(publicKeySpec);
    }
    
    /**
     * 从私钥中获取私钥对象
     */
    public static PrivateKey getPrivateKey(byte[] privateKey) throws NoSuchAlgorithmException, InvalidKeySpecException {
        PKCS8EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(privateKey);
        KeyFactory keyFactory = KeyFactory.getInstance(RSA);
        return keyFactory.generatePrivate(privateKeySpec);
    }
    
    /**
     * 公钥加密
     */
    public static byte[] encrypt(byte[] data, PublicKey publicKey) throws Exception {
        Cipher cipher = Cipher.getInstance(RSA);
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        return cipher.doFinal(data);
    }
    
    /**
     * 私钥解密
     */
    public static byte[] decrypt(byte[] data, PrivateKey privateKey) throws Exception {
        Cipher cipher = Cipher.getInstance(RSA);
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        return cipher.doFinal(data);
    }
    
    /**
     * 获取公钥密钥字符串
     */
    public static String getKeyString(Key key) {
        byte[] keyBytes = key.getEncoded();
        return toHexString(keyBytes);
    }
    
    private static String toHexString(byte[] byteArray) {
        StringBuilder hexString = new StringBuilder();
        for (byte b : byteArray) {
            String hex = Integer.toHexString(0xFF & b);
            if (hex.length() == 1) {
                hexString.append('0');
            }
            hexString.append(hex);
        }
        return hexString.toString();
    }
}

在RSAUtil类中，我们定义了一个常量RSA表示使用RSA非对称加密算法进行加密；generateKeyPair()方法用于生成公钥和私钥对；getPublicKey()方法使用公钥的字节数组获取公钥对象；getPrivateKey()方法使用私钥的字节数组获取私钥对象；encrypt()方法将原始数据使用公钥进行加密后返回加密数据的字节数组；encrypt()方法将加密后的数据使用私钥进行解密后返回原始数据的字节数组。使用示例：

//生成公钥和私钥
KeyPair keyPair = RSAUtil.generateKeyPair();
PublicKey publicKey = keyPair.getPublic();
PrivateKey privateKey = keyPair.getPrivate();

//使用公钥对数据进行加密
byte[] encryptedData = RSAUtil.encrypt("Hello World".getBytes(), publicKey);

//使用私钥对加密后的数据进行解密
byte[] decryptedData = RSAUtil.decrypt(encryptedData, privateKey);

//将解密得到的字节数组转换为字符串
String decryptedStr = new String(decryptedData);

以上代码将会生成RSA公钥和私钥，并使用公钥对字符串"Hello World"进行加密，接着再使用私钥对加密后的数据进行解密，得到原始数据的字节数组，最后将字节数组转换为字符串形式输出。