1. 项目概述：为什么我们需要 Hutool 来简化 AES 加密？

如果你是一名 Java 开发者，并且需要在项目中处理数据加密，那么 AES 这个名字你一定不陌生。高级加密标准，作为目前最主流的对称加密算法，它安全、高效，是保护敏感数据（如用户密码、交易信息、配置文件）的首选。然而，直接使用 Java 原生的 javax.crypto 包进行 AES 加密解密，体验往往一言难尽。你需要处理密钥生成、编码转换、异常捕获，还要面对诸如 NoSuchPaddingException 、 InvalidKeyException 等令人头疼的异常，更别提不同工作模式（如 CBC、ECB）和填充方式（如 PKCS5Padding、PKCS7Padding）的繁琐配置了。

这正是 Hutool 的 Hutool-crypto 模块大显身手的地方。Hutool 是一个小而全的 Java 工具类库，它封装了这些复杂且易错的底层操作，提供了一整套优雅、链式、语义清晰的 API。 SymmetricCrypto 和 AES 等工具类，让你能用一两行代码就完成之前需要十几行甚至几十行才能搞定的加密解密操作。本文将从最基础的 AES 概念讲起，手把手带你通过 Hutool 实现从简单的字符串加密，到应对各种复杂场景（如与前端 CryptoJS 交互、使用国密算法）的高级应用。无论你是刚接触加密的新手，还是被原生 API 折磨过的老鸟，都能在这里找到“开箱即用”的解决方案和避坑指南。

2. AES 加密核心原理与 Hutool 的封装哲学

在深入代码之前，我们有必要快速理解 AES 是什么，以及 Hutool 是如何让它变得“友好”的。

2.1 AES 算法简析：不止是“加密”两个字

AES 是一种 分组密码 算法。你可以把它想象成一个高度复杂的“数字搅拌机”。它把待加密的明文数据，按照固定长度（128位，即16字节）分成一个个“数据块”，然后对每个块进行多轮的混淆和扩散操作。这个过程依赖于一个密钥，密钥的长度决定了加密的强度，常见的有 128位、192位 和 256位。

这里有几个关键概念，直接关系到 Hutool 的 API 设计：

  • 密钥 ：加密和解密的唯一凭证。Hutool 的 SecureUtil.generateKey() 方法帮你安全地生成它。
  • 工作模式 ：定义了如何用同一个密钥加密多个数据块。最常见的是：
    • ECB ：电子密码本模式。每个块独立加密，相同的明文块会产生相同的密文块。 安全性较低，不推荐用于加密有意义的数据 ，但某些简单校验场景可能用到。
    • CBC ：密码分组链接模式。每个明文块在加密前，会先与前一个密文块进行异或操作。这需要一个 初始化向量 来启动第一个块的加密。 这是目前最常用、推荐默认使用的模式 ，安全性高。
  • 填充模式 ：因为明文长度不一定正好是分组长度的整数倍，所以需要对最后一个块进行填充。常见的有 PKCS5Padding / PKCS7Padding （两者在 AES 语境下通常等价）。
  • 初始化向量 ：一个随机数，用于 CBC 等模式，确保即使相同的明文和密钥，每次加密也会产生不同的密文，增强安全性。

2.2 Hutool-crypto 的设计理念：化繁为简

Java 原生的 Cipher 类需要你一步步设置： Cipher.getInstance(“AES/CBC/PKCS5Padding”) -> cipher.init(Cipher.ENCRYPT_MODE, keySpec, ivParameterSpec) -> cipher.doFinal(data) 。任何一步配置错误都会抛出晦涩的异常。

Hutool 的 SymmetricCrypto 类将这些步骤全部封装。它的核心思想是：

  1. 一站式构建 ：通过一个构造方法，传入算法、密钥、（可选的）IV，内部帮你完成所有 Cipher 的初始化和配置。
  2. 统一入口 ：提供 encrypt 、 decrypt 、 encryptHex 、 decryptStr 等重载方法，无论你的输入是字节数组、字符串，还是输出想要十六进制字符串或 Base64，都能找到对应的方法。
  3. 异常转换 ：将底层的受检异常（如 InvalidKeyException ）包装为运行时异常 CryptoException ，让代码更简洁，但同时保留了捕获和处理特定加密错误的可能性。

这种设计让你能更专注于业务逻辑——“我要加密这个字符串”，而不是底层细节——“我该怎么配置 Cipher 实例”。

3. 从零开始：Hutool AES 基础加密解密实战

