企业官网建设流程全解析

1. 项目概述：这不是一次简单的API调用，而是一场对Spring AI工具链健壮性的压力测试

“Spring AI 工具调用不是反射一下就结束”——这句话我第一次在某次内部技术复盘会上听到时，手里的咖啡差点洒出来。它像一记闷棍，精准敲在了我们过去半年里所有“快速集成AI能力”的幻觉上。我们曾天真地以为，只要把@Tool注解打上去、把方法签名写对、再配个SpringAiToolExecutor，工具调用就稳了；结果上线第三天，用户连续点击“生成报告”按钮五次后，系统直接返回500，日志里只有一行孤零零的ToolExecutionException: Failed to execute tool 'generateReport'，连堆栈都懒得打全。这根本不是“反射失败”，而是整个工具执行生命周期里，从参数校验、上下文注入、超时控制、重试策略到错误降级，全部裸奔。

标题里那个看似平平无奇的版本号“2.0.1”，恰恰是这场重构的分水岭。Spring AI 2.0.0 引入了全新的ToolExecutor抽象和ToolInvocation模型，但默认实现极度精简——它不处理重试，不感知限流，不捕获业务异常，甚至不区分“工具不可用”和“工具执行超时”。而2.0.1这个小版本，悄悄补上了FallbackToolExecutor、RateLimitingToolExecutor和ResilientToolExecutor三个关键组件，它们不是锦上添花的装饰，而是把工具调用从“能跑通”拉到“敢上线”的基础设施。我用整整三周时间，在一个模拟金融风控场景的Demo中，把这三者串成一条完整的恢复链路：当工具因网络抖动失败时，先由ResilientToolExecutor触发指数退避重试；若重试3次仍失败，则交由FallbackToolExecutor执行降级逻辑（比如返回缓存结果或兜底文案）；而这一切的前提，是RateLimitingToolExecutor早已在入口处掐住了每秒最多2次的调用闸门，避免雪崩。这不是配置几个Bean就能搞定的事，它要求你真正理解工具调用在LLM流水线中的位置——它既不是纯后端服务，也不是前端按钮，而是横跨AI推理层与业务逻辑层的“语义胶水”。适合正在将Spring Boot应用接入大模型能力的后端开发者、AI工程化负责人，以及那些被“工具调用偶尔失败”问题反复折磨却找不到根因的架构师。如果你还在用@Autowired private ToolExecutor executor;然后直接executor.invoke(...)，那这篇就是为你写的实战手册。

2. 核心设计思路拆解：为什么必须放弃“反射即调用”的思维定式

2.1 工具调用的本质：从Java方法到LLM语义指令的三次跃迁

很多人卡在第一步，就是没搞清“工具调用”在Spring AI里到底指什么。它绝不是Method.invoke()那么简单。整个过程实际经历了三次语义跃迁：

第一次跃迁：Java方法 → ToolDescriptor
当你给一个方法加上@Tool，Spring AI做的第一件事，是把这个方法的签名、Javadoc、参数类型，编译成一个ToolDescriptor对象。这个对象会被序列化为JSON Schema，最终作为system prompt的一部分，喂给大模型。注意，这里的关键是“Javadoc”——模型不是靠猜，而是靠你写的文档来理解这个工具能干什么。我见过最典型的反例：某团队给sendEmail(String to, String content)方法写了@Tool("发送邮件")，结果模型在生成{"name": "sendEmail", "arguments": "{\"to\": \"user@domain.com\", \"content\": \"请查收报告\"}"}时，把content字段当成了HTML模板，导致邮件服务器报错。根源在于Javadoc里没写清楚content是纯文本还是支持Markdown。所以，工具描述的严谨性，决定了模型调用的准确性——这已经脱离了Java反射的范畴，进入了自然语言工程领域。

第二次跃迁：ToolDescriptor → LLM指令解析
大模型收到包含工具描述的prompt后，会根据当前对话历史，决定是否需要调用工具、调用哪个工具、传什么参数。这个决策过程完全黑盒，但Spring AI 2.0.1通过ToolProvider接口暴露了关键钩子。比如，你可以实现一个LoggingToolProvider，在模型返回{"name": "getStockPrice", "arguments": "{\"symbol\": \"AAPL\"}"}时，先记录这条原始指令，再交给下游执行。这步的意义在于：你无法控制模型是否调用工具，但你能控制模型调用指令的可审计性。很多线上问题，最后发现是模型在低置信度下胡乱调用工具，而日志里只有最终失败结果，没有中间指令，排查成本翻倍。

