Java Cipher类深度解析：从AES/RSA原理到实战避坑指南

1. 项目概述：为什么需要深入了解Cipher类？

在Java开发中，数据安全是一个绕不开的话题。无论是用户密码的存储、敏感配置信息的保护，还是网络传输数据的防窃听，加密都是最核心的技术手段之一。你可能用过MD5、SHA-256这样的哈希算法，或者听说过AES、RSA这些加密算法的名字。但在Java的标准库中，javax.crypto.Cipher类才是实现这些加密和解密操作的“总指挥”。它提供了一个统一的、强大的API，让我们能够以相对标准化的方式调用各种加密算法。

很多开发者，尤其是刚接触安全领域的，常常会陷入一些误区：比如认为调用一个MD5工具类就是加密的全部，或者在网上拷贝一段AES代码却对其中Cipher.getInstance(“AES/CBC/PKCS5Padding”)这一长串参数的含义一知半解。结果就是，要么实现的加密强度不足，要么在遇到BadPaddingException、IllegalBlockSizeException这类异常时束手无策。理解Cipher类，不仅仅是学会调用几个方法，更是理解现代密码学在Java中的工程化实践。它能让你从“会用”进阶到“懂原理”，在面对java面试中关于加密的八股文时，也能从容不迫地讲出CBC模式和ECB模式的区别，而不是仅仅背出AES的密钥长度。

这篇文章，我将从一个有十多年经验的开发者视角，带你彻底拆解Cipher类。我们会从最基础的加密模式、填充方式讲起，手把手实现AES和RSA的加解密，并深入那些容易踩坑的细节，比如IV（初始化向量）的管理、密钥的生成与存储、以及如何应对常见的异常。目标很明确：让你不仅能写出能跑的加密代码，更能写出安全、健壮、易于维护的加密代码。

2. 加密基础与Cipher类核心设计解析

在直接敲代码之前，我们必须先打好地基。Cipher类的设计哲学是“引擎”模式，它本身不实现具体的加密算法，而是作为一个统一的接口，背后通过JCA（Java Cryptography Architecture）来调用具体的算法实现，比如SunJCE提供者。这种设计让代码非常灵活，你更换算法时通常只需要改一个字符串参数。

2.1 理解算法、模式与填充：AES/CBC/PKCS5Padding到底在说什么？

当你调用Cipher.getInstance(“AES/CBC/PKCS5Padding”)时，这个字符串包含了三个关键部分，用“/”分隔：

1. 算法（Algorithm）：AES。这是加密的核心算法，决定了加密的数学原理和基本强度。常见的还有DES（已不安全）、RSA（非对称）、Blowfish等。
2. 模式（Mode）：CBC。这是分组密码的工作模式。因为像AES这种算法是一次处理固定长度（如128位）的数据块，模式定义了如何对超过一个块的数据进行加密。
   • ECB（Electronic Codebook）：最简单的模式，相同的明文块加密后得到相同的密文块。绝对不要用于加密有规律的数据，因为它无法隐藏数据模式。想象一张图片用ECB加密后，轮廓依然可见。
   • CBC（Cipher Block Chaining）：每个明文块先与前一个密文块进行异或操作，然后再加密。这需要第一个块有一个初始向量IV。它能很好地隐藏模式，是最常用的分组加密模式之一。
   • 其他模式：如CFB、OFB、CTR等，各有特点，例如CTR模式可以将分组密码转换为流密码，便于并行计算。
3. 填充（Padding）：PKCS5Padding。由于分组加密需要数据长度是块的整数倍，当最后一块数据不足时，就需要进行填充。
   • PKCS5Padding（或PKCS7Padding）：最常用的填充方式。例如，块大小16字节，最后剩3字节，则会填充13个字节的0x0D（十进制13）。
   • NoPadding：不填充。使用此选项时，你必须确保待加密数据的长度恰好是块的整数倍，否则会抛出异常。