让我们抛开理论，直接看代码。首先，确保你的项目引入了 Hutool 的依赖。以 Maven 为例：

<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-crypto</artifactId>
    <version>5.8.25</version> <!-- 请使用最新稳定版本 -->
</dependency>

3.1 场景一：快速加密解密一个字符串（默认 ECB 模式）

这是最简单的场景，适用于对安全性要求不高，或仅需快速进行数据变换的情况。Hutool 的 AES 工具类提供了快速入口。

import cn.hutool.crypto.SecureUtil;
import cn.hutool.crypto.symmetric.AES;

public class AesBasicDemo {
    public static void main(String[] args) {
        String originalContent = “这是一段需要加密的敏感信息，比如用户手机号13800138000”;

        // 1. 快速生成一个随机的 128 位（16字节）密钥
        // 在实际项目中，这个密钥必须安全存储，不能硬编码在代码里！
        byte[] key = SecureUtil.generateKey(SymmetricAlgorithm.AES.getValue()).getEncoded();

        // 2. 使用密钥构建 AES 工具实例（默认使用 AES/ECB/PKCS5Padding）
        AES aes = SecureUtil.aes(key);

        // 3. 加密：将字符串加密为 16 进制字符串，方便查看和传输
        String encryptedHex = aes.encryptHex(originalContent);
        System.out.println(“加密结果（Hex）: ” + encryptedHex);
        // 输出类似：d6f644e5c8c8c4c4e4e4e4e4e4e4e4e4e4e4e4e4e4e4e4e4e4e4e4e4e4e4

        // 4. 解密：将 16 进制密文解密回原始字符串
        String decryptedStr = aes.decryptStr(encryptedHex);
        System.out.println(“解密结果: ” + decryptedStr);
        // 输出：这是一段需要加密的敏感信息，比如用户手机号13800138000

        // 验证
        System.out.println(“解密是否成功: ” + originalContent.equals(decryptedStr)); // true
    }
}

实操心得与避坑指南：

  • 密钥管理是生命线 ：上面例子中动态生成的 key 每次运行都会变，这意味着这次加密的数据，下次程序启动就用新密钥解不开了。 在生产环境中，密钥必须通过安全的方式生成一次，然后妥善保管 （如放入配置中心、KMS 服务或环境变量中），并以固定的方式加载到代码里。切忌将密钥直接写在源码中提交到代码仓库。
  • 默认的 ECB 模式 ： SecureUtil.aes(key) 默认使用的是 ECB 模式 。正如前文所述，ECB 模式对于重复的明文块会产出重复的密文块，存在模式泄露信息的风险。对于加密有意义的业务数据， 强烈不建议使用 ECB 。这个快速方法仅适用于非常简单的、非关键的数据混淆场景。
  • 编码问题 ： encryptHex 和 decryptStr 默认使用系统编码。如果涉及中文或跨系统通信，建议显式指定编码，如 aes.decryptStr(encryptedHex, CharsetUtil.CHARSET_UTF_8) 。

3.2 场景二：使用更安全的 CBC 模式并自定义 IV

对于真正的数据加密，我们几乎总是使用 CBC 模式。这需要我们自己指定一个初始化向量。

import cn.hutool.core.util.CharsetUtil;
import cn.hutool.crypto.Mode;
import cn.hutool.crypto.Padding;
import cn.hutool.crypto.symmetric.AES;

public class AesCbcDemo {
    public static void main(String[] args) {
        String content = “用户机密数据：{‘userId’: 123, ‘balance’: 9999.99}”;

        // 1. 定义密钥和 IV。这里为了演示写死了，生产环境务必从安全渠道获取！
        // 密钥长度必须是 16 (AES-128), 24 (AES-192), 或 32 (AES-256) 字节。
        String keyStr = “0123456789ABCDEF0123456789ABCDEF”; // 32字节，即 AES-256
        String ivStr = “1234567890ABCDEF”; // IV 长度必须为 16 字节

        byte[] key = keyStr.getBytes(CharsetUtil.CHARSET_UTF_8);
        byte[] iv = ivStr.getBytes(CharsetUtil.CHARSET_UTF_8);

        // 2. 构建 AES 对象，明确指定模式为 CBC，填充为 PKCS5Padding，并传入密钥和 IV
        AES aes = new AES(Mode.CBC, Padding.PKCS5Padding, key, iv);

        // 3. 加密并输出 Base64，这在网络传输中比 Hex 更常用、更紧凑
        String encryptedBase64 = aes.encryptBase64(content);
        System.out.println(“CBC 模式加密结果 (Base64): ” + encryptedBase64);

        // 4. 解密
        String decryptedStr = aes.decryptStr(encryptedBase64);
        System.out.println(“CBC 模式解密结果: ” + decryptedStr);
    }
}

