铃阅
❌

普通视图

AI驱动“自动化测试后周期”诊治体系升级

2026年11月12日 22:01

原创 物流 刘锐 2026-11-12 22:01 北京

本文围绕VibeCoding带来的研发效率与质量矛盾,落地AI驱动自动化测试治理实践,从断言质量、冗余用例治理到覆盖度提升,完整呈现问题拆解、落地挑战、架构迭代与业务收益,有真实数据支撑,技术路径清晰。

一、背景与核心价值

随着 VibeCoding 在研发阶段应用的持续深入,源码生产的“体感”更加流畅高效,但代码产出速度提升,会同步拉高单位时间Bug总量,AI的执行速度直接放大了错误的传播速度,如果测试能力跟不上源码生产速度,会进一步推高Bug密度,甚至形成 “越快越乱” 的恶性循环。

自动化测试,作为高效质量保障核心手段,随着交付前中期用例规模的快速扩张,团队普遍面临四大痛点:

  • 用例质量参差不齐:弱断言、用例冗余、重复及僵尸用例大量堆积,维护成本随用例数量指数级上升。

  • 覆盖度不可控:业务代码急速增长,用例数量持续增长,但源码覆盖度、场景覆盖度和覆盖效率匹配度不足,自动化价值难以量化。

基于 AI 技术,构建自动化测试后周期的全链路诊断治理能力,是破解上述痛点、实现自动化测试从 “量变” 到 “质变” 的核心路径。

二、AI 诊治的核心覆盖维度

诊断能力围绕用例全生命周期展开,覆盖从设计、执行到维护的全链路质量问题,每个维度对应明确的业务价值

1. 用例质量的量化精诊

核心目标:剔除无效维护投入,让每一条用例都具备风险识别能力和业务价值。

关键动作:重点诊断断言质量、清理冗余僵尸用例、提升用例颗粒度合理性,从源头控制用例库 “水分”。

2. 用例场景智覆及多样性精洗

核心目标:从 “考核用例数量” 向 “考核业务价值覆盖” 升维

关键动作:从线上流量、覆盖报告、接口契约、业务场景四个维度辅助评估覆盖缺口,暴露高风险高流量未覆盖区域,指导用例补充的优先级,组装可感知适配分布式场景的,高可用测试用例,避免 “经验主义” 盲目堆砌用例。

三、分层落地的AI诊治体系建设

3.1 AI精诊-用例静动态质量智能诊断

无需依赖执行数据,通过静态代码分析 + AI 语义能力即可落地,可基于团队已有的断言、重复用例诊断能力直接升级。

3.1.1 断言质量诊断升级

1)为什么关注断言质量?

日常测试工作中,接口自动化测试已经成为必要的一环,其中断言质量直接决定了自动化测试有效性。有效的断言可在业务代码迭代变更时,精准捕获逻辑缺陷、拦截线上风险。

而无效的断言不仅无法发挥缺陷拦截作用,还会向我们传递“测试已覆盖、质量无风险”的虚假信号,埋下严重的质量隐患。

结合日常自动化测试实践,我们发现当前接口自动化断言质量存在三大核心痛点,直接影响自动化用例的有效性。

①新增用例断言真空问题

目前AI批量生成的自动化用例,普遍存在断言缺失问题,导致测试通过率虚高,业务正确性无法保障。

②存量用例断言浅层问题

人工维护的自动化,也会存在一部分用例断言过于简单(如校验code=200、success=true),未覆盖数据一致性、核心业务规则、业务状态流转等关键验证点,此类用例验证深度不足,导致发现问题的能力大打折扣。

③历史断言陈旧失效风险

历史用例,随着接口代码变更、字段调整导致断言逐渐失效,光依靠人力维护,效率低下且工作量巨大。

2)我们需要补充哪些关键能力?

①增量断言智能推荐

针对新增用例断言真空问题,我们需要一种可以自动补充断言数据的能力。可以快速识别问题用例并推荐出贴合业务场景的、高质量的断言,支持一键补齐空白断言,彻底解决新增用例断言真空问题。

②存量断言智能优化

针对存量用例断言浅层问题,我们需要一种可以自动优化断言数据的能力。结合最新代码逻辑与业务规则重新拆解分析,输出精细化、场景化的断言优化方案。

③无效断言智能清洗

针对历史断言陈旧失效风险问题,我们需要一种能迅速识别失效断言并优化的能力。结合最新代码信息,定期对用例数据进行批量清洗,精准梳理出现存的无效断言,输出标准化清洗结果与优化建议,快速完成历史无效断言的清理迭代。

3)我们遇到了哪些挑战?最终如何落地?

①如何诊断断言?

初期,我们仅依赖接口返回的响应数据判断断言有效性,只要当前已有断言出现在请求返回的结果中,就认为是有效断言。

但落地使用后暴露出严重短板:这种方式无法触及后端真实业务逻辑。许多“通过”的用例,实则跳过了关键业务规则校验,诊断失去风险拦截价值。

因此,仅依靠接口返回结果做断言校验,无法实现真正有效的缺陷诊断。

②如何加强推荐断言的准确性?

为解决断言推荐准确度不足的痛点,我们推翻纯响应式的诊断方式,转向结合源码离岸流分析的诊断模式。

该模式不再局限于接口响应数据,而是结合代码信息,精准提取接口定义、核心业务方法、数据结构体、服务调用链路等真实信息,为 AI 模型提供完整、客观、贴合项目的业务上下文。

基于真实代码逻辑做分析推理,输出的断言适配当前业务场景,显著提高断言推荐精准度。

③如何保证基础平台的数据一致性?

工具能力基本成型后,我们又遇到了新的问题,“基础平台数据一致性差”。

我们日常使用的Deeptest、DongTest等测试平台,用例和断言在持续迭代更新,如果工具只是定时批量同步数据,我们获取到的用例信息,永远是过时的版本。

用旧数据分析新用例,必然会出现推荐错误、分析偏差。同时,推荐的断言只是完成推荐就结束,整个流程无法闭环,工具价值无法落地。

为了解决数据时效性和一致性问题,我们搭建了一套「定时同步+实时校验+反向回写」的闭环机制。

日常定时同步各平台用例数据,保证基础数据同步;每一次发起AI分析任务前,都会实时拉取一次线上最新数据,彻底杜绝数据滞后问题。

同时,打通平台回写流程,只要用户采纳了AI推荐断言,就会自动同步更新到测试平台,真正做到分析、优化、落地、更新全流程闭环。

④如何精准识别无效断言?

在梳理存量用例时,我们发现团队积累了海量历史断言技术债。很多老旧用例已经无法正常执行,断言已经失效,有的字段早已在代码迭代中删除,有的断言逻辑永远为真、毫无校验意义。这类无效断言隐蔽性极强,靠人工逐条核对不仅耗时费力,还极易漏检,导致自动化测试通过率虚高,质量风险长期被掩盖。

这里,我们面临的核心问题是:没有统一标准、没有自动化能力,根本无法高效清理技术债。

为此我们制定了一套清晰可落地的无效断言判定规则,通过比对最新代码结构与存量断言内容,凡是代码中已废弃、不存在的字段断言,以及逻辑固化、永远成立的无意义断言,全部定义为无效断言。

依托这套规则结合多线程并发能力,我们实现了全量用例的自动化批量清洗,精准挖出所有隐藏的无效断言,高效梳理并沉淀了完整的技术债治理方案,彻底解决了历史断言失效、漏检的长期痛点。

⑤纠偏机制:AI推荐的断言,会被AI清洗掉吗?

在工具迭代过程中,我们发现了一个很容易被忽略的问题:AI推荐的断言并不完全可靠。

一方面,批量解析海量代码时,部分特殊场景的代码片段会存在解析不完整的情况,给到AI的上下文本身就有偏差。

另一方面,大模型天然存在AI幻觉问题,偶尔会生成一些脱离业务、不符合代码逻辑的虚假断言。

如果我们只依赖AI生成,不做二次校验,这些不准确的断言就会留存下来,变成全新的质量隐患,相当于“用新问题解决旧问题”。

针对这个AI原生缺陷,我们创新搭建了 AI自我清洗迭代机制。

简单来说:AI推荐出来的所有断言,同样会进入无效断言清洗体系,被二次核验、严格筛查。

系统会持续结合最新代码逻辑,对所有AI生成的断言做复盘校验,把因解析偏差、AI幻觉产生的不准确、无意义、不适配的断言精准筛选出来,自动给出优化或删除方案。让AI既能主动产出优质断言,又能自我纠错、自我净化,从机制上杜绝了AI推荐带来的次生问题。

⑥如何让推荐精度再上一个台阶?

在中期版本中,我们采用的是「代码分析引擎+AI智能体」的双层架构,这套方案已经能满足大部分场景的使用需求。

但我们在复盘时发现,分层处理存在天然短板,代码解析和AI推理是两个独立环节,数据传递、逻辑衔接会产生损耗,部分细微的业务规则、隐蔽的代码逻辑无法完整传递给大模型,导致断言推荐精度触达瓶颈,依然存在部分推荐偏差、场景覆盖不全的问题。

为彻底突破这一瓶颈,我们对核心架构进行了全面重构,从原本分层拆分的处理模式,全面升级为DongCC一体化处理架构,将代码链路解析、语义理解、业务拆解、断言诊断、智能推荐全部整合在同一套体系中联动完成,消除了中间数据传递和逻辑脱节的损耗,能够精准捕捉每一处细微的业务逻辑变化,让断言推荐的准确率、场景适配度、覆盖全面度实现质的飞跃,彻底补齐了早期架构的能力短板。

4)我们达成了哪些阶段性目标?以及中长期规划

①智能推荐精准可用,终结新增用例断言真空

工具基于代码语义分析生成的业务级断言方案,贴合真实接口逻辑与业务规则,团队整体用例诊断覆盖率达到24.1%,AI断言推荐采纳率达到71%,其中原「代码分析引擎+AI智能体」链路断言采纳率70.29%,升级至DongCC链路后,断言采纳率提升到87.53%,充分验证了智能推荐的精准度与落地价值。

同时,有效补齐AI生成用例的断言空白,杜绝“有步骤、无校验、通过率虚高”的虚假质量问题,从源头保障新增自动化用例具备真实缺陷拦截能力。从自动化的终极价值,“风险拦截能力”视角看,自动化测试拦截缺陷,数量级提升62%。

②全面深化校验深度,大幅提升自动化真实覆盖率

通过AI持续对浅层、单一的存量断言进行迭代优化、多维补全,团队接口平均断言密度由1.5迅速提升至3.15+。

用例校验从传统单一的状态码校验,升级为数据一致性、业务规则、状态流转、字段合规性的全方位深度校验,彻底解决自动化测试“覆盖浮于表面、漏检风险高”的痛点,显著提升测试有效性。

③降本提效,建成可追溯的智能化断言体系

目前团队17%(2W+)的有效断言由AI自动生成,采纳率70%(直接采纳不做修改),已大幅减少测试人员手动编写、迭代、清理断言的重复工作量,释放人力投入核心业务场景质量深耕。

同时,依托断言快照版本管理能力,实现断言新增、优化、清洗全流程可追溯、可量化、可管控,构建起标准化、智能化、可持续迭代的自动化断言质量治理体系,持续提升自动化测试可信度与线上风险防护能力。

④中长期规划

断言自动修复:接口返回结构变更导致断言失败时,AI 对比新旧契约自动更新断言字段与校验逻辑,生成修复代码。

从 “有无断言” 进阶为 断言有效性评分:纳入自动化量化评估体系,输出单条用例断言质量分、优化建议与整体断言覆盖率统计。

3.1.2 低价值用例诊断升级

1)行业接口自动化用例重复率现状

接口自动化用例的重复并非仅指文本完全一致,更多是业务语义等价、逻辑覆盖重叠、场景无差异的功能重复,这类重复难以通过文本比对发现,是行业普遍存在的隐性损耗。

①企业级通用水平

根据 Tricentis 2024 年对全球 400 个企业级测试套件的分析,成熟度中等、迭代 2 年以上的接口自动化体系中,18%~25% 的用例属于功能重复用例 - 即验证完全相同的业务行为,仅由不同人员、不同时期编写,参数、命名、断言表述存在差异,但未带来任何额外的覆盖增益。

②中型项目平均水平

对于千人级研发规模、用例量在 1000~5000 条的中型项目,不同程度冗余的用例占比可达30%~40%,其中包含完全重复、逻辑等价、场景重叠三类冗余形态。

③特殊场景下的高冗余率

未做质量管控的 AI 生成用例库,语义冗余率可高达40%,表现为同一接口、同一场景生成多组输入差异极小的用例。某银行自动化平台 2023 年审计数据显示,接口场景冗余用例占比达38%,大量用例仅校验字段不同、核心业务逻辑完全一致。长期无人治理的遗留用例库中,叠加已下线接口的僵尸用例后,无效 + 冗余执行占比可达30%~50%。

2)重复场景带来的多维度效率损耗

重复用例的损耗并非仅体现在执行时间上,而是贯穿执行资源、人力维护、结果分析、交付效率全链路,其中隐性成本往往高于显性成本。

数据口径说明

  • 横轴:冗余用例占比(0%~100%),指逻辑等价、场景重叠的无效重复用例占总用例的比例

  • 基准值:0 冗余时,执行时长、有效效率、维护成本均归一化为 1.0

  • 拐点假设:冗余率超过 50% 后,因并发资源抢占、排队阻塞、失败噪音放大,损耗呈现超线性增长

①执行时长与流水线效率损耗(显性直接损耗)

重复用例会线性增加回归执行总时长,直接拉长 CI/CD 流水线周期,拖慢版本交付节奏。

  • 行业平均水平:30%~40% 的用例冗余,会导致全量回归构建时间平均增加 40% 以上。

  • 规模化效应:对于每日执行多次、多环境并行回归的团队,重复用例的时长损耗会被执行频次成倍放大。例如一套包含 1250 条冗余用例的套件,单条用例平均执行 90 秒,单次回归就会额外消耗 31.25 小时的执行时长。

  • 交付阻塞成本:对于高频发布团队,流水线每增加 10 分钟执行时间,单日可发布次数会对应减少,尤其在版本窗口期,过长的回归执行会直接延误上线节点。

②用例维护人力成本损耗(隐性最大损耗)

用例的维护成本与用例数量正相关,重复用例会带来同比例的维护负担,是测试团队最容易忽视的隐形成本。

行业调研显示,约 60% 的测试团队自动化维护成本远超预期,部分团队维护脚本的时间占总测试时间的比例超过 50%。

接口契约发生变更时,每一处字段、路径、返回码的调整,都需要同步修改所有覆盖该接口的重复用例,维护工作量随重复倍数线性增加。例如一个接口字段变更,若存在 5 条等价重复用例,就需要执行 5 次修改与验证。

按 18%~25% 的重复率估算,团队每年用于重复用例的维护人力成本,占总自动化维护成本的20%~30%,且团队规模越大、迭代越快,损耗越高。

③结果分析与缺陷排查损耗

重复用例会放大失败噪音,显著增加结果分析的认知负荷与排查成本。

  • 失败排查成本倍增:一个接口故障会导致所有覆盖该场景的重复用例同时失败,原本只需排查 1 条用例的工作量,会放大 N 倍;同时大量重复失败会淹没真正的差异化失败,增加根因定位难度;

  • 关键信息被淹没:大量低价值重复用例会稀释核心链路用例的权重,导致测试人员无法快速聚焦高风险失败。行业数据显示,冗余用例泛滥会使关键路径缺陷漏检率提升40%;

  • 报告可信度下降:大量重复失败会让团队对自动化报告产生 “狼来了” 效应,降低对自动化结果的信任度,最终导致自动化报告无人看、失败无人理的恶性循环。

3)我们达成了哪些阶段性目标?以及中长期规划

①系统能力

系统能力已实现 “用例定期自动盘点,基于入参结构及内容筛选重复用例→前端可视化查询与统计→一键暂停处理→持续扫描自动闭环” 的重复用例治理体系,从纯手工排查升级为可度量、可溯源的用例治理能力。

②治理收益

已完成存量回归用例的批量盘点,累计盘点13条回归流水线,涉及12758条接口自动化回归用例,用例冗余率2%,按周均至少3次全量回归节奏估算,包含用例执行失败调校韩式,预计至少减少30min时长投入。

③中长期规划
  • 从 “文本重复” 进阶为逻辑语义等价识别
  • 特征提取:从用例中提取请求路径、方法、核心参数、断言逻辑、前置依赖等结构化特征。

  • 语义向量化:通过 Embedding 模型对用例的业务语义、代码逻辑做向量化,计算余弦相似度。

  • 聚类分析:结合结构特征相似度 + 语义相似度对用例聚类,识别 “参数不同但覆盖同一场景”“步骤顺序不同但结果等价” 的深层冗余。

  • 输出冗余用例聚类清单、合并建议与可删除用例列表。

  • (高阶智能化)冗余用例自动合并:对识别出的等价用例,自动合并为最优版本,删除冗余用例。

  • 低价值用例筛排

  • 关联执行历史:统计近 3 个月用例的失败次数、有效缺陷发现次数。

  • 对接接口资产库:匹配用例覆盖的接口是否已下线、废弃(观测周期内流量趋势)。

  • 低价值规则判定:连续 N 次执行成功且未发现任何缺陷、覆盖接口已废弃、无有效断言的用例。

  • 输出低价值用例清单与下线建议。

  • 产出自动化用例静态质量报告

3.1.3 度量标准:用自动化健康度量化标准

  • 可自动计算:全部通过静态分析、执行数据自动采集,无需人工介入

  • 问题导向:低分项直接对应优化优先级,避免形式化打分

  • 业务价值优先:权重向断言质量、稳定性、业务价值倾斜

  • 兼容现有能力:断言质量、重复用例两项可直接复用已有诊断结果

  • 一票否决项:无有效断言、覆盖接口已下线、连续 30 天执行失败无人维护、存在严重逻辑错误无法执行,满足任意一项直接判定不合格。

  • 落地应用方式:新增用例提交时设置 70 分质量门禁;每周生成健康度报告;按团队 / 模块统计平均分作为质量度量指标。

3.2 覆盖度治理 - 从“人找场景”向“场景找人”融贯升维

3.2.1 AI智覆 - 基于覆盖数据驱动

1)核心痛点

1. 传统测新模式加速风险累积:传统测试模式基于“系统变更→增量代码分析→局部场景构造”机制,确保增量覆盖率达到80%~90%交付条件,会带来两类风险,单次变更覆盖盲区持续累积,存量覆盖盲区缺乏治理,导致覆盖盲区风险叠加。

2. 覆盖率“看得见、补不动”:测试人员面对万甚至十万代码量级的覆盖报告,通过人工逐层定位类、方法和逻辑分支,分析关键链路,并产出高关联度测试场景的 效率低、精度差。

3. “经验主义”陷阱:场景设计高度依赖,个人对技术架构和源码链路的熟悉程度,对大模型的应用能力,以及对边界值、异常场景构造的专业掌握度,极易产生 因个人经验而异的场景偏差。

4. 工具断链低效:覆盖率报告、源码链路分析、AI智能交互、以及自动化平台等基础工具,线上线下分散割裂,缺少更加“直观”“标准”的“高集成度”“线上化”平台。

2)关键能力

1. 从“变更驱动增量覆盖” 升级为 “覆盖盲区靶向治理”:将传统变更测新覆盖模式,升级为覆盖盲区靶向驱动的 “全景盲区定位→关键链路提取→组合场景推荐” 精准突破模式。

2. 从“人工经验驱动场景设计” 升级为 “AI驱动覆盖盲区智能推演”:将依赖测试人员源码熟悉度、架构经验和场景构造能力的“人工设计模式”,升级为 “AI驱动涵盖边界异常的全场景设计模式”。

3. 从“线上线下工具断链” 升级为 “人机高效协同闭环”:打通 “覆盖报告→盲区定位→链路提取→场景组装→人工调校→用例沉淀” 工具链路,实现 “智能化” “一站式” “所见即所得” 的“无缝”覆盖率盲区治理能力。

3)方案设计

1. 产品方案

构建“全景盲区定位→关键链路提取→AI智能推演→人机协同调教”的治理模式,实现 “智能化” “一站式” “所见即所得” 的“无缝”覆盖率盲区治理能力。

  • 盲区定位:聚焦覆盖率报告,以“应用→流水线→快照→包→类→方法”多维度灵活筛排,以覆盖率机会视角,直观展示优先级,快速定位覆盖盲区。

  • 链路提取:智能化提取覆盖目标关联的完整源码链路,为AI智能推演提供精准上下文。

  • 智能推演:以关键链路为核心输入,辅以标准化+定制化Agent交互机制,智能推演“正向”、“边界”及“异常”场景,并推荐有效断言,通过“灵活组装”能力,精准生成面向覆盖目标的测试用例集。

  • 人机协同:结构化展示测试用例集,提供“即时调校”能力 和 “所见即所得”的覆盖结果展示能力,无缝对接回归测试平台,实现数据即时互通。

2. 技术方案

“数据-平台-AI-审核”四层架构

  • 数据层:采集覆盖率报告及同版本制品,解析方法、行与分支。

  • 平台层:定位盲区,提取源码。

  • AI层:Agent提取源码关键链路、推演场景及断言,输出结构化建议。

  • 审核层:人工调校后沉淀至用例平台,以运行时覆盖回验,实现“所见即所得”。

4)核心收益

以覆盖盲区为治理靶点,融合全景定位、关键链路提取、AI场景推演与人机协同调校,打造从盲区发现到用例沉淀的一站式智能治理能力。经预评估,可推动以下核心指标明显改善。

1. 效率-人效-作业效率改善:场景组装效率上,单场景耗时 60min → 30min 以内(效率提升 100%)

2. 效率-流程-自动化率改善:自动化转化率 80% → 90%+(提升 10%+,公式=自动化测试场景/(自动化+人工测试场景)x100 %)

3. 自动化测试-代码覆盖率改善:代码有效行覆盖率 40%→60%+(提升20%+)

4. 自动化测试-测试场景完备性改善:复杂边界及容错场景占比 35%→50%+(提升30%+)

5)中长期规划

  • 接口契约覆盖:解析接口文档提取全量接口、参数、返回字段,与用例库自动做差集计算,输出未覆盖接口与字段明细;

  • 业务场景覆盖:通过大模型基于需求与接口文档梳理全量场景(正向、异常、边界、幂等、权限等),与现有用例做语义匹配,输出场景覆盖缺口;

  • 缺陷风险覆盖:对接缺陷系统统计各模块缺陷密度,结合用例覆盖密度,识别 “高缺陷密度 + 低用例覆盖” 的高风险模块。

  • (高阶智能化)缺失用例自动生成:基于覆盖度缺口,结合接口文档与项目代码规范,自动生成异常、边界场景用例,人工审核后入库。

3.2.2 AI精洗 - 基于生产流量驱动

1)核心痛点

企业级自动化测试,面临 “业务场景覆盖不全、高价值用例生成效率低、存量用例与实际用户场景偏差” 等核心痛点。同时,传统的流量回放测试,一般以上线前的某个流量切片为基线,并未完全解决 “以尽可能小的测试场景集合,覆盖尽可能全备的测试场景” 的效率与覆盖率均衡难题。

痛点①:流量录制依赖盲区

传统流量回放的有效性高度依赖于录制流量的齐全性,对生产流量的真实全景缺乏可见性——无法回答“生产上到底有哪些场景”“各场景占比多少”“当前录制覆盖了百分之几”等基本问题。结果往往陷入“回放数小时,仅覆盖一两种场景”的低效困境,看似投入了大量资源,实则收效甚微。

痛点②:用例资产与业务增长脱节

业务迭代呈指数级增长,版本发布频率不断加快,自动化用例的更新速度却跟不上代码变更的节奏。上线前的回归测试仅能覆盖少量核心路径,大量边界场景、异常场景、多平台差异场景长期处于测试盲区。用例资产与生产真实场景之间的鸿沟随时间推移不断扩大,逐渐沦为“有覆盖率之名,无覆盖实效之实”。

痛点③:影响面评估依赖经验

架构日益复杂、模块间依赖关系错综交织,改动影响范围难以精准量化。大多数团队仍高度依赖个人经验来判断“改了A会不会影响B、C、D”。然而,经验本身具有高度主观性和不可复制性,资深员工的判断力无法批量复制,新人对系统理解不足时评估偏差更大。评估不到位直接导致漏测,而漏测一旦进入生产,便成为线上事故的直接诱因。同类问题在不同人员、不同时期反复上演,质量始终无法形成确定性。

以上痛点形成以下风险放大链路,前端断链(全景不可见→录制不齐全)→ 中端断链(回放价值低→用例持续滞后)→ 末端断链(回归覆盖不足→质量无保障),架构越复杂,经验越难覆盖,评估失准频发,该测的没测到,直接成为线上事故的导火索。

最终指向一个结构性矛盾:业务迭代速度已超越传统人工测试模式的承载极限,依赖人工编写用例、评估影响、判断覆盖的传统模式,在微服务、多平台、高频发布的现实面前难以为继。

  • 人工编写用例 → 跟不上迭代节奏

  • 人工评估影响 → 架构复杂超出人脑承载

  • 人工判断覆盖 → 流量全景超出肉眼可及

质量保障亟需从 “人力密集型” 向 “数据驱动型” 跃迁,用生产真实数据驱动测试资产的自动生成与持续演进,从结构上弥合业务迭代速度与质量保障能力之间的鸿沟。

2)关键能力(价值)

针对上述痛点,我们提出 “流量全景可见 + 自动化精洗 + 用例持续自更新” 的改进策略,通过五步闭环,实现从“被动依赖经验”到“主动数据驱动”的转型。

①全景洞察驱动

