Java常用加密算法详解与实战代码 - 附可直接运行的测试示例

🌷 古之立大事者，不惟有超世之才，亦必有坚忍不拔之志

🎐 个人CSND主页------Micro麦可乐的博客

🐥《Docker实操教程》专栏以最新的Centos版本为基础进行Docker实操教程，入门到实战

🌺《RabbitMQ》专栏19年编写主要介绍使用JAVA开发RabbitMQ的系列教程，从基础知识到项目实战

🌸《设计模式》专栏以实际的生活场景为案例进行讲解，让大家对设计模式有一个更清晰的理解

🌛《开源项目》本专栏主要介绍目前热门的开源项目，带大家快速了解并轻松上手使用

🍎 《前端技术》专栏以实战为主介绍日常开发中前端应用的一些功能以及技巧，均附有完整的代码示例

✨《开发技巧》本专栏包含了各种系统的设计原理以及注意事项，并分享一些日常开发的功能小技巧

💕《Jenkins实战》专栏主要介绍Jenkins+Docker的实战教程，让你快速掌握项目CI/CD，是2024年最新的实战教程

🌞《Spring Boot》专栏主要介绍我们日常工作项目中经常应用到的功能以及技巧，代码样例完整

👍《Spring Security》专栏中我们将逐步深入Spring Security的各个技术细节，带你从入门到精通，全面掌握这一安全技术
如果文章能够给大家带来一定的帮助！欢迎关注、评论互动～

Java常用加密算法详解与实战代码 - 可直接运行的测试示例