注意：在Java中，PKCS5Padding和PKCS7Padding在AES的上下文中通常被视为同义词，因为PKCS#5标准最初是为8字节块设计的，而PKCS#7支持1到255字节的块。但指定时最好使用PKCS5Padding，因为这是JCA的标准名称。

为什么模式如此重要？举个简单例子，如果你用ECB模式加密一个数据库密码字段，而所有用户的密码长度相同，那么攻击者通过观察密文，就能轻易判断出哪些用户的密码是相同的，这严重削弱了加密的安全性。而CBC模式由于引入了IV，即使相同的明文，每次加密也会产生完全不同的密文。

2.2 Cipher对象的核心生命周期：初始化、更新、完成

Cipher对象的操作遵循一个清晰的流程，对应三个核心方法：

1. init(int opmode, Key key)：初始化。这是最关键的一步。

   • opmode：指定是加密还是解密，取值为Cipher.ENCRYPT_MODE或Cipher.DECRYPT_MODE。
   • key：加密密钥。对于AES，是SecretKey；对于RSA，是PublicKey（加密）或PrivateKey（解密）。
   • 对于需要IV的模式（如CBC），你还需要传入一个IvParameterSpec对象，通常通过init(int opmode, Key key, AlgorithmParameterSpec params)这个重载方法。

2. update(byte[] input)：处理数据。对于大文件或流数据，你可以分多次调用update方法传入数据，它返回已处理的部分结果。这对于内存敏感的场景非常有用。

3. doFinal()：结束处理。执行最后的加密或解密操作，并处理可能存在的填充。对于一次性处理所有数据的情况，可以直接调用doFinal(byte[] input)，它等价于update后接doFinal。

一个常见的误解：很多人以为doFinal只是获取结果。实际上，它包含了“完成”操作，比如添加或验证填充。如果你在解密时忘记调用doFinal，或者数据被篡改导致填充验证失败，就会抛出BadPaddingException。

3. 对称加密实战：以AES为例

对称加密意味着加密和解密使用同一把密钥。AES是目前最主流、最安全的对称加密算法。我们来一步步实现一个完整的AES/CBC/PKCS5Padding加密示例。

3.1 密钥生成与安全存储

密钥是加密的命门。绝对不能把密钥硬编码在代码里！