关键点解析与注意事项：

  • 密钥与 IV 的生成与保管 ：再次强调，示例中的硬编码是 大忌 。IV 虽然不需要像密钥一样绝对保密，但为了安全，它也应该是一个密码学安全的随机数，并且通常需要和密文一起存储或传输（因为解密时需要同一个 IV）。Hutool 没有提供单独的 IV 生成工具，你可以用 SecureUtil.generateKey(16) 来生成一个 16 字节的随机数作为 IV。
  • AES-256 与 JCE 无限制强度策略 ：如果你使用 32 字节的密钥（AES-256），在默认的 Java 运行环境下可能会抛出 Illegal key size 异常。这是因为 Java 默认限制了加密强度。你需要从 Oracle 官网下载并安装 JCE 无限制强度权限策略文件 ，替换 $JAVA_HOME/jre/lib/security/ 下的 local_policy.jar 和 US_export_policy.jar 。对于 JDK 8u162 及以上版本，这个限制已被移除。
  • 密文传输 ： encryptBase64() 产生的字符串更适合作为 JSON 字段、URL 参数等进行网络传输，因为它比十六进制字符串更短，且字符集更友好。

4. 高级应用场景与深度配置

掌握了基础用法，我们来看看在实际开发中会遇到哪些更复杂的情况，以及如何用 Hutool 优雅地解决。

4.1 场景三：与前端 CryptoJS 的互操作性

前后端分离架构中，前端经常使用 CryptoJS 库进行加密。要保证后端 Hutool 能正确解密前端发来的数据，双方的配置必须完全一致。

假设前端 CryptoJS 使用如下配置加密：

// 前端 JavaScript (CryptoJS)
var key = CryptoJS.enc.Utf8.parse(‘0123456789ABCDEF’); // 16字节密钥
var iv = CryptoJS.enc.Utf8.parse(‘ABCDEF0123456789’); // 16字节IV
var encrypted = CryptoJS.AES.encrypt(“hello world”, key, {
    iv: iv,
    mode: CryptoJS.mode.CBC,
    padding: CryptoJS.pad.Pkcs7 // 注意这里是 Pkcs7
});
var encryptedBase64 = encrypted.toString();
console.log(encryptedBase64); // 发送这个给后端

后端 Hutool 需要对应的解密代码：

import cn.hutool.core.util.CharsetUtil;
import cn.hutool.crypto.Mode;
import cn.hutool.crypto.Padding;
import cn.hutool.crypto.symmetric.AES;

public class AesWithCryptoJsDemo {
    public static void main(String[] args) {
        // 从前端请求中获取密文
        String encryptedBase64FromFrontend = “...”; // 替换为前端传来的 Base64 字符串

        // 约定好的密钥和 IV（必须与前端一致）
        String keyStr = “0123456789ABCDEF”;
        String ivStr = “ABCDEF0123456789”;

        byte[] key = keyStr.getBytes(CharsetUtil.CHARSET_UTF_8);
        byte[] iv = ivStr.getBytes(CharsetUtil.CHARSET_UTF_8);

        // 关键点：使用 PKCS7Padding。虽然 JDK 标准名为 PKCS5Padding，
        // 但在 AES 的 16 字节块上下文中，PKCS5Padding 和 PKCS7Padding 是等价的。
        // Hutool 的 Padding.PKCS5Padding 内部处理了这一点，可以与 CryptoJS 的 Pkcs7 互通。
        AES aes = new AES(Mode.CBC, Padding.PKCS5Padding, key, iv);

        String decrypted = aes.decryptStr(encryptedBase64FromFrontend);
        System.out.println(“解密前端数据: ” + decrypted); // 应输出 “hello world”
    }
}

联调避坑要点：

  1. 模式与填充 ：必须完全一致，通常是 CBC 模式 和 PKCS7/PKCS5 填充 。
  2. 密钥和 IV ：长度和值必须一致。建议将密钥和 IV 放在前后端共享的配置中。
  3. 编码 ：确保字符串到字节数组的转换编码一致，通常都是 UTF-8。
  4. IV 的处理 ：CryptoJS 在 CBC 模式下必须显式提供 IV。确保后端解密时使用的 IV 与前端加密时使用的完全相同。
  5. 调试技巧 ：可以先在前后端用相同的密钥、IV、明文，分别加密，看产生的密文（Base64）是否一致。这是排查配置不一致问题最快的方法。