• [1. 前言](#1. 前言)
• [2. 加密算法基础分类](#2. 加密算法基础分类)
• • • [2.1 哈希算法](#2.1 哈希算法)
    • [2.2 对称加密算法](#2.2 对称加密算法)
    • [2.3 非对称加密算法](#2.3 非对称加密算法)
    • [2.4 消息认证码（MAC）](#2.4 消息认证码（MAC）)
• [3. 哈希算法](#3. 哈希算法)
• • • [3.1 原理与特点](#3.1 原理与特点)
    • [3.2 Java 示例](#3.2 Java 示例)
• [4. 对称加密算法](#4. 对称加密算法)
• • • [2.1 AES（Advanced Encryption Standard）](#2.1 AES（Advanced Encryption Standard）)
    • [2.2 AES 示例](#2.2 AES 示例)
• [5. 非对称加密算法](#5. 非对称加密算法)
• • • [5.1 RSA算法](#5.1 RSA算法)
    • [5.2 ECC（椭圆曲线加密）](#5.2 ECC（椭圆曲线加密）)
• [6. 消息认证码（HMAC）](#6. 消息认证码（HMAC）)
• [7. 总结](#7. 总结)

1. 前言

在信息安全领域，加密算法是保护数据机密性、完整性和身份认证的核心手段。Java 标准库及第三方框架（如 BouncyCastle）提供了丰富的加解密实现，

这里博主将结合 Java 代码，详细介绍常用的几类加密算法，并给出可直接运行的测试示例，帮助小伙伴们快速上手。

---

2. 加密算法基础分类

2.1 哈希算法

• 特点：单向不可逆，固定长度输出
• 用途：数据完整性验证、密码存储
• 代表算法：MD5、SHA-1、SHA-256、SHA-512

2.2 对称加密算法

• 特点：加密解密使用相同密钥
• 优势：速度快，适合大数据量加密
• 代表算法 ：AES、DES、3DES、RC4

2.3 非对称加密算法

• 特点：公钥加密，私钥解密
• 优势：安全性高，解决密钥分发问题
• 代表算法 ：RSA、ECC、DSA

2.4 消息认证码（MAC）

• 特点：带密钥的哈希函数
• 用途：验证消息完整性和来源
• 代表算法 ：HMAC

---

3. 哈希算法

3.1 原理与特点

Hash（摘要）：将任意长度的数据"压缩"成定长的输出，常用于数据完整性校验。

不可逆：无法从摘要反向推算原文；对抗碰撞攻击（不同输入产生相同输出）是设计目标之一。

3.2 Java 示例

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

public class HashUtils {

    public static String hash(String input, String algorithm) {
        try {
            MessageDigest md = MessageDigest.getInstance(algorithm);
            byte[] digest = md.digest(input.getBytes());
            // 转为十六进制
            StringBuilder sb = new StringBuilder();
            for (byte b : digest) {
                sb.append(String.format("%02x", b & 0xff));
            }
            return sb.toString();
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException("Unknown algorithm: " + algorithm, e);
        }
    }

    // 测试主函数
    public static void main(String[] args) {
        String text = "HelloWorld";
        System.out.println("MD5:    " + hash(text, "MD5"));
        System.out.println("SHA-1:  " + hash(text, "SHA-1"));
        System.out.println("SHA-256:" + hash(text, "SHA-256"));
    }
}

运行后，你将看到三种摘要值，验证不同算法的输出长度和差异。

---

4. 对称加密算法

对称加密使用同一个密钥进行加解密，速度快，适合大数据量场景。

由于 DES 已较为过时，不推荐在新项目中使用，这里就不做DES介绍了，下面主要讲解一下AES

2.1 AES（Advanced Encryption Standard）

密钥长度：128/192/256 位

模式：ECB（电子密码本）、CBC（密码分组链接）等；CBC 更安全但需 IV

2.2 AES 示例

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.IvParameterSpec;
import java.util.Base64;

public class AESUtils {

    // 生成 AES 密钥
    public static SecretKey genKey(int keySize) throws Exception {
        KeyGenerator kg = KeyGenerator.getInstance("AES");
        kg.init(keySize);
        return kg.generateKey();
    }

    // 加密
    public static String encrypt(String plaintext, SecretKey key, IvParameterSpec iv) throws Exception {
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        cipher.init(Cipher.ENCRYPT_MODE, key, iv);
        byte[] encrypted = cipher.doFinal(plaintext.getBytes());
        return Base64.getEncoder().encodeToString(encrypted);
    }

    // 解密
    public static String decrypt(String ciphertext, SecretKey key, IvParameterSpec iv) throws Exception {
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        cipher.init(Cipher.DECRYPT_MODE, key, iv);
        byte[] decoded = Base64.getDecoder().decode(ciphertext);
        byte[] decrypted = cipher.doFinal(decoded);
        return new String(decrypted);
    }

    public static void main(String[] args) throws Exception {
        String text = "SecretMessage";
        SecretKey key = genKey(128);
        // 随机 IV，也可使用固定 IV（不推荐）
        byte[] ivBytes = new byte[16];
        System.arraycopy("RandomInitVector".getBytes(), 0, ivBytes, 0, 16);
        IvParameterSpec iv = new IvParameterSpec(ivBytes);

        String cipherText = encrypt(text, key, iv);
        String plainText = decrypt(cipherText, key, iv);

        System.out.println("原文: " + text);
        System.out.println("加密: " + cipherText);
        System.out.println("解密: " + plainText);
    }
}

---

5. 非对称加密算法

5.1 RSA算法

算法特点：

基于大数分解难题

密钥长度：1024-4096位

用途：数字签名、密钥交换

import javax.crypto.Cipher;
import java.nio.charset.StandardCharsets;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;

public class RSAExample {
    public static void main(String[] args) throws Exception {
        String plainText = "Java非对称加密算法";
        
        // 生成密钥对
        KeyPair keyPair = generateRSAKeyPair();
        PublicKey publicKey = keyPair.getPublic();
        PrivateKey privateKey = keyPair.getPrivate();
        
        // 公钥加密
        byte[] cipherText = encryptRSA(plainText, publicKey);
        System.out.println("RSA加密结果: " + Base64.getEncoder().encodeToString(cipherText));
        
        // 私钥解密
        String decryptedText = decryptRSA(cipherText, privateKey);
        System.out.println("RSA解密结果: " + decryptedText);
        
        // 数字签名示例
        byte[] signature = signData(plainText, privateKey);
        boolean isValid = verifySignature(plainText, signature, publicKey);
        System.out.println("签名验证结果: " + isValid);
    }

    public static KeyPair generateRSAKeyPair() throws Exception {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        keyPairGenerator.initialize(2048); // 密钥长度
        return keyPairGenerator.generateKeyPair();
    }

    public static byte[] encryptRSA(String plainText, PublicKey publicKey) throws Exception {
        Cipher cipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        return cipher.doFinal(plainText.getBytes(StandardCharsets.UTF_8));
    }

    public static String decryptRSA(byte[] cipherText, PrivateKey privateKey) throws Exception {
        Cipher cipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding");
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        byte[] decryptedBytes = cipher.doFinal(cipherText);
        return new String(decryptedBytes, StandardCharsets.UTF_8);
    }

    public static byte[] signData(String data, PrivateKey privateKey) throws Exception {
        Signature signature = Signature.getInstance("SHA256withRSA");
        signature.initSign(privateKey);
        signature.update(data.getBytes(StandardCharsets.UTF_8));
        return signature.sign();
    }

    public static boolean verifySignature(String data, byte[] signatureBytes, PublicKey publicKey) throws Exception {
        Signature signature = Signature.getInstance("SHA256withRSA");
        signature.initVerify(publicKey);
        signature.update(data.getBytes(StandardCharsets.UTF_8));
        return signature.verify(signatureBytes);
    }
}

5.2 ECC（椭圆曲线加密）

算法特点：

同等安全强度下密钥更短

计算效率高

适合移动设备

import java.nio.charset.StandardCharsets;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;

public class ECCExample {
    public static void main(String[] args) throws Exception {
        String plainText = "Java椭圆曲线加密";
        
        // 生成密钥对
        KeyPair keyPair = generateECCKeyPair();
        PublicKey publicKey = keyPair.getPublic();
        PrivateKey privateKey = keyPair.getPrivate();
        
        // 密钥序列化/反序列化演示
        String pubKeyStr = Base64.getEncoder().encodeToString(publicKey.getEncoded());
        String priKeyStr = Base64.getEncoder().encodeToString(privateKey.getEncoded());
        
        // 从字符串恢复密钥
        PublicKey restoredPubKey = restoreECCPublicKey(pubKeyStr);
        PrivateKey restoredPriKey = restoreECCPrivateKey(priKeyStr);
        
        // 数字签名
        byte[] signature = signDataECC(plainText, restoredPriKey);
        boolean isValid = verifySignatureECC(plainText, signature, restoredPubKey);
        System.out.println("ECC签名验证结果: " + isValid);
    }

    public static KeyPair generateECCKeyPair() throws Exception {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("EC");
        keyPairGenerator.initialize(256); // 密钥长度
        return keyPairGenerator.generateKeyPair();
    }

    public static PublicKey restoreECCPublicKey(String keyStr) throws Exception {
        byte[] keyBytes = Base64.getDecoder().decode(keyStr);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("EC");
        return keyFactory.generatePublic(keySpec);
    }

    public static PrivateKey restoreECCPrivateKey(String keyStr) throws Exception {
        byte[] keyBytes = Base64.getDecoder().decode(keyStr);
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("EC");
        return keyFactory.generatePrivate(keySpec);
    }

    public static byte[] signDataECC(String data, PrivateKey privateKey) throws Exception {
        Signature signature = Signature.getInstance("SHA256withECDSA");
        signature.initSign(privateKey);
        signature.update(data.getBytes(StandardCharsets.UTF_8));
        return signature.sign();
    }

    public static boolean verifySignatureECC(String data, byte[] signatureBytes, PublicKey publicKey) throws Exception {
        Signature signature = Signature.getInstance("SHA256withECDSA");
        signature.initVerify(publicKey);
        signature.update(data.getBytes(StandardCharsets.UTF_8));
        return signature.verify(signatureBytes);
    }
}

---

6. 消息认证码（HMAC）

HMAC 用于验证数据完整性及认证，结合了 Hash 与密钥。

算法特点：

输入：密钥 + 消息 → 通过 Hash 计算，输出固定长度摘要。

常见算法：HmacMD5、HmacSHA1、HmacSHA256

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.Base64;

public class HMACExample {
    public static void main(String[] args) throws Exception {
        String message = "重要业务数据";
        String secretKey = "MySecretKey123";
        
        // 计算HMAC
        String hmac = calculateHMAC(message, secretKey);
        System.out.println("HMAC-SHA256: " + hmac);
        
        // 验证消息完整性
        String receivedMessage = "重要业务数据";
        String receivedHmac = calculateHMAC(receivedMessage, secretKey);
        System.out.println("HMAC验证结果: " + hmac.equals(receivedHmac));
    }

    public static String calculateHMAC(String data, String key) 
            throws NoSuchAlgorithmException, InvalidKeyException {
        Mac sha256Hmac = Mac.getInstance("HmacSHA256");
        SecretKeySpec secretKey = new SecretKeySpec(
            key.getBytes(StandardCharsets.UTF_8), 
            "HmacSHA256"
        );
        sha256Hmac.init(secretKey);
        byte[] hmacBytes = sha256Hmac.doFinal(data.getBytes(StandardCharsets.UTF_8));
        return Base64.getEncoder().encodeToString(hmacBytes);
    }
}

---

7. 总结

本文博主介绍了四大类经典加密算法在 Java 中的实现方式：

• 哈希算法：MD5、SHA-1、SHA-256，用于数据完整性校验；
• 对称加密：AES、DES，适合大数据量加密；
• 非对称加密：RSA，实现密钥交换和数字签名；
• 消息认证码：HMAC，用于完整性与认证。

在生产环境中，建议优先选用 AES（至少 128 位）、SHA-256、RSA 2048 位以上，并严格管理密钥和 IV，以确保安全性。希望本文能帮助小伙伴快速掌握 Java 加密实战！

如果你在实践过程中有任何疑问或更好的扩展思路，欢迎在评论区留言，最后希望大家 一键三连 给博主一点点鼓励！

---