全量镜像采集生产流量,按业务来源、业务阶段、字段维度自动生成流量全景地图,录制依赖盲区,解决看不清生产场景全貌痛点。

②自动化精洗

接口级配置清洗字段,自动计算场景指纹,相同指纹去重保留唯一,实现场景压缩,解决回放效率低。大量重复场景挤占资源痛点。

③流量地图全景

精洗后流量自动生成字段枚举统计,直观对比历史用例覆盖缺口,精准锁定缺失场景,看清测试覆盖缺口(不知道测试什么漏了什么)。

④一键组装用例

参数化规则映射(生产值→测试值),前置步骤注入,一键生成可执行自动化用例并关联流水线,解决用例资产脱节,人工设计赶不上迭代速度痛点。

⑤持续演进闭环

每日定时录制→自动清洗→增量对比→自动生成,形成自更新的用例生态,解决质量保障不可持续痛点,一次投入持续受益。

⑥短链修复

全景洞察让录制有据可依(修复前端断链)→ 自动化精洗让回放聚焦精品(修复中端断链)→ 地图补全让覆盖有迹可循 → 一键生成让用例随需而变 → 持续演进让质量保障形成确定性,最终实现从“人工经验驱动”到“生产数据驱动”的根本转变。

3)核心收益

目前AI精洗平台已完成多业务生产流量接入,覆盖核心应用及接口方法,自动化测试接口覆盖率持续提升。同时,流量清洗平台已打通“接口配置→流量录制→智能清洗→流量分析(地图)→用例生成”全流程。通过典型接口实践验证,实现从海量原始请求中提炼精品流量,基于流量地图洞察多维参数分布,并一键生成高覆盖自动化用例,有效补齐真实业务场景下的自动化测试缺口,增量自动化行覆盖率贡献度≥25%。

对比传统测试模式与“AI精洗+自动用例模式”,在场景覆盖、用例维护、场景精洗和用例生成四个维度上的差异,整体体现出AI驱动测试在覆盖度、人力投入、场景质量和用例生成效率方面的明显提升。

  • 场景覆盖率:传统模式约15%,主要覆盖核心路径;AI精洗+自动用例模式能够覆盖线上真实场景分布,可新增识别大量原本未知的业务场景。

  • 用例维护效率:传统模式需要约 2人/周维护;AI模式降低至约 0.2人/周,预计可节省90%的人力。

  • 有效场景精洗:传统模式难以量化;AI模式精品流量占比控制在 <1%,能够有效过滤噪声和冗余流量,去噪效果显著。

  • 用例生成效率:传统人工编写约 5分钟/个;AI自动生成约 2分钟/个,图片标注整体效率可提升约15倍。

更关键的是,以上收益会随着业务迭代的持续进行而持续放大,业务的迭代速度越快、流量的场景变化越频繁,该方案在 “覆盖真实场景、提前发现线上缺陷” 方面的效率和覆盖度收益就越显著。

4)中长期规划

  • 引入AI模型自动推荐清洗字段配置,降低人工介入成本。

  • 拓展业务线覆盖广度,实现基于生产流量的前置场景池标记,实现全域流量清洗及场景组装覆盖。

推荐阅读

跳转微信打开

Agent 研发工作系统:面向多需求并行端到端开发的设计与实践

2026年11月10日 21:45

原创 京东 周子纯 2026-11-10 21:45 北京

让 Agent 改一行代码不难,难的是让它能续接、能验收、能复用经验。这篇文章用八个模块和一条完整链路,回答了“Agent 的工作到底做完了没有”这个关键问题。

让 Agent 完成一次修改,还要回答三个问题:工作如何续接,结果如何验收,经验如何复用。

“修复搜索结果重复,并在预发验证。”

以这个需求场景为例,看似只是一次代码修改,实际却有一串问题需要回答:去重发生在最终响应,还是上游候选池?原有顺序和字段是否保留?本地测试通过后,预发运行的是否正是这次修改对应的镜像?换一个会话继续处理,又该从哪里接着做?

这些问题不能只靠一次工具调用回答。它们要求系统保留任务状态、明确动作范围,并把测试和运行结果对应到具体的完成条件。

这套系统围绕这些要求展开:主 Agent 负责理解目标、组织工具调用;规则与检索提供上下文;任务记录保存进度;动作策略约束执行;质量检查判断是否完成;方法库记录哪些做法在什么条件下得到过验证。

下面先看整体结构,再逐步展开实现。搜索去重的例子会贯穿其中,并在第 10 节串成完整流程。

一、全貌:八个模块,分别解决什么问题

系统划分为 M1—M8 八个模块,但它们是逻辑职责,而不是八个独立微服务。实现以本地文件、SQLite、Python 和 Node.js CLI 为主,由具备工具调用能力的大语言模型组织协作。

八个模块的职责与协作关系

图 1:主 Agent 连接知识、状态、执行与验收;状态和方法反馈也由它组织回写

模块

解决的问题

M1 主 Agent

当前目标是什么,下一步该查什么、做什么?

M2 规则与技能

这个项目有哪些约定,这类操作应该怎样执行?

M3 上下文检索

历史线索和当前源码在哪里,怎样回到原文?

M4 任务状态

工作做到哪了,跨会话和并发更新时如何续接?

M5 工具与平台适配

怎样把操作落实到仓库、测试和企业平台?

M6 动作策略

对这个具体目标执行这项操作,是否符合范围与授权?

M7 证据与质量

已有结果能证明什么,还缺什么才能完成?

M8 方法治理

哪些经验可以复用,方法改版后如何重新验证?

这些模块不是必须逐个经过的流水线。主 Agent 按需读取 M2、M3、M4、M8,组织策略检查、工具执行和验收,再将进度写回 M4,将实际复用结果写回 M8。

二、M1 主 Agent:理解目标,再组织工具调用

“修复重复搜索结果”并没有直接告诉系统应该修改哪里。

最终响应重复、上游候选池重复、某个展示模块重复,可能对应不同的责任位置。主 Agent 首先要理解用户要求解决的是哪一层问题,然后决定读哪个仓库、查哪条调用链、采用什么验证方式。

检索器可以返回匹配的源码,状态程序可以保存当前进度,但它们不会替代这层业务判断。