4.2 场景四：支持 PKCS7Padding 与 Bouncy Castle 集成

在某些特定场景，尤其是与某些移动端或第三方系统交互时，对方可能严格要求使用 PKCS7Padding 。虽然 JDK 标准库中只有 PKCS5Padding ，但通过集成强大的 Bouncy Castle 加密库，Hutool 可以轻松支持。

首先，添加 Bouncy Castle 依赖：

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

然后，在代码中指定 PKCS7Padding ：

import cn.hutool.core.util.CharsetUtil;
import cn.hutool.crypto.symmetric.AES;

public class AesPkcs7Demo {
    public static void main(String[] args) {
        String content = “Requires PKCS7 Padding”;
        String keyStr = “0123456789ABHAEQ”; // 16字节
        String ivStr = “DYgjCEIMVrj2W9xN”; // 16字节

        // 直接使用字符串指定算法、模式、填充。注意第二个参数是 “PKCS7Padding“
        AES aes = new AES(“CBC”, “PKCS7Padding”,
                          keyStr.getBytes(CharsetUtil.CHARSET_UTF_8),
                          ivStr.getBytes(CharsetUtil.CHARSET_UTF_8));

        String encrypted = aes.encryptHex(content);
        System.out.println(“PKCS7Padding 加密: ” + encrypted);

        String decrypted = aes.decryptStr(encrypted);
        System.out.println(“PKCS7Padding 解密: ” + decrypted);
    }
}

原理说明 ：当你传入 ”PKCS7Padding” 字符串时，Hutool 会尝试使用 BouncyCastleProvider 作为安全提供者来创建 Cipher 实例。Bouncy Castle 提供了 JDK 未包含的多种算法和填充方式实现。

4.3 场景五：使用更通用的 SymmetricCrypto 类

除了专用的 AES 类，Hutool 还提供了 SymmetricCrypto 类，它是所有对称加密算法的通用门面。当你可能需要动态切换算法，或者使用如 DES、SM4 等其他算法时，这个类更合适。

import cn.hutool.core.util.CharsetUtil;
import cn.hutool.crypto.SecureUtil;
import cn.hutool.crypto.symmetric.SymmetricCrypto;

public class SymmetricCryptoDemo {
    public static void main(String[] args) {
        String content = “测试通用对称加密”;

        // 1. 使用 AES 算法
        // 随机生成密钥
        byte[] aesKey = SecureUtil.generateKey(“AES”).getEncoded();
        SymmetricCrypto aesCrypto = new SymmetricCrypto(“AES”, aesKey);
        String aesEncrypted = aesCrypto.encryptHex(content);
        System.out.println(“AES 加密: ” + aesEncrypted);
        System.out.println(“AES 解密: ” + aesCrypto.decryptStr(aesEncrypted));

        // 2. 使用 SM4 国密算法（需要 Bouncy Castle）
        SymmetricCrypto sm4Crypto = new SymmetricCrypto(“SM4”);
        // 也可以指定模式和填充：new SymmetricCrypto(“SM4/ECB/PKCS5Padding”);
        String sm4Encrypted = sm4Crypto.encryptHex(content);
        System.out.println(“SM4 加密: ” + sm4Encrypted);
        System.out.println(“SM4 解密: ” + sm4Crypto.decryptStr(sm4Encrypted, CharsetUtil.CHARSET_UTF_8));

        // 3. 使用 DESede (3DES) 算法
        byte[] desedeKey = SecureUtil.generateKey(“DESede”).getEncoded();
        SymmetricCrypto desedeCrypto = new SymmetricCrypto(“DESede”, desedeKey);
        String desedeEncrypted = desedeCrypto.encryptHex(content);
        System.out.println(“DESede 加密: ” + desedeEncrypted);
    }
}

工具选型建议 ：

  • 如果你 只使用 AES ，且需要设置 IV，那么直接用 AES 类，它的构造函数 AES(Mode, Padding, key, iv) 更直观。
  • 如果你需要 支持多种算法 ，或者算法类型可能由配置决定，那么使用 SymmetricCrypto 类更统一、更灵活。
  • SecureUtil.aes() 和 SecureUtil.des() 是 快速工具方法 ，用于最简单的默认场景。

