首页 文章 精选 留言 我的

精选列表

搜索[spring],共10000篇文章
优秀的个人博客,低调大师

《Spring AI 2.0实战》第16招 五种Agent模式

最近团队在做技术选型,需要一份关于开源 API 网关的调研报告。我是老李,起初把任务丢给一个模型,让它一次生成。报告很快出来了,但问题也多:官网链接已经 404,GitHub 的 star 数与实际页面不一致,论文部分只摘了摘要没有结论。最要命的是,模型自己并不觉得有问题,也不会主动回去修改。我们需要的不是更长的输出,而是把任务拆成可检查、可回退、可组合的步骤。今天就用“生成技术调研报告”这个真实场景,聊聊五种协作模式到底怎么落地。 ## 01、痛点 单次生成技术调研报告,通常会遇到四类问题。 第一,信息源单一。模型倾向于从训练数据中拼凑答案,而不是实时访问官网、代码仓库和论文数据库,导致版本、许可证、维护状态等关键信息失真。比如有一份报告里写着“最近版本为 3.3”,实际上项目仓库已经发布了 4.0。 第二,任务边界不清。一份调研报告同时包含背景梳理、社区活跃度评估、性能对比、风险判断,混在一个生成过程里,哪个环节出错很难定位。我们曾遇到报告结构完整,但性能对比部分完全缺失,因为模型把注意力放在了功能列表上。 第三,没有校验闭环。输出完就结束,缺乏“检查—发现问题—重新生成”的机制。模型不会自己质疑自己,尤其当错误藏在细节里时,读的人往往最后才发现。 第四,节点越多越容易失控。很多团队一开始就画一个复杂流程图,结果状态传递混乱,调用成本高,效果反而不如直接生成。这不是说不要拆分,而是说拆分必须有明确边界。 ## 02、是什么 这五种协作模式分别解决不同问题。 链式(Chain)把任务切成前后依赖的步骤,前一步输出作为下一步输入,例如先搜索再摘要最后格式化引用。适合流程天然线性、后一步强依赖前一步的场景。 并行(Parallelization)用于相互独立的子任务,例如同时查官网、GitHub 和论文,最后由合并步骤汇总。适合数据源不同、彼此没有依赖的场景。 路由(Routing)根据输入特征把任务交给专用处理器,例如先判断主题是软件选型还是学术综述,再走不同分支。适合入口多样、不同输入需要不同模板的场景。 编排—执行(Orchestrator-Workers)由一个编排者动态拆解任务,分派给多个执行者,再回收结果并整合。适合任务边界不预先固定、需要按情况拆解的场景。 评估—优化(Evaluator-Optimizer)先由生成者产出初稿,再由评估者指出缺陷,生成者根据反馈修改,形成循环。适合质量要求高、需要多轮校正的场景。 它们不是五个孤立工具,而是一组可以组合的过程控制手段。 ## 03、为什么 现在模型能力虽然强,但复杂任务仍然不能靠一次调用解决。技术调研报告对事实准确性要求高,涉及多个异构数据源,单一模型容易产生幻觉和信息滞后。五种模式的可贵之处在于,它们不改变模型本身,而是改变任务的组织方式。把过程拆开后,我们可以在任意节点插入人工确认、日志、缓存和重试,成本可控。对于技术团队,这意味着从“祈祷模型一次答对”转向“用流程保证结果可验证”。特别是在数据会变化的场景里,单次生成得到的是一份静态快照,而协作流水线得到的是可以持续更新的报告。 ## 04、架构 整体流程可以抽象为六个阶段:入口先经过路由识别主题,然后交给编排者拆解,编排者把子任务分派给官网、代码仓库、论文三个执行者,三者并行工作;结果合并后交给评估者检查,通过则输出报告,不通过则发回对应执行者或重新拆解。 路由节点接收“开源网关选型调研”,判断主题为“开源软件评估”,选择评估模板。编排者拆解三个子任务:官网调研、代码仓库调研、论文调研。三个执行者并行执行,各自返回结构化片段。编排者合并片段,处理冲突。评估者检查数据一致性、信息时效、维度完整性,给每个子任务打分。低于阈值就送回对应节点重做,直到通过。 状态上需要维护任务清单、上下文快照、版本号和重试计数。每个节点只负责自己那一段,输入输出保持结构化,避免把上一节点的自然语言直接透传给下一节点。比如官网执行者只接收项目名称和官网地址,返回许可证、最新版本、维护者三个字段;代码仓库执行者只接收仓库地址,返回 star 数、open issues 数、最近提交时间。 ## 05、实战 以“生成技术调研报告”为例,任务输入是:“调研开源 API 网关项目,产出选型建议”。 第一步,路由判断主题。路由节点根据关键词和项目上下文,输出 task_type = software_evaluation,并选择对应模板。如果没有路由,这份任务可能会被套用学术论文模板,漏掉社区活跃度。 第二步,编排者拆解。拆成三个子任务: - 官网调研:许可证、维护者、架构特性、最近发布版本。 - 代码仓库调研:star 趋势、PR 合并周期、issue 活跃度、最近提交。 - 论文调研:性能对比、安全分析、相关学术结论。 每个子任务都有明确的数据来源和返回字段,避免重复和遗漏。 第三步,并行执行。三个执行者各自调用外部检索工具,返回结构化 JSON 片段。例如官网执行者返回 license、latest_version、maintainer;代码仓库执行者返回 stars、open_issues、last_commit;论文执行者返回 performance_comparison、security_notes。 第四步,编排者汇总。把三份片段合并成初稿,若发现矛盾(例如官网称最近版本为 3.2,代码仓库 tag 最新为 3.1),先保留双方来源并标记冲突,而不是擅自丢弃一方。 第五步,评估者检查。检查维度包括:数据源是否更新到最近 30 天?GitHub 数据是否与页面一致?是否遗漏许可证、安全漏洞、替代方案?是否给出了可复现的性能对比?若未通过,生成一条反馈,比如“补充 Apache 2.0 许可证说明,重新抓取 GitHub 最新 release”,然后发回给编排者或对应执行者。 在一次实际运行中,官网调研节点返回了过期链接,评估者发现后没有直接通过,而是发回“官网链接 404,请从项目 README 或文档站重新获取许可证信息”。执行者重做后,报告才被放行。这个回退过程只重做官网一个节点,不会牵连代码仓库和论文部分。 ## 06、洞见 回到那个问题:是不是节点越多效果越好? 答案是否定的。五种模式的真正成本来自模型调用次数、状态复杂度和不可预测性。每增加一个执行节点,就多一次输入输出、多一份状态要维护、多一个可能出错的位置。以调研报告为例,官网、代码仓库、论文三个节点是合理的,因为数据源不同、无法互相替代;但如果再把代码仓库拆成 star 调研和 issue 调研两个节点,往往收益很低,因为两者可以从同一个页面一起获取。 可以用一句话衡量:节点价值 = 减少的返工成本 - 新增的调用与状态成本。如果一个节点不能替下游省下返工,或者不能补上不可替代的事实来源,就应该合并。好的编排不是图越复杂越牛,而是每个节点都像流水线上的质检工位,有明确的拦截清单。 ## 07、行动 建议先小后大,不要一上来就画大一统流程图。 第一步,把链式、并行、路由、编排—执行、评估—优化各写一个最小 Demo。链式最小 Demo 可以串三个步骤:搜索、摘要、引用格式化。并行最小 Demo 可以同时调用三个独立接口,最后合并。路由最小 Demo 用规则或分类模型把输入分到两个模板。编排最小 Demo 用一个编排者拆出两个执行者。评估最小 Demo 对初稿打分并修改一轮。 第二步,分别跑通五个最小闭环,确认各自能独立运行。 第三步,再组合到技术调研报告场景。组合时先固定数据格式和状态结构,避免节点间字段混乱。 第四步,给每个节点记录调用次数、耗时、失败率,数据不达标就合并或删除节点。验收标准可以简单:报告中的每个关键事实都能追溯到具体来源;任何节点失败都能单独重试;每次重做不需要重跑整个流程。 ## 08、小结 技术调研报告不是一个简单问答,而是一条需要多源采集、交叉校验、回退修正的流水线。链式解决顺序依赖,并行解决独立子任务,路由解决入口分流,编排—执行解决动态拆解,评估—优化解决质量闭环。五种模式组合起来,不是为了把图画得复杂,而是为了让每一步都可控、可回放、可修正。节点不是越多越好,每个节点都必须有明确价值。 ## 09、链接与概念说明 本文涉及的五个概念: - 链式:串行处理,前一步输出作为后一步输入。 - 并行:独立任务同时执行,最后合并。 - 路由:根据输入特征选择专用处理分支。 - 编排—执行:编排者动态拆解任务并分派执行者,回收结果。 - 评估—优化:生成与评估循环,直到满足质量条件。 进一步阅读可参考 Anthropic 官网关于多步骤协作模式的公开技术文档,以及模型 API 文档中的函数调用和结构化输出部分。也可以搜索“多阶段推理”和“结构化生成”等资料,但本文的核心价值在于:先拆成最小闭环,再按价值决定是否增加节点。

