java中常用的几种加密方式举例详解

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
public class MD5Utils {
    public static String md5(String input) {
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
            byte[] digest = md.digest(input.getBytes()); // 生成摘要字节数组
            // 转16进制字符串
            StringBuilder sb = new StringBuilder();
            for (byte b : digest) {
                sb.append(String.format("%02x", b)); // 02x确保不足两位补0
            }
            return sb.toString();
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException("MD5算法不存在", e);
        }
    }
    public static void main(String[] args) {
        System.out.println(md5("123456")); // 输出：e10adc3949ba59abbe56e057f20f883e
    }
}

public class SHA256Utils {
    public static String sha256(String input) {
        try {
            MessageDigest md = MessageDigest.getInstance("SHA-256");
            byte[] digest = md.digest(input.getBytes());
            StringBuilder sb = new StringBuilder();
            for (byte b : digest) {
                sb.append(String.format("%02x", b));
            }
            return sb.toString();
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException("SHA-256算法不存在", e);
        }
    }
    public static void main(String[] args) {
        System.out.println(sha256("123456")); // 输出：8d969eef6ecad3c29a3a629280e686cf0c3f5d5a86aff3ca12020c923adc6c9
    }
}

import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
public class BCryptUtils {
    private static final BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();
    // 加密（自动生成盐值）
    public static String encrypt(String password) {
        return encoder.encode(password);
    }
    // 校验（自动提取盐值比对）
    public static boolean verify(String password, String encryptedPassword) {
        return encoder.matches(password, encryptedPassword);
    }
    public static void main(String[] args) {
        String pwd = "123456";
        String encrypted = encrypt(pwd);
        System.out.println("加密后：" + encrypted); // 格式如 $2a$10$xxx...（包含盐值）
        System.out.println("校验结果：" + verify(pwd, encrypted)); // true
    }
}

<dependency>
    <groupId>org.springframework.security</groupId>
    <artifactId>spring-security-crypto</artifactId>
    <version>5.7.3</version>
</dependency>

public class AESUtils {
    // 密钥（16字节=128位，24字节=192位，32字节=256位）
    private static final String KEY = "1234567890abcdef"; // 16字节
    // IV向量（CBC模式必需，16字节，需与密钥长度一致）
    private static final String IV = "abcdef9012345678";
    // 算法/模式/填充
    private static final String ALGORITHM = "AES/CBC/PKCS5Padding";
    // 加密
    public static String encrypt(String input) {
        try {
            SecretKeySpec keySpec = new SecretKeySpec(KEY.getBytes(), "AES");
            IvParameterSpec ivSpec = new IvParameterSpec(IV.getBytes());
            Cipher cipher = Cipher.getInstance(ALGORITHM);
            cipher.init(Cipher.ENCRYPT_MODE, keySpec, ivSpec);
            byte[] encrypted = cipher.doFinal(input.getBytes());
            return Base64.getEncoder().encodeToString(encrypted); // 转Base64方便存储传输
        } catch (Exception e) {
            throw new RuntimeException("AES加密失败", e);
        }
    }
    // 解密
    public static String decrypt(String encryptedInput) {
        try {
            SecretKeySpec keySpec = new SecretKeySpec(KEY.getBytes(), "AES");
            IvParameterSpec ivSpec = new IvParameterSpec(IV.getBytes());
            Cipher cipher = Cipher.getInstance(ALGORITHM);
            cipher.init(Cipher.DECRYPT_MODE, keySpec, ivSpec);
            byte[] encrypted = Base64.getDecoder().decode(encryptedInput);
            byte[] decrypted = cipher.doFinal(encrypted);
            return new String(decrypted);
        } catch (Exception e) {
            throw new RuntimeException("AES解密失败", e);
        }
    }
    public static void main(String[] args) {
        String input = "Hello AES!";
        String encrypted = encrypt(input);
        System.out.println("加密后：" + encrypted);
        String decrypted = decrypt(encrypted);
        System.out.println("解密后：" + decrypted); // Hello AES!
    }
}