import javax.crypto.KeyGenerator; import javax.crypto.SecretKey; import java.security.NoSuchAlgorithmException; import java.util.Base64; public class AESKeyDemo { public static void main(String[] args) throws NoSuchAlgorithmException { // 1. 获取KeyGenerator实例，指定算法为AES KeyGenerator keyGen = KeyGenerator.getInstance("AES"); // 2. 初始化密钥生成器，指定密钥长度（128, 192, 256位） // 256位强度最高，但某些早期JDK或受限环境可能不支持，需安装JCE无限强度策略文件 keyGen.init(256); // 3. 生成密钥 SecretKey secretKey = keyGen.generateKey(); // 4. 获取密钥的字节数组，可以将其Base64编码后存储 byte[] keyBytes = secretKey.getEncoded(); String base64Key = Base64.getEncoder().encodeToString(keyBytes); System.out.println("生成的AES密钥 (Base64): " + base64Key); // 从Base64字符串恢复密钥 byte[] decodedKey = Base64.getDecoder().decode(base64Key); // 使用SecretKeySpec从字节数组重建密钥对象 javax.crypto.spec.SecretKeySpec keySpec = new javax.crypto.spec.SecretKeySpec(decodedKey, "AES"); } }

实操心得：

• 密钥长度：无特殊要求，优先使用256位。检查你的运行环境是否支持，如果遇到Illegal key size异常，需要从Oracle官网下载并安装Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files，替换JRE_HOME/lib/security下的两个jar包。
• 密钥存储：生产环境中，绝对不要像上面那样打印或写在配置文件明文里。应该使用专门的密钥管理系统（如HashiCorp Vault、AWS KMS），或者至少将加密后的密钥存储在环境变量、受权限严格保护的文件中。

3.2 完整的AES/CBC加密与解密实现

下面是一个包含IV生成和管理的完整工具类示例。IV对于CBC模式至关重要，它不需要保密，但必须不可预测，且每次加密都应使用不同的IV。

import javax.crypto.Cipher; import javax.crypto.SecretKey; import javax.crypto.spec.IvParameterSpec; import javax.crypto.spec.SecretKeySpec; import java.security.SecureRandom; import java.util.Base64; public class AesCbcUtil { private static final String ALGORITHM = "AES"; private static final String TRANSFORMATION = "AES/CBC/PKCS5Padding"; private static final int IV_SIZE = 16; // AES块大小是16字节，IV长度需与块大小一致 /** * 加密 * @param plaintext 明文 * @param base64Key Base64编码的密钥 * @return Base64编码的字符串，格式为 “IV:密文” */ public static String encrypt(String plaintext, String base64Key) throws Exception { // 1. 恢复密钥 byte[] keyBytes = Base64.getDecoder().decode(base64Key); SecretKey secretKey = new SecretKeySpec(keyBytes, ALGORITHM); // 2. 生成随机IV byte[] iv = new byte[IV_SIZE]; SecureRandom random = new SecureRandom(); // 务必使用SecureRandom，不要用Random random.nextBytes(iv); IvParameterSpec ivSpec = new IvParameterSpec(iv); // 3. 初始化Cipher为加密模式 Cipher cipher = Cipher.getInstance(TRANSFORMATION); cipher.init(Cipher.ENCRYPT_MODE, secretKey, ivSpec); // 4. 执行加密 byte[] plaintextBytes = plaintext.getBytes(java.nio.charset.StandardCharsets.UTF_8); byte[] ciphertextBytes = cipher.doFinal(plaintextBytes); // 5. 将IV和密文一起编码返回。IV不需要保密，但解密方必须知道。 String ivBase64 = Base64.getEncoder().encodeToString(iv); String ciphertextBase64 = Base64.getEncoder().encodeToString(ciphertextBytes); return ivBase64 + ":" + ciphertextBase64; } /** * 解密 * @param encryptedText 加密后的字符串，格式为 “IV:密文” * @param base64Key Base64编码的密钥 * @return 明文 */ public static String decrypt(String encryptedText, String base64Key) throws Exception { // 1. 分割IV和密文 String[] parts = encryptedText.split(":"); if (parts.length != 2) { throw new IllegalArgumentException("Invalid encrypted text format"); } byte[] iv = Base64.getDecoder().decode(parts[0]); byte[] ciphertextBytes = Base64.getDecoder().decode(parts[1]); // 2. 恢复密钥 byte[] keyBytes = Base64.getDecoder().decode(base64Key); SecretKey secretKey = new SecretKeySpec(keyBytes, ALGORITHM); // 3. 初始化Cipher为解密模式，传入相同的IV Cipher cipher = Cipher.getInstance(TRANSFORMATION); IvParameterSpec ivSpec = new IvParameterSpec(iv); cipher.init(Cipher.DECRYPT_MODE, secretKey, ivSpec); // 4. 执行解密 byte[] plaintextBytes = cipher.doFinal(ciphertextBytes); return new String(plaintextBytes, java.nio.charset.StandardCharsets.UTF_8); } // 测试 public static void main(String[] args) throws Exception { // 生成一个测试密钥（实际应从安全的地方获取） javax.crypto.KeyGenerator keyGen = KeyGenerator.getInstance(ALGORITHM); keyGen.init(256); SecretKey sk = keyGen.generateKey(); String base64Key = Base64.getEncoder().encodeToString(sk.getEncoded()); String originalText = "这是一段需要加密的敏感数据，比如密码或身份证号。"; System.out.println("原文: " + originalText); String encrypted = encrypt(originalText, base64Key); System.out.println("加密后 (IV:密文): " + encrypted); String decrypted = decrypt(encrypted, base64Key); System.out.println("解密后: " + decrypted); System.out.println("解密是否成功: " + originalText.equals(decrypted)); } }

关键点解析：

1. SecureRandom：生成IV（和密钥）时，必须使用SecureRandom，而不是java.util.Random。后者是伪随机数，可预测，会严重破坏加密安全性。
2. IV的管理：IV不需要保密，但必须唯一且不可预测。常见的做法是将其与密文拼接在一起存储或传输（如本例中的IV:密文格式）。解密时，先提取IV。
3. 字符编码：在将字符串转换为字节数组（getBytes()）和反向转换（new String()）时，务必显式指定字符编码，如UTF-8。使用平台默认编码是导致跨系统乱码的常见根源。
4. 异常处理：doFinal可能抛出BadPaddingException、IllegalBlockSizeException等。在真实应用中，不应像示例这样直接抛出，而应进行适当的日志记录和用户友好的错误处理，但注意不要将详细的异常信息（如堆栈跟踪）暴露给最终用户，以免泄露系统信息。

4. 非对称加密实战：以RSA为例

非对称加密使用一对密钥：公钥（Public Key）和私钥（Private Key）。公钥加密的数据，只有对应的私钥才能解密；私钥加密（签名）的数据，可以用公钥验证。RSA是最常用的非对称算法。

4.1 密钥对生成与格式

import java.security.*; import java.util.Base64; public class RSAKeyPairGenerator { public static void main(String[] args) throws NoSuchAlgorithmException { // 1. 获取KeyPairGenerator实例，指定算法为RSA KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA"); // 2. 初始化密钥对生成器，指定密钥长度（推荐至少2048位，1024位已不安全） keyPairGen.initialize(2048); // 3. 生成密钥对 KeyPair keyPair = keyPairGen.generateKeyPair(); PublicKey publicKey = keyPair.getPublic(); PrivateKey privateKey = keyPair.getPrivate(); // 4. 获取Base64编码的密钥字符串（便于存储或传输） String publicKeyBase64 = Base64.getEncoder().encodeToString(publicKey.getEncoded()); String privateKeyBase64 = Base64.getEncoder().encodeToString(privateKey.getEncoded()); System.out.println("===== 公钥 ====="); System.out.println(publicKeyBase64); System.out.println("\n===== 私钥 ====="); System.out.println(privateKeyBase64); // 注意：直接getEncoded()得到的是PKCS#8格式的字节码。 // 有时需要PEM格式（带BEGIN/END标签），需要额外处理。 } }

4.2 RSA加密解密的限制与分段处理

RSA算法有一个重要特点：它加密的数据长度受密钥长度限制。对于2048位的密钥，其模长（modulus）是256字节。但因为填充（如OAEPPadding）会占用一部分空间，所以实际能加密的明文长度更短（例如，使用RSA/ECB/OAEPWithSHA-256AndMGF1Padding时，明文长度需小于等于190字节左右）。

这意味着，如果要加密的数据（比如一个文件）超过这个长度，就必须进行分段加密。同样，解密时也需要分段解密。

import javax.crypto.Cipher; import java.security.*; import java.util.Base64; public class RsaUtil { private static final String TRANSFORMATION = "RSA/ECB/OAEPWithSHA-256AndMGF1Padding"; // 推荐使用OAEP填充，比PKCS1v1.5更安全 /** * 公钥加密（支持长文本分段加密） */ public static String encryptWithPublicKey(String plaintext, PublicKey publicKey) throws Exception { Cipher cipher = Cipher.getInstance(TRANSFORMATION); cipher.init(Cipher.ENCRYPT_MODE, publicKey); byte[] plaintextBytes = plaintext.getBytes(java.nio.charset.StandardCharsets.UTF_8); int keySize = 2048; // 假设密钥是2048位 int blockSize = keySize / 8 - 42; // 估算，OAEP填充开销约42字节。更准确需动态计算。 // 实际工程中，应通过cipher.getBlockSize()获取最大加密块大小。 int numBlocks = (int) Math.ceil((double) plaintextBytes.length / blockSize); byte[] encryptedBytes = new byte[numBlocks * (keySize / 8)]; // 每段加密后长度固定为密钥字节长度 int encryptedPos = 0; for (int i = 0; i < numBlocks; i++) { int start = i * blockSize; int end = Math.min(start + blockSize, plaintextBytes.length); byte[] block = new byte[end - start]; System.arraycopy(plaintextBytes, start, block, 0, block.length); byte[] encryptedBlock = cipher.doFinal(block); System.arraycopy(encryptedBlock, 0, encryptedBytes, encryptedPos, encryptedBlock.length); encryptedPos += encryptedBlock.length; } // 如果加密块数大于1，需要处理加密后字节数组的长度可能小于预分配长度的情况 if (encryptedPos < encryptedBytes.length) { byte[] trimmed = new byte[encryptedPos]; System.arraycopy(encryptedBytes, 0, trimmed, 0, encryptedPos); encryptedBytes = trimmed; } return Base64.getEncoder().encodeToString(encryptedBytes); } /** * 私钥解密（支持分段解密） */ public static String decryptWithPrivateKey(String base64Ciphertext, PrivateKey privateKey) throws Exception { Cipher cipher = Cipher.getInstance(TRANSFORMATION); cipher.init(Cipher.DECRYPT_MODE, privateKey); byte[] encryptedBytes = Base64.getDecoder().decode(base64Ciphertext); int keySize = 2048; int blockSize = keySize / 8; // RSA解密时，每段的输入长度固定为密钥字节长度 int numBlocks = (int) Math.ceil((double) encryptedBytes.length / blockSize); StringBuilder plaintextBuilder = new StringBuilder(); for (int i = 0; i < numBlocks; i++) { int start = i * blockSize; int end = Math.min(start + blockSize, encryptedBytes.length); byte[] block = new byte[end - start]; System.arraycopy(encryptedBytes, start, block, 0, block.length); byte[] decryptedBlock = cipher.doFinal(block); plaintextBuilder.append(new String(decryptedBlock, java.nio.charset.StandardCharsets.UTF_8)); } return plaintextBuilder.toString(); } // 更常见的用法：公钥加密，私钥解密（用于传输加密密钥） // 以及私钥签名，公钥验签（用于身份验证和数据完整性） }

重要提示：上述分段逻辑是一个简化示例。在实际生产中，直接使用RSA加密大量数据效率很低且复杂。更标准的做法是采用“混合加密”：

1. 生成一个随机的对称密钥（如AES密钥）。
2. 使用这个对称密钥加密实际的数据（高效）。
3. 使用接收方的RSA公钥加密这个对称密钥。
4. 将加密后的对称密钥和加密后的数据一起发送给对方。
5. 对方用自己的RSA私钥解密出对称密钥，再用对称密钥解密数据。

Cipher类同样可以完美支持这种模式，你只需要分别初始化AES和RSA的Cipher实例即可。

5. 常见问题、异常排查与实战心得

即使理解了原理，在实际使用Cipher时，你几乎一定会遇到各种异常。下面我整理了一份“避坑指南”。

5.1 典型异常与解决方案速查表

5.2 实战中的经验与技巧

1. 选择正确的填充和模式：

   • 对称加密：优先选择AES/CBC/PKCS5Padding或更安全的AES/GCM/NoPadding（GCM模式同时提供加密和认证，但使用更复杂）。避免使用ECB模式。
   • 非对称加密：优先选择RSA/ECB/OAEPWithSHA-256AndMGF1Padding，它比旧的PKCS1Padding更能抵抗选择密文攻击。

2. 管理好你的IV和密钥：

   • IV：对于CBC、CFB等模式，每次加密必须使用一个密码学安全随机数生成的、唯一的IV。可以将IV与密文一起存储。
   • 密钥：对称密钥的保密性至关重要。考虑使用硬件安全模块（HSM）或云服务商的密钥管理服务（KMS）。在代码中，至少要从安全的环境变量或配置中心获取，而不是硬编码。

3. 处理大文件或流数据： 使用Cipher的update(byte[] input)和doFinal()方法进行流式处理，避免一次性将整个文件加载到内存。

   Cipher cipher = Cipher.getInstance(“AES/CBC/PKCS5Padding”); cipher.init(Cipher.ENCRYPT_MODE, secretKey, ivSpec); try (InputStream in = new FileInputStream(“input.txt”); OutputStream out = new FileOutputStream(“encrypted.bin”); CipherOutputStream cos = new CipherOutputStream(out, cipher)) { byte[] buffer = new byte[8192]; int bytesRead; while ((bytesRead = in.read(buffer)) != -1) { cos.write(buffer, 0, bytesRead); // CipherOutputStream会自动调用update/doFinal } } // 流关闭时会自动调用doFinal完成加密

4. 关于线程安全：Cipher对象本身不是线程安全的。最佳实践是为每个线程或每次加密/解密操作创建新的Cipher实例，或者使用ThreadLocal进行缓存。初始化（init）是一个相对昂贵的操作，但为了正确性，不应在多线程间共享一个已初始化的Cipher实例。

5. 不要自己发明加密算法： 这是一个基本原则。始终使用经过广泛审查和测试的标准算法（如AES、RSA）和库（Java自带的JCA/JCE）。自己实现的“加密”几乎必然存在漏洞。

6. 性能考量：

   • 对称加密（AES）速度非常快，适合加密大量数据。
   • 非对称加密（RSA）速度慢几个数量级，仅适用于加密小数据（如密钥）或签名。
   • 在需要同时加密和认证大量数据时，AES-GCM模式是性能与安全俱佳的选择。

6. 进阶话题：探索其他模式与算法

掌握了基础之后，你可以根据需求探索Cipher支持的其他强大功能。

6.1 认证加密模式：AES-GCM

GCM（Galois/Counter Mode）是一种同时提供加密和完整性认证的模式。它不需要额外的填充，且效率很高。

import javax.crypto.*; import javax.crypto.spec.GCMParameterSpec; import javax.crypto.spec.SecretKeySpec; import java.security.SecureRandom; import java.util.Base64; public class AesGcmUtil { private static final String ALGORITHM = “AES”; private static final String TRANSFORMATION = “AES/GCM/NoPadding”; private static final int TAG_LENGTH_BIT = 128; // 认证标签长度，可以是128, 120, 112, 104, 96位 private static final int IV_LENGTH_BYTE = 12; // GCM推荐使用12字节的IV public static String encrypt(String plaintext, String base64Key) throws Exception { byte[] keyBytes = Base64.getDecoder().decode(base64Key); SecretKey key = new SecretKeySpec(keyBytes, ALGORITHM); byte[] iv = new byte[IV_LENGTH_BYTE]; new SecureRandom().nextBytes(iv); Cipher cipher = Cipher.getInstance(TRANSFORMATION); GCMParameterSpec parameterSpec = new GCMParameterSpec(TAG_LENGTH_BIT, iv); cipher.init(Cipher.ENCRYPT_MODE, key, parameterSpec); byte[] ciphertext = cipher.doFinal(plaintext.getBytes(java.nio.charset.StandardCharsets.UTF_8)); // 同样，将IV和密文拼接 return Base64.getEncoder().encodeToString(iv) + “:” + Base64.getEncoder().encodeToString(ciphertext); } public static String decrypt(String encryptedText, String base64Key) throws Exception { String[] parts = encryptedText.split(“:”); byte[] iv = Base64.getDecoder().decode(parts[0]); byte[] ciphertext = Base64.getDecoder().decode(parts[1]); byte[] keyBytes = Base64.getDecoder().decode(base64Key); SecretKey key = new SecretKeySpec(keyBytes, ALGORITHM); Cipher cipher = Cipher.getInstance(TRANSFORMATION); GCMParameterSpec parameterSpec = new GCMParameterSpec(TAG_LENGTH_BIT, iv); cipher.init(Cipher.DECRYPT_MODE, key, parameterSpec); byte[] plaintext = cipher.doFinal(ciphertext); return new String(plaintext, java.nio.charset.StandardCharsets.UTF_8); } }

使用GCM时，解密过程会自动验证数据的完整性。如果密文或IV被篡改，doFinal方法会抛出AEADBadTagException，这比CBC模式（可能只产生乱码）安全得多。

6.2 国密算法集成

在一些特定领域，可能需要使用国密算法（如SM2, SM3, SM4）。Java标准库默认不包含这些算法。你需要引入Bouncy Castle这样的第三方安全提供者。

1. 添加依赖（Maven）：

   <dependency> <groupId>org.bouncycastle</groupId> <artifactId>bcprov-jdk15on</artifactId> <version>1.70</version> <!-- 使用最新版本 --> </dependency>

2. 注册提供者并使用：

   import org.bouncycastle.jce.provider.BouncyCastleProvider; import javax.crypto.Cipher; import java.security.Security; public class Sm4Example { static { // 在程序启动时注册BouncyCastle提供者 Security.addProvider(new BouncyCastleProvider()); } public void encryptWithSM4() throws Exception { // 算法名称变为“SM4”，其他使用方式与AES类似 Cipher cipher = Cipher.getInstance(“SM4/CBC/PKCS5Padding”, “BC”); // 指定提供者“BC” // ... 后续初始化、加密步骤与AES相同 } }

7. 总结与最佳实践清单

走到这里，你已经从“知道怎么调用Cipher.encrypt”升级到了“理解并能在生产环境中安全地使用加密”。最后，我把自己多年实践中总结的几条铁律分享给你，希望能帮你避开大多数坑：

1. 明确需求：先想清楚你需要的是机密性（加密）、完整性（签名/MAC）还是两者都要（如GCM）。不要盲目选择算法。
2. 密钥管理是核心：加密系统的安全性不取决于算法是否保密，而取决于密钥是否安全。花至少和选择算法一样多的精力在密钥的生成、存储、轮换和销毁上。
3. 使用经过验证的库和模式：坚持使用Java标准库（JCA/JCE）或像Bouncy Castle这样广泛审计的库。使用推荐的模式（如CBC、GCM）和填充（如OAEP）。
4. 永远使用密码学安全的随机数：SecureRandom是你的朋友，Math.random()或Random类是你的敌人，尤其是在生成密钥和IV时。
5. 处理好IV：对于需要IV的模式，确保每次加密使用唯一的、随机的IV，并将其与密文一起安全地存储或传输。
6. 注意编码：在字节和字符串之间转换时，始终明确指定字符编码（UTF-8）。
7. 考虑性能与兼容性：对称加密处理大数据，非对称加密处理小数据或密钥。确保你的加密方案在所有目标系统（客户端/服务器，不同JDK版本）上都能正常工作。
8. 充分测试异常流：模拟密钥错误、密文篡改、数据长度异常等情况，确保你的程序能优雅地处理BadPaddingException等异常，而不是崩溃或暴露内部信息。

加密是一门实践性极强的学问，Cipher类提供了强大而灵活的工具。理解其背后的原理，严格遵守安全规范，你就能构建出真正坚固的数据安全防线。如果在实际操作中遇到诡异的问题，回头来检查这份清单，很可能就能找到答案。