优秀的个人博客,低调大师

《Spring AI 2.0实战》第17招 Reflection怎么做

## 01、痛点 我是老李。最近在给一个核心业务做架构方案评审时,遇到一件让人哭笑不得的事。团队一位同事用大模型直接生成了一份架构设计文档,拿过来一看,章节齐全、术语专业、图表也画得像模像样。但细读下去,问题就来了:没有限流策略,没有备份方案,多可用区只写了一句“建议部署在多个区域”,成本预估则拍脑袋写了一个数字。最要命的是,模型自己在文档末尾还加了一句“本方案已经过全面评估,具备生产级可靠性”。 这件事让我开始认真思考一个被越来越多团队讨论的做法:让模型对已有的结果进行批评和修正。官方示例里也专门提供了类似的反射实现,用模型对输出做二次评审。但问题来了:模型自己评价自己,到底靠不靠谱?为什么现在要讲这个?因为很多团队已经把它当成了默认动作,每个回答都多跑一次模型,成本翻倍,效果却未必更好。今天就把原理、实战和边界一次说清楚。 ## 02、是什么 先给这个做法下一个定义。所谓反射机制,英文叫 Reflection,本质上是一个“生成 → 评价 → 修改”的反馈回路。具体来说,模型先根据需求产出一份结果,然后由另一个评估角色对这份结果从指定维度进行批评和打分,如果分数不达标,就把批评意见反馈给生成环节,重新生成,直到满足条件或者达到最大轮次。 这个思路和经典的“评估-优化”模式非常接近。在软件工程里,我们早就熟悉这种结构:开发人员写代码,测试人员挑毛病,开发人员再修改。只不过在反射机制里,生成者和评估者往往由同一个底层大模型担任,只是通过不同的角色设定和输入要求来区分职责。生成者负责创造,评估者负责找茬,生成者再根据反馈修改。 需要注意的是,反射不是简单地让模型“多看一遍自己的答案”。它必须引入明确的外部评价维度,例如安全、成本、可靠性、可维护性,并且要求评估器给出具体批评和量化评分。如果只让模型“你再检查一下”,通常效果很有限,因为缺乏明确的评价标准,模型很容易说“看起来没问题”。 ## 03、为什么 为什么需要反射?核心原因是大模型单次生成存在明显的局限性。对于简单问答,一次生成通常足够;但对于架构方案、复杂代码、合同条款、安全策略这类高价值复杂输出,单次生成就像第一版草稿,表面合理但细节往往经不起推敲。模型容易遗漏边界条件、忽略真实的成本约束、或者把常见模板套用在不合适的场景上。 反射的价值在于把隐性的质量要求显性化。我们心里可能知道一份架构方案“应该具备高可用”,但模型不知道。通过评估器把这个要求拆成具体维度,例如“是否包含限流和熔断”“是否有多可用区部署”“是否有数据备份策略”,再逐项打分,模型就有机会发现自己遗漏了什么,并在下一轮补齐。 另外,反射的成本相对人工评审要低得多。一个资深架构师审一份方案可能需要半天,而模型评估只需要几秒钟。对于高价值输出,这种成本是值得的。但不能因此把反射当成万能药,这正是后面要展开讨论的关键。 ## 04、架构 一个典型的反射机制可以抽象成四个部分。 第一是生成器。它接收原始需求和上一轮的反馈意见,生成一份新的结果。生成器可以是同一个模型,只是输入中包含了反馈。 第二是评估器。它接收生成器产出的结果,配合预先定义好的评价维度和打分标准,输出一个评分和具体的批评意见。评估器的输入设计非常关键,如果评价标准模糊,例如只写“评估方案质量”,评估器就很难给出有用的反馈。实际使用中,通常会把每个维度拆成若干子项,并要求逐项打分。 第三是循环控制。它负责判断评分是否达到阈值、是否超过最大轮次。如果达标,就结束并输出结果;如果未达标,就把批评意见作为反馈传给生成器,进入下一轮;如果轮次耗尽仍未达标,则转入人工评审或直接丢弃。 第四是最终输出。可以是达标结果,也可以是附带评估记录和未解决问题的半成品,供人工介入。 用一段伪代码表示这个流程: ```python for i in range(max_rounds): draft = generate(requirement, feedback) score, comments = evaluate( draft, dimensions=['security', 'cost', 'reliability'] ) if score >= threshold: return draft feedback = comments raise NeedHumanReview(draft, score, comments) ``` 这段逻辑并不复杂,但实际效果取决于评估器的维度和标准是否合理。很多团队在这一步偷懒,只写一句“请评估这份方案”,结果反射流于形式。 ## 05、实战 拿一个真实场景来演示。假设我们要设计一个电商订单系统的架构方案,要求是高可用、安全、成本可控。先让模型生成第一版方案。 第一版方案大概是这样的:前端通过负载均衡访问后端服务,后端使用无状态服务集群,数据库采用 MySQL 主从复制,缓存使用 Redis,文件存储使用对象存储。听起来很标准,但很多关键细节缺失。 我们把这份方案交给评估器,从三个维度打分:安全、成本、可靠性。每个维度 0 到 5 分,总分低于 12 分就判定不通过。评估器给出的批评可能包括: - 安全:未提及 API 鉴权、传输加密、敏感数据落盘加密、SQL 注入防护,得 2 分。 - 成本:未考虑数据库连接数、缓存规格、跨可用区流量费用,也没有冷热数据分层,得 2 分。 - 可靠性:缺少限流、熔断、降级、备份策略、多可用区部署说明,得 2 分。 总分 6 分,不通过。反馈写回生成器。第二轮,生成器根据批评补上:增加 API 网关层的鉴权和限流,启用 TLS 传输加密,对用户敏感字段做应用层加密,增加 WAF,数据库改为多可用区部署,Redis 使用哨兵模式,增加每日全量备份和实时 binlog 备份。再次评估,安全 4 分,成本 3 分,可靠性 4 分,总分 11 分,仍差一点。反馈指出成本估算仍然没有具体依据。第三轮,生成器补充了按量付费、预留实例、冷热数据分层和缓存容量评估。最终安全 4 分,成本 4 分,可靠性 4 分,总分 12 分,通过。 这个例子说明反射确实能补上常见遗漏。但注意,评估器对“成本 4 分”的判断本身可能并不可靠——它并不真正知道云资源单价,也不清楚业务实际流量。这正是反射的边界。 ## 06、洞见 这里必须回答一个尖锐的问题:模型自己评价自己,真的可靠吗? 答案是:部分可靠,但远非完全可靠。反射能提升的是“维度覆盖”和“结构完整性”,它更擅长发现“该写没写”的问题,而不是“写了但写错”的问题。例如,补充了备份策略,但备份策略是否真的能恢复数据?评估器很可能判断不了。补充了多可用区,但跨可用区网络延迟对业务的影响有多大?评估器也无法精确评估。 根本原因在于,评估器和生成器共享同一个能力边界。如果底层模型对某个领域的知识存在盲区,那么生成器会犯错,评估器同样会忽略。就像一个实习生写的方案,另一个实习生来审,可能两人都不清楚某个行业合规要求。模型还可能对不确定的事情表现出过度自信,给出看似有理但事实错误的评分。比如成本估算,模型可能编出一个听上去合理的数字,但和云平台实际价格相差很大。 此外,反射还有一个隐性风险:如果评估标准设计不当,模型可能学会迎合标准,而不是真正提升质量。例如只考核“是否提到限流”,模型就会在所有方案里机械地加上“限流”二字,却没有具体阈值或实现方式。这会导致一种表面合规、实际空洞的输出。 因此,反射可以提升部分复杂任务质量,但不能替代确定性的验证、测试和人工审核。确定性的验证包括单元测试、静态扫描、成本计算器、故障注入、安全基线检查等,这些工具不依赖模型的主观判断。人工审核则负责把握那些需要经验和责任兜底的环节。 一句话总结:反射是内审,不是外审。内审有用,但不能取代外部审计。 ## 07、行动 既然反射有边界,我们应该怎么用? 第一,只把反射放到高价值复杂输出上。架构方案、安全策略、合同条款、复杂算法实现,这些值得多跑几轮。普通问答、摘要、文案润色,没必要增加第二次模型调用,因为成本和延迟增加,质量提升却很有限。 第二,评估维度要具体、可打分。不要写“评估方案质量”,而是写“从安全、成本、可靠性三个维度打分,每项 0 到 5 分,列出扣分原因”。维度越具体,反馈越可执行。 第三,设置最大轮次和达标阈值。一般 2 到 3 轮即可,超过这个次数往往收益递减。如果仍未达标,应该转入人工评审,而不是无限循环。 第四,在反射之后加一道确定性校验。例如用云成本计算器核算方案成本,用静态扫描工具检查安全配置,用故障注入测试验证高可用。反射负责查漏,确定性校验负责纠错。 第五,记录评估历史。每次评估的意见和修改过程最好留存,这样能分析模型反复犯的错,也能优化评估标准。 ## 08、小结 反射机制本质上是“生成 → 评价 → 修改”的反馈回路,与评估-优化模式一脉相承。它能帮我们把隐性的质量要求显性化,在架构方案、复杂代码等高价值场景中提升完整性和常见维度覆盖。但模型自己评价自己并不完全可靠,它受限于自身能力边界,不能替代确定性验证、测试和人工审核。 真正成熟的做法,是把它当成一道内置评审工序,而不是质量背书。懂得什么时候用、怎么用、什么时候停下,比盲目叠加模型调用重要得多。 ## 09、链接与概念说明 - Reflection:反射/反思,指让模型对已有输出进行批评和修正的机制,属于“生成→评价→修改”的反馈回路。 - Evaluator-Optimizer:评估-优化模式,将生成和评价分离,由评估器驱动生成器反复优化,与反射机制思路相近。 - 确定性验证:不依赖模型主观判断的检查手段,例如单元测试、静态扫描、成本计算器、故障注入、合规基线检查等。 - 官方示例:主流大模型平台的示例中提供了反射机制的参考实现,可查阅相关文档了解具体用法。 - 推荐实践:将反射作为复杂输出流程中的中间环节,而不是最终质量关卡,最终输出前应尽量经过确定性校验或人工审核。

