Java如何实现加密解密？有哪些常用方法与示例？

Java加密解密技术概述

在Java开发中，加密解密技术是保障数据安全的核心手段，广泛应用于数据传输、存储安全、身份认证等场景，Java提供了强大的加密解密API，涵盖对称加密、非对称加密、哈希算法等多种技术，本文将详细介绍Java中加密解密的实现方式，包括核心类库、常见算法应用及代码示例。

Java加密解密核心类库

Java加密解密功能主要依赖java.crypto包和java.security包中的核心类，这些类提供了统一的加密解密接口，便于开发者快速实现安全功能。

1. MessageDigest：用于计算数据的哈希值，常用于密码加密和数据完整性校验。
2. Cipher：核心加密解密类，支持对称加密和非对称加密算法，如AES、RSA等。
3. KeyGenerator：用于生成密钥，支持对称加密密钥的生成。
4. KeyPairGenerator：用于生成非对称加密的密钥对（公钥和私钥）。
5. SecureRandom：生成安全的随机数，常用于初始化向量（IV）或盐值。

对称加密算法实现

对称加密使用相同的密钥进行加密和解密，速度快，适合大量数据加密，Java中常用的对称加密算法包括AES、DES和3DES。

AES加密解密示例

AES（Advanced Encryption Standard）是目前最流行的对称加密算法，以下为AES加密解密的完整实现：

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;
public class AESUtil {
    private static final String ALGORITHM = "AES";
    private static final String TRANSFORMATION = "AES/ECB/PKCS5Padding";
    // 生成AES密钥
    public static String generateKey() throws Exception {
        KeyGenerator keyGenerator = KeyGenerator.getInstance(ALGORITHM);
        keyGenerator.init(128); // AES密钥长度：128/192/256
        SecretKey secretKey = keyGenerator.generateKey();
        return Base64.getEncoder().encodeToString(secretKey.getEncoded());
    }
    // 加密
    public static String encrypt(String data, String key) throws Exception {
        SecretKeySpec secretKeySpec = new SecretKeySpec(Base64.getDecoder().decode(key), ALGORITHM);
        Cipher cipher = Cipher.getInstance(TRANSFORMATION);
        cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);
        byte[] encryptedBytes = cipher.doFinal(data.getBytes());
        return Base64.getEncoder().encodeToString(encryptedBytes);
    }
    // 解密
    public static String decrypt(String encryptedData, String key) throws Exception {
        SecretKeySpec secretKeySpec = new SecretKeySpec(Base64.getDecoder().decode(key), ALGORITHM);
        Cipher cipher = Cipher.getInstance(TRANSFORMATION);
        cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);
        byte[] decryptedBytes = cipher.doFinal(Base64.getDecoder().decode(encryptedData));
        return new String(decryptedBytes);
    }
}

对称加密注意事项

• 密钥管理：对称加密的安全性依赖于密钥的保密，密钥需通过安全渠道传输或存储。
• 模式与填充：AES支持多种加密模式（如ECB、CBC、GCM）和填充方式（如PKCS5Padding、NoPadding），需根据场景选择。
• 初始化向量（IV）：使用CBC模式时，需随机生成IV并随密文传输，确保相同明文加密结果不同。

非对称加密算法实现

非对称加密使用公钥加密、私钥解密（或私钥签名、公钥验证），安全性高，但速度较慢，适合密钥交换或数字签名。

RSA加密解密示例

RSA是最常用的非对称加密算法，以下为Java实现：

import javax.crypto.Cipher;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
public class RSAUtil {
    private static final String ALGORITHM = "RSA";
    // 生成RSA密钥对
    public static KeyPair generateKeyPair() throws Exception {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(ALGORITHM);
        keyPairGenerator.initialize(2048); // RSA密钥长度：1024/2048/3072
        return keyPairGenerator.generateKeyPair();
    }
    // 公钥加密
    public static String encrypt(String data, String publicKey) throws Exception {
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(Base64.getDecoder().decode(publicKey));
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
        PublicKey key = keyFactory.generatePublic(keySpec);
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, key);
        byte[] encryptedBytes = cipher.doFinal(data.getBytes());
        return Base64.getEncoder().encodeToString(encryptedBytes);
    }
    // 私钥解密
    public static String decrypt(String encryptedData, String privateKey) throws Exception {
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(Base64.getDecoder().decode(privateKey));
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
        PrivateKey key = keyFactory.generatePrivate(keySpec);
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, key);
        byte[] decryptedBytes = cipher.doFinal(Base64.getDecoder().decode(encryptedData));
        return new String(decryptedBytes);
    }
}

非对称加密应用场景

• 密钥交换：使用公钥传输对称加密的密钥，再通过对称加密传输数据。
• 数字签名：通过私钥生成签名，公钥验证签名，确保数据完整性和身份认证。

哈希算法与消息认证码

哈希算法将任意长度的数据转换为固定长度的哈希值，常用于密码存储和数据校验，消息认证码（MAC）则结合密钥和哈希算法，确保数据未被篡改。

SHA-256哈希示例

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
public class HashUtil {
    public static String sha256(String data) throws NoSuchAlgorithmException {
        MessageDigest digest = MessageDigest.getInstance("SHA-256");
        byte[] hashBytes = digest.digest(data.getBytes());
        StringBuilder hexString = new StringBuilder();
        for (byte b : hashBytes) {
            hexString.append(String.format("%02x", b));
        }
        return hexString.toString();
    }
}

HMAC示例

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
public class HMACUtil {
    private static final String ALGORITHM = "HmacSHA256";
    public static String generateHMAC(String data, String secret) throws Exception {
        SecretKeySpec keySpec = new SecretKeySpec(secret.getBytes(StandardCharsets.UTF_8), ALGORITHM);
        Mac mac = Mac.getInstance(ALGORITHM);
        mac.init(keySpec);
        byte[] hmacBytes = mac.doFinal(data.getBytes(StandardCharsets.UTF_8));
        return Base64.getEncoder().encodeToString(hmacBytes);
    }
}

加密解密最佳实践

1. 密钥安全：避免硬编码密钥，使用密钥库（KeyStore）或外部密钥管理服务（KMS）。
2. 算法选择：优先使用AES-256、RSA-2048等强加密算法，避免使用已不安全的DES、MD5等。
3. 异常处理：加密解密过程中可能抛出NoSuchAlgorithmException、InvalidKeyException等异常，需妥善处理。
4. 性能优化：对称加密适合大数据量，非对称加密仅用于小数据或密钥交换。

Java通过丰富的加密解密API，为开发者提供了灵活的安全解决方案，从对称加密的AES到非对称加密的RSA，再到哈希算法的SHA-256，开发者可根据实际需求选择合适的算法，在实际应用中，需结合密钥管理、算法选择和异常处理，确保数据安全性和系统稳定性，掌握这些技术,能有效提升Java应用的安全防护能力。