第三次跃迁：LLM指令 → Java方法执行
这才是最接近“反射”的环节，但2.0.1彻底重构了它。旧版SimpleToolExecutor拿到ToolInvocation后，直接method.invoke(target, args)；而新版ResilientToolExecutor会先做三件事：

1. 参数强校验：检查argumentsJSON是否匹配ToolDescriptor定义的Schema，不匹配则抛ToolValidationException，而不是让方法内部崩溃；
2. 上下文注入：自动把ChatMemory、MessageContext等Spring AI上下文对象，按参数名注入到方法中（比如方法签名含MessageContext context，就自动塞进去）；
3. 执行沙箱：用CompletableFuture.supplyAsync()包裹执行，并设置ThreadLocal隔离，避免工具方法污染主线程状态。

这三次跃迁说明：工具调用不是单点技术，而是一个端到端的语义管道。任何一个环节的松懈，都会在生产环境以“偶发失败”的形式爆发。所谓“反射一下就结束”，本质是把三次跃迁压缩成一次，把责任全推给开发者的直觉。

2.2 2.0.1的三大执行器：不是功能叠加，而是故障域隔离

Spring AI 2.0.1引入的三个新执行器，表面看是“加功能”，实则是按故障场景做了严格隔离：

• RateLimitingToolExecutor：专治流量洪峰。它不关心工具逻辑，只认toolName和ratePerSecond。比如风控场景中，“查询用户信用分”工具必须限制为10QPS，否则下游征信接口直接熔断。它的实现基于令牌桶算法，但关键细节在于：它拦截的是ToolInvocation对象，而非HTTP请求。这意味着即使同一个HTTP请求触发了多个工具调用（比如先查信用分，再查黑名单），每个工具调用都会独立计数。我踩过的坑是：误以为它能保护整个HTTP端点，结果上游Nginx限流+这里双重限流，导致正常流量也被误杀。

• ResilientToolExecutor：专治瞬时故障。它内置了重试策略，但和Spring Retry不同——它的重试是针对单次ToolInvocation的，且重试间隔是动态的。比如第一次失败后等100ms，第二次失败等300ms，第三次失败等900ms（指数退避）。更关键的是，它能识别“可重试异常”：默认只对SocketTimeoutException、ConnectException等网络异常重试，对IllegalArgumentException这种业务异常直接透出。这个判断逻辑在ResilientToolExecutor#isRetryable方法里，你可以继承它并覆盖此方法，加入自定义规则（比如对下游返回{"code": 503}的响应也视为可重试）。

• FallbackToolExecutor：专治长期不可用。它不解决“怎么调”，而是解决“调不通怎么办”。它的fallback方法接收原始ToolInvocation和Throwable，让你能返回一个兜底的ToolResponse。比如“生成财报摘要”工具挂了，就返回"当前财报数据正在更新，请稍后再试"。但要注意：fallback本身不能抛异常，否则会触发上层执行器的fallback，形成无限递归。我在压测时就遇到过，fallback里调用了另一个可能失败的工具，结果整个链路崩成一团。

这三个执行器的组合逻辑，不是简单套娃，而是按故障持续时间分层防御：

提示：限流器在最外层，像交通警察；弹性执行器在中间，像急救车；降级执行器在最内层，像保险丝。顺序错了，整个防御体系就失效。

3. 核心细节与实操要点：从配置到代码的每一处魔鬼细节

3.1 执行器链的装配：Bean定义的顺序即执行顺序

在Spring Boot中，执行器链的装配不是靠@Order注解，而是靠ToolExecutorBean的依赖关系。你必须显式声明哪个执行器包装哪个。以下是我在线上环境验证过的标准配置：