优秀的个人博客,低调大师

《Spring AI 2.0实战》第23招 做到真正能上线

## 01、痛点 凌晨两点,运维群突然炸了。AI客服在订单页里信誓旦旦地告诉用户:您的退货政策是30天内可退,运费由平台承担。问题是,这个政策半年前就改成7天了,而且用户所在地区有特殊规则。为什么AI能一本正经地胡说?因为向量库超时,RAG检索返回空,模型没有拿到知识,又不敢说自己不知道,于是用训练数据里的旧记忆编了一段。 我是老李,过去一年我见过不少团队把演示环境里的AI能力直接推上生产。演示很漂亮,上线很狼狈。撞上的问题基本不是模型不够聪明,而是时间超了、限流了、模型挂了、向量库挂了、工具调用失败了、流式输出断了、成本爆了、厂商要切了。每一个都足够让用户怀疑人生。 最典型的场景:用户问“我的订单到哪了”,Tool去查物流,网络抖动超时。理想情况是系统说“暂时查不到,请稍后再试”。实际情况往往是模型没有拿到Tool返回,就自己补了一个单号,还补得有模有样。这不是技术故障,这是业务事故。 为什么现在要讲这个?因为大模型的接入门槛似乎被拉低了,很多团队以为只要把接口调通、把提示写清楚,就能上生产。但他们忽略了,生产化意味着系统不仅“回答得出来”,还要在回答不出来的时候,依然可控、可预期、可追溯。 ## 02、是什么 生产级AI系统的可靠性,本质不是在追求智能上限,而是在给智能下限兜底。我把它定义为:系统不仅“回答得出来”,还要应对Timeout、429、模型故障、Vector Store故障、Tool失败、流式断连、成本失控和Provider切换。 要做到这一点,靠的不是某一个银弹,而是一组基础能力。这组能力包括: Timeout:每一个外部依赖调用都必须有截止时间。模型生成、向量检索、工具调用、MCP能力发现,都要设置单独的超时,不能无限等待。 Retry:重试要分场景。对幂等的查询可以重试,对已经产生副作用的调用要谨慎。重试必须带指数退避和最大次数,否则会放大故障。 Fallback:主路径失败后,系统要有一条可用的备选路径。备选不一定要同等智能,但必须明确可用。 Rate Limit:对模型、工具、协议的调用要做频率和并发限制,既保护下游,也保护自己的钱包。 Circuit Breaker:连续失败达到阈值后,快速熔断,让流量不再打到已经不可用的依赖上,给下游恢复时间。 Cache:对相似请求做缓存。缓存不是为了让AI更聪明,而是为了降本和提速,尤其是高频知识问题。 Model Router:根据任务难度、成本、延迟、健康状态,把请求分发到不同模型。一个模型挂了,路由要能切到另一个。 Graceful Degradation:最后一道防线,当所有主路径都不可用时,系统能降级到更弱但可用的能力,或者干脆明确拒绝。 这八项能力加在一起,才构成生产化AI的底座。生产化不是让系统更聪明,而是让系统在极端情况下仍然可预期。 ## 03、为什么 有人会问,传统后端不也一直做稳定性吗?为什么AI服务这么特殊? 第一个原因是依赖面变多。传统服务可能只依赖数据库和缓存,而一个生产AI链路往往依赖模型、向量库、外部工具、MCP协议,以及它们之间的网络。假设每个依赖的可用性是99%,四个依赖串行下来只有96.06%,这还没算限流、超时和模型输出的概率波动。 第二个原因是模型本身是概率系统。同样一个问题,可能上一次回答正确,下一次重试却跑偏。超时重试尤其危险,因为两次生成结果可能不一致,甚至产生冲突。这意味着很多传统上靠重试解决的问题,在AI场景下不能无脑用。 第三个原因是静默错误比显式失败更可怕。传统接口报500,大家看得见。AI可能在检索失败后继续生成,把猜测当成事实。这种错误没有异常日志,没有返回码,却会造成最严重的信任问题。所以生产AI必须优先解决不可预测的失败,而不是只关注成功率。 第四个原因是成本失控。模型调用按token计费,工具调用可能有次数配额。如果没有Rate Limit和预算控制,一次故障可能引发重试风暴,几分钟烧掉一个月的预算。429错误本身也常常是因为你在厂商侧的配额被刷爆。 第五个原因是Provider切换不可避免。无论你选哪家模型厂商,都会遇到限流、故障、服务降级。如果没有Model Router和配置化切换,每次切换都要改代码、发版本,这在生产环境是不可接受的。 ## 04、架构 在生产AI的架构里,我建议把系统分成四层:接入层、编排层、依赖层、可观测层。 接入层负责解析用户请求、管理会话和输出格式。编排层是核心,负责调用模型、RAG、Tool、MCP,并执行超时、重试、熔断、降级等策略。依赖层是外部服务和协议,可观测层则贯穿所有调用,记录Trace、日志、指标和账单。 关键是,不要把这些兜底逻辑散落在业务代码里。业务代码只声明意图,具体调用哪个模型、超时多少、失败后降级到哪,应该由编排层统一治理。否则每个业务开发都按自己的理解写一套,最后平台化改造会非常痛苦。 针对四类依赖,要提前设计统一的Failure Mode表: Model的失败模式包括超时、429、内容不合规、输出截断、空响应。RAG的失败模式包括向量库超时、索引缺失、相似度低、返回空、格式错误。Tool的失败模式包括调用超时、返回结构错误、业务拒绝、参数不合法。MCP的失败模式包括协议握手失败、能力发现超时、工具描述变更、权限异常。 每一种失败模式都要有对应的超时策略、重试策略、熔断阈值和降级动作。不要等到线上出问题再拍脑袋。 可观测层同样重要。每一个Model调用、RAG检索、Tool调用、MCP握手都要带上trace_id,并且把耗时、状态、重试次数、降级原因记录下来。没有这些记录,故障复盘就靠猜。 架构原则很简单:主路径可以失败,降级路径必须可解释,所有失败都可以追溯。 ## 05、实战 下面说几个我落地过的具体场景。 场景一,主模型超时降级到备用模型。 我们把主模型的超时设成800毫秒,连续3次超时触发熔断。熔断后Model Router把流量切到备用模型。备用模型能力弱一些,但处理简单咨询够了。同时保留10%的流量继续探测主模型,主模型恢复后再切回来。注意,这里没有做无限重试,因为重试会放大延迟,还会增加成本。 场景二,RAG不可用时禁止编造知识答案。 当向量库超时或相似度低于阈值时,系统必须触发降级模板:我暂时无法查询该政策,请稍后再试或转人工。这里最关键的不是模板写得有多好,而是禁止模型自由发挥。很多事故不是检索坏了,而是检索坏了之后模型还在生成,而且生成得特别自信。 场景三,Tool超时返回可解释失败并保留Trace。 物流查询Tool的调用超时设成800毫秒。超时后,编排层返回一个结构化错误:{ code: TOOL_TIMEOUT, message: 物流查询暂时不可用 },并把trace_id放进上下文。前端展示友好提示,用户不会看到异常堆栈。后端保留完整失败记录,后续可以看是网络问题还是下游故障。 场景四,MCP协议故障降级。 MCP握手或能力发现超时,编排层会禁用该MCP提供的工具,降级为本地只读能力。如果权限校验异常,则直接终止调用链,不允许执行未知工具。 另外,流式断连也不能忽视。SSE流式输出到一半断开,客户端要能够重连,或者服务端要做幂等缓存。对于已经生成的部分内容,如果用户重复请求,可以直接从缓存恢复,避免重复扣费。 成本失控方面,我们给每个用户每天设了token预算,给每个场景设了QPS上限。预算用完就返回明确提示,而不是继续扣费。每个月对账单做一次归因,找出哪些场景是成本黑洞。 这些实战方案都不复杂,关键在于提前设计,而不是等事故发生了再补救。 ## 06、洞见 这里有一个问题值得讨论:AI服务是不是越自动越好? 我的答案是否定的。越自动,越需要人为设定边界。全自动意味着故障也被全自动放大。生成式AI的产出带有不确定性,如果让它在没有边界的情况下自动调用工具、自动回答知识问题,一旦某个环节出错,错误会被包装成非常像正确答案的内容。 生产AI最重要的能力之一,是在智能能力不可用时仍然可预测地失败。这句话听起来有点反直觉,但经历过几次事故就会明白。用户不怕系统说“我现在做不了”,用户怕的是系统说得头头是道,结果全是错的。 失败分三种:可预测失败、不可预测失败、静默错误。可预测失败可以降级,不可预测失败可以熔断,静默错误最难处理。模型编造、工具错误被吞、检索失败后继续生成,都是静默错误。生产AI的稳定性工作,很大程度上是在消灭静默错误。 所以,可解释的“我不能”比强撑的“也许对”更有价值。系统的可信度不是建立在永远正确上,而是建立在错误时也能被识别和处理上。 自动化的边界也应该重新划分:把确定性部分自动化,比如路由、限流、熔断、缓存;把不确定性部分留给可观测和人工复核,比如内容合规、知识准确性。团队的重心要从模型调优,逐步转向失败工程。 ## 07、行动 如果你正在把AI能力推上生产,可以按下面的顺序落地。 第一步,为Model、RAG、Tool、MCP四类依赖分别设计Failure Mode和降级方案。不要笼统地说“要做稳定”,要具体到每一类依赖每一种失败模式。 对于Model:主模型超时,触发熔断并路由到备用模型;遇到429,使用指数退避;内容不合规,拒绝输出并记录;输出截断,提示用户重新生成或缩短上下文。 对于RAG:向量库超时,返回明确不可查提示;相似度太低,告知用户未找到依据;索引缺失,禁止模型自由发挥;返回空结果,走兜底话术。 对于Tool:调用超时,返回可解释失败;返回结构错误,丢弃并重试一次;业务拒绝,原样透传原因;参数不合法,修正参数或拒绝调用。 对于MCP:协议握手失败,禁用该MCP能力;能力发现超时,使用本地缓存的能力列表;工具描述变更,先比对版本再执行;权限异常,终止调用链。 第二步,先做Timeout和Fallback。这两项门槛最低,收益最大。每个依赖都要有超时,每条主路径都要有备选。 第三步,再做Retry和Circuit Breaker。重试只对幂等操作,熔断阈值可以从3次连续失败开始。 第四步,最后做Cache、Model Router和预算控制。这三项需要更多数据支撑,但做好了能明显降本提效。 第五步,每周复盘失败案例,维护一份Failure Mode清单。每出现一种新故障,就补进清单,并落实到代码和配置里。 ## 08、小结 生产化AI不是让回答更聪明,而是让失败更体面。真正拉开差距的,不是模型在正常情况下的表现,而是模型、知识库、工具、协议任何一个环节不可用时,系统是否还能给出确定、可解释、可追溯的结果。 当你把超时、重试、降级、限流、熔断、缓存、路由和优雅降级都做扎实,用户不会觉得系统变笨了。相反,他们会更信任这个系统,因为它知道什么时候该说“我能”,什么时候该说“我不能”。 ## 09、链接与概念说明 这里整理几个文中提到的关键概念: Timeout:调用方为一次外部请求设置的最长等待时间,超过即按失败处理。 Retry:失败后的重试机制,通常配合指数退避和最大次数使用,适合幂等操作。 Fallback:主路径不可用时的备选方案,可以是备用模型、缓存结果或明确拒绝。 Rate Limit:对单位时间内调用次数的限制,保护下游服务和控制成本。 Circuit Breaker:熔断器,当连续失败达到阈值后快速失败,避免雪崩。 Cache:对相同或相似请求的结果进行缓存,降低延迟和成本。 Model Router:根据场景、成本、延迟、健康状态把请求分发到不同模型。 Graceful Degradation:优雅降级,在部分依赖不可用时提供更弱但可用的服务。 这些概念大多来自后端稳定性和分布式系统的经典实践。如果想进一步了解,可以搜索 resilience engineering、circuit breaker pattern、graceful degradation 等关键词。它们不是新概念,但在生成式AI生产化里,被赋予了新的必要性。