M1 的执行方式是一个工具调用循环:

    读取用户目标与当前状态
        ↓
    选择需要的信息或执行工具
        ↓
    构造参数并调用工具
        ↓
    读取结果、错误和证据
        ↓
    继续 / 修正 / 等待 / 验收

    规划、实现和评价可以由同一个主 Agent 顺序完成。只有任务存在独立工作边界,且引入独立角色已获授权时,才安排其他执行者或审阅者。角色名称本身不构成独立审查保证。

    跨模块编排目前主要发生在这套工具调用循环中,还没有一个统一的后台工作流服务自动推进所有步骤。

    三、M2 规则与技能:把项目知识和操作流程分开

    M2 回答两个问题:这个项目怎么工作,这类操作怎么执行。

    这两类知识有关联,但不应该混在一起。交付流程可以复用,应用名、目标分支、实例组等项目参数则需要分别维护。

    因此,操作知识被组织为三个层次:

      全局约定 / 项目 AGENTS.md
          一般规则、项目边界、验证方式
      项目技术地图
          入口、模块职责、调用链、常用命令
      Skill 目录
          SKILL.md       用途、触发条件、操作步骤
          scripts/       可执行程序
          references/    参数、模板、复杂流程细节
          assets/        操作需要的资源

      例如,交付 Skill 说明怎样选择仓库执行合同、调用构建接口、读取产物和运行探针;合同提供该项目的具体参数与执行要求。这样,调整应用参数不必重写通用流程,更新流程也不必把所有项目细节重新组织一遍。

      加载同样按需进行:先识别资源用途,适用时读取正文,执行时再展开必要引用。这与 Agent Skills 的元信息发现、正文激活和资源按需加载方式相对应。

      M2 负责组织规则与操作资源;一套做法是否适用、被验证过几次、修改后是否仍然可靠,则交给 M8 管理。

      四、M3 上下文检索:按缺失的信息选择路径

      查历史讨论、找已知字段、定位一个只知道功能的入口,是三种不同的问题。M3 为它们保留了三条检索路径,而不是把所有查询都交给向量检索。

      历史、精确源码和意图检索三条路径

      图 2:先判断缺什么信息,再选择检索方式;找到候选后,仍需回到当前来源复核

      4.1 查历史:Python + SQLite FTS5

      需要回答“以前在哪里讨论或处理过”时,使用历史检索。

      Python 导入器读取追加式会话记录,将消息和整理摘要写入本地 SQLite。它保存源文件的字节偏移,下次从该位置继续;末尾尚未写完整的一行留待后续处理。每条记录保留项目、会话、时间、来源文件和偏移,便于定位原文。

      查询使用 FTS5 与 BM25,并支持按项目等范围筛选。短查询或全文检索异常时,提供 LIKE 回退。使用顺序是:先用 search 找候选,再用 timeline 看邻近上下文,最后用 show 读取原文。

      这里有两个限制需要记住:热索引会跳过工具大载荷,因此无命中不代表当时没有执行过;历史记录也不能证明今天的分支、配置或运行状态,当前事实仍要从当前来源读取。

      4.2 找已知标识:ripgrep

      已经知道类名、字段、错误字符串或配置 key 时,直接使用 rg 做文本、正则或文件枚举。

      例如查 expected_revision,先找到定义和调用方,比重新描述它的功能再做语义检索更直接。匹配到文件和行号后,再检查调用链,确认它是否处于当前问题的责任范围内。

      4.3 找未知入口:Node.js + 本地模型 + Zvec

      只知道功能、不知道入口名称时,使用 semantic-context.mjs。这条路径的实现如下:

        明确 root 与正向 globs(纳入检索的文件模式)
            ↓
        枚举文件,记录文件哈希与范围快照
            ↓
        zg 0.2.1 抽取文本片段,按范围增量刷新
            ↓
        Transformers.js 加载本地 ONNX 模型
        multilingual-e5-small / 384 维 / CPU
            ↓
        Zvec 向量索引,zg context 返回候选
            ↓
        回读原始源码行,复核范围快照

        zg 支持组合词法与向量候选。本地适配器调用其公共索引和 context API,固定使用本地模型,关闭远端下载与网络回退,没有另建远端向量服务。索引按规范化目录、文件模式和模型隔离,放在源码目录之外,可以重建。

        这条路径不只返回相似片段,还保留三类信息:定位原文的 path、startLine、endLine;标识来源的 sha256、sourceSnapshot;说明匹配与截断情况的 matchedBy、contentTruncated。

        返回前会再次检查文件新增、删除和内容变化,避免将已经漂移的快照当作有效结果。不过,模型输入和输出片段都可能截断,候选仍不能证明完整覆盖。

        该适配路径目前处于有界试用:最多 200 个文件、单文件 256 KiB、合计 4 MiB,超限就缩小范围。这些是本地试用限制,不是底层工具的通用上限;也没有后台全盘扫描或每次任务必跑的要求。

        已有信息直接使用,缺失信息才检索。可复用方法的检索属于 M8,不与这里的源码索引混用。另外,这里的 E5 是嵌入模型名称,与第 8 节的 E5 证据等级无关。

        五、M4 任务状态:既能续接,也能防止旧进度覆盖新进度

        跨会话继续工作,最需要恢复的不是全部聊天,而是四件事:目标是什么,已经确认什么,还缺什么证据,下一步做什么。

        workctl.py 将这些信息保存在 tasks/*.md中。任务文件是权威记录:结构化头部保存 task_id、revision、status、owner 和更新时间,正文记录目标、证据、缺口、阻塞与下一步。总览由程序生成。

        下面是字段与内容示意,不是完整任务文件格式:

          task_id: task-…
          revision: 7
          status: validating
          目标: 修复最终响应重复并完成预发验证
          已确认: 本地完整输出与保留条件通过
          待证明: 当前预发镜像处理固定请求的结果
          下一步: 读回实例,再发业务探针

          保存状态还要处理另一个问题:两个更新者都拿着旧进度,怎么办?

          假设 A、B 都读到 revision = 7。A 先提交,任务变为版本 8;B 随后仍携带 expected_revision = 7 提交,就会被拒绝。B 必须重读最新记录,再判断如何合并自己的更新。

          文件锁协调写入过程,版本检查防止旧状态覆盖新状态。 两者解决的问题不同。

          图 3:持锁读取、比较版本,再写入新状态;发生冲突时保留原记录,由更新者重读

          具体写入顺序是:取得 flock 文件锁,读取任务并比较 expected_revision,写临时文件,执行 flush / fsync,原子替换,再更新派生总览。原子替换用于减少半文件风险;这些机制限于本地记录,不提供分布式事务或远端动作幂等保证。

          恢复工作时,Agent 先核对目标是否变化,再从缺口继续;需要历史线索时调用 M3。后续执行可以由用户继续对话或已配置的定时任务触发,但调度配置和实际运行结果要分别核验,触发过不等于业务已完成。

          5.1 需求卡:把多次任务串成一个需求

          任务卡记录一次工作的进度,但一个需求可能跨多个任务、会话、项目或 Agent。

          2026-09-17 增加的 reqctl.py 用需求卡补上这一层。权威记录是 requirements/req-*.md,集中关联以下对象:

            任务卡      哪些任务在推进这个需求
            会话        哪些宿主、Agent 和会话参与过
            功能模块    pending → in_progress → done → verified
            开发分支    哪个分支完成了哪些模块
            问题记录    open → resolved / workaround,附解决方式
            方法        复用的方法及内容版本哈希
            证据与文档  证据引用、参考文档
            阶段推进    discovering → developing → validating
                        → delivering → observing → closed

            续接时,先从需求卡找到相关任务、分支和问题,再读取具体记录继续工作。需求卡与任务卡使用同一套文件锁、乐观版本检查和原子写协议;都通过程序更新,派生索引只读。

            六、M5 工具与平台适配:把操作落实到真实系统

            理解了目标,也保存了状态,接下来要真正修改代码、构建产物、部署和验证。M5 负责把这些动作连接到本地仓库、测试工具和企业平台。

            典型调用链如下:

              主 Agent / 领域 Skill
                  ↓
              交付驱动:组合 Git、构建、部署、验证步骤
                  ↓
              Python 操作封装:已覆盖的平台原子操作
                  ↓
              manifest 固定的 Node.js 命令行工具
                  ↓
              平台适配器与标准通信接口

              项目路由选择仓库与交付驱动,仓库执行合同提供应用、分支、commit、实例组、镜像、探针 ID、查询范围和结果约束等参数。

              这里还要保证:检查的入口,就是实际运行的入口。因此,运行包、入口及 adapter 通过运行清单(manifest)和 SHA-256 固定,并在执行链路中读回核对。

              工作类别

              工具与平台路径

              返回的能力与材料

              代码与交付

              Git、交付驱动、交付平台

              分支操作、构建、产物身份与预发交付

              运行与业务验证

              日志平台、配置中心、业务验证平台

              配置与运行态读回、业务探针、原始响应

              数据与实验

              数据平台、实验平台等入口

              有范围的查询、实验操作与返回核验

              扩展能力发现

              能力目录与应用元数据路径

              能力 schema 发现与具体接口选择

              各适配器按实际验证范围声明能力。能力发现不代表每项操作都已验收,每个入口也保留自己的参数与范围检查。

              M5 返回结构化结果、错误、产物身份和原始证据。工作流在动作前接入 M6,在执行后交给 M7 验收。遇到超时或响应丢失,先读回远端状态,再决定是否重试,而不是默认再执行一次。

              七、M6 动作策略:能调用工具,不等于有权执行动作

              主机允许执行 Bash,并不等于某次部署、删除或外发消息已经获得业务授权。

              M6 检查的是具体动作。任务范围内、环境明确、可恢复的非生产操作,在满足策略的正向目标 schema(允许的目标结构)和操作合同后可以继续。生产或环境未知的变更、破坏性操作、权限与凭据变化、外发消息、支付等,则需要针对相应动作的明确授权。

              7.1 用指纹绑定具体动作

              authzctl 接收动作类型、稳定范围 ID、精确目标和操作,依据 JSON 策略返回 decision、reason 和动作指纹。

              指纹的计算方式如下。这里是示意,不是可直接运行的完整 Python 程序:

                contract = {
                    "action": action,
                    "scope_id": scope_id,
                    "target": target,
                    "operation_kind": operation_kind,
                    "operation": operation,
                    "resource": resource,
                    "allowlist_id": allowlist_id,
                    "policy_sha256": policy_sha256,
                }
                fingerprint = sha256(canonical_json(contract))

                规范化 JSON 固定键顺序和分隔形式,使同一动作描述得到稳定指纹。目标、参数或策略变化,指纹也随之变化。

                例如,合并产生新 commit 后,构建与部署必须绑定新对象,不能沿用一个没有明确对象的“发布一下”。指纹用于绑定动作描述,授权仍需经过相应策略和用户确认流程。

                精确动作指纹与执行前策略判定流程

                图 4:策略判定绑定具体动作;目标、参数或策略变化后重新判断

                图示为策略与执行关系,不表示所有工具类型都已接入拦截。

                7.2 从显式调用,到宿主执行前拦截

                早期,动作策略依赖工作流在执行前显式调用。后续通过宿主的执行前钩子接入检查,对纳入策略的命令采用 fail-closed 方式:未满足放行条件时,不予执行。

                在已接入策略的执行入口中,需要明确授权的命令,须完成相应判定和授权后才能继续。

                被拦命令需要先经策略判定,取得用户对精确动作、目标与操作的显式授权,再登记授权记录。授权记录与命令及动作指纹绑定;实际操作变化后,需要重新判定并取得相应授权。

                7.3 一次误拦截:连记录问题的命令也被挡住了

                接线验证暴露了一个实际缺陷:拦截器先挡住了包含危险操作描述的验证命令,接着又挡住了“把这条被拦命令记入需求卡”的记录命令。

                原因是,记录命令的参数也包含相同文本。描述危险操作的文字触发了检查,导致授权与记录路径被一起堵住。

                修复针对记录与授权路径设置了受限的处理规则,并补充相关执行检查。问题和修复结果一并登记到需求卡。这个案例说明,拦截设计需要区分实际执行的操作与用于描述操作的普通文本。

                覆盖边界: 策略的有效范围取决于各执行入口的实际接入和验证。分类测试通过,不能证明所有执行路径均已覆盖,仍需逐入口核验。

                八、M7 证据与质量:执行过了,怎样证明完成了

                代码测试通过,只能回答相应测试是否通过。它没有直接回答:预发运行的是什么镜像,用了什么配置,实际业务请求是否正确。

                M7 将执行材料与任务要求对应起来,区分“已经做过什么”和“已经证明什么”。

                8.1 用 E0—E5 界定结论能说到哪一步

                这套系统使用以下证据等级:

                等级

                要回答的问题

                典型材料

                E0 观察

                出现了什么症状?

                用户反馈、历史记录、未验证观察

                E1 代码

                当前源码或本地产物有什么行为?

                源码、差异、完整行为测试、本地产物

                E2 配置与数据

                实际选择了什么配置和数据?

                实验分配、配置读回、索引、缓存、数据集

                E3 运行态

                当前运行的到底是什么?

                不可变产物、实例和 Provider 绑定

                E4 业务验收

                当前目标处理真实业务请求是否正确?

                完整字段、内容、顺序断言及相关负例

                E5 结果效果

                性能、可靠性、成本或业务是否改善?

                预定义指标、人群、窗口、基线或对照

                并非所有任务都必须达到 E5。文档修改可以用本地证据验收;预发交付要核验相应目标的业务行为;要求效果改善的任务,才需要对应的效果证据。

                证据还必须绑定目标。镜像 A 的业务验证通过,不能直接替镜像 B 背书。目标变化后,旧记录保留,但受影响的配置、运行态和请求需要重新核验。请求模式、调用方、数据和时效,也会影响证据能否复用。

                8.2 把验收要求接入任务关闭入口

                quality.json 保存质量合同:原始需求、责任边界、最小必要设计、假设、目标、行为测试与交付检查。

                quality_gate.py 检查字段是否齐全,是否还存在未经验证的实现前提,测试是否对应目标,以及缺不缺任务范围要求的交付证据。

                对登记了quality_contract 和quality_target 的任务,workctl 在写入 closed 或 observing_outcome 前调用关闭检查。检查失败,任务与 revision 不变;通过后,保存检查合同哈希,并允许对应状态更新。

                图 5:已登记任务进入关闭检查;失败保留原状态,未登记旧任务仍走兼容路径

                证据等级是验收规约,程序门禁是可执行检查,两者不能混为一谈。未登记的旧任务仍走兼容路径;程序检查结构和一致性,也不能替代对原始证据真实性及业务语义的审查。

                8.3 效果指标要在看结果之前定义

                要求 E5 时,需要提前写清指标公式、观察人群、完整窗口、数据来源、基线或对照、负责人、停止条件和因果限制。

                不能先挑一段好看的结果,再反过来定义成功。业务请求通过与效果改善,是两个不同的结论。

                九、M8 方法治理:经验可以复用,成功记录不能随意继承

                方法库不只要保存“以前怎么做”,还要回答:这次是否适用,执行的是哪个版本,成功是否经过验证,是否存在反例。

                methodctl.py 管理这类记录。权威数据是 library/*.json,methods/*.md 是阅读视图,registry 与 INDEX 是派生索引。一条方法包含四组信息:

                  适用性:trigger / scope / prerequisites / exclusions
                  执行:decision / procedure / 每步 action、check、stop_if
                  验收:outcome_class / outcome / closure_gate / safety_boundaries
                  反馈:evidence / cases / status / revision

                  这里的“学习”发生在外部方法库、工作上下文和执行约束中,不涉及在线训练模型权重。检索影响下一次做法选择,执行反馈再改变方法的成熟度和适用条件。

                  9.1 先找到候选,再判断能否采用

                  M8 使用词法匹配,与 M3 的源码向量检索分开。英文和标识符提取 token,连续中文按相邻双字切分;再与方法的标题、摘要、领域、触发条件、目标、范围和关键词匹配。

                  评分规则为:

                    coverage = 命中的查询 token 数 / 查询 token 总数
                    score = 10 × coverage + maturity_bonus
                    stable = 4,draft = 3,candidate = 2,needs_review = 1

                    检索先按领域和状态过滤,零命中不返回,再按分数和标题排序。--explain 返回匹配词、内容版本、触发条件、前提、排除项和门槛,供主 Agent 判断。

                    相关只代表值得检查,不代表可以直接采用。是否满足方法前提,仍要结合当前任务判断。

                    9.2 方法改了,旧成功为什么不能继续计数

                    一个反例测试很好地说明了这个问题:旧版本已经成功三次,新版本只成功一次,旧实现却仍将方法判为 stable。

                    修正后,新版本被判为 candidate,四条历史记录全部保留。改变旧案例的独立键,也不能绕过内容版本匹配。

                    要得到这个结果,方法选择、执行和反馈必须连在一起。

                    • 选择时绑定版本。contract_hash 对触发条件、前提、范围、步骤、排除项、完成门槛和安全边界等语义字段计算 SHA-256。执行前保存 method_id + contract_hash + fit,说明准备复用哪一步、怎样验证。关键词、摘要、记账时间等元信息与内容身份分开。

                    • 反馈时绑定实际结果。 登记成功、部分、失败或矛盾,以及目标、证据类型和等级。结果对应执行前选定的版本,不能事后拿当前哈希给旧经历补签。

                    • 计数时区分独立性。independent_key 区分独立任务。同一事件的多轮探测、修复重试和不同阶段,不能拆成多次独立成功。

                    • 语义修订后重新累计。 旧案例继续保留,但不能抬高新版成熟度;未解决的失败或矛盾阻断升级。

                    图 6:先绑定版本,再执行验证与反馈;案例按内容版本和独立任务计数

                    当前项目的规则是:同一内容版本一次独立已验证成功为 candidate,两次为 draft,至少三次且无未解决失败或矛盾为 stable;出现失败或矛盾,优先进入 needs_review。

                    成功还必须达到方法声明的门槛。效果类方法要求 E5,只有 E4 交付证据时记为 partial,不能作为该方法的一次完整成功。

                    旧库未绑定案例仍有兼容路径,但语义修订后不能借这些记录提升新版成熟度。内容哈希也不能证明证据真实、独立键确实独立,或整体成功由这条方法造成。

                    十、完整运行:一次搜索去重请求怎样走完

                    回到开头的教学案例:修复最终搜索响应中的重复,保留首次出现顺序和原对象字段,并在预发验证。以下用于说明模块协作,不是一条新增的实际执行记录。

                    搜索结果去重教学案例的端到端模块协作

                    图 7:从目标澄清到业务验收,再到状态和方法反馈;实际步骤由主 Agent 按需组织

                    • 先明确目标。M1 与 M2 确认问题位于最终响应,并写清顺序、字段等保留条件。M4 建立任务记录;涉及多次任务时,再通过需求卡聚合。

                    • 再找责任位置。知字段或错误时用 rg;只知道功能时用意图检索;需要了解旧处理过程时查历史。M3 返回候选后,仍要读取当前源码与调用链。

                    • 选择可复用方法。 M8 提供相关做法,M1 检查前提和排除项。决定采用后,先绑定方法 ID、内容哈希及验证计划,再执行。

                    • 修改并交付。 按动作范围接入 M6 判定,由 M5 完成代码修改、测试、构建和交付。产物身份与平台返回要保留;合并等操作改变了 commit,后续目标也随之更新。

                    验证完整业务行为。 对下面的输入,验收不能只检查结果数量:

                      输入:[P1, P1, P2]
                      预期:[P1, P2]
                      要检查:身份是否正确、是否保留首次顺序、对象字段是否保留。

                      只断言“数量等于 2”,会漏掉 [P2, P1] 或标题错绑。先验证本地完整行为,再核对预发配置、运行目标和相应业务请求,由 M7 判断是否满足原要求。目标变了,就补充受影响的证据。

                      • 最后回写进度与方法结果。未完成的缺口和下一步写入 M4;满足条件后,通过相应关闭检查更新状态。实际复用的方法,再按选定版本、独立键和证据反馈到 M8,失败与部分成功也要保留。

                      这条链路依靠主 Agent 的工具调用、任务记录和证据引用衔接,不由统一消息总线自动驱动。模型负责语义判断,对应程序执行可计算的约束。

                      十一、对工作带来的作用:看得到哪些产物

                      这套系统的作用,可以从三类可核对的产物来看。

                      • 续接工作,有明确入口。历史检索保留原始线索,任务卡保存目标和缺口,需求卡关联任务、会话、模块、分支和问题。进入陌生代码时,还有项目技术地图、当前文件和责任链可查。

                      • 执行与验收,有对应材料。预发交付保留产物身份、配置与运行态读回、业务响应;动作有范围判定,完成有对应检查,不只留下一个“执行成功”。

                      • 复用经验,有版本与反例。方法有适用步骤、内容合同和验证案例。不再适用的做法进入复审,修订保留旧记录,新版重新验证。

                      这些机制提供了工作支撑,但不能仅凭模块存在或局部测试,就推导总体节省了多少工时、长期准确率提高了多少。效率和效果仍需要在真实任务中持续测量。

                      十二、技术特色与已有方案的关系

                      这套系统复用了乐观并发、内容哈希、显式合同、分层验收和可追踪反馈等工程思想。它的重点不在于替代某个框架,而是把这些机制接到具体研发对象和执行入口上。

                      12.1 与已有机制如何组合

                      下表比较能力所在层次,不作功能排名,也不代表完成了同条件性能基准。

                      方案或机制

                      参考能力

                      本系统侧重的组合方式

                      Agent Skills

                      标准目录封装知识、脚本与资源,按需加载

                      在资源组织之外,管理方法适用条件、版本与验证案例

                      LangGraph Persistence

                      checkpointer 保存线程内图状态,store 保存跨线程数据

                      状态持久化之外,定义环境、产物、配置和请求的验收身份

                      Temporal Workflow

                      事件历史与重放恢复工作流

                      执行恢复之外,由领域合同定义业务证据与完成条件

                      LangSmith Evaluation

                      数据集、评估器、离线与在线评测,失败回流测试

                      在评测之外,跟踪跨任务方法的内容版本、独立性与反例

                      Claude Code Hooks

                      工具调用前允许、拒绝或请求用户决定

                      承载动作策略;本文描述的是已接线宿主中的 Bash 命令级检查

                      这些机制能够扩展和组合,表中区分的是关注点,而不是它们无法实现哪些功能。

                      12.2 三个贯穿全篇的设计选择

                      第一,把目标身份贯穿验收。源码、commit、配置、镜像、请求和证据需要对应起来。目标变化,不直接复用旧目标的通过结论。

                      第二,把方法反馈绑定到执行时的版本。先选版本,后记结果;语义变化重新累计,失败和矛盾不能被成功次数淹没。

                      第三,把可计算的规则接入实际入口。版本冲突检查进入状态写入流程,质量检查进入已登记任务的关闭流程,Bash 策略进入已接线宿主的执行前钩子。能由程序检查的约束,不只依赖 Agent 记住一段文字。

                      12.3 还需要继续验证什么

                      后续仍需扩大 API 与部署适配器级的策略覆盖,核验不同宿主的实际接线,并持续观察长期效果和跨团队迁移情况。

                      内部指令精简另有独立实验,本文未展开相应材料,因此不将其作为这里的效果证据。这些设计也不构成算法首创或全面领先的证明。

                      回到最初的问题:完成一次代码修改之后,系统是否还能说明做到哪了、运行的是什么、凭什么验收,以及这次经验能否在下次使用?

                      这正是八个模块协作的目标:主 Agent 组织工作,规则与检索提供上下文,状态承接进度,工具落实操作,策略约束动作,质量对应证据,方法治理记录经过验证的做法。

                      推荐阅读

                      跳转微信打开

                      从AI写代码到AI重构交付——国际物流技术 Multi AI Native 的 AI 交付转型之路

                      2026年11月5日 20:39

                      京东物流 李俊泉 2026-11-05 20:39 北京

                      如何让AI从写代码到重构交付,京东物流技术Multi AI Native给出了它们的答案。

                      当 AI 已经能替我们写代码,为什么团队整体的交付速度没有想象中那么快? 答案不在工具里,而在工具之外——在流程、在分工、在组织结构里。

                      一、现状:AI 加速了局部,却照出了组织的摩擦

                      近一年,整个产研团队做了大量 AI 编码的实践与推广,AI 代码生成率持续提高,越来越多的需求进入了深度人机协作阶段。

                      但当实践规模扩大之后,一个反直觉的现象浮出水面:

                      参与同一个需求的开发人员越多,AI 带来的提效幅度却不明显。

                      单看局部,一些开发和测试环节确实已经被 AI 显著加速;可从整体数据看,"AI 深度参与的需求占比"并没有像预期那样与"人均需求交付数"同步增长。继续下钻,我们发现真正抵消 AI 收益的,已经不再是工具能力,而是工具之外的环节:

                      • 需求对齐、跨角色协作、任务交接和等待,仍然按照 AI 出现之前的传统方式在运行;

                      • 不同开发者使用 AI 的能力严重分化,同一个工具在不同人手里产出天差地别;

                      • 业务、产品、研发相互分离,让个别标杆团队摸索出来的经验,很难规模化复制到其他团队。

                      一句话概括:AI 加速了局部工作,也让原有组织中的摩擦,更加集中地暴露了出来。 工具越快,流程与组织的"堵点"就越刺眼。这不是 AI 没用,而是我们只把 AI 用在了"写代码"这一个点上,却没有动"怎么协作、谁做什么、团队怎么组织"这些更根本的地方。

                      二、根因剖析:卡点在“人、流程、组织”三层

                      顺着现象往下挖,提效被抵消的根因,可以清晰地归到三层:

                      1. 人:开发人员的 AI 能力两极分化

                      会用的人,让 AI 帮自己完成一整段设计与实现;不会用的人,AI 只是一个更花哨的搜索框。当交付依赖"某几个高手"时,AI 的收益就被牢牢锁死在个人能力上——能力没有沉淀为团队资产,而是散落在个人经验里。

                      2. 流程与分工:参与的人越多,提效幅度越小

                      这是最违反直觉、也最关键的一条。AI 把"写代码"这段压缩得很短,于是需求对齐、跨角色确认、任务交接、互相等待这些"人与人之间"的成本,在总耗时里的占比被急剧放大。参与的人越多,需要对齐和交接的次数就越多,被放大的摩擦也就越多。AI 提速的是"做",但拖住整体的是"等"和"传"。

                      3. 业务特点与组织结构:标杆团队效率高,但规模复制难

                      个别团队靠着对业务的深刻理解和一套自己的协作默契,把 AI 用出了很高的效率。但这套效率高度依赖特定的人、特定的上下文、特定的默契,一旦换一个团队、换一个业务域,就水土不服。烟囱式的组织切分,让经验沉淀在"孤岛"里,难以标准化、难以克隆。

                      两条路径的分野:研发视角 vs 组织视角

                      这三层根因,指向一个更深的判断——我们究竟站在哪个视角上用 AI?

                      AI × 工具 → AI × 研发人员 → 推动研发组织变革。 它从增强工具(AI Coding)起步,再增强研发人员(人均提效),最后试图从研发一侧去推动组织变革。这条路走得对,但走到"推动研发组织变革"这一步就到了边界——因为研发视角只能改研发自己那一段,而现状里真正的堵点(需求对齐、跨角色协作、烟囱式组织)恰恰横跨业务、产品、研发的边界。研发视角够不着这些边界之外的摩擦,自然也就推不动。能力再强的研发,也无法单方面重构一个需要业产技共同参与的交付流程。

                      AI × 工具 → AI × 员工 → AI × 团队 → AI × 组织。 它不把 AI 局限在"研发"这一个工种上,而是:先用 AI 增强工具,再让 AI 增强每一类员工(不只是研发,也包括产品、测试、调度等所有岗位),进而把这些被 AI 增强的岗位重组为人机协同的团队,最终用 AI 去重构整个交付组织的运转方式。

                      两条路径在前半段重合,却在后半段分道扬镳:研发视角止步于"研发内部的优化",组织视角则跨过了那道边界,走向"整个组织的重新设计"。这,就是从"AI 写代码"到"AI 组织转型"的分水岭。

                      三、打法:用 AI 重新设计交付流程、角色分工与组织结构

                      既然根因在"人、流程、组织"三层,卡点又在于研发视角够不到的边界,那么打法就必然是站在组织视角上,用 AI 把交付这件事重新设计一遍——不是给旧流程加个 AI 插件,而是以 AI 为一等公民,重构流程、角色与结构。

                      京东物流国际技术部 Multi AI Native(Multica)平台,正是这套打法的落地载体。它的口号是"你的下一批员工,不是人类"——把 Claude Code、Codex 等主流 AI 编码智能体,转化为真正的团队成员:可以像给同事分派任务一样,把需求分配给 Agent,Agent 会自主接手、编写代码、更新状态、报告阻塞。

                      下面把三层根因与三步打法一一对应起来。

                      3.1 打法一:重新设计“角色分工”

                      把个人能力沉淀为岗位角色与技能库(破解根因①)。针对"能力两极分化",答案不是培训每一个人成为高手,而是把能力从"个人经验"变成"组织资产"。

                      Agent 是数字化的岗位角色,对标企业真实研发岗位。 平台内置调度、产品、研发、测试等专业 Agent,每个 Agent 拥有固定职能边界、标准化工作指令与专属工作场景。测试用例、PRD、消息、行云部署、DB 操作等具体能力,被沉淀为可复用的 Skill 技能库、规约中心,在整个工作区内被各 Agent 反复调用。

                      如此,交付不再依赖"某几个会用 AI 的高手",而是依赖一套标准化、可复用、持续沉淀的岗位角色与技能资产。能力差异不再是瓶颈。

                      3.2 打法二:重新设计“交付流程”

                      以 Issue 为唯一事实源,用调度替代人肉交接(破解根因②)。针对"人越多、提效越小",答案是砍掉需求对齐与任务交接中的人肉损耗。

                      • Issue 是统一的最小交付载体,也是唯一事实源。 需求描述、验收标准、字段、评论、版本快照全部落在同一份 Issue 上,所有 Agent 读写同一份数据。一个 Issue 下的所有文档、改动、上下文,涉及的每个 Agent 都能共享,不会"失忆",不需要反复重新输入——需求记忆共享,从根本上消灭了"反复对齐"这项成本。

                      • Leader 只负责调度,是整个项目的大脑。调度 Leader 拆分任务、分派给各 Agent、汇总验收,Agent 之间可并行推进子任务,再由 Leader 统一收口。人与人之间的"等待与传递",被 Agent 集群的并行协作与自动流转取代。

                      流程的重构,让"参与方越多摩擦越大"的诅咒被打破:协作成本不再随人数线性膨胀,而是收敛到一份结构化的 Issue 与一套自动调度里。

                      3.3 打法三:重新设计“组织结构”

                      用可复制的自治小队替代烟囱式团队(破解根因③)。针对"标杆难复制",答案是把"团队"本身做成一个可标准化、可克隆的单元。

                      Squad 小队是 AI 研发交付的最小自治业务单元。 它以垂直业务域为边界,内置完整的调度、产品、研发、测试 Agent 集群,可独立完成从需求承接、任务拆解、迭代开发、质量校验到交付闭环的全流程。小队权责独立、上下文独立、迭代节奏独立,队内自主协同,跨队统一通过调度中枢对接——这是一种为人机协同重新设计的组织形态。

                      精品小队与模板可一键复制。 创建小队时可浏览、克隆其他工作区已验证的优秀小队,复制时自动带走全部 Agent 的 Skills 与指令。标杆团队的协作范式,第一次变成了可以被整建制克隆的组织资产,而不再是困在某个团队里的默契。

                      组织结构的重构,让"标杆经验"从不可复制的孤岛,变成了可规模化铺开的模板。

                      3.4 打法闭环:规约栅栏 + 持续改进飞轮

                      三步打法之上,还有一个让系统越用越强的机制:

                      • 规约栅栏(持续优化)。 AI 犯错后,正确的动作不是简单地对话纠正,而是沉淀出一条规约去约束它不再犯同样的错。否则人类介入次数会陷入恶性循环。每一次纠错,都固化为组织的护栏。

                      • 持续改进飞轮。 每次业务交付完成后,产出的方案、代码、测试记录、协作经验沉淀为业务知识,反哺 Agent 能力,构成"交付 → 沉淀 → 增强 → 再交付"的持续改进飞轮。

                      四、实践成效:从数据与案例看 AI 组织转型的真实收益

                      前三章讲的是"为什么这么做"和"怎么做",这一章用真实案例与实测数据来验证:站上组织视角、用 AI 重构流程/角色/结构之后,交付到底发生了什么变化。

                      这套打法在物流国际技术部Multi AI Native平台上已经跑出了规模化的实践证据:64 个接入工作区、931 个在线 Agent、120 个研发小队、5945 个累计 Issue、1258 个已交付 Issue(数据持续更新中)。

                      4.1 典型案例

                      一个端到端的真实交付案例,具象化"AI 组织转型"的完整链路——从需求进入、小队拆解、多 Agent 协同,到交付闭环,展示组织视角打法在一个具体项目上是如何跑通的。

                      4.2 使用情况分析

                      平台「全平台看板」的实测规模与质量数据,直观佐证"AI 深度参与后交付的规模化程度"。

                      • 团队负责人先成为AI超级个体,带动团队转型AI Native

                      • AI Native先锋团队复制推广,加速组织的AI进化

                      整体平台使用趋势

                      敏捷迭代AI全栈交付占比

                      效能

                      质量

                      用户反馈

                      4.3 AI Native 前后对比表

                      AI Native进化带来的不只是"更快",而是流程、角色、协作、组织与沉淀方式的结构性重构。下图为组织转型带来的做法对照。

                      五、定制化功能

                      5.1 Coding Agent集群容器化部署, 脱离个人机器, 让AI 24小时运转

                      5.2 京Me机器人集成

                      5.3 行云自动扫描

                      自动扫描指定行云空间创建Issue

                      5.4 规约中心

                      工作区内运行时可授权采集记忆,平台分析生成规约专家复审可以作用于工作区及不同角色,复利至团队所有成员。

                      六、结语

                      AI 写代码,只是这场变革的起点,而不是终点。

                      真正决定一个组织能否吃到 AI 红利的,不是"能不能用 AI 写出代码",而是敢不敢用 AI 重新设计交付流程、重新划分角色分工、重新组织团队结构。研发视角能把工具和个人推到极致,却会在组织的边界前止步;只有站上组织视角,把 AI × 工具 一路推进到AI × 组织,那些被 AI 照出来的摩擦,才会真正被抹平。

                      国际技术部 Multi AI Native 想做的,正是这件事——让 Agent 成为你可靠的数字战友,让每一次迭代交付都快一个量级;更让整个组织,为 AI 而重新生长。

                      你的下一批员工,不是人类。

                      推荐阅读

                      跳转微信打开

                      OxygenData-Vibe搭建:用 AI Coding重新定义数据看板搭建

                      2026年11月3日 20:12

                      京东零售 苏文雄 2026-11-03 20:12 北京

                      来看看如何利用AI Coding,让数据看板的搭建效率与稳定性稳步提升。

                      一、行业痛点:BI看板搭建无法支持高度定制看板

                      长期以来,数据看板开发主要有两种方式:一种是使用标准化 BI 工具,交付快、成本低,但图表样式、交互体验和功能扩展都受限于 BI 本身的能力;另一种是自研定制开发,能够充分满足复杂和个性化需求,但需要投入大量研发资源,交付周期也更长。比如一个通过 BI 只需要 1 天就能搭建出来的看板,如果采用自研方式,可能需要投入 30 PD 的研发人力。

                      既然 BI 交付这么快,为什么不把所有看板需求都交给 BI?

                      原因在于,业务某些场景需要的不只是把数据展示出来。 当看板对交互体验、业务流程和个性化能力有更高要求时,标准化 BI 的通用组件往往难以满足。行业有较多面向商家的数据分析看板产品之所以投入大量资源自研,正是为了突破通用 BI 的能力边界,提供更好的用户体验和业务价值。我们内部不少面向商家和采销业务的数据看板,同样选择了自研的方式。

                      这就带来了一个长期存在的矛盾:能不能既拥有自研看板的灵活性和体验,又具备接近 BI 的开发效率和成本?

                      AI Coding 的快速发展,让这个问题有了新的解法。今年上半年,京东零售数据工程前端团队已经在自研看板项目中进行了实践,AI 生成代码占比超过 90%。这意味着,过去需要研发人员投入大量时间完成的页面开发工作,现在已经可以很大程度上交给 AI。

                      但这也让我们开始思考一个更进一步的问题:既然 AI 已经能够完成大部分编码工作,能不能让业务用户绕过专业研发,直接通过自然语言生成自己需要的数据看板?

                      二、解法和成果

                      OxygenData-Vibe 就是在 AI Coding这一思路下诞生的。用户只需要先配置好数据集,再通过自然语言描述自己的需求,Agent 就能将想法转化为可运行、可持续修改、可发布的数据看板。

                      不必再受限于固定的图表和组件,也不必依赖专业研发逐个实现交互功能,而是通过持续对话,让看板逐步长成自己需要的样子。

                      这不仅是开发效率的提升,更是数据看板生产方式的变化:从过去的「研发写代码」或「用户配置组件」,走向「用户表达需求,AI 完成开发」。

                      OxygenData-Vibe 是通过AI对话式交互搭建看板的功能,零门槛上手。您只需用自然语言描述需求,AI即可自动生成数据看板。看板支持更多个性化交互和图表可视化,视觉呈现更加灵活美观。

                      • 自今年 9 月上线以来,用户已经通过这种方式创建了478 个AI Coding看板

                      • 过去自研交付需要30人天,用新的 OxygenData-Vibe 3天交付初版

                      一些demo:

                      下面先通过一个完整案例看看是怎么使用的

                      • 实际使用演示

                      第一步:描述业务意图

                      用户既可以直接描述分析目标,也可以导入已有的需求文档。Agent 会基于意图和真实数据集,自主完成看板开发,业务语言本身就是开发的起点。

                      第二步:开发完成可预览查看

                      三、核心技术:构建“面向AI的新宇宙”

                      从上面的过程看,用户只需要描述需求,等待一段时间,就能得到一个可以直接使用的数据看板。但在这个看似简单的过程背后,要解决的问题并不少。

                      3.1 项目挑战

                      生成的看板要连接真实动态的数据集,能够基于筛选器的查询准确使用数据集中的指标和维度;当出现问题时,还能基于当前结果继续优化和修复问题;最终生成的内容也不能只停留在 Demo 阶段,而是要能够发布并真正投入使用。

                      3.1.1 动态看板复杂度很高

                      从技术上看,我们真正要构建的是支持动态查询的数据看板,而不是生成一份写死数据的静态页面。相比 Claude Code 分析 Excel 后生成网页,动态查询看板的复杂度要高得多。

                      动态查询看板与静态看板的复杂度对比如下,简单来说:

                      • 静态看板:是Demo

                      • 动态看板:是真实的业务应用

                      对比维度静态看板(Excel → HTML)动态看板(数据集 → 查询)
                      整体复杂度1×(基准)10×+(示意)
                      数据规模通常几十万行以内,数据边界明确千万至上亿行,数据规模和分布难以完整感知
                      数据理解AI 可以直接读取、分析本地数据AI 主要依赖 Schema、抽样数据,无法全面理解真实数据
                      业务规则数据中异常和规则相对容易发现存在脏数据、隐性规则、复杂指标口径,难以完整识别
                      开发方式直接生成包含固定数据的 HTML需要生成查询 DSL、动态参数、数据接口及前端交互
                      筛选交互基于本地数据筛选,逻辑简单筛选条件变化需要重新构造查询并获取数据
                      数据验证可以直接基于 Excel 全量核对需验证不同时间、筛选条件和数据变化下的正确性
                      多数据源通常单 Excel 文件多类型数据集,查询能力及接入方式不统一
                      行业解法相对成熟,已有较多实践仍处于探索阶段,无成熟方案

                      举例来说对于动态看板,用户把时间范围从“全部”切换为“近一年”,再选择“华东区域”。看似只是两次点击,系统背后却要重新识别筛选条件、调整时间粒度、计算同比周期,并为多个图表分别构造查询、处理空值与异常数据,最后完成结果渲染。任何一个环节出现偏差,都可能产生一个“看起来合理、实际错误”的结果。因此,动态看板不仅要保证生成时正确,还要保证在不同数据版本、筛选组合和交互状态下持续正确。

                      3.1.2 两条看似可行的实现路径

                      1. 沿用静态看板的 AI Coding 模式:将数据直接发送给 AI 生成页面。但 BI 数据集通常达到亿级规模,而静态看板处理的数据一般不超过几十万,受模型上下文限制,这条路径并不可行。

                      2. 沿用常规自研看板模式:将 BI 数据查询 API 文档交给大模型,由 AI 自由生成前端代码。经过大量实际测试,这条路径同样没有跑通。BI 查询协议中的筛选条件、环比同比和对比分析等配置非常复杂,会显著影响开发效果,数据正确性也难以保证。

                      两条看似直接的路径最终都没有跑通。这足以说明:动态数据看板既不能照搬静态看板的 AI Coding 模式,也不能简单地把复杂的数据查询交给大模型自由生成代码。真正可行的方案,必须跳出已有模式,以看板生成效率和数据可靠性为核心进行架构创新。

                      3.2 设计理念

                      3.2.1 需认识到 AI 并非万能,必须降低AI开发复杂度

                      以下情况AI实际表现并不好:

                      • 私域知识:llm 未经过该领域知识训练,私域知识并不能通过知识库从根本上解决,因为大模型的token有限制,并且随着输入token 增多幻觉会变多;而Rag信息召回技术,容易召回错误信息或者丢失重要信息,也存在较多问题,比如像 claude-code 并没有使用 rag 技术

                      • 业务规则多和复杂性高,可能在不同场合还有不同的用法

                      3.2.2 架构拆分

                      把原本对 AI 不友好的业务规则,接口查询协议,通过巧妙的架构拆分,构建一套 AI 可理解、上下文充足的环境(for AI 的新宇宙),在这个新环境里,AI 不需要凭空理解所有底层细节,而是可以在明确的边界内发挥创造力。

                      什么是“面向 AI 的新宇宙”?

                      “面向 AI 的新宇宙”并不是让 AI 学会更多 BI 专有知识,而是重新设计 AI 看到的世界,让它需要理解的东西更少、更通用。

                      大模型在训练阶段学习了大量代码、技术文档和通用知识,因此对非私域的业务知识理解很强。相反,企业内部长期演化形成的 BI 协议和业务规则并不在其通用训练知识中,仅靠提示词临时解释,很难保证模型每次都能准确理解。面向 AI 的关键设计,就是把内部专有知识转化为大模型已经熟悉的通用表达,让模型在自己的能力优势区间内工作。

                      在传统 BI 开发中,AI 如果要生成一个同比指标,就需要理解同比周期、时间字段、数据对齐和计算公式;如果要生成一个树形筛选器,还需要理解多层条件 and、or 如何组合,并手工构造复杂的查询参数。这些都是 BI 系统长期积累的专有规则,也是 AI 最容易出错的部分。

                      在新的架构里,复杂规则会在进入 AI 开发环境之前被查询层和组件层消化。站在 AI 的视角,整个世界发生了三个显著变化:

                      1. 开发过程不再包含私域业务规则。同比周期怎样确定、指标如何聚合、筛选条件如何嵌套等 BI 专有规则,不再作为背景知识和接口文档交给 AI。AI 面对的是结构稳定的通用协议,不需要先学习企业内部规则,再尝试把规则翻译成代码。

                      2. 请求参数被转换为简单的筛选值。AI 不再负责构造带有复杂业务逻辑的查询 DSL,只需要传递筛选字段及用户选择的值。树形筛选中的多层 and、or、权限条件和数据集特有参数,都由组件与查询层自动补全。对 AI 来说,一次查询只是“查询哪个数据模块,并传入哪些筛选值”。

                      3. 响应结果被转换为普通返回字段。无论是同比、环比、占比、累计值还是其他衍生指标,计算过程都在查询层完成,并以普通字段形式出现在 response 中。例如,sku_total_yoy_rate 与 sku_total 对 AI 而言没有本质区别:都有明确的字段名、数据类型和业务含义,可以直接绑定到指标卡、图表或表格。

                      因此,“新宇宙”最重要的变化可以概括为:开发侧无业务私域知识,请求侧只有简单筛选值,响应侧只有普通数据字段。 BI 专有知识并没有消失,而是下沉到查询层和组件层,成为稳定的系统能力,不再要求 AI 在每次页面开发中重新理解和实现。

                      这种封装也不是不可理解的“黑盒”。AI 不需要知道环比如何计算、复杂协议如何拼装,但能够清楚地看到字段含义、参数结构和返回结果。也就是说,内部实现被封装,对外使用保持透明。

                      3.3 架构解耦

                      基于这一理念,我们通过架构解耦,把动态看板开发拆分为两个阶段:

                      3.3.1 第一阶段:查询协议构建

                      这一阶段需要处理数据集、指标、维度、筛选条件以及复杂的 BI 查询规则,无法做到完全 AI 友好。因此我们采用人机协同的方式,由 AI 辅助理解和生成,由平台 GUI 能力与人工判断提供约束和确认,最终形成准确、标准化的查询协议。

                      支持GUI人机协同能力。通过图表数据源功能,调整配置和查看 sql 等:

                      3.3.2 第二阶段:基于 AI 友好协议的页面构建

                      查询复杂度被第一阶段隔离后,AI 面对的不再是底层 BI 协议,而是一套语义明确、结构稳定、易于理解和调用的协议。AI 可以据此专注于页面布局、图表表达和交互实现,将业务意图高效转化为最终看板。

                      架构解耦的关键,不是让 AI 强行掌握所有复杂规则,而是先通过人机协同把复杂查询转化为 AI 友好的协议,再让 AI 基于这套协议完成页面创造。由此,我们既保留了查询环节所需的准确性,也释放了 AI 在页面生成阶段的创造力。

                      下面两个具体的 JSON 协议,可以更直观地说明这种解耦。

                      示例一:环比规则被转换为普通指标字段

                      在第一阶段,查询协议需要明确参与计算的原始指标、对比方式、输出类型以及关联的时间筛选器。例如,要计算 SKU 数量同比,实际配置如下:

                        {
                          "ref": [
                            "sku_total",
                            "tag_enum_total",
                            "gmv_total",
                            "sale_qty_total",
                            "brand_total"
                          ],
                          "derive": {
                            "transform": "periodCompare",
                            "compare": "yoy",
                            "output": "rate",
                            "dateRef": "dateFilter"
                          }
                        }

                        这段协议意味着:以 dateFilter 为时间基准,对引用的指标执行 periodCompare 转换,计算同比 yoy,并以比率 rate 形式输出。时间周期对齐、同期数据查询和比率计算等逻辑均由查询层处理。

                        到了第二阶段,查询结果会把衍生指标转换成普通字段:

                          {
                            "response": {
                              "rows": {
                                "type": "array",
                                "item": {
                                  "sku_total_yoy_rate": {
                                    "type": "number",
                                    "role": "measure"
                                  },
                                  "tag_enum_total_yoy_rate": {
                                    "type": "number",
                                    "role": "measure"
                                  }
                                }
                              }
                            }
                          }

                          此时,sku_total_yoy_rate 对 AI 来说只是一个普通数值指标。AI 可以直接绑定到指标卡或图表,无需知道同比周期如何推算、两期数据如何对齐,也不需要在页面代码中实现同比计算。

                          示例二:树形筛选组件自动生成复杂查询条件

                          对于树形筛选,AI 在页面构建阶段只需要感知可筛选字段和操作符:

                            [
                              { "name": "a1", "op": "in" },
                              { "name": "a2", "op": "in" }
                            ]

                            当用户在组件中选择“a1
                             属于 2 或 3”,或者选择“a1
                             等于 11,并且 a2
                             属于 11、22、33”时,前端树形筛选组件会自动生成实际查询协议:

                              {
                                "type": "or",
                                "children": [
                                  { "a1": [2, 3] },
                                  {
                                    "type": "and",
                                    "children": [
                                      { "a1": 11, "a2": [11, 22, 33] }
                                    ]
                                  }
                                ]
                              }

                              AI 只负责声明“有哪些字段可以筛选”,组件负责把用户操作转换成包含 and、or 和嵌套 children 的查询树。这样既降低了 AI 生成错误协议的概率,也避免了页面构建阶段反复解释底层查询规则。

                              四、技术架构

                              如果把一句业务需求变成一个真正能运行的看板,背后大致要经过三步:先对数据做画像理解数据集,再让 Agent 按既定流程完成开发和纠错,最后把代码放进浏览器里跑起来。

                              我们的技术架构基本就是围绕这三件事搭建的。

                              4.1 数据画像

                              数据画像可以简单理解为:在让 AI 做看板之前,先把数据集看明白。

                              如果只给 AI 一份字段列表,AI其实很难判断这些数据应该怎么用。比如一个字段叫“销售额”,AI 还需要知道是金额还是数量、通常在什么范围、能不能求和;一个字段叫“区域”,也需要知道里面是华北、华东这样的枚举值,还是更细的省市层级。不了解这些信息,AI 虽然也能生成页面,但很容易选错字段、用错图表,甚至做出看起来合理、实际没有业务意义的分析。

                              数据画像做的事情,就是先把这些问题回答清楚。它会告诉 AI:数据集中有哪些字段,哪些是维度、哪些是指标,字段里大概有哪些值,指标的数据分布是什么样,哪些指标和维度可以一起查询。这样 AI 拿到的就不再是一堆陌生字段,而是一份关于这个数据集的“使用说明书”。

                              这个思路灵感来自我们对 “Claude Code + Excel 生成 HTML” 过程的研究。Claude Code 拿到 Excel 后,通常不会马上开始写页面,而是先查看表结构和字段信息,再分析维度有哪些典型取值、指标的数值有什么特征。等对数据形成比较完整的认识后,才会结合用户需求决定使用哪些字段、怎样聚合,以及选择什么图表。静态看板之所以容易取得不错的效果,“先理解数据,再开发页面”是一个很重要的原因。

                              但动态数据集通常有千万甚至上亿行,不可能像 Excel 一样把全部数据交给大模型。我们保留了这个思路,把全量读取改成了数据集画像:先获取字段元信息和统计特征,在条件允许时补充少量样本和维度枚举值,同时识别数据集支持哪些查询方式、需要什么权限、哪些字段可以组合。

                              最终交给 AI 的不是全量数据,而是一张足够准确的数据地图。

                              4.2 把数据查询变成 AI 看得懂的 API

                              页面开发并不是从写代码开始的。对动态看板来说,首先要回答的是:这个页面能查询哪些数据、能传入哪些筛选值、又会返回哪些字段?

                              这些先被写进 data-modules.json。可以理解为看板的设计稿,记录每个数据模块使用的数据集、指标、维度、筛选条件,以及派生计算、排序、下钻和汇总方式。AI 和用户通过图形化界面一起完成配置;字段名称、类型等客观信息则直接从数据集元数据中获取,不让模型凭空猜测。

                              配置通过结构校验、数据集校验和线上组合校验后,会被编译成 api-wiki.json。到了这一步,每个 Data Module 都变成了一条清晰的 API:用哪个 queryId 发起查询,可以传哪些筛选值,是否支持分页和排序,以及 response.rows.item 中会返回哪些字段。

                              API Wiki 不是一份需要人工维护的文档,而是 Data Modules 的编译产物。两者变化的关键在于:复杂 BI 规则停留在 Data Module 这一侧,交给 AI 的只是一份简单的接口契约。请求时传普通筛选值,返回时消费普通字段;即使某个字段背后是同比或环比计算,AI 也只需要知道的名称、类型和业务含义。

                              4.3 前端 UI 开发

                              有了 API,还需要告诉 Agent 怎样把页面一步步做出来。

                              4.3.1 代码开发

                              进入代码开发后,Agent 拿到的是业务需求和 API Wiki,同时还可以使用页面模板、组件规范、业务 Case 和 UI 规范。从 params 中知道页面能提供哪些筛选项,从 response 中知道图表能使用哪些字段,不再直接触碰底层 BI 协议。

                              整条链路由 Skill 串起来:先澄清需求,再准备查询协议,然后生成代码、检查错误、打包预览,最后发布。AI 仍然有足够空间决定页面长什么样、采用什么图表和交互,但每一步该用什么输入、工具和完成标准,都是明确的。

                              4.3.2 自研 AST Loop:让错误可以被定位和修复

                              代码能编译,并不代表看板就能正确运行。模型可能写出一个不存在的 queryId,可能让筛选字段与 API Wiki 对不上,也可能用错查询参数或组件。这些代码在语法上完全合法,普通的 Lint 很难发现,真正运行时却一定会出问题。

                              为了解决这类问题,我们基于 TypeScript Compiler API 做了一套 AST Checker。AI会分析源码 AST 和模块依赖,再用查询、筛选、表格、运行时等领域规则检查代码,同时结合 TypeScript 做类型校验。不仅知道“这段代码是否合法”,还知道页面使用的字段、查询和组件是否符合 API Wiki 与平台规范。

                              更重要的是,这个检查不是发布前才跑一次。每一轮代码生成后,Agent 都会执行检查;Checker 会把错误定位到具体文件和代码位置,并给出明确原因;Agent 根据结果修改代码,然后再次检查。这个过程会一直重复,直到所有规则通过。

                              这就是我们所说的 AST Loop:生成代码 → 发现问题 → 定位并修复 → 再次检查。除此之外,spec-check 还会在开发和打包阶段检查工程结构与交付要求。前者关注代码有没有正确使用平台能力,后者关注产物是否满足交付规范,两道检查一起把模型生成的代码逐步收敛成可运行的页面。

                              4.3.3 打包与运行:自研 CodeSandbox

                              最后一个问题是:Agent 写完代码后,在哪里运行?

                              传统前端工程通常要先安装 node_modules,再启动 Node 开发服务,这套流程并不适合在线 Agent。依赖安装很容易受到网络、包源、锁文件和运行环境差异的影响,导致运行不稳定和同一份代码可能在不同容器中出现不同结果。为此,我们自研了一套 CodeSandbox。把 Agent 生成的文件放进内存虚拟文件系统,使用 esbuild 在运行时完成模块解析、编译和打包;React、图表库、EasyBI 等公共依赖组件,则从预先构建好的 CDN 中加载。这样无需安装 node_modules,代码生成后就能直接运行。

                              最直接的收益是节省时间。过去创建新的开发环境,都要先下载和安装完整依赖,通常需要 10 分钟左右;现在公共依赖已经提前构建,Agent 拿到代码后可以直接进入编译和预览。打包也从分钟级缩短到秒级,用户不需要在每一轮修改后长时间等待结果。

                              CodeSandbox 使用统一 CDN Vendor 和同一套运行时,避免了依赖版本漂移,开发和预览、发布使用的依赖环境始终一致。

                              开发过程中,代码可以直接进入沙箱预览,Dev Server 负责实时构建和热更新。发布时,同一套构建能力会把项目代码编译成 IIFE,再与运行时依赖组装成一个可以独立打开的 HTML。HTML 和源码归档上传到 CDN 后,再写入 EasyBI 完成发布。

                              对 Agent 来说,这条链路从传统的“安装依赖—启动服务—本地构建”,变成了更简单的“生成代码—秒级编译—沙箱运行”。更短的反馈周期意味着 Agent 可以在相同时间内完成更多轮生成、验证和修复,也让整个在线开发过程更稳定。

                              五、结语

                              从上文可以看出,在 AI coding 高速发展下,数据看板的生产方式已经开始发生变化。过去做看板,要么在 BI 已有的图表和组件里配置,要么交给研发从头开发;现在,用户可以直接说清楚自己的分析思路,由 AI 把需求变成页面。看板能做成什么样,不再只取决于 BI 预设了哪些能力,或者能投入多少研发资源,而是可以更多地从业务需求本身出发。这个变化一方面提升了开发看板效率,另外一方面让以前做不了高体验需求通过 AI Coding方式支持。

                              从 9 月上线至今,用户已经通过 OxygenData-Vibe 创建了 478 个看板,其中 117 个完成发布并投入使用,也说明这种模式带来的价值。

                              推荐阅读

                              跳转微信打开

                              从“会生成”到“能生产”:萤火虫AIGC平台的 AI Infra 实践

                              2026年10月29日 20:09

                              京东零售 郑忠权 2026-10-29 20:09 北京

                              本文系统呈现了京东AIGC产品萤火虫平台从模型调用迈向规模化生产的工程实践,贯通编排、算力、数据与观测,适合做AIGC内容生产的同学一读。

                              一、引言:从一次内容请求到一套生产系统

                              很多 AIGC 产品最初都从一个聊天窗口开始:用户输入需求,模型返回文本、图片或其他内容。但当生成结果真正进入内容生产,问题就不再是一次模型调用能否成功,而是多种能力能否被稳定地组织起来,持续完成内容生成和交付。

                              萤火虫是面向内容生产的 AIGC 平台,包含内容 Agent、Workflow、生产模板、模型能力和浏览器操作等多种使用方式。用户可以通过对话、工作流或模板组织内容生产,也可以结合萤火虫浏览器扩展完成网页操作、内容发布和多平台分发。

                              对用户来说,一次请求可能只是“帮我生成一篇商品图文内容”;对平台来说,它背后需要完成知识库检索、图片理解、模型推理、文案生成、结果加工和内容交付。不同环节依赖不同的模型、数据和计算资源,还需要被编排成一条可以执行和观察的任务链路。

                              因此,萤火虫平台的 AI Infra 关注的不只是模型能否生成结果,而是模型、数据、任务和算力如何协同,最终形成一套能够稳定运行的内容生产系统。

                              二、为什么内容生产需要 AI Infra

                              AIGC 从单次生成走向规模化内容生产后,系统需要解决四类核心工程问题。

                              1. 能力如何被组织:一次内容生产往往包含知识库检索、商品解析、图片理解、生图、文案生成和结果加工等多个步骤。模型和算法能力如果仍以独立服务或临时脚本存在,很难被统一组合、复用和管理。

                              2. 任务如何被执行:在线请求关注响应速度,批量生产关注吞吐,海量素材处理关注资源弹性。CPU 预处理、GPU 推理和高初始化成本模型也具有不同的运行特征,单一执行方式无法同时覆盖这些场景。

                              3. 数据如何支撑模型效果:模型输出不仅取决于模型本身,还取决于素材质量、特征是否完整,以及能否检索到合适的多模态素材。原始多模态数据需要先被加工、治理和沉淀,才能成为生产阶段可直接使用的输入。

                              4. 长链路如何被观察:一个任务由多个算子组成。发生异常时,平台需要知道任务执行到了哪里、哪个算子失败,以及对应的日志和失败原因。

                              为此,平台需要用统一的方式组织模型和算法能力,根据任务特征选择执行引擎,将原始多模态素材加工为可检索的数据,并建立覆盖工作流的观测能力。这些能力共同构成了面向内容生产的 AI Infra。

                              三、整体架构:统一编排,差异化执行

                              整体架构围绕两条相互协同的链路展开:

                              1. 内容生产链路从萤火虫业务层开始:业务侧通过 Agent、Workflow 和生产模板选择并组合 AIGC 能力,平台层将这些能力解析为可执行的 Pipeline/DAG,再根据任务特征调度到 Ray Serve、Ray Data 或 Spark/Flink 等执行引擎。

                              2. 另一条是多模态数据处理链路:图片、视频等原始素材进入 Lance 多模态表,由弹性算力完成推理打标、内容理解、特征处理和清洗,推理结果、标签和特征等数据回写并沉淀在湖仓中,经过筛选的合格素材再进入图片 / 视频知识库,为内容生产提供检索能力。

                              Trace 横向连接平台层和不同执行引擎,通过 DAG、任务标识、算子标识和日志还原任务的实际执行过程。

                              四、平台层:从业务Workflow到可执行DAG

                              业务侧组合的是面向生产目标的 Workflow,执行引擎需要的则是可以直接调度的算子和依赖关系。平台层位于两者之间,负责把业务能力描述转换成真实的执行计划:

                              4.1 算子管理:把算法能力变成平台执行单元

                              算子是平台能够识别和调度的最小能力单元。它可以是一段图片处理逻辑、一个模型推理能力,也可以是对外部服务的标准化调用。平台通过算子管理统一约束输入输出、资源声明、版本、业务参数和依赖环境,使上层 Workflow 不需要了解算法内部如何实现。

                              模型权重、业务参数、运行配置和核心代码彼此解耦后,同一个能力可以独立升级,也可以根据任务类型进入不同运行方式。算子因此不再是某个需求下的一次性脚本,而是具备契约、版本和资源语义的平台执行单元。

                              4.2 Pipeline/DAG:把能力组合编译成执行计划

                              平台将 Workflow 中选择的能力解析成 Pipeline/DAG。DAG 描述算子之间的依赖关系、执行顺序和数据流转:依赖上游结果的节点按顺序执行,没有依赖关系的节点可以并行执行。

                              上下游之间通过输入输出映射传递数据。下游算子只获取自己需要的字段,算子输出也可以被筛选、重命名和映射到后续节点,避免不同算法实现直接耦合,也避免中间数据在长链路中无边界地传递。

                              4.3 任务管理:从执行计划进入具体运行时

                              DAG 生成后,平台创建对应任务,并关联本次运行所使用的 Workflow、算子版本、业务配置和资源要求。任务管理提供任务提交、运行配置和状态查看等入口,统一编排 DSL 则负责描述任务并选择执行后端。

                              平台统一的是任务、算子和数据流转语义,运行时可以保持差异。在线模型服务、离线批量推理和多模态数据处理分别进入 Ray Serve、Ray Data 和弹性算力。

                              五、执行体系:实时、批量与弹性

                              执行体系:实时、批量与弹性

                              不同 AIGC 任务对延迟、吞吐、模型生命周期和计算资源的要求差异明显。萤火虫没有用一种运行方式承接所有任务,而是在统一任务语义之下,根据任务特征选择实时、批量或弹性执行路径。

                              5.1 为什么选择 Ray

                              Ray 同时提供 Task、Actor 和服务化模型实例三种重要抽象。普通无状态计算可以作为 Task 执行,需要保持状态或复用模型实例的计算可以由 Actor 承载,在线模型则可以通过 Ray Serve 以服务副本方式运行。这些抽象能够匹配 AI 任务中模型初始化成本高、运行时间长、资源类型复杂的特点。

                              对于以 Python 为主的模型和算法算子,Ray 还提供了统一的资源语义。算子可以声明 CPU、GPU、内存、并发度和机器标签等要求,调度时再将图片预处理、文本处理和 GPU 推理放到合适的资源节点。在线与离线任务共享一套分布式执行体系,但分别采用 Ray Serve 和 Ray Data 的运行模型。

                              Ray 的价值并不只是单点推理性能,而是将模型运行、服务副本、资源调度和分布式数据处理组织在同一套体系中,为上层 Pipeline 提供一致的执行接口。

                              5.2 Ray Serve:管理在线模型服务的生命周期

                              实时任务由自研调度引擎统一调度,并通过 HTTP 接口调用 Ray Serve 中部署的算子。

                              Serve 主要提供三个方面的能力:

                              1. 模型常驻与服务副本:模型和算子提前加载在常驻实例中,避免每次请求重复初始化。不同服务可以独立配置副本数量、CPU/GPU 资源和并发能力,单个模型的资源变化不需要带动整条 Workflow 一起扩容。

                              2. 滚动部署与自动扩缩容:模型或算子发布新版本时,Serve 支持逐步切换服务实例,降低版本切换对在线请求的影响;同时具备根据服务负载调整副本数量的能力,用于适应请求的波峰波谷。

                              3. 平台编排与模型运行解耦:自研调度引擎负责任务编排和请求调度,Ray Serve 负责模型加载、服务副本、请求分发和运行资源。两者通过稳定的 HTTP 接口连接,为后续多模型协同和复杂 Workflow 留出扩展空间。

                              5.3 Ray Data:面向模型推理的离线批处理

                              批量内容生产采用 Ray Data 进行离线推理和分布式数据处理。待处理数据以 Dataset 组织,并被分发到不同模型实例上执行;读取、推理和结果写出则被串成连续的数据处理流程。相比逐条调用模型,这种运行方式更适合以 Python 模型为主的大规模批量推理。

                              1. 模型实例复用:模型算子以长生命周期 Actor 运行,模型在 Actor 初始化时加载一次,后续可以持续处理多个数据批次。Actor Pool 负责维护一组可复用的模型实例,降低图片和多模态模型反复初始化的成本。

                              2. 批量推理与资源协同:map_batches 将一批数据交给模型实例集中处理,减少逐条调用产生的调度开销,也更符合 GPU 推理的执行方式。不同算子可以分别配置批大小(batch size)、并发度、CPU/GPU、内存和机器标签,在吞吐、显存占用和资源隔离之间进行调整。

                              3. Pipeline 化并行执行:数据读取、模型处理和结果写出可以随着数据流动并行推进;长链路中没有依赖关系的图片理解、属性提取等分支也可以并行执行,完成后再合并结果。

                              Ray Data 把离线推理从“循环调用模型”,转变为“面向数据集和模型实例的分布式执行”。

                              5.4 弹性算力

                              弹性算力承接多模态数据湖仓中的海量素材处理,包括图片、视频清洗、推理打标、内容理解和特征处理。这类任务通常具有阶段性计算峰值,将其放到独立的弹性资源中,可以减少大规模数据处理对在线内容生成和日常批量生产的资源影响。

                              这套设计的核心是统一任务语义、差异化运行:平台层统一描述任务,执行引擎分别针对在线延迟、批量吞吐和数据规模优化自己的运行方式。

                              六、多模态数据湖仓:从素材治理到数据飞轮

                              模型效果不仅取决于模型本身,还取决于输入数据是否准确、素材是否匹配、上下文是否完整。对于内容生产来说,原始图片和视频需要先经过理解、打标、特征提取和质量清洗,才能成为知识库中可检索、可复用的素材。

                              6.1 为什么选择 Lance

                              多模态数据与传统分析数据具有不同特征。一份素材记录可能同时关联图片或视频、结构化元数据、模型标签、内容理解结果和特征向量;随着算法迭代,同一份数据还会不断增加新的标签、特征和打分列。

                              Lance 面向 AI 数据访问场景设计,能够用一套表格式统一组织图片、视频、结构化元数据、推理标签、内容理解结果、特征和向量。

                              对我们的多模态素材处理来说,选择 Lance 主要看重三点:

                              1. 列式组织与按需读取:素材元数据、标签、内容理解结果、特征和向量按列组织。处理任务可以只读取需要的字段,适合多模态宽表和持续增加的特征列。

                              2. 素材与推理结果统一关联:原始素材、模型推理结果、标签和向量在同一套数据组织中建立关联。算法增加新的特征或处理结果时,可以继续围绕同一份素材数据扩展,减少数据在多个系统之间复制和拼接。

                              3. 向量检索与快速点查:既可以根据标签、属性等结构化条件筛选素材,也可以通过向量检索找到语义相近的图片和视频;检索命中后,还可以快速读取对应的素材信息,为可视化筛选和知识库构建提供统一访问路径。

                              因此,Lance 表既是多模态素材的统一承载方式,也是后续批量处理、可视化筛选和知识库构建共用的数据入口。

                              6.2 素材清洗:从素材入湖到知识库构建

                              当前多模态数据湖仓围绕素材处理和知识库构建形成一条主链路,同时湖仓可视化平台作为连接 Lance 多模态表的旁路入口,为数据观察和人工操作提供支持:

                              业务、算法和运营人员可以通过可视化平台查看整个湖仓中的素材数据集、推理结果、标签和特征,按照标签、属性和处理结果筛选素材,也可以通过向量检索查找相关数据,用于检查清洗结果、观察数据分布和发现异常样本。经过治理和筛选的合格素材进入图片 / 视频知识库,内容生产任务再从知识库中检索模特、上身图和视频素材。

                              通过将图片和视频理解、特征提取等高成本处理前置,生产阶段可以直接使用已经治理的多模态素材,减少在线 Workflow 的临时处理压力。

                              6.3 数据飞轮:从数据沉淀到模型与算子迭代

                              当前已经建设的能力覆盖素材入湖、弹性处理、结果沉淀、可视化观察和知识库构建。在此基础上,后续希望将内容生产过程中的推理结果和问题样本逐步沉淀下来,形成完整的数据飞轮:

                              这条目标链路将数据沉淀、问题分析和模型迭代连接起来,使线上生产过程不再只是消耗模型能力,也能逐步积累下一轮优化所需要的数据。随着这部分能力完善,多模态湖仓可以从当前的素材治理空间,进一步演进为同时服务检索、评测、训练和 Agent 上下文的数据资产空间。

                              七、Trace:让工作流执行过程可见

                              一条内容生产 Pipeline 可能包含多个前后依赖或并行执行的算子。仅依靠分散日志,很难快速判断任务执行到了哪里,以及失败发生在哪个节点。Trace 将 DAG 结构、任务、算子和日志连接起来,形成工作流级的执行视图。

                              7.1 任务、算子与日志的关联机制

                              Trace 使用统一标识串联一次任务的执行过程:

                              task_id 标识一次完整任务,DAG 提供工作流结构,operator_id 对应流程中的具体算子,trace_id 则将算子与实际运行日志关联。平台可以从任务总览进入 DAG,再从具体节点下钻到相关日志,不需要在多个系统之间手工比对标识。

                              7.2 可以观察什么

                              Trace 可以展示任务和算子是否执行、执行结果是成功还是失败,并在失败时定位具体算子、错误上下文和关联日志。它既服务于业务人员查看任务进度,也帮助算法和平台人员理解长链路任务的实际运行情况。

                              在现有工作流观测基础上,后续还可以进一步建设任务自动重试、中间结果恢复等运行管理能力。

                              7.3 总结:让模型、数据和任务在同一套体系中协同

                              萤火虫 AI Infra 围绕多模态内容生产形成了一条清晰的技术链路:平台层将业务 Workflow 转换为可执行 DAG;Ray Serve、Ray Data 和弹性算力让不同任务进入合适的运行方式;Lance 多模态数据湖仓把原始素材加工成知识库可以检索的数据;Trace 则把任务、算子和日志连接成完整的执行视图。

                              关键不在于堆叠组件,而在于统一编排、差异化执行、数据前置治理和工作流级观测之间形成协作。业务可以持续组合新的 AIGC 能力,平台负责将其转换为标准任务,执行引擎按照任务特征分配资源,多模态数据持续沉淀和演进,任务运行过程也能够被观察和定位。由此,模型能力才能从单点调用走向持续、稳定的内容生产与交付。

                              八、写在结尾

                              萤火虫平台是京东面向电商业务的“一站式 AI 内容规模化生产平台”,电商内容生产的基础设施平台,推动商家从单点分散的内容创作,走向平台化、智能化、规模化的协同生产。

                              平台以商品信息和业务需求为核心,依托创作智能体(Agent)与低代码工作流,打通“商品理解-卖点提炼-批量生成-人工质检-一键发布”全链路。

                              在内容形态上,平台不仅能高效产出商品主图等标准化素材,更擅长围绕商品构建立体的人物设定、生活场景、故事线及内容风格。通过持续输出真实、多元、极具“活人感”的图文与视频,萤火虫 AI 致力于赋能电商内容生产,推动其从“单次生成”向“一站式、规模化、可持续运营”长效发展。

                              最后欢迎大家使用萤火虫平台,也欢迎在实际使用过程中多提宝贵意见。无论是产品体验、内容效果,还是工作流和平台能力上的反馈,都会成为我们持续迭代的重要输入。大家的反馈和建议,是我们不断前进、把萤火虫做得更好的最大动力。

                              👉平台地址:https://firefly.jd.com/

                              推荐阅读

                              跳转微信打开

                              EMNLP 2026|京东零售 AI Infra 团队提出分离式多模态训练框架 FlowTrain

                              2026年10月27日 21:28

                              京东零售技术 2026-10-27 21:28 北京

                              本文导读

                              近日,京东零售 AI Infra 团队围绕多模态大模型训练效率提升,提出 FlowTrain 分离式训练框架,并在国产芯片超节点上完成实验验证。FlowTrain 面向视觉语言模型训练中 encoder 与 LLM backbone 同步等待、资源利用率低、变长样本负载不均等核心挑战,提出流式解耦训练范式。依托超节点的高带宽互联、跨设备数据访问和集群训练能力,FlowTrain 在真实工业负载下实现超过 50% MFU,并获得最高 1.7 倍吞吐提升,为自主创新 AI 算力底座上的多模态大模型训练提供了新的技术路径。

                              基于本工作的论文已被 EMNLP 2026 Industry Track 接收,欢迎阅读交流。 

                              · 论文:FlowTrain: Flow-Based Decoupled Training for Industrial-Grade Vision-Language Models

                              · 链接:https://arxiv.org/pdf/2606.23087

                              01

                              背景与挑战

                              多模态大模型正在成为智能零售、内容理解、智能客服、工业质检等场景的重要技术底座。与纯文本大模型相比,多模态训练需要同时处理图像、文本、视频等异构输入,训练链路中通常包含视觉 encoder、投影层、LLM backbone 等多个模块。不同模块的计算形态、并行方式和资源需求差异显著,给训练系统带来了新的效率瓶颈。 在传统训练框架中,多模态样本通常以固定 batch 方式组织。encoder 需要先完成图像或视频特征提取,再将 embedding 交给 LLM backbone 继续训练。由于样本分辨率、图像数量、文本长度差异较大,不同 microbatch 的处理耗时波动明显,容易造成以下问题:

                              • Batch 级同步等待明显:encoder 和 backbone 被固定 batch 边界绑定,快的一侧需要等待慢的一侧,导致算力空转。

                              • 异构模块并行策略难以统一:encoder 更适合轻量化 DP/TP 组合,LLM backbone 则通常需要 DP/TP/PP 等复合并行。如果所有模块采用统一并行策略,会造成资源错配。

                              • 变长多模态样本导致负载不均:padding 浪费、attention计算差异、pipeline stage 负载不均,会进一步拉低集群整体 MFU。

                              针对上述挑战,京东零售 AI Infra 团队提出 FlowTrain 框架,将多模态训练从传统的“同步 pipeline”重构为“生产者—消费者数据流”,FlowTrain包括三个核心亮点。Unified Memory Pool:通过统一内存池打破 encoder 与 backbone 的 batch 级同步屏障,将点对点批量交互转化为全局可寻址的缓冲交换; Heterogeneous Parallel Allocator:将资源分配目标从“单模块最快”转为“生产速率与消费速率匹配”,为 encoder 和 backbone 选择差异化并行策略;Dynamic Packing Scheduler:根据运行时样本长度和真实计算成本动态构造 microbatch,降低 padding 浪费并平衡 PP/DP 负载。 在超节点实验环境中,FlowTrain 进一步结合其高带宽互联与跨设备数据访问能力,验证了框架在工业级多模态训练中的效率潜力。

                              图片

                              02

                              FlowTrain 的关键技术创新

                              Unified Memory Pool:以全局地址空间实现多模态训练时间解耦

                              FlowTrain 的 Unified Memory Pool 是实现时间解耦的基础。该机制通过 64 位全局虚拟地址统一管理跨节点 HBM 与 DRAM 资源,将 encoder 产生的多模态 embedding 与文本 token 纳入全局可寻址空间。backbone 可依据元数据和全局虚拟地址持续访问已就绪数据,无需等待完整 batch 的 encoder 输出。 国产芯片超节点提供的高带宽互联与跨设备访问能力,为 embedding 的透明流转和 backbone 的连续消费提供支撑,使 encoder 侧的运行波动能够被统一内存池吸收,而不直接传导至 backbone 训练阶段。

                              图片

                              FlowTrain 通过消费者-生产者流消除同步训练的 batch-level 同步等待

                              Heterogeneous Parallel Allocator:以吞吐匹配优化异构并行资源分配

                              多模态训练中,encoder 与 LLM backbone 的计算特征不同。Encoder 通常更适合 DP/TP 组合,LLM backbone 则通常需要 DP、TP、PP等复合并行。如果所有模块采用统一并行策略,会造成资源错配。

                              FlowTrain 提出的 Heterogeneous Parallel Allocator,将资源分配转化为生产速率与消费速率的匹配问题,而非依赖经验调参。系统先以小规模吞吐 profiling 建立吞吐代理模型,再通过 MILP 在既定资源预算内,为 encoder 与 backbone 选择各自更匹配的并行配置;优化目标是优先最大化全局吞吐,并进一步降低生产—消费不匹配。 该机制可结合集群拓扑、通信代价、算子执行效率和并行策略组合,更准确地刻画真实训练吞吐,为异构模块提供差异化资源配置。

                              Dynamic Packing Scheduler:基于真实计算成本的动态打包调度

                              多模态训练样本天然存在变长问题。文本长度不同,图像数量不同,视觉 token 数也不同。即使 token 总数接近,最长子序列长度也会显著影响 attention 计算开销。

                              FlowTrain 设计 Dynamic Packing Scheduler,不再仅按 token 数或样本大小进行静态分桶,而是在完成编码后,依据 LLM 侧的实际计算代价动态构造 microbatch。调度器先通过 segment tree-based best-fit packing 降低 padding 浪费,再基于真实计算成本对 microbatch 分桶,并通过 zig-zag dispatch 同时平衡 PP 与 DP 维度负载,从而更有效应对多模态样本带来的计算波动与负载不均。

                              基于 MindSpeed MM 的工程实现

                              在完成 FlowTrain 三项核心方法设计后,京东零售 AI Infra 团队基于 MindSpeed MM 进行工程实现。MindSpeed MM 提供多模态训练所需的数据工程、模型组件、并行训练和算子优化能力,为 FlowTrain 的落地验证提供工程承接。

                              在工程实现层面,FlowTrain 还可利用 MC2 通信计算掩盖技术,将可并行的通信任务嵌入计算窗口执行,减少通信在关键路径上的暴露;在相关工程优化条件下,整体性能可进一步提升约 10%。

                              03

                              实验结果

                              端到端训练性能提升

                              图片

                              我们评估了 FlowTrain 在三种模型规模下的端到端训练性能。上图表明,FlowTrain在与 Megatron-LM、DistTrain 的基线对比中始终实现最高的吞吐量。在 InfoVQA数据集和工业数据集上,FlowTrain 分别带来最高达 1.7 倍和 1.4 倍的吞吐量提升。值得注意的是,随着模型规模增大,FlowTrain 与基线方法之间的性能差距也在不断扩大。在 InfoVQA 数据集上,FlowTrain 相较于 Megatron-LM 的吞吐量提升从VLM-6B 的 1.3 倍增加至 VLM-72B 的 1.7 倍。这是因为基线方法受限于批次级别的同步屏障,导致硬件利用率低下。相比之下,FlowTrain 允许执行解耦,并通过共享内存抽象来协调异构模块,从而显著提升大规模VLM的训练效率。

                              计算效率大幅提升

                              图片

                              基于同样的实验环境,我们比较了不同方法在三种模型规模下的 MFU(模型浮点运算利用率)。如上图所示,FlowTrain 在所有配置下均大幅优于 Megatron-LM。得益于生产者和消费者之间的流匹配优化,FlowTrain 在 InfoVQA 数据集和工业数据集上训练 VLM-72B 时,MFU 分别达到 52.9% 和 50.0%,而 Megatron-LM 由于采用单体设计,MFU 仅达到 31.2% 和 36.9%。此外,虽然 DistTrain 的分离式编排能够缓解一部分并行度不匹配的问题,但由于其僵化的流水线执行方式,MFU仍低于 FlowTrain。FlowTrain 允许 backbone 无需等待整个批次的 encoder 输出即可继续执行,并能够消费均衡的微批次,从而提升了资源利用率。

                              优秀的横向扩展性能

                              图片

                              为了进一步验证可扩展性,我们在不同集群规模下基于 InfoVQA 数据集训练 VLM-32B,并以纯 LLM 训练作为性能参考上限。上图结果展示 FlowTrain 在所有集群规模下均达到 53% 以上的 MFU,吞吐量提升 1.1-1.4 倍,表现出不同训练规模下的鲁棒性,而其他方法的训练效率远低于 FlowTrain。

                              此外,我们观察到 FlowTrain 的性能相比于基线方法更接近纯 LLM 训练。Megatron-LM、DistTrain 和 FlowTrain 与纯 LLM 训练的平均MFU差距分别为 18.7、12.1 和 5.0 个百分点,证实我们的设计能显著缩小 VLM 训练与单模态训练在效率上的差距。

                              在京东电商大模型训练的真实应用

                              京东零售 JoyAI-OxygenVLM 电商多模态 32B Dense 和 35B-A3B MoE 大模型上,训练吞吐分别提升 1.7 倍和 1.4 倍;通用能力与同尺寸开源模型持平,在 OxyEcomBench 零售电商评测任务达到行业 SOTA;已支持 7 个以上零售业务场景,包括 AI 图搜、商品素材质检、穿搭推荐、货不对品、AI 致幻、平生-商品违规巡检、风控-风险商家巡检等多项业务,其中AI图搜相比线上模型 UCVR 核心指标置信提升 +2.24%,且多个核心指标均置信正向。

                              04

                              结论与展望

                              京东近年来大力布局、共建国产 AI 生态。本工作是京东零售 AI Infra 团队与国产芯片团队合作,基于高速互联硬件能力、MemFabric内存池化技术、MindSpeed MM软件栈,结合多模态大模型训练特点所作出的系统级工作,并在京东电商业务真正的应用落地,带来显著的效率提升。

                              我们看到,大模型训练正在从单一模型优化走向系统级协同优化,模型规模、数据形态和业务复杂度将持续提升,训练系统需要同时具备更高的算力利用率、更强的异构并行能力和更灵活的数据调度能力。京东零售 AI Infra 团队围绕 FlowTrain 的技术创新,验证了自主创新 AI 基础设施支撑工业级多模态训练的可行路径。未来,将持续推进面向真实业务场景的训练框架、调度算法和系统优化实践,将 FlowTrain 相关技术能力在更大规模模型、更复杂数据分布和更多产业场景中落地,并面向开发者社区开放更多实践经验,促进高效、开放的多模态大模型训练生态发展。

                              — END —

                              推荐阅读

                              跳转微信打开

                              当我谈数据库高可用时是在谈些什么

                              2026年10月22日 21:46

                              京东零售 赵阳 2026-10-22 21:46 北京

                              “如果程序只需要一个决定,为什么要先让 AI 写一段话?”本文借 TypeSafe AI 的 Jev,讲透 LLM 与决策模型如何重新分工——不生成文字,直接返回有类型的决策与概率,还给出落地四步与四类试点场景。冷静拆解、克制不吹,AI工程化必看。

                              本文主线:单机崩溃可恢复 → 数据复制到备库 → GTID 让复制认得清 → 主备安全切换 → Orchestrator 自动容错。面向 DBA / 后端工程师,偏原理。

                              一、引言:为什么要做数据高可用

                              数据库是有状态的服务,它站在应用链路的最末端,却决定了整条链路能不能"落袋为安"。缓存挂了可以回源,网关挂了可以切流量,但数据库挂了——写入丢、读取错、主从乱,这些问题会造成难以挽回的损失。

                              这些年因为数据库不高可用炸掉的案例,比想象中密集得多:

                              • GitHub 主库脑裂:网络分区导致主库和备库同时可写,自动切换脚本失效,人工介入花了 24 小时才恢复,全球开发者推送、PR、CI 全部停摆,公开事后报告里承认"我们的 HA 机制在这次故障里没起作用"。

                              • AWS RDS/Aurora 某可用区故障:依赖单 AZ 部署的 RDS 实例直接不可用,备库在另一个 AZ 但没开自动 failover,业务侧只能干等 AWS 修复,电商客户当天订单丢失、退款工单爆仓。

                              • 阿里云香港 Region 可用区 C — RDS/PolarDB 不可用(2022-12-18,>15h):跨 AZ 切换的 RDS 实例因为代理服务部署在同一个可用区 C,代理挂了导致无法通过代理地址访问、切换流程起不来;单 AZ 高可用版实例更是直接卡死。部分客户宕机超 24h,澳门金管局/银河/澳觅等一连串客户中招。阿里云自己承认是"运营十多年来持续时间最长的一次大规模故障"。

                              二、全景:一条主线串起五层

                              高可用不是单一技术,而是层层叠加的保证。每一层完成一定程度的高可用,全部叠加才是最完整的状态:

                              层回答的问题关键词
                              ① 单机机器断电,已提交的事务还在吗?WAL、2PC、崩溃恢复
                              ② 复制主库数据怎么到备库?会丢多少?异步 / 半同步、RPO
                              ③ GTID切换后备库怎么知道自己缺哪些事务?全局事务号、auto-position
                              ④ 切换主挂了怎么换,才能不丢、不脑裂?追平、fencing、PRS/ERS
                              ⑤ 自动化谁来发现、谁来决策、谁来执行?选主、probe-agent

                              三、单机一致性:一条事务如何"崩溃不丢、可恢复"

                              高可用的地基是单机持久性:一台 MySQL 断电重启后,已经告诉客户端"提交成功"的事务绝不能丢,没提交的绝不能残留。这靠三种日志 + 两阶段提交实现。

                              3.1 三种日志的分工

                              很多人把 redo、undo、binlog 搞混,其实分工清晰:

                              日志所在层类型作用谁写
                              redo logInnoDB 引擎层物理日志(某页某偏移改成什么)崩溃后前滚已提交事务,实现持久性InnoDB
                              undo logInnoDB 引擎层方向日志(反向操作)回滚未提交事务、支撑 MVCC 快照读InnoDB
                              binlogMySQL Server 层逻辑日志(行/语句变更)主从复制 + 时间点恢复(PITR)Server

                              关键区别:redo 是"引擎的内部账本",binlog 是"对外广播的变更流"。redo 大小固定、循环覆盖;binlog 持续追加、可归档。复制和恢复到某时刻靠 binlog,崩溃恢复靠 redo。

                              3.2 WAL:先写日志,再刷数据页

                              InnoDB 遵循 WAL(Write-Ahead Logging,预写日志):改数据时,不急着把数据页刷回磁盘(随机 IO 慢),而是先把"改了什么"顺序写进 redo log(顺序 IO 快),数据页可以晚点再刷。

                              好处:提交只需等 redo 顺序落盘,不必等数据页随机落盘,大幅提速;即使数据页还没刷、机器就崩了,重启时也能用 redo 把它"前滚"回来。

                              3.3 2pc:redo 与 binlog 的两阶段提交

                              问题来了:redo(引擎层)和 binlog(Server 层)是两份独立的日志。如果只写了一份就崩溃,主库和备库就会不一致(比如 redo 提交了、binlog 没写,备库就永远缺这条)。

                              MySQL 用内部两阶段提交保证两份日志"要么都生效、要么都不生效":

                              顺序是关键:redo-prepare → binlog-write → redo-commit。binlog 写成功是"提交点"的核心依据。

                              3.4 崩溃恢复:怎么决定 prepare 事务的命运

                              重启后,InnoDB 扫描 redo,对处于 PREPARE 状态(有 prepare 但没 commit)的事务这样处理:

                              结论:以 binlog 是否完整落盘,作为"这个事务到底算不算提交"的最终裁决。这样主库的恢复结果,和"备库通过 binlog 看到的"永远一致。

                              3.5 关键参数:什么是"双 1"

                              大家都经常听到说数据库的双1,那双1指的是什么呢?指的是以下两个参数设置为1:

                              参数=1(最安全)≠1(更快但可能丢)
                              innodb_flush_log_at_trx_commit每次提交都把 redo 刷盘0/2:攒着刷,崩溃丢最近 1 秒
                              sync_binlog每次提交都把 binlog 刷盘0/N:攒着刷,崩溃丢最近若干条

                              "双 1"(都设为 1)= 单机不丢已提交事务的前提。生产核心库必须双 1;代价是每次提交两次 fsync。

                              小结:单机层用 WAL 提速、用 2PC 保证 redo/binlog 一致、用崩溃恢复裁决半成品事务、用双 1 兜底持久性。这一层保证的是"一台机器自己不丢"——但机器整个挂了怎么办?这就要靠复制。

                              四、主备复制:数据如何从主库到备库

                              单机再可靠,机器宕了、磁盘坏了,数据就没了。所以要把数据实时复制到备库。

                              复制的本质:把主库的 binlog 搬到备库重放一遍。

                              4.1 复制链路:三个线程

                              4.2 异步复制:默认、最快、可能丢

                              默认模式:主库提交后立刻返回客户端,不等备库。

                              优点:快,主库不受备库拖累。

                              缺点:主库宕机瞬间,已返回成功但没送达备库的事务全丢——丢多少取决于当时的复制延迟。

                              4.3 半同步复制:至少一个备确认

                              为压缩丢数据窗口,引入半同步(semi-sync):主库提交后,要等至少 N 个备库确认收到 binlog,才返回客户端。

                              两个时机(rpl_semi_sync_master_wait_point):

                              模式等待时机一致性风险
                              AFTER_SYNC(5.7+ 默认,推荐)主库 binlog 落盘后、引擎提交前就等备库确认强:确认了才对外可见幽灵读更少
                              AFTER_COMMIT主库引擎提交后再等备库确认弱:主库已可见但备库可能还没有主库能读到、备库却没有的"幽灵"

                              关键参数:

                              • rpl_semi_sync_master_wait_for_slave_count:要等几个备确认,现网配置为1。

                              • rpl_semi_sync_master_timeout:等待超时(毫秒)。

                              超时后退化为异步! —— 这是半同步"名义强、实则可能悄悄降级"的坑:网络一抖,它就变回异步。现网所有的核心系统都设置成了8640000,也就是可以认为半同步不退化,叠加三机房部署保障了RPO=0。

                              小结:复制把"单机不丢"扩展成"一台挂了另一台还在"。异步快但丢得多,半同步用一次网络往返换不丢数据。可是——主库真挂了,备库怎么知道自己缺哪些事务、从哪儿接着复制?这就要靠 GTID。

                              五、GTID 模式原理:让复制和切换"认得清、不重复"

                              5.1 传统 binlog 定位的痛点

                              GTID 之前,备库靠 binlog 文件名 + 位点(position) 记录"复制到哪了",比如 mysql-bin.000123:4567。

                              问题:

                              • 位点是主库本地的,换了新主,同一个事务在新主的 binlog 里位点完全不同。

                              • 切换时,DBA 得人肉找"备库最后那条事务,对应新主 binlog 的哪个位点"——极易错,错了就丢数据或重复执行。

                              5.2 GTID:给每个事务发一个全局身份证

                              GTID(Global Transaction ID)= server_uuid:transaction_id,例如 3E11FA47-...:23。

                              • server_uuid:最初执行这个事务的实例的唯一标识。

                              • transaction_id:在该实例上的递增序号。

                              • 一个事务的 GTID:全局唯一且终身不变——不管它被复制到哪台机器,身份证号不变。

                              备库维护一个 GTID 集合,用区间紧凑表示已执行的事务:

                                gtid_executed = 3E11FA47-...:1-100:102-105
                                                        (缺了 101 这条)

                                5.3 auto-position:切换后自动对齐

                                开启 GTID 后,备库连主库时用 MASTER_AUTO_POSITION=1:

                                核心价值:切换新主后,各备库不用人肉找位点,报出自己的 GTID 集合,新主自动补差集。 这正是自动化切换(Orchestrator)能安全 repoint 的基础。

                                5.4 幂等:不重复执行

                                备库应用一条事务前,先看它的 GTID 是否已在 gtid_executed 里——在就跳过。这保证同一事务不会重放两次(比如切换后拓扑变动导致某条被推送两次)。

                                小结:GTID 把"复制到哪了"从"主库本地位点"升级为"全局事务身份证集合",让切换后各备库能自动对齐、不重复。有了 GTID,我们终于可以安全地谈"主挂了怎么换主"。

                                六、主备切换一致性:不丢数据,不双主

                                主库挂了(或计划内维护要换主),要把某个备库提升为新主,并让其余备库改挂到新主下。这个过程最怕两件事:丢数据和双主(脑裂)。

                                6.1 切换三步

                                6.2 fencing:防止老主"诈尸"

                                最危险的场景:老主并没真死(只是网络分区/假死),切换后它又活过来继续接受写——此时新主也在写,就是双主,两边数据分叉,极难修复。

                                fencing(隔离/围栏)= 确保老主再也写不进去

                                手段:老主一侧 set read_only / 杀连接 / 注销元数据

                                6.3 计划内(PRS)vs 紧急(ERS)

                                Vitess/orchestrator 体系里两种 reparent:

                                PRS(Planned Reparent)ERS(Emergency Reparent)
                                触发

                                主库已挂
                                老主还活着,能配合降级可能已失联
                                RTO可做到接近0( 先追平再切)尽量小(选延迟最小者)
                                关键有序、无损快、防脑裂优先

                                小结:切换的一致性 = fencing(不双主)。GTID 让 repoint 变简单,fencing 让老主不能写入。但——谁来判断"主真的挂了"?谁来决定选哪个备?谁来执行这三步?人肉半夜爬起来太慢也易错。这就是 Orchestrator 要解决的。

                                七、Orchestrator如何选主,以及probe-agent的作用

                                前几章讲清了"怎么才能安全切换"。但真到凌晨主库宕机,靠人来"发现→判断→选主→执行"太慢也太容易错。

                                Orchestrator(orc)就是把这套动作自动化的大脑;而 probe-agent 是它派驻在每台 DB 主机上的"眼睛和手"。

                                7.1 拓扑发现:先画出复制关系图

                                orc 不需要你手工登记主从关系。给它任意一个实例,它就顺着 SHOW SLAVE HOSTS / SHOW SLAVE STATUS主动爬取,把整个复制拓扑(谁是主、谁挂在谁下面)发现出来并持续刷新,这是后面一切判断的基础。

                                7.2 故障检测的精髓:反证法(orc 最值得学的一点)

                                最容易踩的坑:orc 自己连不上 master,就判定 master 死了 → 误切。 网络抖动、orc 到 master 的单条链路故障,都会造成误判,而误切的代价极高(可能引发不必要的切换甚至双主)。

                                orc 的解法是反证法(holistic / cross-check):判断 master 是否真死,不只看 orc 自己能不能连,更看"master 的那些 replica 还连得上它吗"。

                                AnalysisCode含义是否触发切换
                                DeadMastermaster 连不上,且 replica 也连不上是(真死)
                                DeadMasterAndSomeReplicasmaster 死,部分 replica 也失联是
                                DeadMasterAndReplicasmaster 死,replica 全失联是
                                DeadMasterWithoutReplicasmaster 死且没有 replica视配置
                                UnreachableMasterorc 连不上,但 replica 还连得上否(疑似网络问题)
                                UnreachableMasterWithLaggingReplicas连不上 + replica 延迟增大观察
                                LockedSemiSyncMaster半同步锁死(等不到备确认,写被卡)是(专门处理)
                                MasterNotWriteAblemaster 活着但不可写(如误设 read_only)视情况

                                7.3 候选选择:选谁当新主

                                判定要切之后,orc 从存活 replica 里挑新主,综合考虑:

                                • 数据最全:优先选 GTID 集合最完整、复制位点最靠前的(丢得最少)。

                                • promotion rule:管理员给实例打的提升优先级—must/prefer/neutral/prefer_not/must_not。比如把某台标 must_not(如跨机房只读备)就永不选它。

                                • candidate 标记:candidate_database_instance里登记的优选候选。

                                • 同机房/同 cell、版本兼容:尽量同 region 提升(减少跨机房延迟),且新主版本不能低于其 replica(否则复制不兼容)。

                                7.4 切换执行:提升 + repoint + 回调

                                7.5 probe-agent(orc-agent)的作用:补上"内部视角 + 执行手"

                                orc 是"外部观察者",从远端探测有两个天生短板,probe-agent正是来补的:

                                短板 1:外部探测看不到主机内部真相。 orc 从外面连不上,分不清是"DB 真挂了"还是"网络断了""DB 太忙没响应"。

                                probe-agent 跑在 DB 主机本地,能看到内部:

                                probe-agent 文件职责为什么 orc 从外部做不到
                                heartbeat.go定时上报心跳(hostname -I 取本机 IP + 时间戳)给 orc主机侧"我还活着"的主动证明,区分"DB 死"与"网络断"
                                load_checker.go

                                检查本机负载(连接数、线程等)NewConfigurableLoadChecker

                                外部看不到实时主机真实负载

                                big_transaction.go用主备 GTID 差判断是否有大事务在跑(GtidComparisonChecker),并记录失败时刻主/备 GTID 快照切换前必须知道:有大事务时切换会拖很久、风险高
                                disk_check.go磁盘探测(磁盘故障是京东数据库最多的宿主机故障)写本地磁盘
                                probe_agent.go总装:写探测(enableWriteDetect)、连续失败计数(consecutiveFailures)本地"能不能真的写"比外部 ping 可信得多

                                短板 2:orc 决策了,需要有"手"在主机侧执行/兜底。

                                总结分工:

                                八、分层的高可用

                                我们通过分层的设计,每一层都做到极致,尽可能的提升高可用能力。现网通过将数据库设置成半同步不退化,保障了RPO为0;未来通过三机房的建设,提供机房级容灾的能力。但是,就到此为止了吗?

                                数据库高可用不只是数据库的事,应用也要参与。

                                既然数据库总有"短暂不可写"的窗口。如果应用把每一次写都设计成"必须同步写库成功、否则就报错给用户"。那数据库抖一下。应用就跟着抖。真正健壮的系统。是应用和数据库一起做高可用——在 DB 不可用的那几十秒里,应用能不能优雅降级,而不是直接雪崩?

                                几种常见的应用侧兜底思路:

                                手段思路适用场景
                                异步化 + MQ 削峰写请求先进消息队列,应用快速返回"已受理";后台消费者慢慢落库,DB 抖动时消息积压而非丢失可接受"稍后落库"的写(下单后处理、日志、通知)
                                最终一致性不强求"写完立刻全局可见",允许各方在一段时间后收敛一致计数、状态同步、跨系统数据分发
                                读降级主库不可用时,读请求走备库/缓存,返回稍旧但可用的数据读多写少、能容忍短暂 stale 的展示类场景
                                写降级 / 兜底存储DB 写不进时,先落本地/缓存/兜底表,恢复后补偿回放不能丢、但能容忍延迟的关键写
                                快速失败 + 熔断DB 探测到不可用就立即失败并熔断,避免连接池被慢查询占满拖垮整个应用所有场景的基本自我保护

                                数据库这一侧,把高可用一层层做到极致,是为了把"不可用窗口"压到最小;应用那一侧,建立"数据库随时可能短暂不可用"的意识、准备好降级预案,是为了在那个窗口里不被拖垮。两个系统双向奔赴,系统才真正称得上高可用——这也是把数据库高可用当作"数据头等大事"的完整含义。

                                推荐阅读

                                跳转微信打开

                                Jev:当 AI 不再"写答案",而是直接做决策

                                2026年10月20日 22:10

                                原创 京东科技 王晓 2026-10-20 22:10 北京

                                “如果程序只需要一个决定,为什么要先让 AI 写一段话?”本文借 TypeSafe AI 的 Jev,讲透 LLM 与决策模型如何重新分工——不生成文字,直接返回有类型的决策与概率,还给出落地四步与四类试点场景。冷静拆解、克制不吹,AI工程化必看。

                                从 TypeSafe AI 的 System One Model,看 LLM 应用架构与软件工程的下一步

                                核心命题:如果程序只需要一个决定,为什么要先让 AI 写一段话?

                                过去几年,我们习惯了一种 AI 应用模式:把问题交给大语言模型,让它生成一段文字,再把文字解析成程序能够使用的结果。

                                但很多业务根本不需要文字。

                                一张工单应该分给哪个团队?一次工具调用是否应该放行?一组候选答案中哪个更好?这些问题真正需要的,是类别、分数,以及可供程序使用的不确定性信息。

                                TypeSafe AI 推出的 Jev,就是围绕这类任务设计的。官方将其称为 System One Model:接收上下文与结构化问题,返回带类型的决策及概率,而不是生成开放式文本。Pydantic 的相关文档也明确强调:Jev 不是一个用来写文本的语言模型。

                                它值得关注的地方,不只是"又出现了一个更快的模型",而是一个更根本的问题:

                                先理解 Jev:它不是聊天助手,而是语义决策组件。

                                一、先理解 Jev:它不是聊天助手,而是语义决策组件

                                假设我们正在开发客服系统,收到这样一条消息:

                                “上周买的会员重复扣费了,机器人一直让我重试,我要人工处理。”

                                使用 LLM 的常见方式是:

                                  阅读这条消息,判断应该转交哪个团队。
                                  只能输出 billing、technical、account 或 other。
                                  请返回 JSON。

                                  应用再读取:

                                    {"department": "billing"}

                                    而 Jev 所代表的交互方式更接近:

                                      输入:用户消息
                                      问题:应该转交哪个团队?
                                      答案空间:billing / technical / account / other
                                      输出:选择结果及相关概率

                                      示例:一条"重复扣费"消息被直接映射为 billing(92%),附带完整的概率分布,而不是先生成一段文字再解析。

                                      关键变化在于:"答案属于什么类型"成为模型接口的一部分,而不只是提示词中的要求。

                                      官方与相关开发者文档将 Jev 的输出组织为三类基本形式:Choice、Score 和 Noul,分别覆盖选择、评分和带概率的二元判断。

                                      可以把它们理解为:

                                      原语直观含义适合表达的问题

                                      choice

                                      从预定义选项中选择这条请求应该走哪个流程?

                                      score

                                      按给定标准评分这份答案的质量处于哪个等级?

                                      noul

                                      用概率表达二元判断当前条件是否满足?

                                      Jev 的三种输出原语:Choice(选)、Score(评)、Noul(判),覆盖了大多数自动化决策的表达需求。

                                      这意味着,Jev 更适合成为软件内部的一个决策节点,而不是直接面向用户的通用对话入口。

                                      二、"System One"究竟意味着什么?

                                      2.1 它强调的是快速判断,而不是长篇生成

                                      "System One"借用了快思考与慢思考的类比。TypeSafe 用这个概念描述 Jev 所面向的快速、结构化决策任务;相关公开介绍也将 Jev 描述为非自回归模型。

                                      理解这个区别,可以先看两个抽象过程。典型自回归语言模型生成文本时,会依次预测输出 token:

                                      输入 → token 1 → token 2 → token 3 → …
                                      而决策模型的产品接口更像:
                                      上下文 + 问题 + 答案约束 → 决策结果
                                      慢思考:逐 token 生成长文本;
                                      快思考(System One):一步直达决策结果。注意"非自回归"描述的是计算方式,不自动代表"不会出错"。

                                      下面这个数学表达只是帮助理解的抽象,并非 Jev 已公开的内部网络结构:

                                      fθ(x, q, A) → P(y ∣ x, q, A)

                                      其中:

                                      • x:待判断的上下文;

                                      • q:问题;

                                      • A:允许的答案集合或评分标准;

                                      • P(y∣x,q,A):对候选结果的不确定性表达。

                                      工程上的吸引力很直接:如果最终只需要一个类别,就有机会避免为一段不必要的生成文本付出成本。

                                      但需要注意:非自回归描述的是计算方式,不自动代表"不会出错";System One 是产品定位,也不能直接当作模型内部认知机制的证明。 · 现有公开介绍足以解释产品行为,但不足以据此还原其完整网络架构、训练目标或推理实现。

                                      2.2 这和传统分类器有什么区别?

                                      分类、排序、评分,本来就是机器学习的老问题。因此,Jev 的意义不应被理解为"发明了分类",而应从产品形态上理解:

                                      • 传统分类器通常围绕相对固定的标签体系训练;

                                      • LLM 可以通过自然语言描述临时任务,但常以文本生成作为交互方式;

                                      • Jev 则把"上下文理解、自然语言问题和有类型决策"组合成一个面向自动化的模型接口。

                                      演进路线:固定标签的模具(传统分类器)→ 先写作再解析的作家(LLM)→ 直接举牌的裁判(Jev)。Jev 没有发明分类,它发明的是一种面向自动化的接口形态。

                                      它真正需要接受的检验是:

                                      在不为每个任务单独训练模型的情况下,这种通用决策接口,能否在目标业务上同时满足质量、成本、延迟与可靠性要求?

                                      这比争论"它是不是一种全新的 AI"更有工程价值。

                                      三、它与 LLM 的关系:不是全面替代,而是重新分工

                                      3.1 先把"LLM 也能返回 JSON"说清楚

                                      LLM 并非只能自由输出文字。结构化输出、函数调用和约束解码,都可以让 LLM 返回程序可消费的结果。

                                      因此,Jev 与 LLM 的区别,不能简单归结为:Jev 有类型,LLM 没类型。更合理的比较维度是:

                                      维度使用 LLM 的结构化输出Jev 的公开产品定位
                                      主要交互形态生成符合约束的内容返回有类型的决策
                                      自由文本生成可以不提供
                                      决策结果可通过结构化输出表达是核心输出
                                      不确定性需要具体设计与验证接口强调概率与置信信息
                                      选型重点通用性、推理与生成能力目标决策任务上的质量和效率

                                      表中 Jev 的定位来自官方及开发者文档;这不是对两者所有能力的穷尽比较。

                                      3.2 更有价值的组合:LLM 提方案,决策模型做筛选

                                      一种值得试验的架构是:

                                        用户请求
                                           ↓
                                        任务分类与路由
                                           ├─ 简单明确 → 确定性业务流程
                                           ├─ 需要生成 → LLM
                                           └─ 高风险或不确定 → 更强模型 / 人工

                                        对于 Agent,还可以进一步分工:

                                          LLM 生成候选行动
                                                  ↓
                                          决策模型评估候选行动
                                                  ↓
                                          确定性权限与业务规则校验
                                                  ↓
                                          执行工具

                                          推荐分工:LLM 负责开放式理解、规划和生成(提方案),决策模型负责局部、边界明确的判断(做筛选),最后永远保留一道确定性校验。

                                          这里,LLM 负责开放式理解、规划和生成,决策模型负责局部、边界明确的判断。

                                          但必须保留最后一道确定性校验:模型认为"应该执行",不等于系统已经获得"执行权限"。

                                          例如,模型可以判断"这看起来是一笔正常退款",但退款金额上限、账户权限、审批状态与幂等性,都不应该交给概率判断来决定。

                                          四、它真的快几百倍、便宜几百倍吗?

                                          关于 Jev 的传播中,最醒目的数字是性能和成本。

                                          LangChain 的介绍转述了 TypeSafe 的宣称:在分类任务上,相比可比较的 LLM,推理速度最高可达约 200 倍、成本最高可降低至约四百分之一。Browserbase 的介绍则给出了 20—200 倍速度和 40—400 倍成本差异的范围,并明确将这些数字归于 TypeSafe 的基准测试。

                                          这些数字应当加上三个限定:

                                          • 它们是厂商宣称或对厂商基准的转述。

                                          • 它们对应特定任务与对比条件。

                                          • 模型调用的收益,不等于整个应用的收益。

                                          宣传数字很醒目,但别忘了 Amdahl 定律:模型决策只占链路的一小部分,整体加速要按全链路来算。

                                          举个纯假设的例子:

                                          一个工作流中,模型决策占总耗时的 20%,剩下 80% 是数据库、网络和工具执行。即使决策环节加速 100 倍,整体加速也只有:

                                          S = 1 / (0.8 + 0.2/100) ≈ 1.25

                                          因此,采购或迁移前应比较的不是单一宣传数字,而是:

                                          • 相同业务测试集上的准确率、误报率和漏报率;

                                          • 达到相同质量门槛时的成本;

                                          • P50、P95 和 P99 延迟;

                                          • 并发、超时、重试和回退行为;

                                          • 整条链路的最终成功率。

                                          真正有意义的是"每完成一个合格业务结果的成本",而不只是"每次调用的价格"。

                                          五、"类型安全"和"概率输出",究竟能保证什么?

                                          这是理解 Jev 时最容易混淆的地方。

                                          5.1 类型正确,不等于判断正确

                                          假设允许的结果只有:

                                            ALLOW / REVIEW / BLOCK

                                            模型返回 ALLOW,在类型上完全合法。但如果这笔操作实际上应该被拦截,系统依然发生了严重错误。

                                            所以至少要区分三层正确性:

                                            层次需要回答的问题
                                            结构正确返回结果能否被程序合法读取?
                                            语义正确判断是否符合事实和任务标准?
                                            业务安全即使判断错误,损失是否仍然可控?

                                            类型的接口主要解决第一层(结构正确)。第二层需要评测,第三层需要系统设计。不能把"不会生成答案集合之外的文本"扩大成"不会发生业务误判"。

                                            有类型的接口主要解决第一层。第二层需要评测,第三层需要系统设计。

                                            不能把"不会生成答案集合之外的文本",扩大成"不会发生事实错误或业务误判"。

                                            5.2 有概率,不等于概率已经可靠

                                            官方与相关介绍强调 Jev 返回概率,并使用了"校准"这一描述。但在你的业务中,这些数值是否可靠,仍然需要验证。

                                            例如,模型给出:

                                              P(可以自动处理) = 0.95

                                              这不意味着当前个案必然有一个可直接保证的"95% 正确率"。概率校准通常关注的是:在大量相似预测中,被模型赋予约 0.95 概率的事件,是否确实以接近 95% 的频率发生。

                                              概率校准看的是群体频率而非个案保证:被赋予 0.95 概率的事件,在大量样本中是否真的以接近 95% 的频率发生?落地前请看可靠性图与 Brier Score。

                                              因此,落地时应关注:

                                              • 可靠性图;

                                              • Brier Score 等概率质量指标;

                                              • 不同业务分组的校准表现;

                                              • 自动处理覆盖率与错误率之间的关系;

                                              • 数据分布变化后的性能。

                                              概率最有用的用途,不是给用户一个看似精确的数字,而是帮助系统决定:什么时候自动执行,什么时候升级处理,什么时候拒绝作答。

                                              六、哪些场景最值得落地?

                                              下面是基于 Jev 接口形态提出的应用设计建议,不是已经被统一验证的客户效果

                                              四个值得试点的方向:客服分流、Agent 动作审核、RAG 相关性筛选、研发局部评审。共同点是:高频、边界清楚、可评测、可回滚。

                                              6.1 场景一:客服、邮件与工单分流

                                              输入是非结构化文本,输出是有限的部门、意图或优先级。可以采用:

                                                高置信度 → 自动分流
                                                低置信度 → LLM 进一步分析
                                                敏感类别 → 人工复核

                                                这是一个适合试点的方向:标签明确、历史数据较容易整理、错误通常可回滚,也容易与现有系统做对比。

                                                需要防止的问题是:如果选项中没有"其他"或"无法判断",系统可能把陌生问题强行归进已知类别。

                                                6.2 场景二:Agent 的动作审核与工具路由

                                                Agent 准备调用工具前,可以提出局部问题:

                                                • 这个动作是否回应了用户请求?

                                                • 当前信息是否足够执行?

                                                • 是否应该升级为人工审批?

                                                • 多个候选工具中哪个更匹配任务?

                                                建议把它作为辅助判断层,而不是安全边界本身。

                                                  语义判断
                                                     +
                                                  确定性权限、金额、资源范围校验
                                                     =
                                                  是否允许进入执行阶段

                                                  即使输出只允许"是或否",恶意输入仍可能诱导模型选错;答案空间受限,并不自动解决提示注入。

                                                  6.3 场景三:RAG 的相关性判断与候选筛选

                                                  在检索增强生成中,可以试验让决策模型负责:

                                                  • 判断检索片段是否相关;

                                                  • 为候选证据按标准评分;

                                                  • 判断是否需要继续检索;

                                                  • 从多个候选答案中选择较合适的一项。

                                                  一个可能的流程是:

                                                    检索 → 相关性筛选 → LLM 生成 → 证据检查 → 输出或回退

                                                    这里有一个容易忽略的陷阱:分别得到的分数,未必天然适合跨查询、跨评分标准比较。排序效果仍应通过专门的检索评测验证。

                                                    6.4 场景四:软件研发中的局部评审

                                                    可以探索的任务包括:

                                                    • 判断 PR 是否涉及数据库迁移;

                                                    • 为变更选择评审团队;

                                                    • 按明确清单检查发布条件;

                                                    • 对测试失败进行初步分类。

                                                    更稳妥的定位是:补充人工和确定性工具,而不是取代编译器、测试、安全扫描与代码评审。

                                                    "模型认为变更风险低"不应成为跳过测试的理由。

                                                    七、怎么真正接进生产系统?

                                                    不要一开始就重构整个 Agent。更好的方式是挑选一个高频、边界清楚、可评测、可回滚的决策点。

                                                    落地四步:定义决策契约 → 建立多方基线 → 把输出包进业务策略 → 影子运行再逐步放量。工程重点不在那一行模型调用,而在阈值、降级、审计与漂移监控。

                                                    7.1 第一步:定义决策契约

                                                    至少明确:

                                                      输入:模型能看到哪些信息?
                                                      输出:允许哪些标签或评分?
                                                      规则:每个标签的业务含义是什么?
                                                      弃权:何时算无法判断?
                                                      回退:转给谁处理?
                                                      后果:误判会造成什么损失?

                                                      这比单纯优化提示词更重要。

                                                      7.2 第二步:建立多方基线

                                                      不要只比较 Jev 和一个昂贵 LLM。至少考虑:

                                                      • 确定性规则;

                                                      • 传统分类器或小模型;

                                                      • LLM 结构化输出;

                                                      • Jev。

                                                      否则,可能只证明了"原来的实现过度使用了大模型",却没有证明 Jev 是最优方案。

                                                      7.3 第三步:把模型输出包进业务策略

                                                      以下是架构伪代码,不是 Jev 官方 SDK 调用方式:

                                                        def route_ticket(ticket):
                                                            result = decision_adapter.evaluate(
                                                                context=ticket.text,
                                                                question="这条工单应交给哪个团队?",
                                                                choices=["billing", "technical", "account", "other"],
                                                            )
                                                            # 阈值必须来自业务验证,而不是拍脑袋设定
                                                            threshold = policy.threshold_for(result.choice)
                                                            if result.choice == "other":
                                                                return fallback_queue(ticket)
                                                            if result.confidence < threshold:
                                                                return deeper_analysis(ticket)
                                                            if policy.requires_review(ticket, result.choice):
                                                                return human_review(ticket)
                                                            return assign_ticket(ticket, result.choice)

                                                        工程重点不在那一行模型调用,而在:

                                                        • 阈值如何确定;

                                                        • 不同类别是否需要不同策略;

                                                        • 失败时如何降级;

                                                        • 如何审计和回滚;

                                                        • 如何发现性能漂移。

                                                        7.4 第四步:先影子运行,再逐步放量

                                                        建议顺序是:

                                                          离线评测
                                                            → 影子运行,不影响真实决策
                                                            → 低风险流量灰度
                                                            → 分类别扩大自动化范围
                                                            → 持续监控与复评

                                                          同时记录模型版本、问题模板、答案集合、策略版本和最终业务结果。否则,模型或提示变化后,很难判断到底是哪一层导致性能退化。

                                                          八、它可能怎样影响软件工程?

                                                          如果这类产品被证明有效,AI 软件可能拆成四个职责清晰的组件:生成模型负责表达、决策模型负责选择、检索系统负责证据、确定性程序负责约束与执行。

                                                          8.1 AI 能力将不再只有"聊天接口"

                                                          如果这类产品在真实业务中证明有效,AI 软件可能进一步拆成不同组件:

                                                            生成模型:负责表达和方案
                                                            决策模型:负责选择与评分
                                                            检索系统:负责获取证据
                                                            确定性程序:负责约束与执行

                                                            这是一种架构判断,而不是已经完成的行业结论。它的价值在于:不必让一个模型包办所有事情,而是让每个组件承担更清晰、可测量的职责。

                                                            8.2 API 契约将开始容纳"不确定性"

                                                            传统函数往往返回:

                                                              functionclassify(input: string): Category

                                                              概率性决策组件则可能需要:

                                                                type Decision<T> = {
                                                                  value: T
                                                                  confidence: number
                                                                  policyVersion: string
                                                                }

                                                                这不是 Jev 的实际 API 定义,而是一种工程封装建议。

                                                                变化在于:调用者不再只处理"成功或异常",还必须处理"合法但不够确定"的结果。不确定性会从模型内部的问题,变成应用接口必须明确表达的状态。

                                                                8.3 测试将从单点断言扩展到统计保证

                                                                传统测试可以断言:

                                                                  输入 A,必须输出 B。

                                                                  概率性组件还需要回答:

                                                                  • 在哪些样本上错误最多?

                                                                  • 特定类别的漏报是否超出容忍范围?

                                                                  • 自动化覆盖率提高后,错误是否同步上升?

                                                                  • 新版本是否破坏了旧业务的关键指标?

                                                                  因此,黄金测试集、分组评测、影子发布和线上反馈,会成为 AI 软件测试的重要组成部分。

                                                                  8.4 工作量会从"解析输出"转向"治理决策"

                                                                  结构化决策接口有望减少一部分 JSON 修复、格式重试和文本解析工作。但它不会消除工程复杂性,而是改变复杂性的分布:

                                                                  从"让模型按格式说话",转向"定义正确的任务、验证概率、管理风险,并控制执行后果"。

                                                                  这一变化,可能比单次调用便宜多少更深远。

                                                                  九、结语

                                                                  Jev 真正挑战的,是"所有 AI 任务都应该交给 LLM 生成"

                                                                  Jev 的公开定位很清楚:它不生成开放式文本,而是面向结构化问题返回有类型的决策和概率。

                                                                  它是否适合你的系统,最终取决于业务评测,而不是"System One"这个名称,也不是最高几百倍的性能数字。

                                                                  更值得记住的是三点:

                                                                  • 不需要生成文字的任务,未必应该通过文字生成来完成。

                                                                  • 类型约束能改善接口可靠性,但不能代替语义正确性与业务安全。

                                                                  • LLM、决策模型与确定性软件,更可能形成分工,而不是彼此完全替代。

                                                                  对于工程团队,最好的起点不是"全面换掉 LLM",而是找出系统里那些一天执行成千上万次、最终只需要一个类别或判断的节点。

                                                                  然后问一个简单的问题:

                                                                  这里真的需要一个会写作的模型,还是只需要一个能够被测量、被约束、会在必要时交还决定权的决策组件?

                                                                  推荐阅读

                                                                  跳转微信打开

                                                                  大表治理之分表实践:带你手搓一个简单的数据库分表组件

                                                                  2026年10月15日 21:31

                                                                  原创 京东科技 郭忠强 2026-10-15 21:31 北京

                                                                  不知道大表数据如何处理?本文带你手搓一个简单够用的数据库分表组件。

                                                                  一、背景

                                                                  在大型系统中,流量大,数据量大,很容易出现大表,一般来说,大表有以下几方面特征:

                                                                  1. 数据量维度:通常认为单表数据量超过1000万行或10GB以上可以视为大表。

                                                                  2. 性能维度:当表的查询、插入、更新、删除操作开始出现明显性能下降。

                                                                  3. 维护维度:当对表进行DDL操作(如添加索引、修改字段)需要很长时间(如超过1小时)。

                                                                  4. 业务维度:根据具体业务场景,影响核心业务流程的表即使数据量不大也可能被视为大表。

                                                                  以库存流水表为例,一天的流水量是3400万行,大小为31GB。

                                                                  大表会伴随着产生读写性能下降、服务耗时长、DDL、DML时间长、备份恢复难度大、统计信息不准确等弊端,需要进行大表治理优化。

                                                                  二、治理方案

                                                                  2.1 大表的治理优化方案

                                                                  一般有几个思路:

                                                                  • 分库分表:按业务维度(仓号、SKU、主键ID等)水平拆分。

                                                                  • 表分区:按时间、哈希或范围分区,提高查询效率。

                                                                  • 冷热分离:冷数据归档结转,超过一定时间的热数据则转为冷数据存储。

                                                                  • 索引优化:删除冗余和低效索引,减少索引维护成本,提升单表读写性能。

                                                                  • 读写分离:主库写操作,从库读操作,减轻主库压力。

                                                                  在本系统的治理中,除了表分区方式暂未使用,其他优化策略均有使用,尤其是在分库分表方面,通过水平拆分数据量降维最直接高效,也是本文阐述的重点,其他策略不重点赘述。

                                                                  2.2 分表组件选择

                                                                  分库方面,之前已接入分库,按仓号分库,但流水表尚未分表,单表的流水量依然很大,其中一个分库下20天的单表存量数据行在四五千万行左右。

                                                                  本次是在分库的基础上进行分表。在分库分表的组件选择上,业界常用的分库分表组件有Sharding-JDBC、Mycat‌、Cobar‌、TDDL‌、Atlas‌等,他们的优劣势各不相同,但这些分库分表插件在SQL语法支持上都存在自己的局限性。

                                                                  例如:

                                                                  • Sharding-JDBC

                                                                  • SQL语法限制‌:

                                                                  • 不支持复杂的SQL语法,如OR、UNION和UNION ALL等操作

                                                                  • 不支持HAVING子句

                                                                  • 不支持子查询的完整支持

                                                                  • 不支持DISTINCT聚合操作

                                                                  • 不支持SELECT LAST_INSERT_ID()语句

                                                                  • 不支持CASE WHEN语句

                                                                  • 不支持VALUES后有多行数据的INSERT语句

                                                                  • 不支持dual虚拟表

                                                                  Mycat

                                                                  • ‌SQL语法限制‌:

                                                                  • 不支持跨库多表关联查询和子查询

                                                                  • 不支持CREATE TABLE LIKE xxx和CREATE TABLE SELECT xxx等语句

                                                                  • 不支持SELECT FOR UPDATE、SELECT LOCK IN SHARE MODE等语句

                                                                  • 不支持跨分片的UPDATE/DELETE操作

                                                                  • 不支持多表UPDATE或UPDATE分片键

                                                                  • 不支持跨分片的ORDER BY LIMIT操作

                                                                  Cobar

                                                                  • ‌SQL语法限制‌:

                                                                  • 不支持跨库情况下的JOIN、分页、排序、子查询操作

                                                                  • 不支持SAVEPOINT操作

                                                                  • SET语句执行会被忽略(事务和字符集设置除外)

                                                                  • 分库情况下INSERT语句必须包含拆分字段列名

                                                                  • 分库情况下UPDATE语句不能更新拆分字段的值

                                                                  • 仅支持部分SQL数据节点

                                                                  TDDL

                                                                  • SQL语法限制‌:

                                                                  • 不支持JOIN、多表查询等语法

                                                                  • 不支持跨库JOIN操作

                                                                  • 不支持存储过程、函数等复杂SQL操作

                                                                  Atlas

                                                                  • ‌SQL语法限制‌

                                                                  • 社区维护较久,功能相对有限

                                                                  • 不支持跨库JOIN等复杂操作

                                                                  这些组件在SQL语法支持上的局限性主要源于分库分表场景下对SQL解析和路由的复杂性,以及各组件架构设计的差异。

                                                                  正因为这些SQL语法的局限性,在之前分库时,部门没再继续使用Sharding-jdbc作为分库分表的插件,而是部门自研了一个适合自己的分库插件。关于自研这件事,造轮子目的很直接简单,并不是为了证明什么,仅仅是为了适配自己的场景,组件设计和实现也并不复杂,远远不如行业里的哪些插件强大,根据KISS原则,够用+1而已。

                                                                  在分表时,依然选择了部门自研这个条路。

                                                                  三、组件设计

                                                                  基于 MyBatis 插件机制实现的分表拦截器,采用策略模式 + 责任链模式的架构设计。

                                                                  ┌─────────────────────────────────────────────────────────────┐

                                                                  │ MyBatis 插件链 │

                                                                  ├─────────────────────┬───────────────────────────────────────┤

                                                                  │ SQLMarkingPlugin │ SQLBasedDatabaseProtectorPlugin │

                                                                  ├─────────────────────┼───────────────────────────────────────┤

                                                                  │ DataSourceRouting │ TableShardingInterceptor │

                                                                  │ Interceptor │ (分表拦截器) │

                                                                  └─────────────────────┴───────────────────────────────────────┘

                                                                  模块划分

                                                                  • 拦截处理模块:intercept() 方法,负责拦截 SQL 执行。

                                                                  • 策略模块:Policy 枚举,定义不同的读写策略。

                                                                  • SQL处理模块:负责 SQL 的解析、修改和重写。

                                                                  • 路由计算模块:与 ShardingSuffixCalculator 交互,计算分表后缀。

                                                                  • 参数处理模块:处理 SQL 参数映射。

                                                                  四、组件研发

                                                                  4.1 分表策略

                                                                  分表规则:

                                                                  • 基于仓库编号(warehouseNo)进行分表

                                                                  • 支持多种分表策略:单写单读、单写双读、双写单读、双写双读

                                                                  • 分表数量可配置,如st_stock_stream:128表示分为128张表

                                                                  分表后缀计算:

                                                                    // 分表后缀计算流程
                                                                    1. 从SQL参数中提取 warehouseNo
                                                                    2. 查询配置表,看是否已有分配的分表
                                                                    3. 如果有,直接使用
                                                                    4. 如果没有,通过负载均衡算法选择一个分表
                                                                    5. 使用分布式锁确保分配的唯一性

                                                                    4.2 读写策略

                                                                    四种策略模式:

                                                                    1. doubleWriteAndReadOld:双写读旧表

                                                                    • 写操作:同时写入旧表和新表

                                                                    • 读操作:只读旧表

                                                                    2. doubleWriteAndReadNew:双写读新表

                                                                    • 写操作:同时写入旧表和新表

                                                                    • 读操作:只读新表(分表)

                                                                    3. singleWriteAndReadOld:单写读旧表

                                                                    • 写操作:只写入新表(分表)

                                                                    • 读操作:只读旧表

                                                                    4.singleWriteAndReadNew:单写读新表

                                                                    • 写操作:只写入新表(分表)

                                                                    • 读操作:只读新表(分表)

                                                                    5. singleWriteAndDoubleRead:单写双读

                                                                    • 写操作:只写入新表(分表)

                                                                    • 读操作:同时读旧表和新表,结果合并

                                                                    4.3 SQL处理机制

                                                                    SQL解析与重写

                                                                    1. 识别SQL中的表名

                                                                    2. 判断是否需要分表处理

                                                                    3. 提取分表键(warehouseNo)

                                                                    4. 计算分表后缀

                                                                    5. 重写SQL,替换表名

                                                                    6.处理参数映射

                                                                    特殊SQL处理:

                                                                    • COUNT查询:SELECT COUNT(*) FROM table→SELECT SUM(countNumForSharding) FROM (SELECT COUNT(*) AS countNumForSharding FROM table_0 UNION ALL ...)

                                                                    • SUM查询:SELECT SUM(column) FROM table→SELECT SUM(sumNumForSharding) FROM (SELECT SUM(column) AS sumNumForSharding FROM table_0 UNION ALL ...)

                                                                    • ORDER BY/LIMIT:在双读模式下需要特殊处理

                                                                    4.4 双写的处理

                                                                    4.4.1 核心功能

                                                                    该方法的核心功能是:将单条写入 SQL 转换为双写 SQL,即同时写入原始表和分表。

                                                                    4.4.2 实现逻辑详解

                                                                    1. 前置检查

                                                                      String sql= boundSql.getSql().trim();
                                                                      log.trace("TableShardingInterceptor#changeStatementForDoubleWrite, SQL: {}", sql);
                                                                      // 检查是否在忽略列表中if (StringUtils.isNotBlank(ignoredTables)) {
                                                                          for (String ignoredTable : StringUtils.split(ignoredTables, COMMA)) {
                                                                              if (StringUtils.containsIgnoreCase(sql, ignoredTable)) {
                                                                                  return; // 忽略配置的表,不进行双写
                                                                              }
                                                                          }
                                                                      }

                                                                      逻辑说明:

                                                                      • 首先获取原始 SQL 并记录日志

                                                                      • 检查当前 SQL 涉及的表是否在忽略列表中

                                                                      • 如果是忽略的表,则直接返回,不进行双写处理

                                                                      2. 分表处理

                                                                        if (StringUtils.isNotBlank(shardingTables)) {
                                                                            StatementChangeResultstatementChangeResult= changeSql(sql, metaParam);
                                                                            if (statementChangeResult.isSqlChanged()) {
                                                                                // 构建双写 SQL
                                                                                sql = statementChangeResult.getSql().concat(DOUBLE_WRITE_JOINER).concat(boundSql.getSql().trim());


                                                                                // 更新 BoundSql 中的 SQL
                                                                                ReflectionUtils.setFieldValue(BoundSql.class, boundSql, "sql", sql);


                                                                                // 复制参数映射
                                                                                boundSql.getParameterMappings().addAll(boundSql.getParameterMappings());
                                                                            }
                                                                        }

                                                                        逻辑说明:

                                                                        • 检查是否配置了分表

                                                                        • 调用changeSql方法处理 SQL,获取分表后的 SQL

                                                                        • 如果 SQL 发生变化(即需要分表),则构建双写 SQL

                                                                        • 使用DOUBLE_WRITE_JOINER(;)连接分表 SQL 和原始 SQL

                                                                        • 更新BoundSql对象中的 SQL

                                                                        • 复制参数映射,确保双写 SQL 的参数正确

                                                                        3. 双写 SQL 构建示例

                                                                        原始 SQL:

                                                                          INSERT INTO st_stock_stream (id, warehouse_no, sku, quantity) VALUES (?, ?, ?, ?)

                                                                          双写SQL:

                                                                            INSERT INTO st_stock_stream_5 (id, warehouse_no, sku, quantity) VALUES (?, ?, ?, ?) ; INSERT INTO st_stock_stream (id, warehouse_no, sku, quantity) VALUES (?, ?, ?, ?)

                                                                            使用场景

                                                                            1. 数据迁移场景

                                                                            在从单表架构向分表架构迁移的过程中,使用双写策略可以确保:

                                                                            • 新数据同时写入旧表和新表

                                                                            • 保证迁移期间的数据一致性

                                                                            • 支持平滑迁移,可随时回滚

                                                                            2. 策略配置

                                                                            双写策略通过 policy 配置项控制:

                                                                            • doubleWriteAndReadOld:双写读旧表

                                                                            • doubleWriteAndReadNew:双写读新表

                                                                            4.4.3 关键点

                                                                            1. SQL 连接符

                                                                              public static final String DOUBLE_WRITE_JOINER=" ; ";

                                                                              使用分号作为 SQL 语句分隔符,这是 SQL 支持的多语句执行格式。

                                                                              2. 参数映射处理

                                                                                boundSql.getParameterMappings().addAll(boundSql.getParameterMappings());

                                                                                由于双写 SQL 包含两套相同的参数,需要将参数映射列表复制一份,确保参数正确绑定。

                                                                                3. 反射更新

                                                                                  ReflectionUtils.setFieldValue(BoundSql.class, boundSql, "sql", sql);

                                                                                  使用反射机制更新 BoundSql 对象中的 SQL,这是 MyBatis 插件开发中的常用技巧。

                                                                                  执行流程图

                                                                                  changeStatementForDoubleWrite方法是实现平滑数据迁移的关键组件,它使得系统可以在不中断服务的情况下,从单表架构平滑过渡到分表架构,大大降低了系统升级的风险。

                                                                                  4.5 双读的处理

                                                                                  用于实现双读策略下的 SQL 处理。在双读模式下,系统会同时查询原始表和分表,并将结果合并,确保在数据迁移过程中能够读取到完整的数据。

                                                                                  方法

                                                                                    privatestaticvoidchangeStatementForDoubleRead(BoundSql boundSql, MetaObject metaParam)
                                                                                    4.5.1 核心功能

                                                                                    该方法的核心功能是:将单表查询 SQL 转换为双读 SQL,即同时查询原始表和分表,并处理结果合并。

                                                                                    实现逻辑详解

                                                                                    1. 前置检查

                                                                                      String sql= boundSql.getSql().trim();
                                                                                      log.trace("TableShardingInterceptor#changeStatementForDoubleRead, SQL: {}", sql);
                                                                                      // 检查是否在忽略列表中if (StringUtils.isNotBlank(ignoredTables)) {
                                                                                          for (String ignoredTable : StringUtils.split(ignoredTables, COMMA)) {
                                                                                              if (StringUtils.containsIgnoreCase(sql, ignoredTable)) {
                                                                                                  return; // 忽略配置的表,不进行双读
                                                                                              }
                                                                                          }
                                                                                      }

                                                                                      逻辑说明:

                                                                                      • 获取原始 SQL 并记录日志

                                                                                      • 检查当前 SQL 涉及的表是否在忽略列表中

                                                                                      • 如果是忽略的表,则直接返回,不进行双读处理

                                                                                      2. 分表处理与SQL重写

                                                                                        if (StringUtils.isNotBlank(shardingTables)) {
                                                                                            StatementChangeResultstatementChangeResult= changeSql(sql, metaParam);
                                                                                            if (statementChangeResult.isSqlChanged()) {
                                                                                                sql = mergeSqlForDoubleRead(statementChangeResult.getSql(), boundSql.getSql().trim());


                                                                                                // 处理ORDER BY子句
                                                                                                if (StringUtils.containsIgnoreCase(sql, ORDER_BY)) {
                                                                                                    intorderByIndex= StringUtils.lastIndexOfIgnoreCase(sql, ORDER_BY);
                                                                                                    StringorderByAndLimitSql= StringUtils.substring(sql, orderByIndex);
                                                                                                    StringsqlBeforeOrderBy= StringUtils.substring(sql, 0, orderByIndex);


                                                                                                    // 移除表别名前缀,避免UNION ALL后的列引用错误
                                                                                                    orderByAndLimitSql = orderByAndLimitSql.replaceAll("\\w+\\.", StringUtils.EMPTY);
                                                                                                    sql = StringTools.getJointCodeWithSpace(sqlBeforeOrderBy, orderByAndLimitSql);
                                                                                                }


                                                                                                // 处理COUNT查询
                                                                                                if (StringUtils.containsIgnoreCase(sql, COUNT_NUM_FOR_SHARDING)) {
                                                                                                    sql = "SELECT SUM( " + COUNT_NUM_FOR_SHARDING + " ) FROM (" + sql + ") ".concat(TEMP_TABLE_NAME);
                                                                                                }


                                                                                                // 处理SUM查询
                                                                                                if (StringUtils.containsIgnoreCase(sql, SUM_NUM_FOR_SHARDING)) {
                                                                                                    sql = "SELECT SUM( " + SUM_NUM_FOR_SHARDING + " ) FROM (" + sql + ") ".concat(TEMP_TABLE_NAME);
                                                                                                }


                                                                                                // 更新BoundSql
                                                                                                ReflectionUtils.setFieldValue(BoundSql.class, boundSql, "sql", sql);
                                                                                                appendParameterMappings(boundSql);
                                                                                            }
                                                                                        }

                                                                                        4.5.2 关键技术点解析

                                                                                        1. SQL合并机制

                                                                                          private static String mergeSqlForDoubleRead(String changedSql, String originalSql) {
                                                                                              StringnewSql= StringUtils.removeEnd(originalSql, SEMICOLON);
                                                                                              newSql = newSql.trim().replaceAll(RegExpConstants.SQL_ORDER_BY, StringUtils.SPACE);
                                                                                              newSql = newSql.trim().replaceAll(RegExpConstants.SQL_LIMIT, StringUtils.SPACE);
                                                                                              return appendSelectColumns(newSql, changedSql);
                                                                                          }

                                                                                          处理步骤:

                                                                                              1.移除原始SQL末尾的分号

                                                                                              2.移除ORDER BY子句(后续会重新处理)

                                                                                              3.移除LIMIT子句(后续会重新处理)

                                                                                              4.调用appendSelectColumns合并SELECT列

                                                                                          2. ORDER BY处理

                                                                                            if (StringUtils.containsIgnoreCase(sql, ORDER_BY)) {
                                                                                                intorderByIndex= StringUtils.lastIndexOfIgnoreCase(sql, ORDER_BY);
                                                                                                StringorderByAndLimitSql= StringUtils.substring(sql, orderByIndex);
                                                                                                StringsqlBeforeOrderBy= StringUtils.substring(sql, 0, orderByIndex);


                                                                                                // 关键:移除表别名前缀,避免"Unknown column"错误
                                                                                                orderByAndLimitSql = orderByAndLimitSql.replaceAll("\\w+\\.", StringUtils.EMPTY);
                                                                                                sql = StringTools.getJointCodeWithSpace(sqlBeforeOrderBy, orderByAndLimitSql);
                                                                                            }

                                                                                            问题背景: 在UNION ALL查询中,如果ORDER BY子句包含表别名(如m.update_time),会导致"SQL Unknown column"错误,因为UNION ALL后的结果集不再有原始表的别名。

                                                                                            3. COUNT查询处理

                                                                                              if (StringUtils.containsIgnoreCase(sql, COUNT_NUM_FOR_SHARDING)) {
                                                                                                  sql = "SELECT SUM( " + COUNT_NUM_FOR_SHARDING + " ) FROM (" + sql + ") ".concat(TEMP_TABLE_NAME);
                                                                                              }

                                                                                              转换示例:

                                                                                              • 原始:SELECT COUNT(*) FROM table

                                                                                              • 双读:SELECT COUNT(*) AS countNumForSharding FROM table_0 UNION ALL SELECT COUNT(*) AS countNumForSharding FROM table

                                                                                              • 最终:SELECT SUM(countNumForSharding) FROM (SELECT COUNT(*) AS countNumForSharding FROM table_0 UNION ALL SELECT COUNT(*) AS countNumForSharding FROM table) tempForSharding

                                                                                              4. SUM查询处理

                                                                                              与COUNT查询类似,将多个分表的SUM结果再求和。

                                                                                              5. 参数映射处理

                                                                                                privatestaticvoidappendParameterMappings(BoundSql boundSql) {
                                                                                                    Stringsql= boundSql.getSql().trim();
                                                                                                    intlimitIndex= StringUtils.lastIndexOfIgnoreCase(sql, LIMIT);


                                                                                                    if (limitIndex < 0) {
                                                                                                        // 无LIMIT,直接复制所有参数
                                                                                                        boundSql.getParameterMappings().addAll(boundSql.getParameterMappings());
                                                                                                        return;
                                                                                                    }


                                                                                                    // 处理LIMIT参数
                                                                                                    StringlimitOffset= StringUtils.substring(sql, limitIndex);
                                                                                                    intcountMatches= StringUtils.countMatches(limitOffset, SQL_PLACEHOLDER);


                                                                                                    if (countMatches == 2) {
                                                                                                        // LIMIT ?, ? (offset, pageSize)
                                                                                                        List<ParameterMapping> originalParameterMappings = Lists.newArrayList(boundSql.getParameterMappings());
                                                                                                        // 移除最后两个参数(LIMIT参数)
                                                                                                        boundSql.getParameterMappings().remove(boundSql.getParameterMappings().size() - 1);
                                                                                                        boundSql.getParameterMappings().remove(boundSql.getParameterMappings().size() - 1);
                                                                                                        // 添加完整的参数列表
                                                                                                        boundSql.getParameterMappings().addAll(originalParameterMappings);
                                                                                                    }
                                                                                                    // ... 其他情况处理
                                                                                                }

                                                                                                4.5.3 SQL转换示例

                                                                                                1. 简单查询

                                                                                                原始SQL:

                                                                                                  SELECT * FROM st_stock_stream WHERE warehouse_no = ? AND deleted =0

                                                                                                  双读SQL:

                                                                                                    SELECT * FROM st_stock_stream_5 WHERE warehouse_no = ? AND deleted =0 UNION ALL SELECT * FROM st_stock_stream WHERE warehouse_no = ? AND deleted =0

                                                                                                    2. 带ORDER BY和LIMIT的查询

                                                                                                    原始SQL:

                                                                                                      SELECT * FROM st_stock_stream WHERE warehouse_no = ? ORDERBY update_time DESC LIMIT 10

                                                                                                      双读SQL:

                                                                                                        SELECT * FROM st_stock_stream_5 WHERE warehouse_no = ? UNION ALL SELECT * FROM st_stock_stream WHERE warehouse_no = ? ORDERBY update_time DESC LIMIT 10

                                                                                                        3. COUNT查询

                                                                                                        原始SQL:

                                                                                                          SELECT COUNT(*) FROM st_stock_stream WHERE warehouse_no = ?

                                                                                                          双读SQL:

                                                                                                            SELECT SUM(countNumForSharding) FROM (
                                                                                                                SELECT COUNT(*) AS countNumForSharding FROM st_stock_stream_5 WHERE warehouse_no = ? 
                                                                                                                UNION ALL 
                                                                                                                SELECTCOUNT(*) AS countNumForSharding FROM st_stock_stream WHERE warehouse_no = ?
                                                                                                            ) tempForSharding

                                                                                                            执行流程图

                                                                                                            在从单表向分表架构迁移的过程中,使用双读策略可以:

                                                                                                            • 确保读取到完整的数据(旧表+新表)

                                                                                                            • 支持平滑迁移,无需停机

                                                                                                            • 提供回滚能力

                                                                                                            4.6 路由计算

                                                                                                            分表路由的一个具体实现,可以扩展实现为其他方式。

                                                                                                            路由算法:

                                                                                                            1. 配置优先:首先检查是否已有配置的分表

                                                                                                            2. 负载均衡:选择分配仓库最少的分表

                                                                                                            3. 分布式锁:使用分布式锁确保分配的唯一性

                                                                                                            4. 容错机制:支持重试。

                                                                                                            4.7 参数处理

                                                                                                            参数映射处理:

                                                                                                            • 双写模式下,参数列表需要复制一份

                                                                                                            • 双读模式下,需要根据LIMIT子句调整参数

                                                                                                            • 保持参数与SQL占位符的一致性

                                                                                                            4.8 性能优化

                                                                                                            优化策略:

                                                                                                            1. 缓存机制:使用ThreadLocal缓存分表后缀

                                                                                                            2. 批量处理:支持批量操作的分表

                                                                                                            3. 索引优化:分表键上有索引,提高查询效率

                                                                                                            4. 连接池优化:每个分表使用独立的连接池

                                                                                                            4.9 可扩展性

                                                                                                            扩展点:

                                                                                                            1. 自定义分表策略:通过实现ShardingSuffixCalculator接口

                                                                                                            2. 灵活配置:通过mybatis-config.xml配置分表规则

                                                                                                            3. 策略模式:支持多种读写策略,可动态切换

                                                                                                            4.10 监控与日志

                                                                                                            监控指标:

                                                                                                            • SQL重写耗时

                                                                                                            • 分表路由计算耗时

                                                                                                            • 分表命中率

                                                                                                            • 分布式锁竞争情况

                                                                                                            日志记录:

                                                                                                            • 分表键提取日志

                                                                                                            • SQL重写前后对比

                                                                                                            • 路由计算结果

                                                                                                            • 异常情况记录

                                                                                                            五、组件研发过程问题和解决方案

                                                                                                            5.1 双读,排序字段缺失报错

                                                                                                            案例:

                                                                                                            报错信息:

                                                                                                            ERROR 1250 (42000): Table 'm' from one of the SELECTs cannot be used in field list

                                                                                                            解决方案:将排序字段放在子查询的select column中

                                                                                                            select1, m.update_time from wms_stock.st_stock_stream m UNIONALLselect1, m.update_time from wms_stock.st_stock_stream_0  m orderby m.update_time asclimit1;

                                                                                                            5.2 双读,select count 报错

                                                                                                            案例:

                                                                                                            select count(1) from wms_stock.st_stock_stream UNION ALL select count(1) from wms_stock.st_stock_stream_1

                                                                                                            解决方案:先将select count 通过UNION ALL 合并,然后外层进行sum

                                                                                                            5.3 sum() 函数 UNION ALL 后需要再次 sum

                                                                                                            案例:

                                                                                                            selectsum(stock_qty)from wms_stock.st_stock UNIONALLselectsum(stock_qty)from wms_stock.st_stock_1

                                                                                                            解决方案:每个sum 语句作为子查询,外层再次sum,累加所有的子数量,作为总数量。

                                                                                                            推荐阅读

                                                                                                            跳转微信打开

                                                                                                            京东攻克业界难题:KMP组件交付从大仓模式到分仓模式

                                                                                                            2026年10月13日 20:29

                                                                                                            原创 京东零售  何亚兰 2026-10-13 20:29 北京

                                                                                                            这篇把鸿蒙和 iOS 的关键坑讲得很具体:桥接编号为何错位、类型判断为何失效、stdlib 怎样按需裁剪,以及 Gradle、集成单和流水线如何衔接。正在做 KMP、多端组件化或原生包治理的同学,可以把它当作一份很实在的设计检查清单。

                                                                                                            一、背景与现状

                                                                                                            用 KMP 复用 Android、iOS 和鸿蒙的业务逻辑。目前,各组件分别维护源码仓库、依赖和版本,再打包成各平台可用的库,供 App 工程集成。

                                                                                                            改造前的交付方式(业界通用方案):

                                                                                                            • Android:通过 AAR / Gradle Module 交付,由 Gradle 管理依赖。

                                                                                                            • iOS:将全部 KMP 业务模块打进一个 Umbrella Framework(聚合 Framework)。

                                                                                                            • 鸿蒙:将全部 KMP 业务模块聚合打包为一个 HAR。

                                                                                                            iOS 和鸿蒙各自的聚合包中,业务模块共用一份 Kotlin 标准库(stdlib)和 Native runtime(原生运行时)。修改任一组件,都要重新生成、发布整个聚合包。源码和版本已按组件管理,iOS、鸿蒙的交付包仍是一个整体。

                                                                                                            01-聚合模式.png

                                                                                                            图 1 聚合模式:所有业务模块随同一个产物交付

                                                                                                            如果每个组件都编译出一份包含全部依赖的 Native 库,stdlib、runtime 和部分依赖代码就会重复出现。拆分时需要确定:哪些代码由组件自己生成,哪些放入共用的基础库。文中将这些基础库称为“公共基座”。

                                                                                                            二、改造目标与方案

                                                                                                            目标是让 iOS 和鸿蒙按组件构建、发布 Native 产物,并共用公共基座。Gradle 管理依赖,插件与 CI/CD 负责打包、发布三端产物,再将新版本加入集成。

                                                                                                            针对每种目标架构和构建配置,我们分别生成 stdlib、runtime 的公共基座,在本方案中称为 stdlib carrier 和 runtime carrier。业务组件通过函数、类型等符号引用基座,链接时再找到对应实现,不必重复携带 stdlib/runtime 的主体代码。Android 沿用 AAR 交付。

                                                                                                            鸿蒙拆分编译以开源方案为基础。我们完成后续优化,并自研 iOS 分模块编译、Gradle 插件、组件模板和三端 CI/CD。

                                                                                                            图 2 总体方案:鸿蒙采用开源方案并继续优化,iOS 拆分交付由我们自主实现

                                                                                                            三、KN编译器基础:华为鸿蒙开源方案

                                                                                                            我们借鉴的鸿蒙开源方案为华为跨平台框架社区KMP公版。

                                                                                                            开源方案为每个组件生成独立的 .so,供后续打包成 HAR。编译器以 klib(Kotlin/Native 的中间库)为单位,确定代码由哪份 .so 提供。每次编译都会读取所需依赖,但只生成当前组件负责的实现,对其他组件保留符号引用。

                                                                                                            以组件 A 依赖组件 B 为例:

                                                                                                            • 编译 A 的 .so 时,生成 A 的实现,对 B 和基座保留外部符号引用;

                                                                                                            • 编译 B 的 .so 时,生成 B 的实现;

                                                                                                            • stdlib 和 Native runtime 分别生成基座 .so,业务 .so 不重复携带其主体实现。stdlib 基座保留公共 API,供业务组件调用。

                                                                                                            该方案用 moduleIncludes 和 outputModule 选择本次生成的代码,用 emitStdlib、emitRuntime 控制是否生成对应的基础库实现。同时,调整 LLVM linkage(链接属性),并通过 llvm.used 标记需要保留的入口,避免它们被当作无用代码删除。

                                                                                                            我们采用的开源版本要求在发布前重新编译全部集成组件。即使只修改了 A,其他组件也要重新编译、打包为 HAR,不能直接沿用旧包。

                                                                                                            四、鸿蒙端:KN编译器我们的后续优化

                                                                                                            鸿蒙后续优化主要解决跨 .so 的桥接和类型编号不一致问题。

                                                                                                            4.1 修复跨 .so 的桥接编号错位

                                                                                                            Kotlin 代码调用 C / N-API 时,编译器会生成一小段负责转接调用的代码,这就是桥接函数。同一个文件中的桥接函数按处理顺序编号,名字可以简化为 knbridge0、knbridge1 等。这里的 0、1 只是顺序编号,并不代表固定功能。

                                                                                                            组件 A 依赖 B。编译 A 时,编译器也可能读取并处理 B 中的 C / N-API 调用代码。同一处调用在编译 A、B 时,生成的桥接名必须一致。

                                                                                                            问题是:编译 B 时会读取完整代码,而编译 A 时可能只读取 B 中实际用到的部分,编号顺序就可能变了。以 B 的同一个文件中“创建对象”和“读取回调参数”两处调用为例:

                                                                                                              编译 B:先处理“创建对象”,再处理“读取回调参数”
                                                                                                                knbridge0 → 创建对象
                                                                                                                knbridge1 → 读取回调参数
                                                                                                              编译 A:只处理用到的“读取回调参数”
                                                                                                                knbridge0 → 读取回调参数

                                                                                                              这样,A 以为knbridge0 是“读取回调参数”的入口,B 提供的同名入口却负责“创建对象”。运行时,系统按函数名查找实现,并不知道两边对这个名字的理解不同,A 的调用就可能落到错误的函数上。

                                                                                                              03-桥接编号错位.png

                                                                                                              图 3 同一个桥接名对应了不同功能,统一读取和处理顺序后恢复一致

                                                                                                              我们的修复方式是:各组件编译时,都把相关业务 klib 中的代码读全,再按相同顺序处理。这样,无论编译 A 还是 B,“创建对象”都对应 knbridge0,“读取回调参数”都对应 knbridge1,调用方和提供方就能对上。

                                                                                                              读全代码是为了统一编号,不是把所有依赖都打进当前组件;各组件仍只生成自己的业务代码。这种方式可能增加编译耗时和内存占用;后续可根据函数名、参数类型等信息生成稳定的桥接名,不再依赖处理顺序。

                                                                                                              4.2 修复跨 .so 的类型编号问题

                                                                                                              Global Hierarchy Analysis(GHA,全局类层次分析)根据类和接口的继承关系分配编号(classId / interfaceId),并将类型判断和接口调用所需的信息写入编译结果。运行时利用这些信息,加快 is、as 和接口方法的查找。

                                                                                                              单体编译共享一套类型集合和编号。拆分后,A、B 的 .so 各自编译,同一类型可能得到不同 ID。A 用自己的编号判断 B 创建的对象时,is / as 就可能出错,即使链接过程正常。

                                                                                                              我们在鸿蒙拆分构建中关闭 GHA,改用不依赖全局编号的类型检查和接口调用方式。经业务测试确认,这一调整对运行性能没有较大影响。

                                                                                                              五、iOS:KN编译器自研分模块编译

                                                                                                              iOS 分模块编译和多个 Framework 之间的链接处理由我们自主实现。业务组件和公共基座分别生成静态 Framework,再封装为 XCFramework。App 链接时,由系统链接器 ld64 为各 Framework 的符号引用找到对应实现。

                                                                                                              5.1 符号、桥接与共享状态

                                                                                                              • 符号导出:组件生成自己的实现,对依赖组件保留符号引用。我们也明确了哪些 C / Objective-C 互操作代码(cinterop)随当前组件生成。其他 Framework 需要调用的入口会被标记保留,避免被优化或链接裁剪(dead_strip)误删。

                                                                                                              • 重复定义:共享 cinterop klib 生成的部分枚举、Objective-C 基础类可能出现在多个 Framework 中。对于这些语义一致的重复定义,我们使用 LLVM weak_odr,允许链接器合并,避免重复符号冲突。这种处理只针对确认一致的定义,并非所有同名符号都能合并。

                                                                                                              • Objective-C 与 runtime 状态:私有类名加上模块后缀,避免重名。每个业务 Framework 注册自己的类型适配表,避免被其他组件覆盖。共享配置由 runtime 基座提供,Objective-C runtime 注入逻辑增加检查,防止重复执行。

                                                                                                              普通跨组件 Kotlin 调用仍使用原生符号,不引入额外的业务桥接层。

                                                                                                              iOS 在判断其他 Framework 创建的对象类型时,也会遇到前述编号问题。关闭 GHA 的处理最初用于 iOS,随后应用到鸿蒙拆分构建。

                                                                                                              5.2 stdlib 按需导出

                                                                                                              我们根据本次集成的 iOS 组件裁剪 stdlib。基座内部未使用的函数,可能正被业务 Framework 调用,裁剪时必须考虑这些调用。

                                                                                                              以开启优化的 iOS Release 构建为例,设置 stdlibPruneMode=input 后,处理过程如下:

                                                                                                              第一步:传入参与集成的业务 klib。

                                                                                                              构建 stdlib 基座时,启用 emitStdlib=true 和 stdlibPruneMode=input,传入当前 iOS 目标下的业务 klib 及其平台依赖。编译器读取业务函数体和类型信息,找出业务需要的 stdlib 实现。这些业务代码只参与分析,仍由各自组件生成。

                                                                                                              第二步:汇总组件用到的符号,补齐间接依赖。

                                                                                                              编译器先汇总各组件直接使用的 stdlib 函数、构造函数、字段和类型,再检查 vtable(虚方法表)、itable(接口方法表)、自动生成的 Objective-C 调用桥,以及全局变量的初始化代码。这些地方也会引用 stdlib。沿调用和类型关系继续查找,就能得到“必须保留的符号集合”。

                                                                                                              例如,业务枚举对 kotlin.Enum 继承方法的引用可能只出现在 vtable 中,某些类型转换只由生成的 Objective-C 桥调用。漏掉这些符号会导致链接或初始化失败。

                                                                                                              在内联、去虚化等关键优化前,编译器先保存一份符号需求,供后续分析合并。基座编译时可能把某个调用展开或改写掉,但其他独立编译的 Framework 仍需要按原符号找到它。

                                                                                                              第三步:根据符号需求删除无用代码(DCE)。

                                                                                                              Dead Code Elimination(DCE,死代码消除)从业务所需符号和必要的运行时入口出发,保留它们直接或间接依赖的函数、类型和初始化代码,再删除其余实现。这样就不必默认保留 stdlib 的全部公共函数。

                                                                                                              第四步:保护 LLVM 链接入口。

                                                                                                              在 Intermediate Representation(IR,中间表示)层完成裁剪后,还要防止 LLVM 再次误删代码。基座中实际生成并保留下来的函数,继续使用外部链接属性(ExternalLinkage),并加入 llvm.used 保留清单。它们虽然可能没有本库调用方,仍需供其他 Framework 链接使用。类型信息和部分静态全局符号也做相应保护。

                                                                                                              第五步:链接时由基座提供实现。

                                                                                                              stdlib 主体由基座生成,业务 Framework 保留对它的外部引用。宿主 App 链接各静态 Framework 时,由 stdlib 基座提供定义。

                                                                                                              图 4 input 模式:分析业务需求 → 裁剪无用代码 → 保护链接符号 → 链接各 Framework

                                                                                                              定制分支也支持通过文件传递符号清单:业务编译时,用 stdlibDepsOutput 按行输出所需符号;基座通过 stdlibDepsInput 读取、合并这些清单,补齐依赖后裁剪。input 模式直接分析业务 klib,无需先编译业务 Framework 来收集清单。

                                                                                                              这里导出的符号用于 Native 链接,不会把整个 stdlib 变成 Swift / Objective-C 可见的 API。参与集成的组件或依赖变化后,需要重新分析符号需求,必要时重新生成基座。

                                                                                                              六、自研 Gradle 插件:按组件生成 HAR 和 XCFramework

                                                                                                              插件提供鸿蒙和 iOS 单组件打包任务,通过 moduleName 选择要构建的组件。业务在 Gradle source set(源码集)中声明依赖,通过 version catalog(版本目录)管理依赖坐标和版本。脚本指定本次构建的组件及版本;插件设置编译参数、整理对外接口,再打包成 HAR 或 XCFramework。以聚合模块 KMPBom 中的组件 A 为例:

                                                                                                                # iOS
                                                                                                                ./gradlew :KMPBom:podPublishReleaseModuleXCFramework \
                                                                                                                  -PmoduleName=com.example:moduleA -Pversion=1.1.0
                                                                                                                # 鸿蒙
                                                                                                                ./gradlew :KMPBom:assembleModuleHarReleaseOhosArm64 \
                                                                                                                  -PmoduleName=com.example:moduleA -Pversion=1.1.0

                                                                                                                将 moduleName 换成 std 或 runtime,即可构建对应基座。插件根据模块配置设置 moduleIncludes、outputModule、emitStdlib、emitRuntime 等参数。

                                                                                                                6.1 确定每个组件生成哪些代码

                                                                                                                Gradle 根据组件坐标、版本和目标平台,解析对应的 variant(平台变体),取得本次构建所需的 klib。执行 Native link(链接)任务前,插件读取 klib manifest(库描述文件):通过 unique_name 识别库,通过 depends 查找依赖。

                                                                                                                插件据此生成 moduleIncludes,告诉编译器“每个产物包含哪些 klib 的代码”;outputModule 指定“本次生成哪个产物”。以 A 依赖 B 的 iOS 业务编译为例:

                                                                                                                  moduleIncludes={moduleA:[com.example:moduleA];moduleB:[com.example:moduleB]}
                                                                                                                  outputModule=moduleA
                                                                                                                  emitStdlib=false
                                                                                                                  emitRuntime=false

                                                                                                                  编译器会读取 A、B 的 klib,本次只生成 moduleA 分组的实现。B 的实现由 B 的库提供,stdlib/runtime 由各自基座提供。

                                                                                                                  两端查找依赖、生成分组的方式有所不同:

                                                                                                                  • 鸿蒙:从目标 klib 的 depends 开始,逐层查找组件及其依赖,再将业务 klib 分组。stdlib、平台库和 cinterop 单独处理,不放入普通业务分组。

                                                                                                                  • iOS:从 Gradle 已找到的 iosArm64 klib 中读取目标组件的 manifest,按 depends 建立分组,并用依赖的 short_name 确定组名。插件不额外递归查找下一层依赖,同时保留平台库和 cinterop 的分组信息。

                                                                                                                  6.2 鸿蒙:从 klib 准备独立 HAR 工程

                                                                                                                  组件发布 klib 时,插件会写入 KSP 生成的内容和组件信息,包括名称、版本、OHPM 依赖及是否需要 N-API 入口。聚合模块的插件在出包时读取这些信息。

                                                                                                                  出包分为四步:

                                                                                                                  1. 选择本次生成的代码。根据 moduleName 确定目标组件,默认不在业务库中生成 stdlib/runtime 主体。std、runtime 等特殊产物通过 kmp-har-config.json5 配置;也可以在该文件中调整模块名、编译参数和 HAR 信息。

                                                                                                                  2. 准备需要链接的库,生成 .so。链接前读取 manifest 中的 linkerOpts,选出应由当前组件链接的原生库参数,并保留平台必需的参数。随后安装对应的 OHPM 依赖,把 .so 所在目录加入搜索路径,再调用定制编译器。moduleIncludes 决定生成哪些 Kotlin 代码;链接哪些原生库,需要单独处理。

                                                                                                                  3. 准备 HAR 工程。 从目标 klib 读取组件信息,优先提取其中的 ArkTS 模板,只合并当前组件的类型声明和导出内容。复制生成的 .so 及所需头文件,再写入包名、版本、组件依赖和基座依赖。如果需要 N-API 入口,还会准备加载器(loader)的初始化代码和 CMake 配置,交给下一步 hvigor 编译;不需要这一入口的基础库可以只携带自身 .so。

                                                                                                                  4. 生成 HAR。执行 ohpm install 和 hvigorw assembleHar,收集产物并按模块命名。

                                                                                                                  6.3 iOS:按组件导出接口,生成 XCFramework

                                                                                                                  iOS 插件复用 CocoaPods 构建任务,在模板已有的静态 Framework 配置上,根据本次构建对象设置参数:

                                                                                                                  • 业务组件:确定该组件需要生成哪些代码,不重复生成 stdlib/runtime 主体;

                                                                                                                  • stdlib:开启emitStdlib 和 stdlibPruneMode=input,直接分析业务 klib 的符号需求;

                                                                                                                  • runtime:只开启 runtime 主体代码的生成。

                                                                                                                  插件先清空聚合工程原先导出全部组件的 export 设置,再让业务 Framework 只导出当前组件;stdlib/runtime 基座不导出业务组件。进入链接任务前,插件会再次应用这些设置,防止其他 Gradle 配置把导出范围改回全部组件。

                                                                                                                  插件还会按目标组件设置 CocoaPods 名称、Framework 名称和 podspec 版本。各架构的静态 Framework 生成后,由 CocoaPods 任务将它们组合为 XCFramework,连同 podspec 一起交给流水线上传发布。

                                                                                                                  插件会将实际使用的编译参数和导出配置写入build/parameter/ios-cocoapods.gradle.kts,并为每个模块留存一份,便于排查符号缺失、接口导出和命名问题。

                                                                                                                  6.4  KMP 组件间依赖如何传到 HAR、XCFramework 之间

                                                                                                                  以A依赖B为例:拆分后,B仍独立出包,依赖关系对应A.har→B.har 和 A.xcframework→B.xcframework。编译器保留 A 对 B 的符号引用,包管理工具则根据依赖声明,为 App 同时安装 A、B 两份产物。

                                                                                                                  鸿蒙:让 A.har 声明对 B.har 的依赖。 这部分已由插件实现:

                                                                                                                  1. 从 A 的 klib manifest 读取依赖,找到 B,再逐层查找 B 依赖的组件。

                                                                                                                  2. 按组件坐标找到对应 klib,读取组件信息中的 ohpmName,得到 HAR 包名;未配置时按默认规则生成包名。

                                                                                                                  3. 将这些包名写入A的oh-package.json5的dependencies。业务组件不携带 stdlib/runtime 主体时,再补上两份基座 HAR 的依赖。组件中声明的原生OHPM 依赖,也通过上述组件信息传递。

                                                                                                                  App 工程安装 A 时,OHPM 根据声明取得依赖包。各 HAR 中的 .so 随平台打包进入 App,运行时由系统动态链接器找到跨库调用的实现。B 的主体实现保留在自己的 HAR 中。

                                                                                                                  自动写入的组件及基座 HAR 依赖版本目前是 *,不会直接沿用 KMP 构建时选定的版本,集成时仍需指定能配套使用的版本。

                                                                                                                  iOS:通过 Pod 依赖关联 A.xcframework 和 B.xcframework。 两份 XCFramework 独立存放,由配套的 podspec 声明包依赖。iOS 插件完成以下步骤:

                                                                                                                  1. 读取当前组件的 KMP 依赖,结合本次 Gradle 解析结果,确定依赖组件对应的 Pod 名称和版本。

                                                                                                                  2. 在A的podspec中生成对B的spec.dependency,并声明所需的stdlib/runtime基座。若B还依赖C,则在生成B的podspec时继续声明 C。

                                                                                                                  3. App 接入A对应的Pod后,CocoaPods根据声明取得B、C及基座的 XCFramework,一并加入工程。App 链接时,再为各 Framework 的符号引用找到对应实现。

                                                                                                                  export 只控制 Objective-C 接口导出,不能代替 podspec 的包依赖声明。

                                                                                                                  6.5 单独更新组件,不需要重新生成整套产物

                                                                                                                  以 iOS 为例:只要现有依赖和基座仍能配套使用,就可以通过 moduleName 指定待更新组件,只生成它的 XCFramework。

                                                                                                                  假设 App 已经接入 A、B、C 和两份公共基座,现在修改 A:

                                                                                                                  • 只改 A 的业务逻辑,现有依赖仍能配套使用。 只生成并发布 A 的新包,App 工程更新 A 的版本;B、C 和基座继续使用原来的产物。

                                                                                                                  • A 需要的函数,旧基座没有提供。例如 A 新调用的 stdlib 函数已被旧基座裁掉。此时还要汇总新版 A 与现有 B、C 的符号需求,重建 stdlib 基座,保留所有组件需要的函数。

                                                                                                                  将新包与继续使用的旧包放在一起验证,通过后再更新 App 工程的依赖。

                                                                                                                  首次接入且没有可用产物时,需要分别为各业务组件和两份基座出包。目前仍需人工确定要重新构建哪些组件,插件不会根据代码改动自动判断。

                                                                                                                  图 5 iOS 更新场景:只更新 A,或同时更新 A 与 stdlib 基座;新旧包一起验证后再集成

                                                                                                                  七、自研 CI/CD:组件构建一次,发布三端产物

                                                                                                                  发起一次组件构建,流水线分别完成 Android、iOS 和鸿蒙的编译打包,发布 AAR、XCFramework 和 HAR;随后添加集成,将组件版本写入对应平台集成单。

                                                                                                                  图 6 两层模板完成三端构建;产物发布后添加集成,再更新平台集成单,供后续构建读取

                                                                                                                  7.1 两层模板:外层聚合模块,内层业务组件

                                                                                                                    component-template/
                                                                                                                    ├── settings.gradle.kts         # 注册 iOS、鸿蒙两份版本配置
                                                                                                                    ├── 集成单-iOS.json
                                                                                                                    ├── 集成单-鸿蒙.json
                                                                                                                    ├── gradle/
                                                                                                                    │   ├── bom.ios.versions.toml    # iOS 组件坐标与版本
                                                                                                                    │   └── bom.ohos.versions.toml   # 鸿蒙组件坐标与版本
                                                                                                                    ├── Script/kmp_build.sh
                                                                                                                    └── KMPBom/                     # 外层:聚合模块
                                                                                                                        ├── build.gradle.kts        # 引用两端版本配置,声明组件依赖
                                                                                                                        └── moduleA/                # 内层:业务组件
                                                                                                                            ├── build.gradle.kts
                                                                                                                            └── src/

                                                                                                                    两个模块属于同一个 Gradle 构建:

                                                                                                                    • 内层业务组件:存放业务源码、声明组件自身依赖,编译并发布各 Native 目标的 klib,以及 Android AAR。

                                                                                                                    • 外层聚合模块:根据 iOS、鸿蒙两份版本配置找到所需组件,再用插件为选定组件生成 XCFramework 或 HAR。它读取已发布的 klib,不通过 project(...) 直接引入内层源码。

                                                                                                                    settings.gradle.kts 将两份 toml 注册为 Gradle version catalog:iOS 使用 iosBoms,鸿蒙使用ohosBoms。外层KMPBom/build.gradle.kts通过它们添加依赖。例如,api(iosBoms.componentA) 就是把 iOS toml 中 componentA 对应的组件和版本加入依赖。以下用 componentA 作为示意别名:

                                                                                                                      kotlin {
                                                                                                                          sourceSets {
                                                                                                                              iosMain.dependencies {
                                                                                                                                  api(iosBoms.componentA)  // 使用 bom.ios.versions.toml 中的版本
                                                                                                                              }
                                                                                                                              ohosMain.dependencies {
                                                                                                                                  api(ohosBoms.componentA) // 使用 bom.ohos.versions.toml 中的版本
                                                                                                                              }
                                                                                                                          }
                                                                                                                      }

                                                                                                                      外层准备好编译所需的依赖,再由 moduleName 决定本次为哪个组件出包。

                                                                                                                      新组件接入时,修改内层模块名并声明业务依赖,在两份 toml 中登记组件坐标和版本,再将组件加入外层依赖。

                                                                                                                      7.2 构建前:拉取集成单,修改工程依赖版本

                                                                                                                      平台集成单列出该平台已选用的组件及版本。iOS、鸿蒙构建前,先把这份清单拉到模板工程,再更新工程中的依赖版本:

                                                                                                                      1. 拉取平台集成单。 将iOS、鸿蒙集成单分别保存到工程根目录的 集成单-iOS.json、集成单-鸿蒙.json,供构建脚本读取。

                                                                                                                      2. 修改工程依赖版本。脚本将集成单中的组件版本写入 gradle/bom.ios.versions.toml 或 gradle/bom.ohos.versions.toml。

                                                                                                                      如果 iOS 集成单指定 A 为1.0.0,脚本就把 bom.ios.versions.toml 中 A 的版本改为1.0.0。外层仍通过 api(iosBoms.componentA) 引用 A,但 Gradle 此时取得的是 A 1.0.0 的 klib。鸿蒙同理。

                                                                                                                      脚本只修改已有组件的版本,不会自动把新组件加入聚合模块。

                                                                                                                      7.3 两阶段构建:内层发布 klib,外层生成平台产物

                                                                                                                      1. 内层组件先发布 klib。内层将当前源码编译为所选 Native 目标的 klib。模板默认发布到工程内的 Maven 仓库,供外层读取。

                                                                                                                      2. 外层聚合模块再出包。 脚本把当前组件的依赖版本改为刚发布的 klib 版本,其他组件仍使用集成单中的版本。外层取得这些 klib 后,执行 XCFramework / HAR 任务,为 moduleName 指定的组件出包。

                                                                                                                      如果内层本次发布 A 的 1.1.0 klib,外层就将 A 的依赖版本从 1.0.0 改为 1.1.0,再生成平台产物。此时修改的是当前工程的依赖;平台集成单要等三端产物发布、添加集成后再更新。

                                                                                                                      同一平台、架构下,配套使用的 KMP Native 库需要统一编译器版本、构建模式(Debug/Release)、垃圾回收(GC)与 runtime 配置、Objective-C 导出配置和拆分参数,再放在一起验证。

                                                                                                                      采用前述鸿蒙开源版本时,发布前仍需重新编译全部集成组件,再分别打包为 HAR。

                                                                                                                      Android 按原有流程生成并发布 AAR,由 Gradle 管理组件依赖。三端共用发布入口,各自按平台方式出包。

                                                                                                                      7.4 发布三端产物,添加集成,再写入平台集成单

                                                                                                                      指定组件和版本后,流水线完成构建、打包和产物核对,再依次执行:

                                                                                                                      1. 发布三端产物。上传Android AAR、iOS XCFramework 和鸿蒙 HAR,确保对应版本可获取。

                                                                                                                      2. 添加集成。选择本次要纳入集成的组件及其已发布版本。

                                                                                                                      3. 写入对应平台集成单。新组件新增条目,已有组件更新版本,供后续构建读取。

                                                                                                                      A 的1.1.0三端产物发布并添加集成后,写入对应平台集成单,随后发送通知。其他组件下次构建时重新拉取集成单,将 A 的1.1.0带入自身外层聚合模块的依赖。

                                                                                                                      发布脚本会列出产物及体积。如果某个组件的包突然变大,应检查它是否正确引用公共基座,以及 moduleIncludes 中该组件的分组是否误包含了其他组件的 klib。

                                                                                                                      交付前还需验证:

                                                                                                                      • 符号链接:检查未定义符号、重复定义、导出符号和依赖库,确认跨组件调用能找到对应实现;

                                                                                                                      • 组件联调:将组件放在一起,验证跨组件调用、OHOS 加载顺序、is / as、接口方法调用、全局初始化及 Objective-C / N-API 桥接;

                                                                                                                      • 配置兼容:核对编译器版本、基座的二进制接口(ABI)、构建模式和拆分参数,确保各个包能配套使用。

                                                                                                                      已发现的桥接编号和类型检查问题应加入跨组件回归测试,防止后续改动再次引入同类问题。

                                                                                                                      八、落地收益

                                                                                                                      • 鸿蒙启动提速:缩短 App 启动耗时。

                                                                                                                      • KMP 编译提速:减少单次编译耗时。

                                                                                                                      • 矩阵 App 按需集成:矩阵 App根据各个 App 的业务需求,按需集成 KMP 组件的各端产物:Android AAR、iOS XCFramework 和鸿蒙 HAR,避免带入不需要的KMP组件。

                                                                                                                      九、总结与展望

                                                                                                                      本次在鸿蒙开源方案上完成后续优化,并自研 iOS 分模块编译、链接适配和 stdlib 按需导出。Gradle 插件、两层组件模板与 CI/CD 将拆分能力接入构建和发布流程,使业务组件与公共基座分别交付。

                                                                                                                      接下来继续优化包大小,减少 stdlib、互操作和桥接代码中的冗余,并验证裁剪后的跨组件链接与运行结果。

                                                                                                                      推荐阅读

                                                                                                                      跳转微信打开

                                                                                                                      ❌