@Configuration public class ToolExecutorConfig { @Bean @Primary public ToolExecutor resilientToolExecutor( @Qualifier("baseToolExecutor") ToolExecutor baseExecutor, Resilience4jRetryProperties retryProperties) { // 创建ResilientToolExecutor，传入基础执行器和重试配置 return new ResilientToolExecutor(baseExecutor, Retry.ofDefaults("tool-retry", RetryConfig.custom() .maxAttempts(retryProperties.getMaxAttempts()) .waitDuration(Duration.ofMillis(retryProperties.getWaitDuration())) .retryExceptions(IOException.class, TimeoutException.class) .build())); } @Bean @Qualifier("baseToolExecutor") public ToolExecutor rateLimitingToolExecutor( @Qualifier("fallbackToolExecutor") ToolExecutor fallbackExecutor, RateLimiterRegistry rateLimiterRegistry) { // 创建RateLimitingToolExecutor，传入降级执行器 return new RateLimitingToolExecutor(fallbackExecutor, rateLimiterRegistry.rateLimiter("tool-rate-limiter", RateLimiterConfig.custom() .limitForPeriod(5) // 每5秒最多5次 .limitRefreshPeriod(Duration.ofSeconds(5)) .timeoutDuration(Duration.ofMillis(100)) // 等待令牌超时100ms .build())); } @Bean @Qualifier("fallbackToolExecutor") public ToolExecutor fallbackToolExecutor( @Qualifier("actualToolExecutor") ToolExecutor actualExecutor) { // 创建FallbackToolExecutor，传入真实执行器 return new FallbackToolExecutor(actualExecutor, (invocation, throwable) -> { // 降级逻辑：根据工具名返回不同兜底内容 if ("generateFinancialReport".equals(invocation.toolName())) { return ToolResponse.from("当前财报生成服务暂不可用，已为您准备上月报告"); } else if ("checkCreditScore".equals(invocation.toolName())) { return ToolResponse.from("信用分查询暂时繁忙，请稍后重试"); } return ToolResponse.from("服务异常，请联系管理员"); }); } @Bean @Qualifier("actualToolExecutor") public ToolExecutor actualToolExecutor() { // 最底层：真实的工具执行器 return new SimpleToolExecutor(); } }

这段代码有三个极易被忽略的细节：

1. @Primary必须打在最外层的resilientToolExecutor上，否则Spring会注入默认的SimpleToolExecutor；
2. @Qualifier的命名必须严格对应，rateLimitingToolExecutor依赖fallbackToolExecutor，而fallbackToolExecutor又依赖actualToolExecutor，环环相扣；
3. RateLimiterConfig.timeoutDuration设为100ms是关键：它表示当令牌桶空时，最多等待100ms获取令牌，超时则直接拒绝。这个值必须小于你的HTTP超时（比如3s），否则用户会看到“请求超时”而非“服务繁忙”。

3.2 工具方法的编写规范：Javadoc即契约，参数即接口

工具方法不是普通Service，它的签名和文档共同构成了与LLM的契约。我整理了一套线上验证过的编写规范：

@Component public class FinancialTools { /** * 查询指定股票代码的实时价格和涨跌幅。 * <p> * 注意：仅支持A股代码（如"600519.SH"），不支持美股（如"AAPL"）。 * 返回格式为JSON字符串，包含price（浮点数）、changePercent（百分比字符串）、lastUpdated（ISO8601时间戳）。 * * @param symbol A股股票代码，格式为"XXXXXX.SZ"或"XXXXXX.SH" * @return 包含价格信息的JSON字符串 * @throws IllegalArgumentException 当symbol格式不正确时 * @throws RuntimeException 当上游行情接口不可用时（此异常将触发ResilientToolExecutor重试） */ @Tool public String getStockPrice(@NonNull String symbol) { // 1. 参数强校验：必须符合A股代码正则 if (!symbol.matches("\\d{6}\\.(SZ|SH)")) { throw new IllegalArgumentException("股票代码格式错误，应为6位数字+.SZ或.SH，如'600519.SH'"); } // 2. 调用下游行情服务（此处省略HTTP客户端代码） try { return marketService.getPrice(symbol); } catch (TimeoutException | IOException e) { // 3. 将网络异常包装为RuntimeException，确保被ResilientToolExecutor捕获 throw new RuntimeException("行情服务调用失败", e); } } /** * 生成用户指定时间段的财务分析报告。 * <p> * 支持的时间范围：最近3个月、最近6个月、最近12个月。 * 报告包含收入、成本、净利润、毛利率四大核心指标。 * * @param userId 用户唯一标识符 * @param period 时间范围，取值为"3M"、"6M"、"12M" * @return 分析报告的Markdown格式字符串 * @throws IllegalArgumentException 当period不在允许范围内时 */ @Tool public String generateFinancialReport(@NonNull String userId, @NonNull @Pattern(regexp = "3M|6M|12M") String period) { // 使用@Pattern注解进行参数校验，Spring AI会自动将其转为JSON Schema的enum约束 return reportService.generate(userId, period); } }

这里的关键实践：

• Javadoc必须包含“注意”段落：明确告知模型哪些输入是非法的，避免模型生成无效参数；
• @NonNull和@Pattern等JSR-303注解会被Spring AI自动提取，生成的JSON Schema里会包含"required": ["symbol"]和"enum": ["3M","6M","12M"]，这是防止模型乱传参数的第一道防线；
• 异常分类要清晰：IllegalArgumentException代表模型输错了，不该重试；RuntimeException包装的网络异常才该重试。这个边界一旦模糊，重试机制就会变成放大故障的杠杆。

3.3 失败恢复的完整链路：从日志到监控的闭环

光有执行器还不够，你得知道失败时发生了什么。我在ResilientToolExecutor基础上扩展了一个LoggingResilientToolExecutor，它会在每次重试前、降级前、成功后都打日志：

public class LoggingResilientToolExecutor extends ResilientToolExecutor { private static final Logger log = LoggerFactory.getLogger(LoggingResilientToolExecutor.class); public LoggingResilientToolExecutor(ToolExecutor delegate, Retry retry) { super(delegate, retry); } @Override public ToolResponse invoke(ToolInvocation invocation) { long start = System.currentTimeMillis(); try { ToolResponse response = super.invoke(invocation); log.info("ToolSuccess|tool={}||duration={}ms||args={}", invocation.toolName(), System.currentTimeMillis() - start, invocation.arguments()); return response; } catch (Exception e) { log.error("ToolFailure|tool={}||duration={}ms||args={}||error={}", invocation.toolName(), System.currentTimeMillis() - start, invocation.arguments(), e.getMessage(), e); throw e; } } // 重写onRetry方法，记录重试事件 @Override protected void onRetry(RetryContext context) { ToolInvocation invocation = (ToolInvocation) context.getArguments()[0]; log.warn("ToolRetry|tool={}||attempt={}||args={}||reason={}", invocation.toolName(), context.getAttemptCount(), invocation.arguments(), context.getLastThrowable().getMessage()); } }

配合ELK日志系统，我建立了三个核心监控看板：

1. 工具调用成功率看板：按toolName分组，计算ToolSuccess日志数 / (ToolSuccess+ToolFailure)总数；
2. 重试率看板：统计ToolRetry日志占ToolFailure日志的比例，超过10%就要预警；
3. 降级率看板：统计ToolFallback日志占总调用的比例，超过1%说明下游服务稳定性堪忧。

有一次，getStockPrice的降级率突然升到5%，排查发现是行情服务DNS解析超时，但我们的ResilientToolExecutor只重试了3次，而DNS问题往往需要更长时间恢复。于是我把重试次数从3提到5，并增加了DnsException到可重试异常列表——这就是日志驱动的优化闭环。

4. 实操过程与核心环节实现：从本地调试到生产灰度的全流程

4.1 本地调试：用MockServer伪造下游故障

在本地验证失败恢复逻辑，绝不能等线上出问题。我用mockserver伪造了一个不稳定的行情服务：

// 启动MockServer，模拟50%概率返回超时 MockServerClient mockServer = new MockServerClient("localhost", 1080); mockServer.when( request() .withMethod("GET") .withPath("/api/price/.*") ).respond( response() .withStatusCode(200) .withBody("{\"price\": 1800.5, \"changePercent\": \"+2.3%\", \"lastUpdated\": \"2024-05-20T10:00:00Z\"}") .withDelay(TimeUnit.MILLISECONDS, 50) // 固定50ms延迟 ); // 再添加一个高概率超时规则 mockServer.when( request() .withMethod("GET") .withPath("/api/price/.*") .withDelay(TimeUnit.MILLISECONDS, 3000) // 3s延迟，触发超时 ).respond( response() .withStatusCode(200) .withBody("{\"price\": 1790.0, \"changePercent\": \"-0.5%\", \"lastUpdated\": \"2024-05-20T10:00:00Z\"}") .withDelay(TimeUnit.MILLISECONDS, 3000) );

然后在测试中，我构造了一个会触发重试的场景：

@Test void testStockPriceRetryOnTimeout() { // 给工具方法注入MockServer地址 financialTools.setMarketServiceUrl("http://localhost:1080"); // 调用工具，预期会重试3次后成功 String result = financialTools.getStockPrice("600519.SH"); // 验证结果正确性 assertThat(result).contains("1800.5"); // 验证日志中确实有3次重试记录 List<String> logs = loggingAppender.getLogs(); long retryCount = logs.stream() .filter(log -> log.contains("ToolRetry|tool=getStockPrice")) .count(); assertThat(retryCount).isEqualTo(3L); }

这个测试的价值在于：它把“重试逻辑”从黑盒变成了白盒。你不仅能验证最终结果，还能确认重试是否真的发生、是否按预期次数发生。很多团队跳过这步，直接上生产，结果重试配置错了都不知道。

4.2 生产灰度：用Feature Flag控制执行器链

上线新执行器链不能一刀切。我用LaunchDarkly的Feature Flag做了渐进式灰度：

@Bean @Primary public ToolExecutor productionToolExecutor( @Qualifier("resilientToolExecutor") ToolExecutor resilient, @Qualifier("legacyToolExecutor") ToolExecutor legacy, LDClient ldClient) { return new FeatureFlagToolExecutor(resilient, legacy, ldClient, "tool-executor-v2"); } // FeatureFlagToolExecutor根据Flag值决定走哪条链 public class FeatureFlagToolExecutor implements ToolExecutor { private final ToolExecutor v2Executor; private final ToolExecutor v1Executor; private final LDClient ldClient; private final String flagKey; @Override public ToolResponse invoke(ToolInvocation invocation) { // 根据userId做分流，比如10%的用户走新链 LDUser user = new LDUser.Builder(invocation.userId()) .custom("toolName", invocation.toolName()) .build(); boolean useV2 = ldClient.boolVariation(flagKey, user, false); return useV2 ? v2Executor.invoke(invocation) : v1Executor.invoke(invocation); } }

灰度期间，我重点关注两个指标：

• P95响应时间对比：新链因为多了限流和重试，P95应该比旧链高100-200ms，但不能高过500ms；
• 错误率收敛速度：当某个工具下游故障时，新链的错误率应在30秒内收敛到降级率（比如1%），而旧链会持续报错直到超时。

有一次灰度发现，generateFinancialReport在新链下P95飙升到1.2s，排查发现是降级逻辑里调用了另一个慢SQL。于是我把它改成同步返回静态文案，P95立刻回落到300ms——这就是灰度的价值：在影响小部分用户时，暴露出设计缺陷。

4.3 调用上限的硬核实现：不只是QPS，更是资源水位

“调用上限”在标题里常被误解为“每秒最多调多少次”，但真正的上限是资源水位。比如，你的服务器只有4核CPU，而每个工具调用平均消耗15% CPU，那么理论最大并发就是4 / 0.15 ≈ 26。Spring AI 2.0.1的RateLimitingToolExecutor只管QPS，不管资源。所以我加了一层ResourceAwareToolExecutor：

public class ResourceAwareToolExecutor implements ToolExecutor { private final ToolExecutor delegate; private final MeterRegistry meterRegistry; private final double cpuThreshold = 0.7; // CPU使用率阈值70% public ResourceAwareToolExecutor(ToolExecutor delegate, MeterRegistry meterRegistry) { this.delegate = delegate; this.meterRegistry = meterRegistry; } @Override public ToolResponse invoke(ToolInvocation invocation) { // 获取当前CPU使用率 double cpuUsage = getSystemCpuUsage(); // 如果CPU超阈值，直接降级，不走后续执行器 if (cpuUsage > cpuThreshold) { meterRegistry.counter("tool.rejected.cpu.high", "tool", invocation.toolName()).increment(); return ToolResponse.from("系统负载过高，请稍后再试"); } return delegate.invoke(invocation); } private double getSystemCpuUsage() { // 使用Micrometer的SystemMetrics获取CPU使用率 return SystemMetrics.getSystemCpuUsage(meterRegistry); } }

这个执行器放在整个链的最顶层（比RateLimitingToolExecutor还高），它让“调用上限”从静态配置变成了动态水位。当服务器CPU飙到85%时，所有工具调用瞬间降级，避免OOM。这个设计在一次大促中救了我们——当时流量没超QPS阈值，但CPU因GC频繁飙升，旧方案毫无反应，新方案直接熔断，保住了核心交易链路。

5. 常见问题与排查技巧实录：那些文档里不会写的血泪教训

5.1 典型问题速查表

5.2 我踩过的三个深坑

坑一：Javadoc里的标点符号引发JSON Schema解析失败
某次上线后，getStockPrice工具突然不被模型识别。排查发现，我在Javadoc里写了：“返回格式为JSON字符串，包含price（浮点数）、changePercent（百分比字符串）、lastUpdated（ISO8601时间戳）。” 这里的中文括号（）被Spring AI的Doclet解析器当成了非法字符，生成的JSON Schema里description字段直接截断。解决方案：所有Javadoc必须用英文半角括号()，并避免任何特殊符号。现在我的IDE设置了保存时自动替换中文标点。

坑二：@Pattern注解在嵌套对象中不生效
我有个工具方法参数是@NonNull StockRequest request，而StockRequest类里有@Pattern字段。结果Spring AI生成的Schema里没有enum约束。原因：Spring AI 2.0.1只扫描方法参数的直接注解，不递归扫描POJO。解决方案：要么把@Pattern移到方法参数上（@Pattern(regexp="...") String symbol），要么用@JsonSchema注解手动定义Schema。

坑三：FallbackToolExecutor的降级逻辑里调用Thread.sleep()
为了模拟“优雅降级”，我在fallback里写了Thread.sleep(100)，结果整个线程池被阻塞。FallbackToolExecutor是在CompletableFuture线程里执行的，sleep会阻塞工作线程。解决方案：降级逻辑必须是纯内存操作，所有IO都要移除。如果真需要异步操作，要用CompletableFuture.supplyAsync()另起线程，但要小心线程爆炸。

5.3 性能压测的黄金参数

用JMeter对工具调用链做压测时，我发现三个关键参数决定了结果的真实性：

1. 线程组设置：不要用“线程数=100”，而要用“RPS=50”，因为真实场景是流量恒定，不是并发数恒定；
2. HTTP Header：必须带X-User-ID，否则RateLimitingToolExecutor的keyResolver无法区分用户；
3. 断言规则：除了HTTP状态码，必须校验响应体是否包含"tool_response"字段，避免模型返回{"name":"fallback","arguments":"..."}这种假成功。

我用这套参数压测时，发现当RPS从45升到46时，getStockPrice的降级率从0%飙升到30%。定位到是RateLimiterConfig.limitForPeriod(5)的5秒窗口太短，改成limitForPeriod(10)后，平稳支撑到RPS=60。这说明：调用上限不是拍脑袋定的，而是压测出来的水位线。

6. 工具链演进思考：从2.0.1到未来的韧性基建

Spring AI 2.0.1的执行器链，解决了“工具调用失败怎么办”的问题，但它没解决“工具调用是否应该发生”的问题。比如，模型在对话中反复要求“再给我讲一遍”，而你每次都调用getStockPrice，这既浪费资源，又可能触发限流。下一代方案，应该是上下文感知的工具调用门控：在ToolProvider层，根据ChatMemory中最近3次调用记录，自动判断本次调用是否冗余。我已经在实验一个SmartToolProvider，它会检查memory.getMessages().subList(0, 3)，如果发现连续两次getStockPrice的arguments相同，就直接返回缓存结果，不走执行器链。

另一个方向是工具调用的可观测性深化。现在的日志只告诉你“谁调了、结果如何”，但没告诉你“为什么调”。如果能在ToolInvocation里注入traceId，并关联到LLM的ChatResponse，就能构建完整的调用溯源图：从用户提问→模型决策→工具调用→下游服务→最终回复。这个图谱对优化Prompt、训练微调模型、定位长尾问题，价值巨大。

最后想说，技术演进从来不是版本号的简单叠加。Spring AI 2.0.1之所以重要，是因为它把AI工程从“能用”推向了“敢用”。而“敢用”的底气，不来自某个炫酷的新API，而来自你亲手拧紧的每一颗螺丝：Javadoc里的一个标点，RetryConfig里的一个异常类名，RateLimiterConfig里的一个毫秒数。这些细节堆起来，才是生产环境里风雨不动的基石。我最近在团队里推行一个新习惯：每次提交工具方法代码前，先问自己三个问题——这个Javadoc能让模型读懂吗？这个异常会被正确重试吗？这个调用在CPU 80%时还会成功吗？答案不全是“是”，那就继续改。毕竟，AI时代的稳定性，就藏在这些不 glamorous 的细节里。