优秀的个人博客,低调大师

《Spring Boot + JPA 实战》第8招 关联关系别乱加

## 01、痛点 前几天,团队里一个做了三年后端的兄弟在群里甩了一张堆栈截图,附了一句:“我明明只加了一个订单项,怎么它给我更新了订单表?”我点开一看,Order 实体上标着 @OneToMany,OrderItem 上又标着 @ManyToOne,两边都配了 JoinColumn。保存订单时,Hibernate 先插了 OrderItem,又回头更新 Order 的外键,最后还抛了个约束冲突。这哥们很委屈:“写起来就两个注解的事,咋还翻车了?” 我是老李。今天我们不聊花活,就聊每个写 JPA 的人都会踩的坑:关联映射不是写注解,而是在设计对象图和数据库之间的契约。尤其 Customer → Order → OrderItem → Product 这条链,几乎每个电商项目都会遇到,但能一次写对的人不多。要么是外键为 null,要么是子实体删不掉,要么是双向关系内存和数据库各说各话。更隐蔽的是,很多人根本没意识到问题出在哪,只能靠“清缓存、重新查”硬扛。 ## 02、是什么 要搞明白这个坑,先得把几个概念钉在墙上:owning side、mappedBy、Cascade、orphanRemoval、双向关系同步、DDD 聚合边界。 先说 owning side 和 mappedBy。在 JPA 里,关系映射不是“定义关系”,而是“定义谁负责把关系写进数据库”。拥有外键列的那一方,就是 owning side。对于 @ManyToOne 和 @OneToMany 这种一对多组合,外键总是放在“多”的那一端。也就是说,OrderItem 表里有个 order_id 字段,那么 OrderItem 就是 owning side,Order 上的 @OneToMany 只是反向映射,必须写 mappedBy = "order"。mappedBy 的意思很直白:我不维护外键,我只是对方关系的镜像。如果你在 Order 上写了 @JoinColumn,又不在 OrderItem 上写 @JoinColumn,Hibernate 会以为有两个不同的关系,从而生成两个外键列,或者产生一堆冗余的 UPDATE 语句。 再说 Cascade 和 orphanRemoval。Cascade 描述的是持久化操作在关系上的传播范围。比如 CascadeType.ALL 表示父实体的 persist/merge/remove 等操作会传递给子实体。orphanRemoval 则更精细一点,它回答的问题是:当一个子实体从父集合中被移除,并且不再被任何父引用时,要不要直接删掉数据库记录?把 orphanRemoval 想象成“孤儿清除”,它只对从集合中移除的子实体生效。CascadeType.REMOVE 则是在父实体被删除时级联删除所有子实体。两者容易混淆,但很多场景下会配合使用:父删子也删,子被踢出集合也删。 双向关系同步是内存层面的工作。因为 Java 对象图是双向引用,数据库却只有外键。如果 Order.getItems().add(item) 之后,item.getOrder() 还是 null,那么持久化上下文在脏检查时就可能做出错误的 SQL 操作。真正可靠的同步方式是在聚合根里提供管理方法,比如 addItem、removeItem,把双向引用一起维护。 最后是 DDD 聚合边界。聚合边界决定了一组对象应该作为一个整体被外部访问。Order 就是聚合根,OrderItem 是聚合内部的实体,外部只允许通过 Order 来修改订单项。这样就把“谁负责维护关系”锁定在了聚合内部,避免外部代码随意操作子实体导致不一致。 ## 03、为什么 你可能会问,为什么双向关系这么容易导致 Java 内存状态和数据库状态不一致?核心原因是对象图有多个入口,而数据库只有一个事实来源。当你拥有 Order 和 OrderItem 两个方向的引用时,其实是同一个业务事实在内存里存了两份。如果只更新其中一份,另一份还停留在旧状态,持久化上下文却会在事务提交时尝试同步所有变更。它的脏检查机制会根据对象当前状态生成 SQL,但它不负责帮你调和两个方向之间到底谁说了算。于是你就会看到一些诡异的 SQL:明明只改了一个字段,却多出几条 update;明明从集合里删了,子实体还赖在数据库里。 另外,ManyToMany 在真实项目中经常应该改成显式中间 Entity。因为 ManyToMany 隐藏了中间表,中间表里只有两个外键,加不了任何业务字段。一旦业务需要一个“打标签的时间”或者“角色里的部门范围”,你就得拆。拆成显式中间实体之后,对象图更简单,关系更清晰,还能顺便把聚合边界收紧。 更深一层的原因是,实体之间的关联越多,不代表模型越丰富,反而可能意味着对象图越来越不可控。每一条双向关联都是一条需要维护一致性的路径。如果你在 Customer、Order、OrderItem、Product 之间都放上双向导航,任何一端的变化都可能触发连锁加载和连锁 SQL。更糟的是,级联范围一旦配错,删除一个用户可能会把整条订单链全部带走。这也是为什么很多有经验的开发者会刻意减少实体之间的导航线,能用 ID 引用就不用对象引用,能用单向就不用双向。 ## 04、架构 聊完原理,我们把它放到一个实际的电商订单场景里。聚合边界应该怎么画? 先看 Customer 和 Order 的关系。Customer 是一个聚合根,Order 通常也是独立聚合根。它们之间用单向的 @ManyToOne 从 Order 指向 Customer 就够了,不需要 Customer 上放 @OneToMany 集合。如果你确实需要“某个用户的所有订单”,可以通过 OrderRepository 里加一个 findByCustomerId 来查询,而不是在 Customer 对象上维护一堆 Order。这样聚合边界清楚,也不会因为加载用户时把订单全部扯出来。 再看 Order 和 OrderItem。Order 是聚合根,OrderItem 是聚合内部实体。两者的关系是双向的,但维护权必须交给 Order。Order 上配置 @OneToMany(mappedBy = "order", cascade = CascadeType.ALL, orphanRemoval = true),OrderItem 上配置 @ManyToOne(fetch = FetchType.LAZY) @JoinColumn(name = "order_id")。注意,@OneToMany 默认是懒加载,@ManyToOne 默认是急加载,所以这里显式改成 LAZY 可以避免查订单项时把每个订单项关联的 Order 全部查出来。虽然这里 Order 已经在上下文里,但显式 LAZY 是一种习惯,能减少意外查询。 OrderItem 与 Product 的关系。Product 是独立聚合,OrderItem 需要引用商品,但最好不要直接用对象引用去穿到 Product 聚合内部。更稳妥的做法是在 OrderItem 里保留 productId 和必要的快照字段(比如商品名称、单价、下单时的规格)。如果一定需要实体关联来查询,可以使用 @ManyToOne(fetch = FetchType.LAZY) 加 @JoinColumn(name = "product_id"),但务必注意跨聚合的级联要关闭,否则保存订单时可能意外修改商品表。 再看看 ManyToMany。在 OrderItem 里,如果出现商品和优惠券、商品和标签等多对多,真实项目里几乎都要拆成显式中间实体。比如 Product 和 Tag 原来是 @ManyToMany,后来业务要求记录“谁在什么时候打了这个标签”,这时就要新建 ProductTag 实体,包含 product、tag、createdBy、createdAt。这样既保留了多对多关系,又扩展了业务属性,还没有隐式中间表带来的维护难度。 ## 05、实战 下面用代码把这条链串起来。假设我们有四个实体:Customer、Order、OrderItem、Product。 先定义 Customer: ```java @Entity public class Customer { @Id @GeneratedValue private Long id; private String name; // 不配置 orders 集合,需要时通过 OrderRepository 查询 } ``` 这里故意不配置 @OneToMany,保持 Customer 聚合根干净。 再定义 Order: ```java @Entity public class Order { @Id @GeneratedValue private Long id; @ManyToOne(fetch = FetchType.LAZY) @JoinColumn(name = "customer_id") private Customer customer; @OneToMany(mappedBy = "order", cascade = CascadeType.ALL, orphanRemoval = true) private List items = new ArrayList<>(); public void addItem(OrderItem item) { items.add(item); item.setOrder(this); } public void removeItem(OrderItem item) { items.remove(item); item.setOrder(null); } } ``` addItem 和 removeItem 是唯一允许修改 items 集合的入口。它们同时维护了双向引用。这样外部代码就不会出现只加了一边的情况。 接着定义 OrderItem: ```java @Entity public class OrderItem { @Id @GeneratedValue private Long id; @ManyToOne(fetch = FetchType.LAZY) @JoinColumn(name = "order_id") private Order order; @ManyToOne(fetch = FetchType.LAZY) @JoinColumn(name = "product_id") private Product product; private int quantity; private BigDecimal priceSnapshot; } ``` 最后是 Product: ```java @Entity public class Product { @Id @GeneratedValue private Long id; private String name; private BigDecimal price; } ``` 新增订单项时,可能写成这样: ```java Order order = orderRepository.findById(orderId).orElseThrow(); Product product = productRepository.findById(productId).orElseThrow(); OrderItem item = new OrderItem(); item.setProduct(product); item.setQuantity(2); item.setPriceSnapshot(product.getPrice()); order.addItem(item); // 关键:这里同时设置了 item.order = order orderRepository.save(order); ``` 因为 Order 上的 items 是 mappedBy = "order",真正的 owning side 是 OrderItem 的 order 字段。addItem 方法内部调用了 item.setOrder(this),所以外键不会为 null。同时 cascade = CascadeType.ALL 会在保存 Order 时级联保存 OrderItem。orphanRemoval = true 则在删除订单项时发挥作用。 删除订单项: ```java Order order = orderRepository.findById(orderId).orElseThrow(); OrderItem target = order.getItems().stream() .filter(i -> i.getId().equals(itemId)) .findFirst() .orElseThrow(); order.removeItem(target); // 从集合中移除,并把 target.order 置为 null orderRepository.save(order); ``` 事务提交时,Hibernate 会发现 target 已经不在 items 集合中,并且 order 引用被置为 null,于是触发一条 delete from order_item where id = ?。这就是 orphanRemoval 的效果。 这里有一个常见错误:有人直接在业务代码里写 order.getItems().remove(target),但不调用 item.setOrder(null)。这样会导致 order 集合里移除了,但 item 仍然持有 order 引用。持久化上下文可能认为 item 还有指向 order 的引用,于是不会删除,反而尝试把 order_id 更新为 null 或抛出约束冲突。所以,双向同步必须封装在聚合根内,不能依赖外部自觉。 ## 06、洞见 写了这么多年 JPA,我越来越觉得:实体之间的关联越多,不代表模型越丰富,反而可能意味着对象图越来越不可控。很多项目的实体关系图看起来密密麻麻,线画得很有成就感,但一到运行时,加载策略、级联策略、脏检查互相作用,调试起来异常痛苦。 一个真正成熟的模型,会刻意保持对象图的稀疏。能用单向关联,就不上双向;能用 ID 引用,就不引入对象引用;能用显式中间实体,就不留隐式 @ManyToMany。这样做不是技术上做不到,而是为了可控。每少一条关联线,就少一处需要维护一致性的地方。 订单这个例子就很典型:Customer 不持有 Order 集合,Order 聚合内维护 OrderItem 的双向关系但外部只能通过 Order 操作。Product 作为独立聚合只被引用 ID,不反向持有订单项。整个对象图的方向是清晰的,外键所有权也一清二楚。即使系统后续扩展优惠、退款、分期等,也不会因为关联太密而需要推翻重来。 ## 07、行动 如果你现在的项目里还有 @ManyToMany,建议你尽快动手把它改掉。别等业务字段来了再改,那时候成本更高。 举个具体的行动场景:Product 和 Tag 原来是多对多,现在需要记录“谁在什么时候给商品打了某个标签”。你可以这样做。 第一步,新建中间实体 ProductTag: ```java @Entity public class ProductTag { @Id @GeneratedValue private Long id; @ManyToOne(fetch = FetchType.LAZY) @JoinColumn(name = "product_id") private Product product; @ManyToOne(fetch = FetchType.LAZY) @JoinColumn(name = "tag_id") private Tag tag; private String createdBy; private LocalDateTime createdAt; } ``` 第二步,把 Product 和 Tag 上的 @ManyToMany 去掉,改为通过 ProductTag 来查询关联。可以在 Product 上配置 @OneToMany(mappedBy = "product"),也可以完全不加,通过 ProductTagRepository 查询。我更倾向于后者,因为这样 Product 聚合不负责维护标签关系。 第三步,业务代码从 `product.getTags().add(tag)` 改为: ```java ProductTag productTag = new ProductTag(); productTag.setProduct(product); productTag.setTag(tag); productTag.setCreatedBy("laoli"); productTag.setCreatedAt(LocalDateTime.now()); productTagRepository.save(productTag); ``` 以后如果要加“删除原因”或者“有效期”,直接往 ProductTag 上加字段,完全不会影响 Product 和 Tag 本身的模型。中间实体成了业务概念的载体,而不是一段只有两个外键的隐式关系。 ## 08、小结 JPA 的关联映射,写注解只是第一步,真正的功夫在边界和所有权。owning side 和 mappedBy 决定外键由谁维护;Cascade 和 orphanRemoval 决定生命周期如何传播;双向同步决定内存状态是否一致;DDD 聚合边界决定对象图的复杂度上限。 回到最开始那个问题:为什么双向关系容易内存和数据库不一致?因为内存里有两个事实副本,数据库只有一个。谁负责同步,谁就是聚合根的方法。不要让外部代码直接伸出无数只手去改动集合,否则对象图迟早变成一团乱麻。 下次再写 @OneToMany 时,先停下来想一想:谁持有外键?谁来维护双向引用?子实体从集合移除时,是要删掉还是只解除关系?这三点想清楚,比记住一百个注解配置都有用。 ## 09、链接与概念说明 这里把文中反复提到的几个概念做一次集中说明: - owning side:持有外键列的关系方,数据库根据它来持久化关联。 - mappedBy:标注在非 owning side 上,表示“我不维护外键,只是对方关系的镜像”。 - Cascade:级联操作范围,告诉 JPA 父实体的哪些持久化操作要传递给子实体。 - orphanRemoval:孤儿删除开关,当子实体从父集合中移除时,是否直接删除数据库记录。 - 双向关系同步:在内存中同时维护两个方向的引用,通常封装在聚合根的方法里。 - DDD 聚合边界:将一个聚合根及其内部实体作为一个整体对外访问,外部不允许绕过聚合根直接修改内部实体。 建议进一步阅读:Hibernate 官方文档中关于 association 的部分;Vlad Mihalcea 的博客里有关双向关联同步、@ManyToMany 拆中间实体的文章;以及 Eric Evans 在《领域驱动设计》中关于聚合边界的论述。你不需要一次掌握全部,但每次写实体关系时,回来对照这几个概念,慢慢就能形成肌肉记忆。