5. 生产环境实战：密钥管理、性能与常见问题排查

将加密功能应用到生产环境，远不止调用一个 API 那么简单。下面是一些至关重要的实战经验。

5.1 密钥的生命周期管理

这是加密系统中最重要也是最脆弱的一环。绝对不要像示例中那样硬编码。

  • 方案一：环境变量/配置中心 这是最常见的方式。将加密密钥的 Base64 或 Hex 编码字符串，放在项目的配置文件（如 application.yml ）或环境变量中，在应用启动时读取。

    # application.yml
app:
  crypto:
    aes:
      key: “MTIzNDU2Nzg5MEFCQ0RFRjAxMjM0NTY3ODkwQUJDREVG” # Base64 编码的 32 字节密钥
      iv: “MTIzNDU2Nzg5MEFCQ0RFRg==” # Base64 编码的 16 字节 IV

    @Component
public class CryptoConfig {
    @Value(“${app.crypto.aes.key}”)
    private String aesKeyBase64;

    @Value(“${app.crypto.aes.iv}”)
    private String aesIvBase64;

    @Bean
    public AES aesInstance() {
        byte[] key = Base64.decode(aesKeyBase64);
        byte[] iv = Base64.decode(aesIvBase64);
        return new AES(Mode.CBC, Padding.PKCS5Padding, key, iv);
    }
}

  • 方案二：密钥管理服务 对于更高安全要求的系统，应使用专业的 KMS（如阿里云 KMS、AWS KMS、HashiCorp Vault）。应用在启动时，通过安全身份认证从 KMS 获取数据密钥（DEK）或直接获取加密密钥。KMS 主密钥（CMK）由云服务商或 Vault 管理，实现了密钥的集中管理、轮转和审计。

  • 密钥轮转 ：定期更换密钥是良好的安全实践。设计系统时，密文应包含密钥版本号或生成时间戳，以便在解密时能够找到正确的历史密钥。

5.2 性能考量与最佳实践

  • 对象复用 ： AES 或 SymmetricCrypto 实例是线程安全的吗？查看 Hutool 源码可以发现，其内部核心的 Cipher 实例是通过 ThreadLocal 来维护的，因此 构建好的加密对象是线程安全的，可以放心作为单例使用 。避免在每次加密/解密时都重新 new 一个对象。

    // 推荐：在配置类中创建单例 Bean
@Bean
public AES aes() {
    // ... 初始化逻辑
    return aes;
}
// 在业务类中注入并使用
@Autowired
private AES aes;
public void doBusiness() {
    String encrypted = aes.encryptHex(data);
}

  • 大文件加密 ：对于非常大的文件或数据流，不应一次性读入内存进行加密。虽然 Hutool 的 encrypt 方法接收字节数组，但对于文件，你应该使用 CipherInputStream 和 CipherOutputStream 进行流式加密。Hutool 的 SymmetricCrypto 提供了 encrypt 和 decrypt 方法的重载版本，支持 InputStream 和 OutputStream 。

    try (InputStream in = new FileInputStream(“source.zip”);
     CipherInputStream cipherIn = aes.getCipherInputStream(in);
     OutputStream out = new FileOutputStream(“encrypted.zip”)) {
    IoUtil.copy(cipherIn, out);
}

5.3 常见问题排查速查表

在实际开发中，你可能会遇到以下问题。这里提供一个快速排查指南：

问题现象 可能原因 解决方案
InvalidKeyException: Illegal key size 使用了 AES-256 但未安装 JCE 无限制策略文件。 下载并安装对应 JDK 版本的 JCE 策略文件。
解密后得到乱码 1. 前后端或加解密双方密钥/IV不一致。
2. 密文在传输过程中被篡改或编码错误（如 URL 编解码）。
3. 加密和解密时使用的字符编码不一致。		 1. 核对密钥和 IV 的字节序列是否完全一致。
2. 确保密文完整传输，对于 URL 参数，使用 URL 安全的 Base64 编码。
3. 在 decryptStr 方法中显式指定字符集，如 CharsetUtil.CHARSET_UTF_8 。
BadPaddingException: Given final block not properly padded 1. 密钥错误。
2. 密文损坏或不完整。
3. 加密和解密使用的填充模式不匹配。		 1. 首先确认密钥是否正确。
2. 检查密文是否被截断或多余空格。
3. 确认双方使用的都是 PKCS5Padding （或等价的 PKCS7Padding ）。
使用 CBC 模式，相同明文每次加密结果不同 这是正常现象，也是 CBC 模式安全的体现 。因为 IV 是随机的。 无需处理。解密时需要提供加密时使用的同一个 IV。
与 CryptoJS 等库交互失败 算法、模式、填充、密钥长度、IV、编码任一不匹配。 进行“单元测试”式比对：用相同的明文、密钥、IV 在两端分别加密，看密文是否一致。
加密后的 Base64 字符串包含 + 、 / 等特殊字符，放入 URL 或 JSON 有问题 Base64 标准编码包含 + 、 / 和 = ，这些字符在 URL 和某些 JSON 上下文中有特殊含义。 使用 Hutool 的 Base64.encodeUrlSafe() 进行 URL 安全的 Base64 编码（将 + 和 / 替换为 - 和 _ ，并省略填充 = ）。解密时使用对应的 Base64.decode() 即可。