public class RSAUtils {
    // 密钥对（实际开发中需提前生成并存储，不硬编码）
    private static KeyPair keyPair;
    static {
        try {
            // 生成RSA密钥对（2048位）
            KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA");
            generator.initialize(2048);
            keyPair = generator.generateKeyPair();
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException("RSA密钥对生成失败", e);
        }
    }
    // 获取公钥（Base64编码）
    public static String getPublicKey() {
        return Base64.getEncoder().encodeToString(keyPair.getPublic().getEncoded());
    }
    // 获取私钥（Base64编码）
    public static String getPrivateKey() {
        return Base64.getEncoder().encodeToString(keyPair.getPrivate().getEncoded());
    }
    // 公钥加密
    public static String encryptByPublicKey(String input, String publicKeyStr) {
        try {
            // 解码公钥
            byte[] publicKeyBytes = Base64.getDecoder().decode(publicKeyStr);
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKeyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            PublicKey publicKey = keyFactory.generatePublic(keySpec);
            // 加密（RSA加密长度有限制，2048位密钥最多加密245字节）
            Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            byte[] encrypted = cipher.doFinal(input.getBytes());
            return Base64.getEncoder().encodeToString(encrypted);
        } catch (Exception e) {
            throw new RuntimeException("RSA公钥加密失败", e);
        }
    }
    // 私钥解密
    public static String decryptByPrivateKey(String encryptedInput, String privateKeyStr) {
        try {
            // 解码私钥
            byte[] privateKeyBytes = Base64.getDecoder().decode(privateKeyStr);
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKeyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
            // 解密
            Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            byte[] encrypted = Base64.getDecoder().decode(encryptedInput);
            byte[] decrypted = cipher.doFinal(encrypted);
            return new String(decrypted);
        } catch (Exception e) {
            throw new RuntimeException("RSA私钥解密失败", e);
        }
    }
    public static void main(String[] args) {
        String input = "AES密钥1234567890abcdef"; // 小数据示例
        String publicKey = getPublicKey();
        String privateKey = getPrivateKey();
        System.out.println("公钥：" + publicKey);
        System.out.println("私钥：" + privateKey);
        String encrypted = encryptByPublicKey(input, publicKey);
        System.out.println("公钥加密后：" + encrypted);
        String decrypted = decryptByPrivateKey(encrypted, privateKey);
        System.out.println("私钥解密后：" + decrypted); // AES密钥1234567890abcdef
    }
}

public class SignatureUtils {
    private static final String ALGORITHM = "SHA256withRSA"; // RSA+SHA256签名
    // 私钥签名
    public static String sign(String data, String privateKeyStr) {
        try {
            byte[] privateKeyBytes = Base64.getDecoder().decode(privateKeyStr);
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKeyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
            Signature signature = Signature.getInstance(ALGORITHM);
            signature.initSign(privateKey);
            signature.update(data.getBytes());
            byte[] signBytes = signature.sign();
            return Base64.getEncoder().encodeToString(signBytes);
        } catch (Exception e) {
            throw new RuntimeException("签名失败", e);
        }
    }
    // 公钥验签
    public static boolean verify(String data, String signStr, String publicKeyStr) {
        try {
            byte[] publicKeyBytes = Base64.getDecoder().decode(publicKeyStr);
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKeyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            PublicKey publicKey = keyFactory.generatePublic(keySpec);
            Signature signature = Signature.getInstance(ALGORITHM);
            signature.initVerify(publicKey);
            signature.update(data.getBytes());
            byte[] signBytes = Base64.getDecoder().decode(signStr);
            return signature.verify(signBytes);
        } catch (Exception e) {
            throw new RuntimeException("验签失败", e);
        }
    }
    public static void main(String[] args) {
        String data = "需要签名的数据";
        String privateKey = RSAUtils.getPrivateKey(); // 复用RSA密钥对
        String publicKey = RSAUtils.getPublicKey();
        String sign = sign(data, privateKey);
        System.out.println("签名：" + sign);
        boolean verifyResult = verify(data, sign, publicKey);
        System.out.println("验签结果：" + verifyResult); // true
        // 篡改数据后验签
        boolean fakeVerify = verify(data + "篡改", sign, publicKey);
        System.out.println("篡改后验签结果：" + fakeVerify); // false
    }
}