优秀的个人博客,低调大师

《Spring Boot + JPA 实战》第15招 JPA也要懂索引

我是老李,最近被问到一个问题:为什么在订单 Entity 上加了几个 @Index,查询还是慢?我让他把慢 SQL 发来,一看,租户隔离的订单列表,过滤 tenant_id 和 status,再按 created_at 倒序分页。SQL 大概长这样: ```sql SELECT id, tenant_id, status, created_at, amount FROM orders WHERE tenant_id = 10001 AND status = 'PAID' ORDER BY created_at DESC LIMIT 20; ``` 表里几百万行,tenant_id 有索引,status 也有索引,但 MySQL 依然全表扫描或 filesort。这时候说“JPA 可以生成 SQL,但不能替你设计 MySQL 索引和执行计划”,就不是一句正确的废话,而是线上事故总结出的结论。 ## 01、痛点 在 ORM 里,加索引往往变成给实体类字段加注解,比如 @Table(indexes = @Index(...))。但注解只是建表 DDL 的一部分,不感知组合查询、排序方向、回表代价。MySQL 优化器可能选择错误的路径,因为多个单列索引不如一个联合索引。问题经常出现在分页查询、租户隔离系统、订单状态流转等核心链路。注解索引造成“有索引”的假象,线上慢查询依然发生。 更麻烦的是,JPA 生成 SQL 时可能对实体关系进行意外 join、distinct、in 展开等,进一步偏离开发者印象。你以为会走 idx_tenant,实际执行计划却走了 idx_status,甚至全表扫描。慢查询不是一个固定 SQL,而是随数据分布、参数变化、优化器统计信息变化而漂移。 ## 02、是什么 先厘清几个概念。JPA 或者具体到 Hibernate,会根据方言把 JPQL、Criteria 或方法名派生的查询转换成数据库 SQL,同时处理分页、批量、缓存。Hibernate 打印出来的 SQL 只是最终字符串,真正执行在数据库。SQL 生成不等于 SQL 执行,中间隔着编译器、优化器和存储引擎。 MySQL 侧的核心概念有这些。 B+Tree 是 InnoDB 的默认索引结构,叶子节点按索引键排序,叶子间有双向链表。主键索引是聚簇索引,整行数据存在叶子节点;二级索引叶子节点存索引键和主键值。 联合索引是多个列组成一个 B+Tree 键,先按第一列排序,第一列相同再按第二列,依次类推。最左匹配要求查询条件包含联合索引最左连续列才能有效利用。例如 (tenant_id, status, created_at) 可以支持 tenant_id= ?,也可以支持 tenant_id=? AND status=? 以及三列全给;但如果只给 status 而没有 tenant_id,就不能有效利用这个联合索引。 覆盖索引指查询需要的所有列都在索引里,直接从索引叶子拿到数据,不再回表。执行计划的 Extra 会出现 Using index。回表是指二级索引找到主键后,还要回到主键索引查完整行,成本随行数线性增加。 Cardinality 是索引列或索引组合中不同值的估计数量,优化器用它估算选择性。数据倾斜会导致估算偏差,需要 ANALYZE TABLE 更新统计信息。EXPLAIN 展示优化器估计的执行计划,包括 type、possible_keys、key、rows、filtered、Extra。EXPLAIN ANALYZE 是 MySQL 8.0.18 起支持的实际执行分析,会真实执行查询并返回每步实际行数、耗时。 ## 03、为什么 为什么在 Entity 上随便加几个 @Index 不叫索引设计?因为索引设计必须与查询模式对齐,必须观察真实 SQL 和真实执行计划。注解只是建表选项,不会根据 Repository 方法的组合条件、排序方向、分页大小动态调整。你写的 @Index(columnList = "tenant_id") 和 @Index(columnList = "status"),是两根单列索引,不等于联合索引。数据库优化器很难同时利用两个单列索引完成等值过滤和排序。 为什么必须捕捉真实 SQL?JPA 可能生成不是你印象中的 SQL。自动分页可能改写成 limit/offset,实体关联可能引入 join,多态查询可能生成 union。参数绑定类型、会话变量、方言差异都会影响最终 SQL 和优化器行为。凭 JPQL 猜索引常常是刻舟求剑。 为什么 ORM 改变不了物理成本?ORM 省去手写 SQL 和结果集映射的力气,但没有消除数据库访问数据页、判断键范围、排序、回表、加锁的成本。无论 SQL 是手写还是框架生成,执行计划都会落到 InnoDB 的 B+Tree 上。框架只能决定发送什么 SQL,不能决定存储引擎怎么执行。 ## 04、架构 可以把一次查询的路径拆成:Repository 方法 -> Hibernate 生成 SQL -> JDBC 发送 -> MySQL 解析/优化 -> 选择索引 -> InnoDB 读取 B+Tree -> 回表/排序 -> 返回结果集。每一层都可能出问题,但最容易忽略的是优化器选择索引和 InnoDB 扫描范围。 针对 tenant_id + status + created_at 的订单查询,如果只有 idx_tenant 和 idx_status 两根单列索引,优化器通常会选择选择性更高的一列,先用索引扫出一批主键,再回表过滤另一列,最后对 created_at 做 filesort。这个 filesort 可能成为灾难,因为每一页查询都要把一个大租户的所有订单捞出来排序,再取前 20 条。由于 ORDER BY 和过滤条件无法同时被一个索引覆盖,性能随数据量增长而急剧下降。 如果建立联合索引 (tenant_id, status, created_at),执行路径会完全不同。tenant_id 和 status 是等值条件,命中前两列;created_at 在第三列,索引天然按 created_at 升序排列。查询要求 ORDER BY created_at DESC,MySQL 可以反向扫描索引,从最后一个满足 tenant_id 和 status 的索引条目开始向回读取,直接得到有序结果,不再需要 filesort。如果查询只需要索引里的列,还能变成覆盖扫描,连回表都省了。 ## 05、实战 先拿真实 SQL。打开 Hibernate 日志,可以用 show_sql、format_sql,或者把 org.hibernate.SQL 的日志级别调到 DEBUG。看到 SQL 后,把绑定参数替换成具体值。慢查询示例: ```sql SELECT id, tenant_id, status, created_at, amount FROM orders WHERE tenant_id = 10001 AND status = 'PAID' ORDER BY created_at DESC LIMIT 20; ``` 初始表结构: ```sql CREATE TABLE orders ( id BIGINT PRIMARY KEY AUTO_INCREMENT, tenant_id BIGINT NOT NULL, status VARCHAR(32) NOT NULL, created_at DATETIME NOT NULL, amount DECIMAL(10,2), INDEX idx_tenant (tenant_id), INDEX idx_status (status) ) ENGINE=InnoDB; ``` 对这 SQL 执行 EXPLAIN,结果类似: | id | select_type | table | type | possible_keys | key | key_len | rows | Extra | | --- | --- | --- | --- | --- | --- | --- | --- | --- | | 1 | SIMPLE | orders | ref | idx_tenant | idx_tenant | 8 | 180000 | Using where; Using filesort | type=ref 表示用了非唯一索引,但 rows 还是 18 万,说明一个租户下订单很多。status 过滤发生在回表之后,所以 Extra 是 Using where;排序无法利用索引,所以 Using filesort。 建立联合索引: ```sql ALTER TABLE orders ADD INDEX idx_tenant_status_created (tenant_id, status, created_at); ``` 再执行 EXPLAIN,结果可能变成: | id | select_type | table | type | possible_keys | key | key_len | rows | Extra | | --- | --- | --- | --- | --- | --- | --- | --- | --- | | 1 | SIMPLE | orders | ref | idx_tenant_status_created | idx_tenant_status_created | 70 | 20 | Using index condition; Backward index scan | rows 从 18 万降到 20,不再有 Using filesort。Backward index scan 表示优化器反向扫描联合索引来满足 ORDER BY created_at DESC。Using index condition 表示使用索引条件下推,减少回表行数。 如果业务查询只需要 id、tenant_id、status、created_at、amount 五列,可以把 amount 也加入索引,做成覆盖索引: ```sql ALTER TABLE orders ADD INDEX idx_tenant_status_created_cover (tenant_id, status, created_at, id, amount); ``` 在执行计划中 Extra 可能出现 Using index,表示直接从二级索引取数,不再回表。代价是索引变大,写入性能略微下降。需要根据读写比例权衡。 再用 EXPLAIN ANALYZE 看真实耗时: ```sql EXPLAIN ANALYZE SELECT id, tenant_id, status, created_at, amount FROM orders WHERE tenant_id = 10001 AND status = 'PAID' ORDER BY created_at DESC LIMIT 20; ``` 输出可能包含 actual time、rows、loops,例如: ```text -> Limit: 20 row(s) (actual time=0.213..0.221 rows=20 loops=1) -> Index lookup on orders using idx_tenant_status_created (tenant_id=10001, status='PAID') (actual time=0.210..0.216 rows=20 loops=1) ``` 这说明实际只扫描了 20 行,而不是估计值。 有时优化器不选联合索引,可以检查 Cardinality。执行: ```sql ANALYZE TABLE orders; SHOW INDEX FROM orders WHERE Key_name = 'idx_tenant_status_created'; ``` 重点关注 Cardinality 一列,它不是精确值,但用于估算选择性。如果租户数据倾斜,某些 tenant_id 下有大量订单,优化器可能认为过滤性不足而放弃索引。此时需要结合 query 类型和实际排序需求决定是否使用 force index 或调整索引列顺序。 ## 06、洞见 ORM 改变 SQL 的生成方式,却不会改变数据库执行 SQL 的物理成本。这是整件事的核心。很多团队把性能问题归咎于 JPA 不行,或者怪 Hibernate 生成 SQL 难看,但实际上多数慢查询的根子在索引和执行计划。框架可以替你写 SQL,但不能替你决定数据怎么存、怎么扫、怎么排序。 索引设计是数据库侧的工程,不是注解层面的工程。它要回答的是:这条查询会访问多少行?能不能靠索引完成过滤和排序?会不会回表?索引维护成本能否接受?这些问题只有对着真实 SQL 和 EXPLAIN 才答得出来。 另一个容易被忽视的点是,执行计划不是一劳永逸。表数据增长、统计信息过期、查询参数改变,都会导致优化器改变决策。因此核心查询需要持续监测,而不是上线后就不再回头。 ## 07、行动 为 5 条核心 Repository 查询建立“方法 → SQL → Plan → Index”对照表。这是最小可行动作。示例: | Repository 方法 | 生成 SQL 摘要 | 初始 EXPLAIN | 索引设计 | 优化后 EXPLAIN | | --- | --- | --- | --- | --- | | findPageByTenantAndStatusOrderByCreatedAtDesc | select ... where tenant_id=? and status=? order by created_at desc limit ? | type=ref, key=idx_tenant, rows=180000, Using filesort | (tenant_id, status, created_at) | type=ref, key=idx_tenant_status_created, rows=20, Backward index scan | | findByIdList | select ... where id in (?, ?, ?) | type=range, key=PRIMARY, rows=取决于列表长度 | 保持主键索引 | type=range, key=PRIMARY | | countByTenantAndStatus | select count(*) ... where tenant_id=? and status=? | type=ref, key=idx_tenant, rows=大 | (tenant_id, status) | type=ref, key=idx_tenant_status_created | | findRecentByTenant | select ... where tenant_id=? order by id desc limit ? | type=ref, key=idx_tenant, rows=大, Using filesort | (tenant_id, id) 或依赖主键顺序 | type=ref, key=复合索引, Backward index scan | | findExpiredOrders | select ... where status='EXPIRED' and created_at < ? order by created_at | type=ref 或 range,但排序差 | (status, created_at) | type=range, key=idx_status_created, rows=小 | 对照表要落到代码仓库,贴在仓库文档或评审模板里。具体步骤: 1. 打开 SQL 日志,收集 5 条核心方法的真实 SQL。 2. 对每条 SQL 执行 EXPLAIN,记录 type、key、rows、Extra。 3. 设计联合索引,遵循最左匹配,把等值条件列放前面,排序列放后面。 4. 在从库或预发环境执行 ALTER TABLE,观察写放大和锁等待。 5. 执行 EXPLAIN ANALYZE,确认真实行数和耗时。 6. 将方法、SQL、Plan、Index 写入对照表,随代码评审一起合并。 7. 定期查看慢日志,当数据分布变化或查询模式变化时重新生成对照表。 ## 08、小结 JPA 能给你生成 SQL,但不能替你设计 MySQL 索引和执行计划。索引设计必须从真实 SQL 出发,结合 B+Tree、联合索引、最左匹配、覆盖索引、回表和 Cardinality 来判断。EXPLAIN 是侦查,EXPLAIN ANALYZE 是验证。对核心查询建立方法到 SQL 到 Plan 到 Index 的对照表,比在实体上加一堆注解有用得多。数据库的物理成本不会因为 ORM 而消失,它只会在你忽略执行计划时,在线上慢慢累积。 ## 09、链接与概念说明 B+Tree:InnoDB 使用的平衡多路搜索树,叶子节点有序并携带数据或主键。 联合索引:多列按序构成的索引键,能同时加速等值过滤和排序,但需满足最左匹配。 最左匹配:查询条件必须包含联合索引的最左连续列,否则索引不能完整使用。 覆盖索引:索引包含查询需要的所有列,Extra 可看到 Using index,避免回表。 回表:通过二级索引定位主键后,再回聚簇索引读取完整行的过程。 Cardinality:优化器用于估算索引选择性的统计量,可用 SHOW INDEX 和 ANALYZE TABLE 查看或更新。 EXPLAIN:输出优化器估计的执行计划,关注 type、key、rows、Extra。 EXPLAIN ANALYZE:MySQL 8.0.18 起支持,实际执行查询并输出每步真实行数和耗时。 更多细节见 MySQL 官方手册中关于 InnoDB 索引、优化器统计信息、EXPLAIN 和 EXPLAIN ANALYZE 的章节。

资源下载

更多资源
优质分享App

优质分享App

近一个月的开发和优化,本站点的第一个app全新上线。该app采用极致压缩,本体才4.36MB。系统里面做了大量数据访问、缓存优化。方便用户在手机上查看文章。后续会推出HarmonyOS的适配版本。

Nacos

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称,一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集,帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Spring

Spring

Spring框架(Spring Framework)是由Rod Johnson于2002年提出的开源Java企业级应用框架,旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念,提供核心容器、应用上下文、数据访问集成等模块,支持整合Hibernate、Struts等第三方框架,其适用范围不仅限于服务器端开发,绝大多数Java应用均可从中受益。

Rocky Linux

Rocky Linux

Rocky Linux(中文名:洛基)是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版,作为CentOS稳定版停止维护后与RHEL(Red Hat Enterprise Linux)完全兼容的开源替代方案,由社区拥有并管理,支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性,采用模块化包装和SELinux安全架构,默认包含GNOME桌面环境及XFS文件系统,支持十年生命周期更新。

用户登录
用户注册
修改密码
忘记密码