5.4 一个综合实战案例：加密存储用户手机号

假设我们需要在数据库中加密存储用户的手机号。

  1. 密钥准备 ：通过安全流程生成一个 AES-256 密钥和一个固定的 IV（或每次加密随机生成 IV 并存储）。将其 Base64 编码后存入环境变量。
  2. 服务层工具类 ： 
    @Component
public class PhoneCryptoService {
    private final AES aes;

    public PhoneCryptoService(@Value(“${crypto.aes.key}”) String keyBase64,
                               @Value(“${crypto.aes.iv}”) String ivBase64) {
        byte[] key = Base64.decode(keyBase64);
        byte[] iv = Base64.decode(ivBase64);
        this.aes = new AES(Mode.CBC, Padding.PKCS5Padding, key, iv);
    }

    public String encryptPhone(String plainPhone) {
        if (StrUtil.isBlank(plainPhone)) {
            return null;
        }
        // 使用 URL 安全的 Base64，防止后续处理出现问题
        return aes.encryptBase64(plainPhone, true);
    }

    public String decryptPhone(String encryptedPhone) {
        if (StrUtil.isBlank(encryptedPhone)) {
            return null;
        }
        try {
            return aes.decryptStr(encryptedPhone);
        } catch (CryptoException e) {
            // 记录日志，可能是数据损坏或密钥错误
            log.error(“解密手机号失败: ”, e);
            return null;
        }
    }
}
  3. 使用 ：在用户注册或更新时，调用 encryptPhone 方法加密后存入数据库。在需要显示或验证时，调用 decryptPhone 方法解密。
  4. 注意事项 ：
    • 索引问题 ：加密后的字段无法进行模糊查询和高效的范围查询。如果需要对手机号进行查询，可以考虑额外存储一个哈希值（如 SHA-256）作为查询索引，但哈希是不可逆的，只能用于等值匹配。
    • 数据迁移 ：如果未来需要更换密钥，需要设计一个密钥版本体系，并编写数据迁移脚本，用旧密钥解密后再用新密钥加密。

通过 Hutool，我们得以从 Java 加密繁琐的细节中解脱出来，将重心放在更重要的密钥管理、业务流程和安全设计上。它提供的简洁 API 和健全的默认配置，让实现安全的 AES 加密解密从一项复杂的任务，变成了几行清晰的代码。记住，工具虽好，但安全的核心永远在于对密钥的敬畏和对流程的严谨设计。

Logo
https://edu.csdn.net/learn/39067/627173?utm_source=2019755004

汇聚全球AI编程工具，助力开发者即刻编程。

更多推荐

cover

如何用Codex实现亚马逊运营自动化？附SOP与实操教程

avatar AI编程社区

解决 Codex 接入 DeepSeek V4 Pro 的协议不兼容问题实战

本文详解解决 Codex 接入 DeepSeek V4 Pro 时的协议不兼容问题。针对 wire_api 报错，通过部署暴喵 AI 管家搭建本地协议转换层，实现 Responses API 到 Chat Completions 的无缝对接，助开发者快速打通国产大模型调用链路。

avatar AI编程社区

Mac 电脑安装 Claude Code 并接入 DeepSeek V4 Pro 满血版教程

本文详解 Mac 电脑安装 Claude Code 并接入 DeepSeek V4 Pro 满血版的完整教程。通过配置 Node.js 环境与 CC Switch 中间件，开发者可轻松调用 deepseek-v4-pro[1m] 模型，享受百万级上下文窗口带来的高效本地 AI 编程体验，大幅降低开发成本。

avatar AI编程社区