铃阅
❌

普通视图

侠客汇 AI-Native 之路:如何打造「可自进化」的端到端 AI 工作流

2026年6月2日 15:11

原创 杨乐、金丽华 2026-06-02 15:11 北京

想了解更多转转公司的业务实践,欢迎点击关注下方公众号:

2026 年 2 月,侠客汇一个会员改版需求,整整做了 3 个月才上线,业务一堆项目卡在后面干等。

1 个月后的今天,同样规模的需求,我们 3 周就能交付。而且变化远不止「快」这一点:

维度

改造前

改造后

协作角色

6 种(运营/产品/UI/前端/后端/测试)

3 种(运营 / 产品设计 / 技术)

文档产出

纯人工撰写

AI 出初稿、人审(纪要/PRD/技术文档/用例)

信息衰减

跨 6 角色层层衰减、反复对齐

产品-技术两端直连,纪要即「需求契约」

典型需求周期

会员改版 3 个月

同类需求 3 周交付

研发效率

—

整体提升 50%

经验复用

靠人记、人传,人走即清零

沉淀进知识库,越用越聪明、抗人员流动

但最核心的改变不在这张表里——是我们打造出了一条「可自进化」的端到端 AI 工作流:从需求沟通到上线交付全程由 AI Agent驱动,而它每跑一个需求,就把新经验沉淀进「组织记忆」、自动变得更懂业务。正因如此,效率提升不再是一次性的,而是可累积、可复利:需求做得越多,工作流越聪明,下一个需求就越快。

我们只做了两件事:

  • 让 AI Agent 驱动每个环节,人只做决策和审核

  • 把团队每一次的经验沉淀成那份会自进化的「组织记忆」

下面,就从那个「耗时 3 个月」的需求讲起,说说这一切是怎么发生的。


一次「3 个月才上线」的改版

先把这 3 个月,慢在哪拆开看。

一个会员改版需求,要走完这样一条链路:运营提需求、产品调研现有系统能力并梳理改动点、反复开会确认决策点;产品手写 PRD、画原型、改方案;再拉上前端、后端、测试、UI,开需求评审会、技术评审会、测试用例评审会……6 种角色、15 个节点、5 场评审会,需求在一个个角色之间层层传递。

问题就出在「传递」上。每经过一个角色,信息都在衰减:运营的真实意图,产品转述时会走样;技术理解需求时又有 gap;UI 拿到再问一轮……于是反复沟通、反复返工。更棘手的是,会员系统历经 2 年、多次小改版,没人能完整复述线上逻辑,光是翻历史代码、捋清现状就耗掉大量时间。

而最深的一道坑是:这条链路上的经验,没有沉淀下来。上次改版踩过的坑、定过的规则,都散在个别人的脑子里、某次会议的纪 要里。下一个需求来了,一切又从零开始。

所以我们想做的,不只是「把这次改版做快」,而是让整个组织既快、又会越来越快——这就引出了贯穿全文的两条线:产品线与技术线。


一、慢的真相:拆开旧流程

那 3 个月,不是哪个人不努力,而是整条流水线的结构就注定了慢。把旧流程摊开,慢有三个根源:

慢的根源

具体表现

重复劳动多

需求现状调研、写 PRD、画原型、画 UI、写用例——大量人工撰写,纯耗时

信息层层衰减

需求跨 6 个角色传递,每过一道手就走样一次,理解偏差只能靠反复开会对齐

经验不沉淀

踩过的坑、定过的规则只在个人脑子里,下个需求从零开始,同样的弯路再走一遍

解法的方向因此也很清楚:用 AI 替代重复劳动、精简角色与环节、消除信息衰减、把经验沉淀下来让组织复用。

旧流程 vs AI-Native 新流程
旧流程 vs AI-Native 新流程

二、我们的两条信念

信念一:每一个环节,都由 AI Agent 来操作和驱动,人只做决策和审核。

AI Agent 是流水线的操作者——它读需求、查代码、写文档、自检、评审、归档,一整套连贯地跑下来。人退到该在的位置:在关键岔路口做判断、为模糊处拍板、对最终结果负责。重复劳动交给 Agent,高价值的决策留给人。

信念二,也是本质:我们要的不是一个工具,而是一份「可自进化的组织记忆」。

经验不再靠人「抽空整理」,而是在 Agent 执行任务的过程中被自然沉淀,再供给下一次的 Agent 或下一个人。需求做得越多,这份记忆越丰富、越准确、越成熟。它如同一位永不离职、且持续精进的资深同事。

下面分产品、技术两条线看它们怎么落地——你会发现,它们其实是同一个故事的两种讲法。


三、产品线:找关键提效点,约定输入输出标准

这一段在解决什么:产品设计链路上「找真需求、写 BRD、写 PRD、画原型图、画 UI」的耗时与信息衰减。

怎么解:先想清楚 AI 该先打哪、产品和技术怎么分工,再用 AI 替代重复撰写,把 6 种角色协作在生产端收敛成「产品设计、技术开发」两端的「1+1」极简协作——运营提出的需求,将产品设计、UI 设计都归到「产品」这一端。

3.1 启动之前:先想清楚 AI 解决什么问题

很多事情都可以通过AI赋能,但需要想清楚我们先解决什么问题,于是我们把需求分了类:

需求分类

特点

怎么对待

现有系统日常迭代

占整体 90% 以上,依托业务系统、直面终端用户,业务逻辑复杂、中台逻辑耦合深

痛点是上线流程繁琐、排期周期长、机会成本极高——本次优先攻坚

纯增量创新需求

创新型项目需求,多为内部运营配套系统,不直接面向终端用户。目前该类需求落地较少,投入产出比(ROI)偏低、业务优先级靠后,但实际也存在明确优化痛点。

AI Agent 可全流程闭环,留作后续创新空间

综合业务痛点优先级、落地难度及价值回报,本次产品的AI原生工作流建设,优先聚焦现有系统日常需求迭代的效率痛点,开展优化落地。

我们参考了一下目前互联网企业AI工作流落地模式,不同公司不同部门工作范式差异巨大,没有统一标准,也无法直接照搬,要根据实际业务的情况和组织现状,去思考合适的范式。

最终我们借鉴阿里「1+1协作」范式并进行本地化适配——舍弃产品闭环前端开发那一环,把范式定为产品-技术的「1+1」分工——【产品端:运营需求 + 完整方案 + 高保真 UI】+【技术端:全流程生产交付】。

3.2 痛点:每个角色到底卡在哪

前面「慢的真相」看的是全链路的三个结构性根源;现在把镜头推近,只看产品设计这一段,每个角色具体卡在哪:

角色

工作环节

核心痛点

运营

需求采集、优先级判定

如何找到真需求,并准确总结,定义优先级

需求整理、BRD 输出

纯人工撰写,耗时耗力,效率偏低,描述准确性低

产品

PRD 设计、原型输出

人工调研周期长,跨角色传递信息衰减、理解偏差,反复沟通,修改成本高。

UI

UI 方案设计

人工设计耗时久;跨角色理解偏差,需频繁与产品对齐,沟通成本高

目标因此明确:用 AI 替代各环节重复性工作,精简协作角色与流转环节,从根上解决跨角色的信息衰减与理解偏差,把链路收敛成产品设计-技术两端的「1+1」协作。

从「6 角色层层传递」到「产品-技术 1+1」
从「6 角色层层传递」到「产品-技术 1+1」

具体怎么落?我们从需求输入、PRD设计、UI设计 三个环节分步解决。

3.3 第一步:把「写 BRD」换成「开一场好会」

第一个关键判断是:不要拿 BRD 喂 AI。因为 BRD 有 AI 克服不了的天然缺陷——我们实测过不同投喂物料的效果:

投喂物料

效果

BRD噪音多

(背景与目标混杂、方案脑补、逻辑跳跃)、
方案越界(写"我要这个功能",而非"要解决什么问题")、
共识模糊(运营单向输出、未经产品校验)
——AI 会把错误假设当事实,生成看着完整、实则全是坑的 PRD

会议纪要信息纯净

(只记双向确认后的结论)、
需求聚焦(会上已把"解法"拉回"需求")、
共识强绑定(相当于双方签字的"需求契约")
——是当前条件下的最优解

于是探索出一条高效的「产运工作流」:

需求输入标准化:会议 → AI飞书纪要 → PRD
需求输入标准化:会议 → AI飞书纪要 → PRD

这条工作流背后是一个固化的 AI 技能:上传会议逐字稿、一句固定指令「按 BRD 结构输出文档」,自动产出覆盖核心痛点、数据支撑、P0/P1/P2 分级功能、业务流程、规则、风险、待办的标准化纪要,并且会自动创建飞书文档连接。它对业务无感、无负担——运营不必再提前花大量时间写 BRD,仅一场标准需求沟通会就完成共识;我们还可以统一需求会议标准,反向推动业务一起从源头提升需求沟通质量。

3.4 第二步:PRD 从「人工撰写」到「AI 分步生成 + 人工逐段确认」

对标传统 PRD 全流程,我们搭了一条分步人机校验的自动化工作流——不追求"一键生成完整 PRD"(那只会批量出错),而是 AI 分步起草、人工逐段把关:

PRD 自动化五步
PRD 自动化五步

这条流水线不是一蹴而就的,它踩着坑迭代了六个阶段才成型——这段历程,恰好就是「知识沉淀」这件事的最初摸索:

阶段

做了什么

踩到什么坑 / 得到什么认知

尝鲜期

直接用 AI 一键生成完整 PRD

幻觉严重、编造业务逻辑——大模型只是概率预测工具,不是万能魔法

规范期

固定团队 PRD 模板投喂

格式规范了,内容仍不达标——格式规范 ≠ 内容可用

拆解期

拆成多模块分步生成、逐模块人工核对

出错率大降——最优模式是「AI 快速起草 + 人把控方向与逻辑」

寻源期

接入历史 PRD 与真实代码校准

全量投喂导致上下文溢出——堆数据 ≠ 有效输入,必须精炼

降噪期

只投喂精炼核心:《产品逻辑时间轴》+《底层代码索引》

输出质量质的跃迁,贴合真实业务、不再编造

进化期

搭「错题本」+ 动态纠错

人工纠错自动沉淀为规则门禁,工作流自我纠错、持续进化

走到「进化期」你会发现:产品线踩出来的这套「精炼知识 + 自动纠错」,恰恰就是技术线那座「项目知识库」的雏形。两条线在这里第一次握手。

3.5 第三步:UI 从「反复对齐」到「AI 直出可交付物料」

摒弃原有「产品手绘原型 + 提 UI 需求 + 反复沟通对齐」的低效模式:产品依托 AI 工具Claude code直接生成标准化 UI 交付文件(Figma),全程无需与 UI 设计师反复对齐,产出物可直接交付技术开发。这一步依托 UI 与前端的组件标准化基建。

3.6 怎么把它稳稳铺开:先内部打磨,再业务无感渗透

好工具还得能落地。我们没有一上来就全员铺开,而是走「先内部打磨、再对业务无感渗透」的两段节奏:

双轨落地节奏
双轨落地节奏
  • 团队内部:初期不追求全员铺开,聚焦小范围核心力量攻坚,在不影响正常业务迭代的前提下,快速跑通、打磨AI工作流。产品负责人亲自跟进所有AI产出结果,针对输出质量给出精准反馈,真实摸清当前AI能力的边界、优势与短板,明确后续技能优化、流程迭代的方向。接下来将已验证可行的AI工具、自定义Skill,优先培训给团队业务骨干,由骨干率先落地使用,持续收集一线使用问题,迭代优化工具与流程,打磨出稳定可用的标准化方案,再推广给全员。

  • 业务侧:不打乱业务原有节奏——先保留运营宣讲 BRD 的习惯,由产品侧独立把「会议转 BRD」跑通;再用统一的会议标准反向推动业务提升需求会议质量。核心原则是利他赋能、绝不把成本转嫁上游,靠真实的效率提升赢得业务配合。

产品线这三步,节省的都是「重复撰写」和「跨角色对齐」——而 PRD 流水线里那个「错题本」,正是「可自进化的组织记忆」在产品线上的雏形:每一次人工纠错,都自动沉淀成规则门禁,下次主动规避。下一步,产品工作还会从「承接需求提效」往前延伸到「主动挖掘真实需求」,把闭环补全。


四、技术线:从「老项目考古」到「会自进化的知识库」

产品借助 AI 实现了效率的质变,那么研发侧该如何用 AI 提效?最直接的答案是 AI Coding,而过去普遍的做法是 Vibe Coding——凭感觉让 AI 直接写。

但这条路有一个致命缺陷:AI只能看到代码"是什么样",看不到代码"为什么是这样"。而在一个老项目里,最要命的恰恰就是那些「为什么」:这条链路当年为什么不敢加缓存、这个字段为什么删不得、那段绕远的逻辑当初到底是为了填哪个坑——这些约束全都不写在代码里,只装在老员工的脑子里。人一走,就成了没人能解的谜。所以问题的本质,是要把藏在人脑里的隐性约束,显式地搬进 AI 的上下文,让它在和资深工程师同等的信息条件下工作。

想清楚这一点,结论就很自然了:AI 缺的从来不是能力,而是「这个项目的上下文」。与其每个需求都临时喂一遍背景,不如一次性把整个项目的知识沉淀下来,建成一座 AI随时能查、而且越用越厚的「项目知识库」——这才是靠知识沉淀提效,而不是靠 Vibe Coding 碰运气。

这座知识库的形成分两段——先一次性「打好地基」,再让它在每个需求里自我进化。下面这张图,先把整个闭环看一遍:

闭环全景图:从老项目到「越用越懂行」的完整飞轮
闭环全景图:从老项目到「越用越懂行」的完整飞轮

关键点:知识库如何设计

知识库目录结构
知识库目录结构

4.1 冷启动:给老项目「打一次地基」

在进行老项目考古的时候,一个难点是你需要让AI知道什么东西,AI才能很好的理解这个项目,并在一定的规范的前提下,去进行需求的开发,这里面我们把AI想象成一个新人,当团队来新人之后,我们是怎么去培养新人的,让新人去理解整个项目。

第一步 · 先带它了解项目全貌

  1. 告诉新人整个转转的技术体系,项目的代码结构,各模块之间的依赖关系,项目中用了什么外部能力

  2. 告诉新人项目对外提供了什么能力,这些能力在项目中是怎么分类的

  3. 告诉新人数据库在哪里,都有什么表,表结构怎么样,表之间的关联关系

通过以上的三步,新人大体就能了解整个项目是如何运转的,以及接到需求之后,该如何下手,所以我们也将这些信息告诉AI,就有了以下三张蓝图:

蓝图文件

记录什么

让 AI 能做什么

① 架构总览

系统分层 + 全景图 + 下游依赖清单

接到需求就判断「改动会影响哪几层、会调到哪些下游服务」

② 接口 清单

(含全量入口速查表 + 循环依赖检测)

每个对外接口的落点、参数、归属模块

关键词一搜就命中「这个需求动哪些表、改哪个 Facade、会牵动谁」

③ 数据库 ER 图

(含真实索引明细)

全表清单 + 字段 + 线上真实索引

写 SQL 知道走哪个索引、改字段前知道会影响哪些表

过程中需注意的点:

  • 接口注释与实现脱节:人改代码常不维护注释(比如:名叫「查询」的方法实际还改状态),照搬就会得到错误的接口说明。机制是让 AI 逐行比对实现与注释,不一致就让人确认,绝不轻信接口注释。

  • 索引必须拿真实 DB 结果:线上索引几乎一定和代码里的不一致(手工加过、DBA 调过)——强制阻塞,等人回贴真实的 SHOW INDEX,不许从代码反推。

  • AI 会漏扫:强制它自检——拿接口清单里的实体去和数据库实体逐一比对,降低漏扫的发生。

第二步 · 把「隐性知识」问出来

认全项目后,AI 知道了「代码该怎么写」。但真到写需求时,还有大量隐性知识它不知道:历史上为什么这么设计、有哪些坑、哪些地方碰不得。这些代码里根本没有,新人也只能去问老员工——那怎么让 AI 也知道?我们的做法是「人设计问题、AI 扫代码、人来解答」:

  • 先按当前业务的特点,自己列出核心要关注的问题(长事务、锁设计、Facade 设计理念、联表查询等),让 AI 去扫代码、由人给解答;

  • 让 AI 扫描核心接口,我们设计好问题,由人补充业务逻辑和隐藏的坑——因为这些业务规则,AI 根本不可能从代码里推测出来。

最终我们把这个过程中我们的回答,全部沉淀到知识库,这样AI在下次进行需求开发的时候,就有知识可以参考:

这一步同样有两个关键要点:

  • 别直接问「有什么坑」:而是通过 AI 扫出的规则 + 代码证据去唤起老员工的记忆——「原来这块当年踩过坑」,顺手就补出了代码里扫不到的隐性坑(线上事故、上下游兼容历史),比干问准得多。

  • 核心接口不是扫得越全越好:扫太多会让 AI 上下文爆炸。我们做两个取舍——近三个月没有流量调用的接口不扫;再根据上下文容量,判断到底扫多少个接口合适。

4.2 日常飞轮:每个需求都让知识库更聪明

老项目进行了一次性的知识沉淀,是给了AI在做需求过程中一个参考,但知识会升级会新增也会过期,如何在日常需求承接过程中,让知识库可以自进化。

从产品侧每来一个飞书格式的新需求,Agent 都会跑一遍 装载 → 归档 → 入库,外加一道贯穿其中的淘汰。我们先用一张表看清四个动作的边界:

动作

通俗定位

能不能改知识库

这一步的重点

装载

开工前一次装 + 开工中按阶段动态投喂

❌ 只读

用「三级漏斗 + 反向检索」精准取出该用的几条,全程留痕

归档

收工后理经验

❌ 只产建议

既登记「旧知识又被用了一次」,又萃取「本次新增的经验」

入库

把建议安全写回

✅ 唯一可改

并发检测 + 自动恢复;升级成熟度、淘汰过时知识

淘汰

让错的旧知识退场

定期触发

每三个月清理一次,把零引用的知识移出活跃库

① 装载 —— 知识的「抽取」与「使用」

装载要回答两个问题:一个项目沉淀了几百条知识,该抽哪几条喂给 AI?喂进去之后,怎么保证 AI 真的用了、用对了?

知识装载总流程:基础认知一次装,专业知识按阶段装
知识装载总流程:基础认知一次装,专业知识按阶段装

先说「抽取」。知识装备分两种节奏——基础认知一次性全装,专业知识按阶段精准投喂:

装载节奏

装什么

为什么这样做

基础认知

(一次性全装)

项目定位 + 团队红线 + 业务术语 + 架构/数据库快照 + 知识总目录

无论做什么需求都得懂的「常识」,开工时一次读完

专业知识 · 写需求分析前

业务规则 + 历史踩坑 速查表

最怕漏掉业务规矩、最该参考前人的坑

专业知识 · 写技术方案前

架构决策 + 编码指南 + 数据模型 速查表

必须对齐已有架构选型

专业知识 · 写代码前

数据模型 + 踩坑 + 指南 速查表

聚焦表结构、避坑、代码规范

成百上千条知识不可能全塞给 AI(会超出上下文上限),所以靠一套「三级知识漏斗」层层收敛——用一页目录 + 几行卡片,就锁定真正该读的三五条:

三级知识漏斗:从一页目录逐级缩小到整条经验
三级知识漏斗:从一页目录逐级缩小到整条经验

而到底抽哪几条,不是预设的,是被对话驱动的。用户每回答一个关键问题,Agent 就自动跑一遍「反向检索」四步闭环:

反向检索循环:用户每答一句,触发一次「按需取知识」
反向检索循环:用户每答一句,触发一次「按需取知识」

背后是一张「锚点 → 取知识」的映射,让自然语言里的线索精准命中知识:

用户在对话里提到

AI 自动触发读取

涉及某条业务线

业务线隔离规范 / 术语表对应段落

金额相关字段

金额处理规范(如必须用 BigDecimal)

用到消息队列 / RPC

对应的集成架构决策(ADR)

改了表结构 / 增减接口

数据库 ER 图、模块地图,核对影响面

提到某个历史遗留逻辑

当年那条决策记录 + 相关踩坑

再说「使用」。抽出来还不够,得保证它真被用上——这里有两道硬约束:

  • 高风险强制必读:一旦用户的回答改变了影响范围、改变了数据流向、或触碰了红线(业务线隔离 / 金额 / 状态机),AI 不读对应知识就不许往下走;若项目里压根没有这条知识,它会反过来提醒「这里以后要补一条」。

  • 全程留痕账本:每读一条都登记「读了哪条 / 为什么读 / 谁触发 / 哪个环节」。这本账有两个硬价值——它是当下的质量闸门(账本为空 = AI 没参考任何经验,直接拦下),又是下一步升级知识的唯一证据。

中间过程产物,如设计方案文档、与前端(APP 端、h5)的交互文档、修改范围文档等会同步上传到飞书,沉淀成一份结构化的在线文档——人不必额外整理。

② 归档 —— 历史知识的「复用登记」与新增知识的「萃取」

一个需求做完,归档要同时处理两类知识:这次复用过的历史知识,和这次新产生的经验。它们走两条完全不同的路径,但都只产「建议」、绝不直接碰正式库。

归档全流程
归档全流程

第一条路径 · 历史知识的「复用登记」。本次需求在「装载」阶段引用过哪些已有知识,会从那本留痕账本里被逐条提取出来。它们不新建条目,而是给对应的旧知识各记一笔「又被引用了一次」。这一步回答的是——「哪些旧经验,这次又被验证了一遍」。它正是后面成熟度升级的唯一证据来源:一条知识被多少个不同需求真实用过,全靠这里一笔笔攒出来。

第二条路径 · 新增知识的「萃取」。本次需求新产生的经验,由多个 AI 分身并行从需求侧和代码侧开采:

来源

从这里萃取

得到什么知识

需求侧

设计方案 spec、技术方案 plan

业务规则、架构决策

代码侧

代码评审记录、Git 提交历史

踩坑、编码约定、数据模型

代码侧 · 对比

实际代码 vs 旧快照

架构图 / 模块地图 / ER 图的「蓝图变更」

两条路径汇到一起,产出一份结构化知识草稿(决策 / 规则 / 踩坑 / 指南 / 模型 + 蓝图变更),每条新知识都带一个成熟度标签。而升级靠的不是「我觉得有用」,是第一条路径攒下的真实引用次数:

成熟度

含义

升级门槛(量化)

draft(初稿)

第一次沉淀,还没被验证

—

verified(已验证)

在多个需求里被反复用到

被 ≥3 个不同需求真实引用

proven(已夯实)

足够可靠,可对外输出

被 ≥5 个不同需求真实引用

归档故意只产「建议」、不直接入库,原因有三:① 安全——萃取可能出错,先让人审;② 可反悔——建议是结构化文件,可改可重跑,正式库始终干净;③ 冲突要人拍板——当新代码证明旧决策错了,必须人在环。最终产出两份知识合并建议(业务知识 + 蓝图)

③ 入库 —— 知识的「更新」与「升级」

到这里,才真正动手改写「项目知识库」。整个体系里,只有「入库」这一道门能写正式库——为什么单拎出来?因为「写入正式库」是高风险操作:多人协作时,可能你在整理的同时,同事已往同一份文件写了别的内容。

入库全流程
入库全流程

入库前的安全闸门:先检查远程是否有人并发改了同一份知识(同分支被同事推过?目标分支有别的需求刚归档?)。一旦发现重合,AI 会自动备份 → 拉取最新 → 基于最新状态重算建议 → 再检测一次,才敢落盘——彻底杜绝「一保存把同事的改动覆盖掉」。

更新按固定六步执行(先建档、再更新、最后维护索引,因为索引依赖前面的内容先就位):

步骤

做什么

① 建新知识档案

全新知识正式建档

② 给旧知识打补丁

已有条目增量增强

③ 追加术语 / 背景

补全业务认知层

④ 知识演化(升级关键)把归档登记的「又被引用一次」落账 + 据此自动升级成熟度

⑤ 回填交叉链接

知识之间建立关联

⑥ 更新导航速查表 + 总目录

刷新分类索引 / 总目录

「升级」就发生在第四步。它把「归档」阶段第一条路径登记的引用记录正式落账,并据此把成熟度进行升级:draft → verified → proven。这正是前面那本「留痕账本」的价值兑现处——账本里「真被用过」的记录,是唯一被认可的升级证据,整个飞轮就此闭合。每一步都记进入库台账,带来两个核心价值:可续跑(中途失败修复后重跑,自动跳过已成功的)和可追溯(随时能回答「这条知识是哪次需求、哪次入库建立的」)。

和装载阶段一致,知识的更新和升级信息同步上传一份到飞书文档。

④ 淘汰 —— 让错的、过时的旧知识「退场」

一个只增不减的知识库,迟早会变臃肿——三个月前的最佳实践可能已经过时,当年沉淀的某些知识可能再没人用过。知识不仅要能进,还要能退。

每三个月定期清理一次,把这段时间里一次都没被用到的知识清出去。

淘汰全流程
淘汰全流程

判断依据,正是前面那本留痕账本——每条知识被哪些需求引用过,都有记录。定期清理时扫一遍全库:一条知识若连续三个月零引用,就说明它要么过时、要么本就没价值,移出活跃知识库(淘汰记录留档可溯,不是物理抹掉)。这样库里留下的,永远是真正在被用的「活知识」。

一句话:新知识靠「被用过 N 次」升级,旧知识靠「长期没人用」退场。有进有出,知识库才不会越来越臃肿。

于是闭环成立了:需求做得越多 → 知识库积累的经验越多、越成熟、越干净 → AI 设计方案越快、越少踩坑、越符合团队规矩。这正是那句「用得越多,效果越好;效果越好,用得越多」的复利效应。


五、其实,从头到尾都是同一个故事

把两条线并排放在一起,你会看到它们高度同构:

产品线

技术线

谁在驱动

AI Agent 全程操作

AI Agent 全程操作

砍掉什么

人工撰写 + 跨角色对齐

重复考古 + 反复踩同一个坑

经验装在哪

会议纪要标准 + PRD 错题本

项目知识库

怎么沉淀

纠错自动进规则门禁

经验按引用次数升级、按零引用淘汰

共同内核AI 驱动、人决策、经验自进化

两条线,同一个内核。所以我们想说的从来不是「AI 替代人」,而是——AI 接管重复劳动,人去做需要判断力的决策;团队的经验第一次从「个人的脑子」搬进「系统的记忆」,并且会持续自我进化。


六、回到开头那个会员改版

文章开头那个做了 3 个月的会员改版,如果放到今天的工作流里会是什么样?

运营几场需求沟通会即出结构化纪要,产品 AI 分步生成 PRD、直出 UI,技术带着知识库快速落地——不再是 3 个月,而是 3 周。

开篇那张对比表里的每一个数字,背后都是前面五节讲的这套机制在支撑:6 个角色收敛成 3 个、纯人工撰写变成 AI 出初稿、跨角色衰减变成两端直连、3 个月减少到3周、整体效率目标提升 50%。

而比数字更重要的,是这条端到端 AI 工作流本身是「可自进化」的——每跑完一个需求,它就把新经验沉淀进组织记忆,下一次就更快、更少踩坑。所以这次提速不是终点,而是起点:效率提升不再是一次性的,而是可累积、可复利的——需求做得越多,工作流越聪明,下一个需求就越快。这,才是我们想打造一条「可自进化」工作流的真正意义,也是「既快、又会越来越快」的来处。


七、写在最后

想在自己的团队跑通这件事,我们沉淀出三条经验:

  1. 立「事实来源」让 AI 不臆造(产品靠会议纪要、技术靠真实代码)

  2. 设「质量闸门」让 AI 不敷衍(PRD 检查清单、知识库只读隔离)

  3. 建「沉淀飞轮」让经验自己生长、也自己除旧

技术会迭代,模型会更新,但沉淀下来的领域知识,是更长久的竞争力。当所有工作流都由 AI Agent 驱动起来之后,团队真正拥有的,是一份持续在线、不随人员流动而流失、且每天都比昨天更懂业务的「组织记忆」。

从「一个需求迭代 3 个月」到「会自进化的组织」,我们要打造的从来不是一个工具,而是一条可自进化的端到端 AI 工作流——它由 AI Agent 全程驱动,把经验沉淀成组织记忆,并且每跑一个需求就更懂业务一分。这条路我们会持续走下去,如果你也着迷于「如何打造可自进化的 AI 工作流」这件事,欢迎与我们深入交流。

关于作者

杨乐,侠客汇业务线技术负责人。主导侠客汇技术架构建设与技术先进性演进,负责 AI-Native 研发工作流在业务线的落地。

金丽华,采货侠产品负责人。主导采货侠App、侠客汇App的产品架构建设。负责AI-Native 产品设计工作流体系的搭建和落地。

跳转微信打开

拍图识款在转转的进阶实践

2026年4月15日 18:40

原创 刘天悦 2026-04-15 18:40 北京

转转拍图识款

  • 1、背景

    • 1.1 为什么要做“拍图识款”?

    • 1.2 “拍图识款”的本质

  • 2、技术方案选型

    • 2.1 主流技术方案

    • 2.2 转转技术方案:度量学习

  • 3、“拍图识款”在转转的进阶实践

    • 3.1 整体架构设计

    • 3.2 度量学习训练

    • 3.3 落地成果

    • 3.4 可改进点

  • 4、总结

1、背景

1.1 为什么要做“拍图识款”?

商品挂接是转转二手商品质检与入仓流程中的关键环节,目标是在海量SKU库中完成商品与标准SKU的匹配。传统流程主要依赖人工判断,难以兼顾效率与一致性。在规模化场景下,引入AI识款能力可快速召回Top相似候选,辅助人工完成最终判定与挂接,在保证准确性的同时显著提升效率。

与此同时,在用户侧,“拍图识款”同样是核心能力之一。用户上传包袋图片后,希望系统能够快速识别出相同或相似款式的商品,从而完成浏览与购买决策。因此,在转转的业务中,“拍图识款”主要同时服务于两个关键链路:

●供给侧,商品挂接与入库标准化
●需求侧,以图搜商品(同款)的搜索体验

“拍图识款”并非新问题,早在2014年淘宝推出“拍立淘”,标志着图像检索在电商场景的规模化落地。此后,各大厂均构建了基于深度学习的通用图像检索体系,比如百度的拍照识图、Google Lens等。但是,包袋这个品类中,通用方案仍存在明显局限:

●复杂场景鲁棒性不足,真实业务中,包袋图片常包含背景干扰、局部遮挡等,导致通用模型易出现特征混淆,效果不佳
●细粒度区分能力不足,包袋识别关键在于图案 Logo、包型、材质纹理、颜色等细节差异,通用模型在“极似款式”中的区分能力有限
●缺乏业务闭环能力,识款能力需要全面支持 Badcase 回流、长尾款和新SKU的泛化能力等,通用模型一般难以与业务数据形成深度闭环

基于上述技术与业务约束,转转选择自研“拍图识款”系统,主要原因如下:

●面向二手场景的专用建模能力,以包袋品类率先示范,提升细粒度表达能力与检索稳定性
●持续支持业务闭环,支持 Badcase 驱动迭代、SKU 动态更新及效果可观测能力建设,实现模型能力与业务增长的持续演进

除此之外,在转转业务中,“拍图识款”不仅用于SKU检索,也是“拍图验真”的关键前置环节。其输出的品牌与系列信息会直接影响后续鉴定点位的选择及真假判断。一旦识款出现偏差,误差将在AI鉴定链路中逐步放大,最终影响整体准确性。

1.2 “拍图识款”的本质

用户拍摄一张或多张商品图片后,“拍图识款”算法的目标,是在标准 SKU 库中检索出最相似的图片,并基于其已知 SKU 信息,反推出输入图片对应的SKU。这一过程本质上就是典型的以图搜图(Image Retrieval)任务。

从技术角度来看,该问题可以抽象为一个图像相似度学习问题:对于同一SKU 的不同商品图片,其特征向量在特征空间中的相似度应尽可能高,通常使用“余弦相似度”进行度量(值越接近 1 表示越相似);而对于不同 SKU 的商品图片,其特征相似度则应被显著拉开,从而在检索空间中形成清晰的判别边界。围绕这一目标,“拍图识款”系统通常由三个核心模块构成:

●主体目标检测:从复杂背景中定位并裁剪主体区域,降低背景噪声干扰
●图像关键特征提取:将视觉信息编码为“高维向量”表示,是决定识别上限的关键模块
●向量检索系统:基于海量 SKU 向量库进行高效近邻搜索,实现 Top-K 相似SKU召回

其中,图像关键特征提取是整个系统的核心瓶颈与效果上限决定因素,直接影响识款的准确性与稳定性。其本质是为每一张图片构建一套可用于机器理解与比对的“数字指纹”,实现对视觉信息的压缩表达与语义编码。

转转图像算法团队,以包袋品类作为拍图识款示范,我们发现,包袋图片中隐藏的视觉信息并非无序分布,而是呈现出一套由粗到细的多层次特征体系:

●图案 Logo:决定品牌归属,是快速收敛候选范围的首要信号
●包型(形状):定义基础款型类别,是识别的“骨架级特征”
●材质与纹理:反映工艺与版本差异,是重要的细粒度补充信号
●五金刻印:提供高区分度信息,用于区分同系列的不同款式
●颜色:用于区分配色或限定版本

image
包袋关键部位

这些信息从整体到局部逐级展开,形成一个稳定的层次化视觉表征体系,共同构成包袋的“数字指纹”。因此,一个高质量的图像特征提取模型,本质上并非单一视觉因素的编码,而是对图案Logo、包型、五金刻印等多种视觉信号进行融合建模后的综合表达结果,其目标是在压缩信息的同时最大化类别可分性与检索稳定性。

2、技术方案选型

2.1 主流技术方案

拍图识款的主流技术路线,主要分为两类:分类模型和检索模型。

由于包袋品类具有明显的“长尾特征”,SKU 规模达到“百万量级”,若采用分类方案,本质上会面临类别空间过大、类别不均衡以及泛化能力不足等问题,因此整体效果很差。当前工业界主流方案,已基本统一为以检索模型为核心的技术架构[1],如下图所示。

image
基于检索模型的识款流程设计

从系统角度来看,拍图识款的效果主要受两方面因素影响:一是图像关键特征向量的表达质量,二是大规模向量库的检索效率与召回能力,本篇主要围绕前者展开。

在图像特征向量学习层面,对比学习(Contrastive Learning)是当前主流技术范式之一。该方法通过拉近同类样本、拉远异类样本,在特征空间中构建具有判别能力的表示。在转转的多个业务场景中,对比学习已得到广泛应用。

● 在风控业务中,采用基于 CLIP[2] 的对比学习模型,结合 Milvus 向量检索系统,实现风险图片样本的高效召回与匹配

● 在搜推业务中,基于双塔(Siamese / Two-Tower)结构的对比学习方法,将商品图片映射为向量表示,用于推荐系统召回模块,在线上带来了超过 10% 的下单提袋率提升
● 在质检业务中,通过引入自监督对比学习思想,数据增强自动构建正负样本对,在弱监督标注的情况下提升多种图像模型的泛化能力与细粒度识别能力

总体来看,对比学习已成为图像表征学习中的基础方法之一,并在转转不同业务线中承担统一的“视觉语义对齐”能力。

2.2 转转技术方案:度量学习

度量学习(Metric Learning)与对比学习本质上都属于“表示学习”范式,核心目标都是学习一个Embedding(向量表示)空间,使得相似 SKU 在特征空间中距离更近,不相似 SKU 距离更远。但二者在监督信号与优化目标上存在明显差异:

●对比学习通常以自监督或弱监督为主,通过数据增强等方式构造正负样本对,学习的是通用视觉表征能力,其核心目标是提升表示质量与泛化能力。
●度量学习则更依赖显式标签监督,通过构造样本间的距离约束,直接优化“类间可分性”与“类内紧致性”,本质上是在 Embedding空间中学习更清晰的判别边界,对细粒度识别任务更为敏感、可靠。

在包袋拍图识款场景中,这种差异显得尤为明显。

对于大量“外观极其相似”的 SKU,仅依赖通用表征学习的对比学习方法,容易出现特征聚合不充分的问题,而基于度量学习的方法则能够通过“强监督信号”,显式拉开细粒度 SKU 间的边界,从而获得更稳定的判别能力。此外,转转在包袋品类中积累了海量的“高质量”、“带SKU标签”的商品图片数据,使得基于监督信号的度量学习具备良好的数据基础。综合业务特性与数据条件,最终我们选择以“度量学习”为主的技术路线,打造转转拍图识款系统。

3、“拍图识款”在转转的进阶实践

3.1 整体架构设计

转转“拍图识款”系统整体采用检索式视觉理解架构,整体架构设计如下:

image
转转拍图识款的架构设计

用户上传商品图片后,系统首先通过主体目标检测与分割模块,从复杂背景中提取出包袋主体区域,以降低环境噪声对特征表达的干扰。随后,主体区域进入特征提取模块,通过识款 Embedding 网络将图像编码为“高维向量”表示,完成从“像素空间”到“语义向量空间”的映射。在向量空间中,系统通过与包袋向量数据库进行相似度检索,实现 Top-K 候选 SKU 召回。向量数据库中同时存储SKU Embedding 与 SKU 结构化属性信息,用于后续相似图片匹配与结果约束。最终,实现“以图搜图 → SKU 识别”的完整闭环链路。

在“拍图识款”整体链路中,为了提升复杂真实场景下的检索效果,我们在系统设计上重点做了三点优化:

1)主体目标检测 + 分割增强的双阶段建模
为降低背景干扰,系统首先需要具备对图像中主体目标的定位能力,并提取稳定的主体特征表示。但在实际实验中我们发现,仅依赖目标检测仍不足以应对复杂场景(如背景复杂、遮挡严重等)。因此,在检测模块之后进一步引入一个轻量级目标分割模型(segmentation model),对主体区域进行更精细的边界提取,从而显著提升特征纯度与识别稳定性。

2)依赖大规模 SKU 底库的长尾覆盖能力
拍图识款的效果,在很大程度上由 SKU 底库的规模与质量决定。SKU 种类越丰富、单SKU数量越多,模型在检索阶段的可匹配空间越完整。这一点正是转转在二手奢侈品领域中的核心优势之一,依托长期积累的真实交易数据与商品沉淀,构建了高覆盖度的 SKU 标准数据库,从而提升了整体识别的召回能力与长尾覆盖能力。

3)向量库的“向量 + 标量”联合检索机制
在检索系统设计上,我们不仅依赖图片向量的相似度,同时引入 SKU 结构化属性(标量信息),构建向量 + 标量的联合检索框架。

● 向量检索,负责根据图片相似度召回 

● 标量检索,包括品类、品牌、系列等,负责约束检索空间

通过两者结合,可以在保证召回效率的同时,提高结果的业务一致性与可解释性。

3.2 度量学习训练

基于度量学习的包袋拍图识款,是在百万量级包袋 SKU 中完成高精度检索匹配,主要包括数据构建与挖掘、模型训练及工程优化三个方面。

image
度量学习训练流程

3.2.1 数据构建与挖掘

1)度量学习Scaling Law
实验表明,识款模型性能与度量学习的训练数据规模呈显著正相关关系,构建百万量级 SKU + 单SKU多视角图像的训练集是模型性能的基础。

2)Badcase 驱动的数据增强
与通用数据增强方法不同,本文采用基于误判样本(Badcase)的定向优化策略:
● 收集模型高频误判样本对
● 分析误判原因(遮挡、光照、角度等),构造针对性增强数据
该方法显著提升了模型在复杂场景下的鲁棒性。

3)困难样本挖掘
在每个 batch 内进行在线困难样本挖掘(Online Hard Mining)[3],该策略使模型重点优化最易混淆的样本对,从而提升整体区分能力。

训练过程中采用 Anchor-Positive-Negative(APN)结构,Anchor(当前样本)、Positive(同 SKU 样本)、Negative(不同 SKU 样本)。其中,Negative 样本采用相似样本挖掘策略,以增强模型对细粒度差异的判别能力。

3.2.2 模型训练trick

1)相似度函数选择
采用 Cosine Similarity 作为相似度度量,其优势包括:对特征尺度不敏感、在高维空间中更稳定及向量归一化兼容等

2)学习率调度策略
采用逐步衰减(Learning Rate Decay)策略,初期使用较大学习率,加速收敛;后期使用较小学习率,精细优化 Embedding 空间。该策略有助于提高模型在细粒度区分任务中的性能。

3)度量学习损失函数
采用典型度量学习损失函数(如Triplet Loss[4]/Circle Loss[5]),该类损失直接优化样本之间的距离关系,相较于分类损失函数,更适用于大规模类别场景。

3.2.3 工程优化

1)推理服务优化
采用模型服务框架torchServe进行部署,实现多实例并行推理、批量请求处理,从而满足线上高并发需求。

2)向量检索加速
基于 Faiss 构建离线向量测试库,使用Faiss-GPU 版,在百万量级SKU底库数据下,实现30—50倍检索效率加速,便于快速筛选最优模型

3)索引更新机制
为适应动态数据增长,系统支持增量索引更新。为平衡实时性与系统开销,我们采用“小时级”更新策略。

4)阈值动态调整
在实际应用中需对 Cosine 相似度进行归一化处理,将相似度分数映射到[0,1]之间(原始范围 [-1, 1]),业务可根据需求动态调整相似度阈值。

3.3 落地成果

主要落地场景有转转商品挂接、转转APP拍图识款(回收业务)等 

1)转转商品挂接页面

image

2)转转APP拍图识款页面

image

在拍图识款效果评测中,自研模型在Top-4准确率,超过三方8%以上,特别在复杂背景图片上要明显好于三方(一线业务反馈)。

3.4 可改进点

当前包袋拍图识款仍存在“尺度无法识别”问题,由于缺乏参考物,不同拍摄条件下的包袋尺寸(大中小号)难以统一建模,后续可引入标准参照物或显式尺度建模。此外,细粒度差异主要集中在五金、纹理等局部区域,需增强局部特征建模能力,未来可进一步探索多模态识款方法,引入文本与结构化属性信息,实现“图+文”联合检索。

4、总结

“拍图识款”本质是以图搜图,通过主体检测、特征提取与向量检索,在海量SKU数据库中完成“款式匹配”。其核心在于学习图像Embedding,构建细粒度SKU图片的“数字指纹”。在包袋场景中,需融合图案Logo、包型、材质纹理、颜色与五金等特征,实现多层次表达。相比分类方案,检索方案更适合大规模长尾SKU。转转采用以“度量学习”为核心的技术方案,通过监督学习“类内紧致性”与“类间可分性”,并结合困难样本挖掘,提升细粒度识别能力。在工程层面,结合TorchServe与增量索引更新机制,实现高效线上服务。整体技术方案已在转转商品挂接与C端识款等场景落地,未来将探索多模态融合以提升识别效果。

参考资料 

[1] Deep Ranking for Image Similarity. 

[2] Radford A, et al. Contrastive Language–Image Pre-training (CLIP). 

[3] Hermans A, et al. In Defense of the Triplet Loss for Person Re-Identification. 

[4] Schroff F, et al. FaceNet: A Unified Embedding for Face Recognition and Clustering. 

[5] Wang W, et al. Circle Loss: A Unified Perspective of Pair Similarity Optimization.

跳转微信打开

一条命令让CDN视频带宽成本降低90%!!!

2026年2月5日 18:30

原创 邹泉安 2026-02-05 18:30 广东

本文主要探究在 HTTP 场景下 MP4 视频频繁产生多次 Range 请求的原因,并分析其对带宽和播放性能的影响。

  • 1 背景

  • 2 现象定位

    • 2.1 问题流量定位

    • 2.2 流量使用验证

  • 3 问题探究

    • 3.1 MP4 文件结构

    • 3.2 浏览器播放流程

    • 3.3 源码分析

    • 3.4 测试验证

  • 4 分析原因

    • 4.1 为什么一开始会出现3个206请求?

    • 4.2 为什么会发起多个206请求,且Range范围来回跳动?

    • 4.3 为什么使用ffmpeg处理视频后能解决这个问题?

  • 5 总结

  • 6 参考

1 背景

一个春暖花开的午后,发生了一个诡异的现象:

IT同学:哪个域名流量这么大,太占用公司办公网资源了!
某业务:想问下这个问题需要怎么解决呢,我们已经遇到好几例了,上次有个店员一天消耗了60G,这个店员130G 
我:收到CDN带宽告警,🤔哪个cdn域名用了这么多带宽啊!

2 现象定位

2.1 问题流量定位

通过CDN流量分析,定位到top流量消耗都是几个MP4视频。 点击流量最高的视频链接分析了下,是一个大小1G,视频时长约30分钟的MP4视频

于是找业务同学确认:

我:这个视频是做什么用的啊?
业务同学:这是一个学习培训视频,推送给了2500人学习观看。
我:嗯?不对啊,CDN监控显示花费流量120TB,如果2500人完播看完一个视频,正常应该是 2500x1g =2.5TB,这多出的50倍流量怎么来的?

2.2 流量使用验证

我通过谷歌浏览器访问了业务上传的另一个视频(视频大小500M时长40分钟),观看视频并开启F12分析下流量使用

完播居然花了8G,发送了3700个206请求!!!!

现象:

  • 开始播放后,会出现3个206请求。

  • 第三个请求发完后,浏览器随时间发起多个206请求

  • 请求来来回回Range

我:这不行啊,我赶紧ai、百度、google各种搜索
发现通过命令ffmpeg处理视频可以解决这个问题
ffmpeg -i bad.mp4 -c copy -movflags faststart good.mp4
  • 将新视频上传,f12分析视频

  • 206请求只有一个了

  • 且多206请求现象消失

  • 完播视频流量消耗=原视频大小

ffmpeg能解决该问题,但长视频还是将其转为流媒体格式,推动业务改进后流量监控如下图

3 问题探究

四个问题

  • 为什么一开始会出现3个206请求?

  • 3个206请求后,为什么会发起多个206请求?

  • 为什么请求头Range会来回跳跃?

  • 为什么使用ffmpeg处理视频后能解决这个问题?

要分析该奇异现象发生原因就得知道整个播放流程是怎么运作的。

3.1 MP4 文件结构

MP4 文件由多个 Box(盒子)组成,主要包括:

MP4 文件结构:
┌─────────────────────────────────────┐
│ ftyp (文件类型)                      │  ← 文件开头
├─────────────────────────────────────┤
│ mdat
─────────────────────────────────────┤
│ moov (元数据)                        │  ← 可能在开头或结尾
│  ├─ mvhd (文件头信息)                │
│  ├─ trak (视频轨道)                  │
│  │   ├─ stco (Chunk偏移表)          │  ← 记录数据位置
│  │   ├─ stsz (样本大小表)            │  ← 记录每帧大小
│  │   └─ stsc (样本到Chunk映射)       │  ← 记录帧的分布
│  └─ trak (音频轨道)                  │
│      ├─ stco (Chunk偏移表)          │
│      ├─ stsz (样本大小表)            │
│      └─ stsc (样本到Chunk映射)    │
└─────────────────────────────────────┘

关键点:

  • moov box 包含了所有的索引信息(类似目录)

  • mdat box 包含了实际的音视频数据

  • 播放器必须先读取 moov 才能知道数据在哪里

3.2 浏览器播放流程

从Media信息得知Chrome 浏览器使用 FFmpegDemuxer 来解析读取 MP4 文件,参考谷歌浏览器源码,播放流程如下:

3.3 源码分析

mov_find_next_sample(这一个函数返回的是下一个样本位置):

static AVIndexEntry *mov_find_next_sample(AVFormatContext *s, AVStream **st)
{
..........
..........
    // 遍历所有流,找到最佳样本
for (i = 0; i < s->nb_streams; i++) {
        AVIndexEntry *current_sample = &index_entries[current_index];
        int64_t dts = current_sample->timestamp;
        // 
if (dtsdiff <= AV_TIME_BASE && current_sample->pos < sample->pos) {
            // DTS 差 ≤ 1 秒,选择位置靠前的(减少 seek)
            sample = current_sample;
        } elseif (dtsdiff > AV_TIME_BASE && dts < best_dts) {
            // DTS 差 > 1 秒,选择 DTS 最小的(保证顺序)
            sample = current_sample;
            ..........
..........
        }
    }
return sample;
}
}

在mov_find_next_sample函数中还有一个开关interleaved_read:

在解复用器层对多个轨道的包进行交错。对于交错不良的文件,这可以防止由于不同轨道之间包的大间隙而引起的播放问题,因为MOV/MP4文件对包的放置没有要求。然而,对于非常交错不良的文件,这可能会导致过多的寻道操作,因为需要在轨道之间寻道,所以禁用此功能可能会防止I/O问题,但代价是可能影响播放。

理想情况下,一个交错良好的 MP4 文件 会将音频和视频数据包按照时间顺序交替排列:

[视频包1] [音频包1] [视频包2] [音频包2] [视频包3] [音频包3] ...

这种交错存储方式的主要优点包括:

  • 减少磁盘访问次数:播放器能连续读取音视频数据,提高读取效率。

  • 降低播放缓冲区需求:播放时能够平滑加载音视频数据。

  • 支持渐进式下载和播放:支持按需下载,提升流媒体性能。

然而,如果音视频数据没有交错,而是集中存储,比如:

[视频包1] [视频包2] [视频包3] ... [音频包1] [音频包2] [音频包3] ...

会带来以下问题:

  • 频繁寻址:播放器需要在视频和音频数据之间跳转,增加磁盘访问次数。

  • 大量 HTTP Range 请求:每次跳转都需要发起新的 HTTP 请求,降低性能。

  • 播放不稳定:频繁请求数据会导致卡顿和延迟,影响用户体验。

3.4 测试验证

由于谷歌浏览器使用的是 FFmpegDemuxer 解码并读取视频信息,其底层依赖于 FFmpeg 代码实现,只是在上层进行了浏览器的缓冲/预读封装。

测试视频:longbad.mp4(该视频存在较差的音视频交错问题)

测试工具:FFmpeg(模拟谷歌浏览器的解码处理过程)

本次测试旨在评估 interleaved_read 参数对视频播放的影响,并借助ffmpeg工具分析视频多206的问题。

交错读取(Interleaved Read):默认情况下,FFmpeg 会将音视频数据交错存储,Interleaved为1;
ffmpeg  -i https://xxxx/longbad.mp4 -ss 60 -t 5.0 -y output.mp4 -loglevel trace 2>&1 | grep "Range"
-i https://...:从远程服务器读取输入文件
-ss 60:从视频的第60秒开始
-t 5.0:截取5秒的片段
-y:覆盖输出文件
output.mp4:输出文件名
通过wc -l统计发现请求了5078次!,看5s的视频请求了5078次。

结合cdn日志和longbad视频的音视频轨道分析

  • Range来回跳动,在60s时刻从5967030跳到46622680

  • 相同时间范围,音频offset和视频offset距离很远

非交错读取(Non-interleaved Read):通过设置 -interleaved_read 0,FFmpeg 会将音频和视频数据分开读取。
ffmpeg -interleaved_read 0 -i https://xxxx/longbad.mp4 -ss 60 -t 5.0 -y output.mp4 -loglevel trace 2>&1 | grep "Range"
通过wc -l统计发现请求了3只请求了三次

4 分析原因

4.1 为什么一开始会出现3个206请求?

原因:moov box 在文件末尾

moov存着视频的索引信息,详细看MP4 文件结构

正常的 MP4 文件播放流程:

读取 ftyp+moov → 在头部直接读mdat ----一个206

但问题视频的 moov 在文件末尾

导致:

1. 读取 ftyp和moov →  不在头部啊去尾部查    -----第一个206
2. 读取尾部moov    →                     -----第二个206
3. 开始播放视频    →                      -----第三个206 

4.2 为什么会发起多个206请求,且Range范围来回跳动?

原因:视频文件交错不良 + FFmpeg 的读取策略

交错不良的文件布局

通过获取视频文件offset的信息制作了一个图

音视频物理位置交错图情况:
X轴 = Packet在文件中的物理顺序(按pos(offset)排序后的索引)
Y轴 = Stream类型(0=视频,1=音频)
每个条形 = 一个packet
颜色 = 红色=视频packet,青色=音频packet
可以看到有一大片音频在前边
[音频包1] [音频包2] [音频包3] ...  ... [视频包1] [视频包2] [视频包3]

FFmpeg 的读取策略导致来回跳跃

mov_find_next_sample() 的选择逻辑

  • 时间差 ≤ 1 秒时,优先选择位置靠前的帧

  • 但交错不良导致"位置靠前"的帧距离offset很远

举例
音视频两个offset
A1 下一个V0
选择策略
时间轴(微秒):
0        10000      20000      30000      40000
├─────────┼──────────┼──────────┼──────────┤
│                    │          │
│                    A1         V0
│                 (23219)    (33333)
│                    │          │
│                    └──10114──┘
│                    (差值 < 1秒)
│
A0 (0)
V0 (0)
当视频帧之间时间<1秒 会选择最小的offset( pos )
这就导致交错不良的文件,DTS 差小但文件位置差大,然后来回请求

4.3 为什么使用ffmpeg处理视频后能解决这个问题?

原因:fmpeg对视频处理后,会对音视频的位置进行重新编排(流媒体除外),底层默认处理

处理视频文件后的音视频交错图

ffmpeg -i bad.mp4 -c copy -movflags faststart good.mp4
-i 输入指定文件
-c -copy  流拷贝
- movflags faststart 将视频moov提提前
ffmpeg会对其物理位置进行重新编排!!!
av_interleaved_write_frame() (libavformat/mux.c)  
    ↓
ff_interleave_packet_per_dts() (libavformat/mux.c) 
    ↓
static int interleave_compare_dts(AVFormatContext *s,
                                  const AVPacket *next,
                                  const AVPacket *pkt)
{
    AVStream *st  = s->streams[pkt->stream_index];
    AVStream *st2 = s->streams[next->stream_index];
    // 1. 比较 DTS(转换到统一时间基)
    int comp = av_compare_ts(next->dts, st2->time_base,
                            pkt->dts, st->time_base);
    // 2. 处理音频预加载(audio_preload)
if (s->audio_preload) {
        int preload  = st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO;
        int preload2 = st2->codecpar->codec_type == AVMEDIA_TYPE_AUDIO;
if (preload != preload2) {
            // 音频包提前一点时间
            int64_t ts = av_rescale_q(pkt->dts, st->time_base, AV_TIME_BASE_Q)
                       - preload * s->audio_preload;
            int64_t ts2 = av_rescale_q(next->dts, st2->time_base, AV_TIME_BASE_Q)
                        - preload2 * s->audio_preload;
            comp = (ts2 > ts) - (ts2 < ts);
        }
    }
    // 3. DTS 相同时,按流索引排序
if (comp == 0)
return pkt->stream_index < next->stream_index;
return comp > 0;
}

5 总结

    流媒体格式(如HLS)在带宽使用和播放流畅度上更优,但改造成本高。MP4格式因兼容性强和成本较低,仍是主流选择。综合考虑使用场景和成本,我们选择:

  • 短视频统一使用 FFmpeg 处理,确保 moov box 在文件开头,优化音视频交错,避免频繁的 Range 请求。

  • 长视频采用 HLS 等流媒体格式,按需加载视频片段,提升播放流畅度和带宽利用率。


6 参考资料

[1]

The investigation of excessive FFmpeg requests: https://blog.dreamfever.me/posts/2024-06-09-poor-performance-of-ffmpeg-i-url/#reference

[2]

endless canceled http requests when playing an mp4 in a <video> tag: https://issues.chromium.org/issues/40292515

[3]

ChromiumSrouce: https://source.chromium.org/chromium/chromium/src/+/main:third_party/ffmpeg/libavformat/mov.c;l=11048;bpv=1;bpt=1

[4]

FFmpegSoure: https://github.com/FFmpeg/FFmpeg/blob/94f2274a8b61438572f0873ccf430e55ce0e0e2b/libavformat/mov.c#L9767-L9795

关于作者 邹泉安,转转运维部。

想了解更多转转公司的业务实践,欢迎点击关注下方公众号:

跳转微信打开

2025 转转技术团队精选文章汇总

2025年12月31日 15:07

原创 转转技术团队 2025-12-31 15:07 北京

在 2026 年春节将至之际,我们从中精选了一批年度文章:既有架构与性能的硬核实战,也有前端、移动端、测试与效率工具的体系化沉淀。希望这份精选文章能成为你回顾与进阶的捷径:少踩坑、少走弯路,多一点确定性与灵感。

时光翻篇,技术却从不按下暂停键。回望 2025 年,转转技术团队把“能跑”进一步做到“跑得稳、跑得快、跑得省”。从线上稳定性建设到高并发秒杀,从亿级流量开放平台的架构演进到亿级核心表的字段扩展,我们在真实业务压力下打磨系统韧性;从“慢 SQL”治理到统一缓存 Easy-cache、从 MyBatis-Plus 的踩坑复盘到深度实战指南,我们用工程方法把效率与规范沉淀成可复用的能力。与此同时,AI 也不再只是概念:LLM 在主搜向量召回场景落地,让“理解用户意图”真正进入生产系统;在研发协作上,从日志插件到 Cursor 提效,再到自动化走查、压测巡检、双库同步工具与 AI 规则驱动测试,我们让工具链和流程一起进化,把时间还给创造。

在过去的这⼀年⾥,转转研发中⼼三个公众号《转转技术》、《⼤转转FE》和《转转QA》共计发表百余篇技术⽂章,涉及各个部⻔的⼀线实践经验。在 2026 年春节将至之际,我们从中精选了一批年度文章:既有架构与性能的硬核实战,也有前端、移动端、测试与效率工具的体系化沉淀。希望这份精选文章能成为你回顾与进阶的捷径:少踩坑、少走弯路,多一点确定性与灵感。

愿你在阅读的每一篇,都能找到可直接落地的方案与可迁移的方法论;也欢迎把它分享给同样关心工程实践与 AI 落地的朋友,一起交流、共同成长。新的一年,我们继续在技术与生活的交汇处,把复杂问题拆解成清晰路径,把用户体验做得更好。

祝大家新年快乐,阖家幸福,身体健康,工作顺利!


01 要想线上事故少,系统稳定性建设得搞好

系统的稳定性建设是一个庞大的话题,其贯穿了产品研发整个流程:需求阶段、研发阶段、测试阶段、上线阶段、运维阶段。从系统规模上看,小到单个系统,大到一个域的系统集,再大到支撑整个公司全业务的系统全集,都离不开系统稳定性建设。大家日常工作中可能会有一些关于系统稳定性的疑惑,比如经典三问“是什么、为什么、怎么做”,本文从一个后端研发的视角,来和大家聊一聊系统稳定性建设的总结与思考。(阅读原文)


02 高并发下秒杀系统的设计

在电商这片红海,秒杀活动无疑是屡试不爽的流量密码、销量利器。然而,在应对其并发请求时,其中的设计门道暗藏玄机。并发量小,数据库单表便能一夫当关,稳保活动无虞;一旦碰上爆款引爆流量,并发呈井喷式增长,单表瞬间独木难支,此时,一套高并发 “抗压” 组合拳必不可少。接下来,咱们就一起深挖业界那些屡建奇功的妙招,直击高并发痛点,重点解析其中两大 “硬核” 方案,助你轻松拿捏秒杀场景的技术难点。(阅读原文)


03 打造亿级流量开放平台的架构演进与工程实战

开放平台不是简单的API接口聚合,它是一个需要承载高流量、高并发的系统,是边界清晰的“操作系统”,也是具备持续演进能力的产品级架构体系。真正有生命力的开放平台,一定是 “稳定、扩展、安全、生态” 兼备的长期主义架构产物。本文将结合工程实战,从整体架构拆解到底层技术演进,逐步解构如何打造高性能、高可用、可持续演进的亿级流量开放平台系统。(阅读原文)


04 亿级核心表如何优雅扩展字段?中台团队实战经验揭秘

亿级数据的核心表新增一个字段,远不止一句简单的“ALTER TABLE”,锁表风险、页分裂、索引性能衰减……每一个问题都可能引发线上事故。如何在不影响业务的前提下,只需简单的配置,即可实现字段的动态扩展?本文将带你揭秘中台团队的实战解决方案。(阅读原文)


05 加Log就卡?不加Log就瞎?”——这个插件治好了我的精神内耗

本文提出的优化方案突破传统日志分级思维的桎梏,创新性地提出双轨制日志管理体系:将日志划分为功能型与诊断型两类,前者确保核心业务脉络的持续可见,后者实现按需动态管控。通过编译期字节码增强技术,我们实现代码行级别的精准控制,配合IDE插件的可视化操作,使开发人员能够像调试断点般自由启停日志输出。这种"外科手术式"的日志管理,既避免了传统方案"一刀切"的弊端,又赋予系统在高负载场景下的弹性适应能力。(阅读原文)


06 Easy-cache:统一缓存解决方案,让开发人员告别重复的缓存代码

本文介绍 Easy-cache 统一缓存解决方案,旨在让业务开发“只写注解、不写缓存逻辑”。它基于 Spring AOP 提供注解式读写缓存能力,默认采用 Redis 集群 + 本地二级缓存的多级架构,并通过健康度监控实现动态升降级与容错。为解决一致性与击穿等问题,方案使用 Redis-Hash + Lua 脚本原子操作实现分布式锁与“标记删除/弹性过期”,在可控不一致窗口(默认 1.5s)内保障最终一致,必要时可切换实时一致;同时通过 Lua 预加载与 EVALSHA 降低高并发下的网络开销。(阅读原文)


07 "慢SQL"治理的几点思考

本文围绕“慢SQL治理”做阶段性复盘:从一次线上慢查询告警切入,解释 MySQL 优化器如何基于 IO/CPU 成本选择执行计划。指出“加了索引也不生效”的常见原因(区分度、数据分布与回表代价),并提醒关注表统计信息与内存/页碎片对性能的影响。同时结合案例总结前缀索引在唯一约束下的坑、索引合并的适用场景,以及磁盘负载、长事务等“SQL本身没问题但仍变慢”的系统性因素,为排查与治理提供思路。(阅读原文)


08 MyBatis-Plus踩坑血泪史:那些年我们踩过的坑!

本文以生产事故为线索,总结 MyBatis-Plus 在高并发、容器/K8s 等真实环境里最易“暴雷”的坑:雪花ID重复、批量插入乱序、枚举落库不按 code、连续大写导致驼峰映射错位、批量写入自动填充失效、复杂 JSON/Map/List 字段写入丢失或格式异常,并给出可落地的排查与修复思路(如显式配置 workerId/改用自增或外部ID、控制批处理刷新/自定义批量SQL、@EnumValue、@TableField 明确映射、批量前手动填充、统一序列化或结构拆分)。(阅读原文)


09 MyBatis-Plus 深度指南:从基础到实战,让 DAO 层开发效率起飞

本文是一份 MyBatis-Plus 的“从能用到用好”实战指南:先用“零侵入增强”的视角解释其价值——在保留 MyBatis 灵活性的同时,把单表 CRUD、条件构造等能力工具化,并通过拦截器/插件补齐安全与规范(分页、全表更新/删除拦截、乐观锁、多租户等)。进一步给出工程化落地方案:在微服务/RPC 场景用自定义 QueryCondition 替代 QueryWrapper,配套 Builder 实现类型安全的查询、排序、分页与字段选择,并增加全表扫描/全表更新拦截,形成可复用的 DAO 分层架构。(阅读原文)


10 LLM在转转主搜向量召回的应用

本文介绍 LLM 在转转主搜“向量召回”中的落地实践,聚焦多品类(N 品类)因黑话/隐性术语导致的“少无结果 query”问题:传统 ES 文本硬匹配难以理解如“小痰盂”等圈内表达。团队选择“不造大模型”,走“中小型领域模型 + 极小任务模型”的敏捷路线,采用“离线训练—在线推理”架构:离线用私域支付日志约 30 万条 query-商品对做 Post Training 与 LoRA 注入业务知识;再用硬负样本+对比学习(InfoNCE)提升向量区分度;最后通过知识蒸馏把 qwen2.5-7B 能力迁移到 BERT,将模型体积压缩到约 1/60、显著提升推理速度,并在线上提升召回全面性与筛选精准度。(阅读原文)


11 转转前端覆盖率优化方案

通过创新性引入NYC工具链,彻底解决了Vue多版本混编场景下的代码覆盖率失真难题!方案突破传统插桩技术局限,实现三大升级:

精准解析:基于AST的源码行号映射,攻克Vue2/3混合项目、装饰器语法等复杂场景的覆盖率误报问题;

智能合并:独创跨Commit覆盖率数据继承算法,确保增量代码统计连续性;

性能飞跃:通过Clover格式解析优化,将报告生成速度提升300%。(转转前端覆盖率优化方案)


12 188工时压到149!揭秘我们如何用Cursor让前端效率狂飙

通过Cursor实现前端开发效率飙升21%,188工时压至149工时!揭秘五大核心场景:1)原型图秒变路由代码,命名规范自动生成;2)UI设计稿精准转DOM,接口字段智能匹配;3)Mock数据与TS类型一键生成;4)复杂组件AI智能拆分,主文件严控800行;5)动效逻辑深度优化。经验表明:AI最擅长结构化任务(提效60%),而复杂业务逻辑仍需人工把控。(188工时压到149!揭秘我们如何用Cursor让前端效率狂飙)


13 RN技术在转转的落地与实践 (前端篇)

从Webview技术栈转向React Native的探索,通过混合开发模式实现了高效迁移与性能提升。文章详细介绍了工程架构选择(Expo CLI+自定义脚本)、组件库适配(基于react-native-elements二次开发)、多包拆分策略(基础包+业务包)及热更新方案。创新性利用AI辅助Vue2到RN的代码转换,通过精准提示词工程和组件映射知识库提升迁移效率。实践数据显示RN页面加载时间从2137ms降至842ms,业务转化率提升4%,兼具热更新能力与原生体验。(RN技术在转转的落地与实践 (前端篇))


14 转转UI自动化走查方案探索

创新性地通过结构化数据比对(而非传统图像识别)破解UI走查效率难题!该方案将Figma设计稿JSON与前端DOM树归一化为同构数据,独创节点间距算法处理CSS margin折叠、行高等复杂场景,实现像素级精准比对。核心突破在于:1)AST解析解决Vue2/3混编覆盖率失真;2)动态调校px2rem误差;3)智能合并padding提升比对稳定性。实践数据显示走查效率提升300%,异常标注耗时从3小时压缩至30分钟。这不仅是一套工具,更重新定义了"设计-开发"协作范式——让主观的UI还原度变得可量化、可追溯,推动团队在规范层面达成共识。(转转UI自动化走查方案探索)


15 Android图片编辑器的自研之路:从需求痛点到技术突破

团队针对仓内质检场景的特殊需求,自主研发了一套高效精准的图片编辑器,彻底解决了传统方案无法满足的四大痛点:多图批量编辑、旋转后框线保持、撤销重做功能和自定义标注需求。基于Android原生API构建的编辑引擎,创新性地采用命令模式管理操作历史,结合Matrix变换实现精确的坐标系转换,并通过状态管理机制支持多图无缝切换。(Android图片编辑器的自研之路:从需求痛点到技术突破)


16 测试工程师的「武器库」:这8款效率神器让你告别无效加班

在软件研发这条高速运转的流水线上,测试工程师往往站在最靠近“质量风险”的位置。一边要保障功能正确、系统稳定,一边还要应对接口调试、抓包分析、数据校验、日志排查等大量重复却不可或缺的工作。时间被切碎、精力被消耗,无效加班也就成了不少测试同学的日常写照。

但问题的根源,往往不在于工作不努力,而在于工具是否趁手、方法是否高效。选对工具,很多原本耗时耗力的操作,其实可以被大幅压缩,甚至“一键完成”。这篇文章,正是基于真实测试场景,系统整理了一份测试工程师的「效率武器库」——从浏览器插件、抓包工具,到 IDE 插件与日常辅助工具,帮助你减少机械劳动,把时间和精力真正留给分析、判断和质量本身,告别无意义的加班。(测试工程师的「武器库」:这8款效率神器让你告别无效加班)


17 例行压测巡检-设计&实践

在服务规模不断扩大、系统复杂度持续提升的背景下,单纯依赖人工经验和被动响应的质量保障方式,已经难以支撑业务的稳定运行。压测是否执行、结果是否有效、问题是否被及时发现,往往依赖人工巡查与事后补救,不仅效率低,也容易留下隐患。

基于此,我们设计并落地了「例行压测巡检」这一主动式、自动化的服务质量保障能力。它不再等问题暴露后再处理,而是通过自动巡检、智能分析和精准通知,持续感知服务健康状态,将风险前移、将执行自动化。该项目旨在构建一套可扩展、可复用的智能化质量保障体系,推动服务稳定性从“人为保障”向“系统保障”演进,为业务持续增长提供可靠底座。(例行压测巡检-设计&amp;实践)


18 告别人工搬运!TiDB/MySQL双库同步工具如何为业务提效100%?

你是否也经历过这样的时刻:测试执行被迫中断,只因为线上和线下一个不起眼的配置不一致?一次看似简单的问题排查,跨 QA、PM、RD 多方沟通,最终发现只是“少配了一项”,却轻易消耗了 1–2 个小时的测试时间。

这篇文章正是从这些真实而高频的卡点出发,拆解配置不一致给测试效率、产品质量和系统安全带来的连锁影响。我们逐步意识到,问题不在某一次配置失误,而在“数据如何在不同环境间被可靠同步”这件事本身。于是我们探索并落地了一套更通用、更安全的数据同步能力。目标只有一个:数据同步不是复制粘贴,而是业务流程的隐形引擎,让配置和数据不再成为测试的隐形阻力。(告别人工搬运!TiDB/MySQL双库同步工具如何为业务提效100%?)


19 从"人工催办"到"AI 规则驱动":我们如何解放测试团队的生产力

很多测试同学在承担测试工作的同时,还被动接过了项目管理的职责,逐渐变成了项目里的“人工待办清单”。我们靠记忆去记节点、靠人工去催进度,结果是:真正该投入在深度测试、质量分析和风险识别上的精力,被流程管理一点点消耗掉。

这篇文章正是从这一真实困境出发,讲述我们如何意识到“问题不在个人能力,而在管理方式本身”,并尝试用一种更轻量、更贴合日常协作习惯的方式,把项目管理从“人肉记忆”交还给规则和工具。通过让规则在项目群中主动提醒、主动校验、主动推动事情发生,我们希望减少无效消耗,让测试回归测试,把时间和精力用在真正有价值的质量工作上。(从&quot;人工催办&quot;到&quot;AI 规则驱动&quot;:我们如何解放测试团队的生产力)

想了解更多转转公司的业务实践,欢迎点击关注下方公众号:

跳转微信打开

回收团队基于Cursor集成MCP的智能代码修复提示词生成实践

2025年12月26日 18:20

原创 刘雅斌 2025-12-26 18:20 北京

一、痛点

痛点一:为什么我的Token消耗的这么快

Token的消耗量通常受到下面两个因素的影响

  • 输入和输出的Token数量:输入的Token越多,输出的Token也会相应增加,因为模型会基于输入的上下文进行内容生成。

  • 任务复杂性:更复杂的任务通常需要消耗更多的Token,而多模态的Agent往往消耗的Token会更高。

为什么模糊的提示词会增加Token的消耗量?

  • 模糊的提示词可能包含大量与输出不相关的内容,增加输入的Token量。

  • 模糊的提示词通常缺乏具体细节或明确约束,导致模型无法直接理解用户意图。为了覆盖可能的解释,模型倾向于生成更长、更全面的响应,以避免遗漏关键信息,从而增加输出token数量。

  • 模糊的提示词往往无法精准地生成用户想要的内容。用户可能因输出不符合预期而多次修改提示,形成无效交互循环,无形中浪费Token。

痛点二:AI修复代码为什么总是"差点意思"?

一般都是拿到Sonar 扫描结果复制粘贴, 让AI修复后,一个一个改, 又太慢, 太多问题要么修复不准确,要么把好的代码也改坏了,还有就是问题 太多, 上下文超限修改失败

举个真实的例子:Sonar报告:ActivityServiceImpl.java 第120行存在空指针风险

我的提示词(第一版):

请修复以下问题:第120行存在空指针风险
代码:
[粘贴整个ActivityServiceImpl.java文件,可能是几千行]

AI的回复:

  • 情况1:"这个文件太长了,请提供更具体的代码片段"

  • 情况2:修复了空指针,但把旁边的业务逻辑也改了

  • 情况3:"Token超出限制,无法处理"

问题根源在哪?

  1. 上下文冗余:超大文件代码中,真正相关的可能只有20行

  2. 缺乏规范引导:没告诉AI要遵循什么编码规范

  3. 信息不准确:没有精确指出问题在哪个方法、什么结构中

  4. 没有示例:AI缺乏类似问题的修复参考

二、转机:Cursor结合MCP打造自动化修复流程

关键问题在于:如何将Sonar扫描结果转换为AI能高效理解的结构化提示词。

于是,我利用MCP(Model Context Protocol)协议为Cursor开发了一套智能提示词生成系统。

什么是MCP?

MCP(Model Context Protocol)是一个开放协议,Cursor支持这个协议,允许我们通过Python等语言编写自定义工具,直接集成到Cursor的AI助手中。简单说就是:让AI拥有调用你自己编写的工具的能力。

我的方案架构

三、核心方案:六步智能提示词生成法

这套方案的核心思想是:让AI精确理解问题,而不是让AI去猜测问题。

整个系统基于以下6个步骤构建:

第一步:问题类型识别

classIssueTypeClassifier:
"""将Sonar规则映射到问题类型"""
    RULE_MAPPING = {
# 空指针问题
"java:S2259": "NullPointer",
"java:S2637": "NullPointer",
# 资源泄露
"java:S2095": "ResourceLeak",
"java:S2093": "ResourceLeak",
# 安全漏洞
"java:S3649": "SQLInjection",
"java:S2076": "CommandInjection",
# 代码规范
"java:S117": "NamingConvention",
"java:S1192": "DuplicateString",
    }
    @staticmethod
defclassify(rule_key: str) -> str:
"""根据规则ID分类问题类型"""
return IssueTypeClassifier.RULE_MAPPING.get(
            rule_key, 
"General"
        )

第二步:AST代码结构解析

什么是AST?

AST(Abstract Syntax Tree,抽象语法树)是将代码理解成树形结构的技术。

当Sonar告诉你"第120行有空指针问题",我们需要知道:

  • 第120行在哪个方法里?

  • 这个方法从哪行开始,到哪行结束?

  • 方法的完整信息(方法名、参数、返回值)

AST解析 = 像编译器一样理解代码结构

想象代码是一个家族,AST就是家谱树:

ClassDeclaration: ActivityServiceImpl(类)
 │
 ├─ FieldDeclaration: activityFacadeHelper(成员变量)
 │
 ├─ MethodDeclaration: queryActivityListWithNewImei(方法)
 │   ├─ position: line 106
 │   ├─ parameters: [Long orderId, String newMachineUuid]
 │   ├─ return_type: OrderAllowActivityMiVO
 │   └─ body: {...}  ← 第120行在这里
 │
 └─ MethodDeclaration: editActivityListWithNewImei(另一个方法)

使用javalang进行AST解析

javalang是一个纯Python库,用Python重新实现了Java语法解析器,不需要安装Java环境。

import javalang
classJavaCodeParser:
"""Java代码结构解析器 - 使用AST精确解析"""
    @staticmethod
defextract_method_context(file_path: str, line_number: int) -> Optional[Dict]:
"""使用javalang进行AST解析,精确定位方法"""
with open(file_path, 'r', encoding='utf-8') as f:
            code = f.read()
# 1. 解析Java代码,生成AST(语法树)
        tree = javalang.parse.parse(code)
# 2. 遍历AST,查找包含目标行的方法节点
for path, node in tree.filter(javalang.tree.MethodDeclaration):
            method_start = node.position.line
            method_end = calculate_method_end(node)  # 计算方法结束位置
# 3. 检查目标行是否在此方法范围内
if method_start <= line_number <= method_end:
return {
'class_name': extract_class_name(path),
'method_name': node.name,              # 方法名
'start_line': method_start,            # 方法开始行
'end_line': method_end,                # 方法结束行
'modifiers': node.modifiers,           # ['public', 'static']
'return_type': node.return_type.name,  # 返回值类型
'parameters': [p.name for p in node.parameters],  # 参数列表
                }
returnNone

AST解析的价值:

  1. 精确定位:直接知道第120行在queryActivityListWithNewImei方法内,而不是editActivityListWithNewIme方法

  2. 完整信息:获取方法名、参数类型、返回值等元信息

  3. 语法理解:像编译器一样理解Java语法,不会被注释、字符串、Lambda表达式干扰

  4. 高准确率:准确率可达99%+

javalang的特点:

  • 纯Python库,只需pip install javalang

  • 不需要安装JDK或Java环境

  • 提供完整的Java语法树节点

  • 支持Java 8+的语法特性

第三步:智能上下文提取

classContextExtractor:
"""根据问题类型智能提取代码上下文"""
# 不同问题类型的提取策略配置
    EXTRACTION_RULES = {
"NullPointer": {
"range": "full_method",           # 提取完整方法
"max_lines": 150,
"include_imports": True,           # 包含import语句
"include_class_declaration": True, # 包含类声明
        },
"ResourceLeak": {
"range": "full_method",
"max_lines": 100,
"include_imports": True,
"include_class_declaration": True,
        },
"SQLInjection": {
"range": "full_method",
"max_lines": 120,
"include_imports": False,
"include_class_declaration": True,
        },
"NamingConvention": {
"range": "surrounding",            # 只提取周围代码
"max_lines": 30,
"include_imports": False,
"include_class_declaration": False,
        },
"General": {
"range": "surrounding",
"max_lines": 50,
"include_imports": False,
"include_class_declaration": False,
        },
    }
    @staticmethod
defextract(file_path: str, line_number: int, issue_type: str) -> str:
"""智能提取代码上下文"""
        rules = ContextExtractor.EXTRACTION_RULES.get(
            issue_type,
            ContextExtractor.EXTRACTION_RULES["General"]
        )
try:
with open(file_path, 'r', encoding='utf-8') as f:
                lines = f.readlines()
            context_lines = []
# 1. 提取package和imports(如果需要)
if rules.get("include_imports"):
for line in lines[:50]:
if line.strip().startswith(('package ', 'import ')):
                        context_lines.append(line)
elif line.strip() andnot line.strip().startswith('//'):
break
if context_lines:
                    context_lines.append('\n')
# 2. 提取方法或周围代码
if rules["range"] == "full_method":
                method_info = JavaCodeParser.extract_method_context(file_path, line_number)
if method_info:
                    start = method_info['start_line'] - 1
                    end = method_info['end_line']
# 如果需要类声明,向上查找
if rules.get("include_class_declaration"):
for i in range(start, -1, -1):
if'class 'in lines[i]:
                                context_lines.append(lines[i])
                                context_lines.append('    // ... 其他成员 ...\n\n')
break
                    context_lines.extend(lines[start:end])
else:
# 回退到周围代码
                    start = max(0, line_number - 25)
                    end = min(len(lines), line_number + 25)
                    context_lines.extend(lines[start:end])
else:
# 提取周围代码
                max_lines = rules["max_lines"]
                start = max(0, line_number - max_lines // 2)
                end = min(len(lines), line_number + max_lines // 2)
                context_lines.extend(lines[start:end])
# 3. 限制总行数
if len(context_lines) > rules["max_lines"]:
                context_lines = context_lines[:rules["max_lines"]]
                context_lines.append('\n// ... 后续代码省略 ...\n')
return''.join(context_lines)
except Exception as e:
            logging.error(f"提取失败: {e}")
returnf"// 无法读取文件: {file_path}"

核心策略:

  • 差异化提取:空指针问题提取150行含imports,命名规范只提取30行

  • 智能回退:AST解析失败时自动回退到简单提取

  • Token控制:通过max_lines限制,避免上下文过长

第四步:分层模板体系

classPromptTemplateEngine:
"""分层的提示词模板引擎"""
# Java语言规范
    JAVA_STANDARDS = """
请遵循以下Java开发规范:
1. 遵循阿里巴巴Java开发手册的编码规范
2. 所有可能为null的参数必须进行防御性检查
3. 资源(文件流、数据库连接等)必须使用try-with-resources自动管理
4. 异常必须妥善处理,不得吞掉异常
5. 方法复杂度不得过高,保持代码可读性
6. 变量和方法命名要清晰、符合驼峰命名规范
"""
# 问题类型特定模板
    ISSUE_TEMPLATES = {
"NullPointer": {
"task": "修复以下代码中的空指针风险问题",
"requirements": """
修复要求:
1. 在方法开始处对可能为null的参数进行检查
2. 如果参数为null,抛出IllegalArgumentException异常,并提供清晰的错误信息
3. 保持原有业务逻辑不变
4. 不要修改方法签名
5. 确保修复后不影响其他正常调用
"""
        },
"ResourceLeak": {
"task": "修复以下代码中的资源泄露问题",
"requirements": """
修复要求:
1. 使用try-with-resources语句包裹需要关闭的资源
2. 确保在任何情况下(正常或异常)资源都能正确释放
3. 保持原有异常处理方式
4. 保持方法签名不变
"""
        },
"SQLInjection": {
"task": "修复以下代码中的SQL注入安全漏洞",
"requirements": """
修复要求:
1. 必须使用参数化查询(PreparedStatement)替代字符串拼接
2. 使用占位符(?)和参数绑定传递用户输入
3. 不得使用字符串拼接或格式化方式构建SQL语句
4. 保持查询逻辑不变
"""
        },
    }
    @staticmethod
defgenerate(issue_type: str, issue_data: dict, code_context: str, examples: str = "") -> str:
"""生成最终提示词"""
        template = PromptTemplateEngine.ISSUE_TEMPLATES.get(
            issue_type,
            {"task": "修复以下代码问题", "requirements": "保持代码风格与项目一致"}
        )
# 组装提示词
        prompt = f"""你是一位精通Java开发的资深工程师。
任务:{template['task']}
编码规范:{PromptTemplateEngine.JAVA_STANDARDS.strip()}
"""
# 添加示例(如果有)
if examples:
            prompt += f"\n{examples}\n"
# 添加问题详情
        prompt += f"""
问题详情:
- 规则ID: {issue_data.get('rule', 'Unknown')}
- 问题类型: {issue_type}
- 严重级别: {issue_data.get('severity', 'MAJOR')}
- 问题描述: {issue_data.get('message', '')}
- 问题位置: 第{issue_data.get('line', 0)}行
待修复代码:
```java
{code_context}
``` {data-source-line="360"}
{template['requirements'].strip()}
输出格式:
- 仅输出修复后的完整方法代码
- 使用```java```格式包裹代码
- 不要输出多余的解释文字
- 确保代码可以直接替换原有方法
"""
return prompt

模板设计:

  • 三层结构:角色设定 + 编码规范 + 问题类型特定要求

  • 灵活扩展:新增问题类型只需添加模板配置

  • 规范注入:自动注入阿里巴巴Java开发手册规范

第五步:Few-shot示例库

classExampleRepository:
"""问题修复示例库 - 提供修复前后的对比案例"""
    EXAMPLES = {
"NullPointer": """
参考示例:
示例1 - 空指针防御性检查:
修复前:
```java
public String getUserEmail(User user) {
    return user.getEmail();
}
``` {data-source-line="395"}
修复后:
```java
public String getUserEmail(User user) {
    if (user == null) {
        throw new IllegalArgumentException("用户对象不能为空");
    }
    return user.getEmail();
}
``` {data-source-line="404"}
示例2 - 多参数空值检查:
修复前:
```java
public void processOrder(Order order, User user) {
    order.setUser(user);
    order.setStatus("processed");
}
``` {data-source-line="413"}
修复后:
```java
public void processOrder(Order order, User user) {
    if (order == null) {
        throw new IllegalArgumentException("订单对象不能为空");
    }
    if (user == null) {
        throw new IllegalArgumentException("用户对象不能为空");
    }
    order.setUser(user);
    order.setStatus("processed");
}
``` {data-source-line="426"}
"""
,
"ResourceLeak": """
参考示例:
示例 - 使用try-with-resources:
修复前:
```java
public String readFile(String path) throws IOException {
    FileInputStream fis = new FileInputStream(path);
    byte[] buffer = new byte[1024];
    int length = fis.read(buffer);
    return new String(buffer, 0, length);
}
``` {data-source-line="440"}
修复后:
```java
public String readFile(String path) throws IOException {
    try (FileInputStream fis = new FileInputStream(path)) {
        byte[] buffer = new byte[1024];
        int length = fis.read(buffer);
        return new String(buffer, 0, length);
    }
}
``` {data-source-line="450"}
"""
,
"SQLInjection": """
参考示例:
示例 - 使用PreparedStatement:
修复前:
```java
public User findUserByName(String name) {
    String sql = "SELECT * FROM users WHERE name = '" + name + "'";
    return jdbcTemplate.queryForObject(sql, User.class);
}
``` {data-source-line="462"}
修复后:
```java
public User findUserByName(String name) {
    String sql = "SELECT * FROM users WHERE name = ?";
    return jdbcTemplate.queryForObject(sql, User.class, name);
}
``` {data-source-line="469"}
"""
,
    }
    @staticmethod
defget_examples(issue_type: str) -> str:
"""获取相关示例"""
return ExampleRepository.EXAMPLES.get(issue_type, "")

示例库价值:

  • Few-shot学习:让AI通过案例学习修复模式

  • 格式统一:修复前/后对比,清晰明了

  • 易于扩展:新增示例只需添加字符串配置

第六步:整合到MCP服务

现在,将所有组件整合到MCP服务中:

from mcp.server import FastMCP
import httpx
import logging
import os
mcp = FastMCP("intelligent-code-fix")
classIntelligentPromptGenerator:
"""智能提示词生成器 - 整合6步生成法的核心类"""
    @staticmethod
defgenerate_for_issue(issue: dict, base_dir: str) -> dict:
"""为单个issue生成智能提示词"""
try:
# 1. 提取issue信息
            rule_key = issue.get('rule', '')
            component = issue.get('component', '')
            file_path = component.split(':', 1)[1] if':'in component else component
            full_path = os.path.join(base_dir, file_path)
            line_number = issue.get('line', 0)
            message = issue.get('message', '')
            severity = issue.get('severity', 'MAJOR')
# 2. 问题类型识别
            issue_type = IssueTypeClassifier.classify(rule_key)
            logging.info(f"处理问题: {file_path}:{line_number} - {issue_type}")
# 3. 提取代码上下文
            code_context = ContextExtractor.extract(full_path, line_number, issue_type)
# 4. 获取示例
            examples = ExampleRepository.get_examples(issue_type)
# 5. 生成提示词
            issue_data = {
'rule': rule_key,
'severity': severity,
'message': message,
'line': line_number,
            }
            prompt = PromptTemplateEngine.generate(
                issue_type=issue_type,
                issue_data=issue_data,
                code_context=code_context,
                examples=examples
            )
# 6. 计算元数据
            token_estimate = len(prompt) // 4# 粗略估算
return {
'success': True,
'prompt': prompt,
'metadata': {
'file': file_path,
'line': line_number,
'issue_type': issue_type,
'rule': rule_key,
'severity': severity,
'token_estimate': token_estimate,
                }
            }
except Exception as e:
            logging.error(f"生成提示词失败: {e}")
return {
'success': False,
'error': str(e),
'file': file_path,
'line': line_number,
            }
@mcp.tool("auto-fix-sonar-issues")
asyncdefauto_fix_sonar_issues(
    project_name: str,
    cookie: str,
    base_dir: str,
    branch: str = None,
    page_size: int = 10,
    page_num: int = 1,
    is_new_code_period: bool = False
)
 -> str:
"""智能修复Sonar扫描问题 - 核心MCP工具"""
# 获取Sonar问题列表
asyncwith httpx.AsyncClient() as client:
        params = {
"components": project_name,
"ps": page_size,
"p": page_num,
        }
if branch:
            params["branch"] = branch
if is_new_code_period:
            params["inNewCodePeriod"] = "true"
        response = await client.get(
"https://sonar.zhuanspirit.com/api/issues/search",
            params=params,
            headers={"Cookie": cookie},
            timeout=10.0
        )
        data = response.json()
        issues = data.get('issues', [])
        total = data.get('total', 0)
# 为每个issue生成智能提示词
    results = []
    success_count = 0
for idx, issue in enumerate(issues, 1):
        result = IntelligentPromptGenerator.generate_for_issue(issue, base_dir)
if result['success']:
            success_count += 1
            metadata = result['metadata']
            results.append(f"""
{'='*80}
## Issue {idx}: {metadata['file']} (第{metadata['line']}行)
**问题类型**: {metadata['issue_type']}
**严重级别**: {metadata['severity']}
**预估Token**: {metadata['token_estimate']}
### 生成的智能提示词:
{result['prompt']}
{'='*80}
"""
)
# 组装最终输出
returnf"""
# 智能代码修复提示词生成完成
## 统计信息
- **项目**: {project_name}
- **总问题数**: {total}
- **本批次**: {len(issues)} 个
- **成功生成**: {success_count} 个
## 智能提示词列表
{"".join(results)}
---
由智能提示词生成引擎提供支持
"""
if __name__ == "__main__":
    mcp.run("stdio")

整合要点:

  • 错误处理:每个issue独立处理,单个失败不影响其他

  • 元数据追踪:记录文件、行号、问题类型、Token估算

  • 结构化输出:Markdown格式,便于Cursor展示

安装依赖包

在使用MCP服务之前,需要先安装必要的Python依赖包。创建requirements.txt文件:

# 智能代码修复MCP服务依赖包
# MCP框架 - 用于构建MCP服务
mcp>=0.9.0
# HTTP客户端 - 用于调用Sonar API
httpx>=0.27.0
# Java AST解析器 - 精确解析Java代码结构(强烈推荐)
# 优势:准确率99%+,不受注释、字符串、Lambda影响
# 注意:这是纯Python库,不需要Java环境
javalang>=0.13.0

安装命令:

pip install -r requirements.txt

依赖说明:

  • mcp:MCP协议框架,让Python脚本能够被Cursor识别和调用

  • httpx:现代化HTTP客户端,用于调用Sonar API获取扫描结果

  • javalang:纯Python的Java AST解析器,用于精准定位代码结构,无需安装Java环境

配置MCP(让Cursor识别你的服务)

%这里改成你本地的路径% 在 ~/.cursor/mcp.json 中添加:

{
"mcpServers": {
"intelligent-code-fix": {
"command": "python",
"args": ["/Users/Desktop/cursor/intelligent-code-fix.py"],
"env": {}
    }
  }
}

配置说明:

  • intelligent-code-fix:MCP服务名称,在Cursor中通过@intelligent-code-fix调用

  • command: Python解释器命令

  • args: Python脚本的绝对路径(请修改为你的实际路径)

  • 修改配置后需要重启Cursor生效

四、使用体验:在Cursor中一键修复

配置好MCP后,在Cursor中的使用非常简单

步骤1:在Cursor聊天窗口调用MCP工具

使用 auto-fix-sonar-issues 工具修复Sonar问题
参数:
- project_name: hunter_partner_recycle_core
- cookie: sso_uid=xxx; ticket=xxx; aid=xxx
- base_dir: /Users/xxx/projects/hunter/src/main/java
- branch: feature-3278-163 (可选)
- page_size: 10

步骤2:MCP服务自动处理

系统自动完成:

  1. 调用Sonar API获取问题列表

  2. 为每个问题智能生成提示词

  3. 返回结构化的修复建议

步骤3:AI生成修复后的代码

已生成10个问题的修复建议:
Issue 1: ActivityServiceImpl.java 空指针修复
修复后代码:
[完整的修复代码]
Issue 2: FileUtil.java 资源泄露修复
修复后代码:
[完整的修复代码]

步骤4:一键应用修复

直接在Cursor中review并应用修复

改进效果:

  1. 成本降低70% :精准提取上下文,token使用量大幅减少

  2. 准确率提升30%:结构化提示词+示例引导,AI理解更准确

  3. 效率提升3倍:自动化流程,无需人工干预

  4. 质量可控:分层模板确保代码符合团队规范

  5. 易于扩展:新增问题类型只需添加配置

五、写在最后

真正有效的AI辅助开发,不是简单地把代码扔给AI,而是要做好:

  • 问题的精准识别:知道是什么类型的问题

  • 上下文的智能提取:给AI最相关的代码,而不是全部代码

  • 规范的有效注入:让AI知道要遵循什么标准

  • 经验的系统沉淀:用示例库让AI学习最佳实践

这套方案不仅适用于Sonar,也可以推广到其他代码扫描工具(ESLint、Checkstyle等)。核心思想都是:将非结构化的扫描结果转换为结构化的AI提示词。

希望这篇文章能给大家带来启发。如果大家也在探索AI辅助开发,欢迎交流!

关于作者,刘雅斌,侠客汇Java开发工程师。

想了解更多转转公司的业务实践,欢迎点击关注下方公众号:

跳转微信打开

ASR+LLM+RAG视频内容识别全方案

2025年12月24日 18:10

原创 顾守业、王志远 2025-12-24 18:10 广东

ASR+LLM+RAG视频广告品类识别全方案:从架构到落地实操

1 引言:技术背景与核心挑战

在视频内容爆发式增长的当下,品牌广告植入场景日益复杂,如何快速精准判断推广品类,成为转转内容运营、竞品分析的核心需求。当前传统方案主要依赖关键词匹配与规则引擎,面临三大技术痛点:

ASR 转写准确性不高,输入数据质量低下

产品表述异构性

模型泛化与迭代能力弱

本文提出基于 “ASR+LLM+向量知识库” 的技术方案,通过分层处理、语义修复、历史常见词匹配、知识检索融合,解决上述痛点,实现推广品类的精准识别与自迭代优化。

2 技术架构设计

[视频语音输入] → [ASR转写层] → [文本预处理层] → [精准匹配层] → [模糊检索层] → [识别结果输出]
                                                ↑                            ↓
                                         [映射case反馈]     ←          [人工审核反馈]

2.1 各模块核心功能与技术选型

2.1.1 ASR 转写层

语音输入 → [降噪预处理(远场降噪 + 双声道分离)] → [语音转写]  → 原始文本输出

● 功能:将视频语音流转换为原始文本

● 技术选型:采用 ASR 引擎,配置 “远场降噪”“口语化清洗” 参数

2.1.2 文本预处理层

ASR 原始文本 → [语义纠错(错字 / 口音修正)] → [语序规整(如 “苹果手机”→“手机苹果”)] → [字段校验(过滤无核心信息文本)] → 预处理结构化文本
  • 功能:基于LLM对ASR文本的语义修复,修正上下文文逻辑错误(如“手机苹果 IPHONE15”→“手机苹果 iPhone 15”)

2.1.3 精准匹配层

● 功能:实现标准化文本与已知产品信息的精准映射,分为两级匹配:

○一级匹配:基于 MySQL 存储的标准产品库(字段包括 “产品 ID、标准型号、品类、品牌”),采用 “全量字符串匹配 + 前缀匹配” 策略,命中则直接输出品类结果;

预处理文本 → [全量字符串匹配(标准型号完全命中)] → 命中则输出品类

○ 二级匹配:基于 人工历史确认 库(存储 “错误表述 - 标准型号” 映射关系)进行匹配,ASR文本修复后仍有错别字问题(如“手机华硕11U”→“手机华硕 ZenFone 11 Ultra”)

预处理文本 → [错误表述映射(如 “米 14U”→“小米 14 Ultra”)] → 命中则输出品类

2.1.4 模糊检索层

预处理模糊文本→ [文本向量化]  → [余弦相似度检索(Top-10 结果)]  → [LLM 判断映射匹配(匹配型号 + 品类)] → 识别结果输出

● 功能:解决未命中精准匹配的模糊表述识别,核心技术为知识库搭建:

○ 知识库构建:采用向量数据库存储产品信息,将 “标准型号” 转换为向量嵌入;

○ 检索逻辑:将预处理后的模糊表述(如 “某品牌 14 寸笔记本”“米 14U”)转换为向量后,采用 “余弦相似度排序 + Top-3 结果筛选”,结合 LLM 生成标准化匹配结果;

2.1.5 常见映射case 闭环模块

识别结果 → [人工审核(错误案例标记)] → [错误纠正] → [自动入库(常见case映射)] → [同步至预处理层(修复词典更新)] → 效果监控(错误复发率统计)

● 功能:实现错误案例的回收与复用,流程包括: 

○ 人工审核:通过轻量化平台完成 “错误表述 - 标准型号” 标注,支持批量审核与规则配置 

○ 自动入库:审核通过的案例自动同步至【常见case映射库】

3 关键技术难点与解决方案

3.1 单 LLM 节点拆分:降低负载与提升准确率

问题:传统方案采用单 LLM 节点处理 “语义修复 + 产品提取 + 识别”,导致上下文过长模型注意力机制分配失衡、准确率下降

解决方案:节点拆分,将原单节点拆分为 3 个独立模块,各模块专注单一任务:

● 文本修复模块:仅处理 ASR 文本的错漏修正

● 产品提取模块:基于LLM从修复后文本中提取疑似产品关键词 

● 结果生成模块:结合精准匹配与检索结果,生成标准化品类识别结果

3.2 知识库检索优化:提升模糊表述召回率

问题:模糊表述(如 “米 14U”“某品牌扫地机器人”)因信息不全,传统关键词检索召回率低下 解决方案:知识库增强+检索策略优化

知识库增强:在标准产品信息基础上,补充“常见错误表述”“产品简称”“品牌别名” 等维度,如 “小米 14 Ultra” 补充 “米 14U”“小米 14 超” 等表述;

检索策略优化:采用 “向量检索 + 关键词过滤” 混合策略,先通过向量检索获取 Top-10 相似结果,再基于关键词(如品牌、型号数字)筛选,示例:

● 模糊表述:“米 14U”

● 向量检索 Top-3:“小米 14 Ultra”“小米 13 Ultra”“红米 14 Pro” 

● 关键词过滤:基于 “米”(品牌别名)、“14”(型号数字)、“U”(Ultra 简称),最终匹配 “小米 14 Ultra”; 3.3 LLM 参数优化:精准调参提升识别稳定性

3.3 LLM 参数优化:精准调参提升识别稳定性

解释:LLM 的温度、重复惩罚等参数直接影响文本修复、产品提取、知识库检索结果生成的准确性,不同任务阶段需针对性调整,避免 “过度创作”“重复冗余” 等问题。以下为适配本场景的参数配置表:

应用场景

核心目标

温度

Top-K

Top-P

长度惩罚

ASR 文本修复

精准修正错漏,保留品类 / 品牌/ 型号等关键信息

0.2

20

0.7

1.1

产品关键词提取

无遗漏、无冗余提取核心产品信息

0.1

10

0.6

1.1

参数配置原理:

  1. 温度(temperature):决定输出的 “脑洞大小”,值越高越放飞发散(易出新奇 / 混乱内容),值越低越严谨保守(输出越固定),这里主要是防止文本提取时输出过多冗余内容,如:"小米 14 Ultra" 输出为 "文本中提到的机型是 小米 14 Ultra ..."

  2. Top-K:限制模型选词的 “候选池大小”,只从概率最高的 K 个词里挑,K 越小选择越集中(输出越确定);

  3. Top-P(核采样):按概率 “打包选词”,只从累积概率达 P 的最小词集里选,比 Top-K 更灵活,避免遗漏低概率但合适的词;

  4. 长度惩罚(length_penalty):调节输出的 “啰嗦程度”,值越大越简洁(甚至简短),值越小越详尽(可能冗余)

4 效果反馈

从准确度的维度来看,关键词匹配>历史常见case映射匹配>知识库匹配,随着常见映射case库的不断沉淀,在精准匹配 -> 二级匹配层会兜住更多数据,也意味着准确率也会随着数据的沉淀逐渐上升。

5 总结

本文提出的 “ASR+LLM+知识库” 方案,通过分层处理解决了视频广告推广品类识别的核心痛点,实现了 “精准识别 + 自迭代优化”,这套方案理论可应用到各类AI识别类场景,本质思考点是如何保证输入数据质量 -> LLM基础参数调优 -> 常见映射case沉淀反馈。

关于作者:

顾守业:转转新媒体业务Java开发工程师,主要负责新媒业务后端开发、Ai应用开发

王志远:转转大数据开发工程师,主要负责大数据相关基础平台建设

跳转微信打开

ITCP联盟第五届技术大会【AI应用专场】报名火热开启!

2025年12月8日 14:28

人才发展中心 2025-12-08 14:28 北京

以下文章来源于:Qunar技术沙龙

Qunar技术沙龙

Qunar技术沙龙是去哪儿网工程师小伙伴以及业界小伙伴们的学习交流平台。我们会分享Qunar和业界最前沿的热门技术趋势和话题,为中高端技术同学提供一个自由的技术交流和学习分享平台。

AI基建专场 收官!11月29日,去哪儿旅行、转转、核桃编程的四位技术专家为大家带来了各自领域内AI基建实

AI基建专场

  收官!

11月29日,去哪儿旅行、转转、核桃编程的四位技术专家为大家带来了各自领域内AI基建实践的干货经验分享,现场听众就主题进行热烈提问,内容的开放性、实用性、可借鉴性受到大量好评。

大会联合dbaplus、麦思博进行了同步推流直播,累计吸引到2000+同学观看。

AI应用专场介绍

      紧随【AI基建专场】的精彩分享,12月13日,去哪儿旅行携手转转、自如,重磅推出【AI应用专场】。本专场将聚焦AI技术与业务场景的深度融合,共同分享 AI 落地过程中的关键技术突破、场景创新实践与避坑经验 —— 从需求拆解到方案设计,从技术选型到效果验证,全方位拆解 AI 如何赋能业务提效、优化用户体验。

我们将共同挖掘能够切实提升企业核心效益的 AI 应用路径,探讨技术与业务同频共振的底层逻辑,为更多企业提供可复用、可落地的 AI 实践范本,助力行业伙伴在智能化转型浪潮中精准破局、加速前行!

【时间】12月13日13:45-17:50

【地点】北京市维亚大厦8F大会议室

报名直通车

报名时间

12月3日-12月12日

报名方式

扫描二维码,提前预定席位

现场席位有限,先到先得呦

精彩预告

大会讲师及主题简介

应阔浩

自如技术副总经理

负责自如整个技术团队,包括技术中台、数据中台、AI 架构搭建等。曾任阿里、京东架构师,华为云联创营 MVP 得主,《云原生落地》、《工程师文化 10 法则》作者、 CCF-TF 工程师文化 SIG 主席。

自如企业级AI架构落地的思考与实践

在 AI 浪潮加速渗透各行各业的背景下,如何在真实业务实战中高效落地 AI 成为企业共同面临的关键课题。本次分享将以自如的实践为核心,从场景选择出发,深入剖析自如在 AI 找房助手、AI 定价后训练等业务中的落地路径与实战经验,并介绍技术提效方向的创新探索。

同时,分享将进一步探讨支撑多AI应用的通用能力建设,包括MCP市场、Agent管理平台与知识库管理平台,为企业构建可复用、可扩展的AI基础设施提供参考。

分享大纲:

1、意图识别的问题与挑战

2、视觉垂直模型的微调

3、知识库RAG的建设

孟繁茂

去哪儿机票辅营搜索负责人

负责去哪儿辅营搜索和商品策略相关业务,长期深耕去哪儿机票 AI 业务实践,在TOC场景中,通过推进 AI 客服、导购、搜索等项目,实现了业务指标的显著提升,同时主导探索了多种Agent架构和模式。

去哪儿机票AI导购和搜索

本主题深入复盘了去哪儿网在机票 AI 导购与搜索场景中的整体落地实践。面对用户意图复杂、多Agent协作导致上下文窗口溢出以及技术难以转化为业务增量等痛点,我们将分享一套经过实战验证的系统化解决方案。

本次分享将涵盖以下亮点:

①架构创新: 详解“专家+专员”的二层路由与协调合成模式(SubAgent+ReAct),实现灵活的意图处理。

②工程突破: 探讨如何通过上下文工程与L3逻辑记忆规划,解决有限Token下的信息丢失问题。

③业务闭环: 分享如何通过分场景圈人与显性化交互,在6+个核心场景实现AB测试正向收益。以及如何结合 AI 实现开发、运营闭环双双提效的。

分享大纲:

1、场景洞察:机票业务场景痛点与AI能力的匹配

2、解决方案:基于多Agent协作的架构演进 

3、工程难点:L3记忆规划与上下文工程

4、业务落地:价值闭环与实战成效

刘丹

去哪儿酒店研发供应链

QA负责人

长期专注于全链路质量保障体系构建与优化,致力于通过自动化、智能化手段推动研测效率提升与风险防控。曾作为特邀讲师出席QCon、携程集团技术分享会、QTEST等多场行业会议。

去哪儿 AI 变更巡检

在数字化转型与业务快速迭代背景下,线上系统频繁变更,传统人工巡检面临效率低、风险高、经验难复用等痛点。为此,我们研发了“AI 变更巡检”,通过 AI 驱动运维自动化,构建从变更接入、智能分析到报告推送的端到端闭环,实现了巡检流程标准化,有效提升效率、降低风险。

本次分享将基于真实业务场景,系统呈现这一解决方案的架构设计与实施路径,深入解析关键技术细节。听众将直观理解变更运维中“人工巡检效率低、覆盖不全、风险高”的核心痛点,并看到如何借助自动化与智能化手段,使巡检效率提升 90% 以上,为变更运维带来更高的可靠性与可控性。

分享大纲:

1、背景洞察:线上变更人工巡检痛点

2、破局之道:AI 驱动的变更巡检平台设计

3、实战细节:技术难点与创新实践

4、成果与展望

黄家兴

转转前端架构负责人

负责转转公司的前端架构与中台业务前端,拥有丰富的前端架构体系建设经验,对于前端性能优化有着丰富的经验。近年主要专注于 AI+前端,通过 AI 提升前端开发效能。

AI-D2C:设计稿转代码在转转的实践

设计稿生成代码(D2C)一直是前端工程师关注的方向,传统 D2C 长期受限于代码质量低、与项目难以结合等问题,导致生成代码的可用率始终难以突破。本次分享将聚焦这一核心痛点,介绍如何利用 AI 对项目代码、设计图的理解以及多模态能力,实现设计稿还原方案的全面升级,使代码可用率提升至 80% 以上,显著提高前端开发效率。

围绕真实场景与落地经验,本次分享将带来从原理到实践的完整路径。听众不仅能够了解传统 D2C 的局限与的 AI 在其中的关键价值,还将掌握提升 D2C 代码可用率的方法技巧,获得适用于实际工程的可落地方案,为构建更高效的前端研发体系提供有益参考。

分享大纲:

1、传统 D2C 的问题与困境

2、转转 D2C 落地的方案

3、落地中遇到的问题与关键技术点

4、落地效果的总结与长期迭代

大会流程

汇聚 AI 先锋,共探技术前沿;

这场干货盛宴,等你赴约!

跳转微信打开

回收系统架构演进实战:与Cursor结对扫清系统混沌

2025年11月28日 18:21

原创 于天奇 2025-11-28 18:21 北京

"最好的代码不是一次写对的,而是不断重构出来的。" —— Martin Fowler

前言:技术债务带来的效能瓶颈

我所在的团队负责一个多渠道回收业务系统,接入了十几个外部渠道。每个渠道都有自己独特的协议规范、业务流程和特殊要求。随着业务发展,系统逐渐的遇到了一系列问题:

  • 代码膨胀:单个策略类代码超过800行,包含大量if-else判断,可读性极差

  • 重复代码:不同渠道间有70%的代码逻辑相似,有很多都是逻辑类似,但参数名称、结构不一致,难以复用

  • 难以测试:业务逻辑与协议处理耦合,单元测试覆盖率不到30%,主要依赖人工测试

  • 维护困难:改一个渠道的逻辑,需要理解整个类的800行代码,调研成本极高

技术债务不仅影响代码质量,更直接冲击了团队的研发效能。我们在日常开发中遭遇了三个核心瓶颈:

① 新人上手困难,培养周期长

新同学加入团队后,需要2-3个月才能理解现有代码逻辑:

  1. 单个策略类800+行,找一个业务逻辑点要翻半天

  2. 协议处理、业务逻辑、数据操作混在一起,理不清头绪

  3. 没有清晰的架构文档,只能靠"师傅带徒弟"口口相传

② 需求承接效率低,开发成本高

每次接入新渠道,都是一次"复制粘贴+魔改"的过程:

  1. 复制一个相似渠道的策略类

  2. 对照需求文档,逐个方法修改参数、逻辑

  3. 开发写入个性化逻辑

③ 测试回归成本高,质量保障困难

代码耦合导致"牵一发而动全身":

  1. 修改一个渠道的逻辑,可能影响其他渠道,测试范围难以评估

  2. 单元测试覆盖率低(30%),主要靠人工回归测试

  3. 每次发版前,测试同学要回归受影响渠道的核心流程

此时我的脑子里出现了一个想法:为了早点下班~ 必须重构了!

一、 重构方案设计

针对上述的三大痛点,我们很快制定了初步的重构规划:

痛点

重构目标

预期效果

新人上手慢

架构清晰化、职责单一化

培养周期从3周降到1周,调研成本降低70%

需求效率低

通用逻辑可复用、新增渠道可配置化

新渠道接入成本降低70%

测试成本高

解耦分层、单元测试覆盖率≥80%

回归测试时间减半,Code Review时间降低80%

三大技术策略:

  1. 分层解耦:将协议层、业务层、数据层清晰分离,让新人快速定位代码

  2. 责任链模式:每个Handler职责单一,可独立开发、测试、复用

  3. 适配器模式:新渠道只需实现Adapter,组装Handler即可

目标有了,问题也来了:这是一个对接10余个活跃渠道的业务系统,系统复杂,且每日有数百万请求打进系统,如何在不影响线上业务的前提下进行重构?

渐进式落地,而非一步到位

出于对生产环境的敬畏之心,我们不敢"一刀切"地推倒重来。经过评估,我们选择了渐进式重构策略: 整体改进是一个持续的过程,目标清晰但落地需要时间。我们会逐步验证架构可行性,再慢慢进行迁移,确保每一步都是稳定可控的。

阶段规划:

阶段

时间

目标

第一阶段

1-2周

架构验证:完成1个渠道的规范化改造

第二阶段

1-2个月

核心迁移:完成50%渠道的迁移

第三阶段

3-6个月

全量迁移:剩余渠道全部迁移

第四阶段

持续优化

补充协议Handler、完善监控

关键原则

  1. 新老并行:新架构与旧代码并存,通过配置开关灰度切换

  2. 小步验证:每完成一个渠道,立即上线验证,确保稳定后再推进下一个

  3. 数据对比:新老架构同时执行,对比结果一致性,发现问题及时回滚

二、 基于PDCA思想驱动的人机协作模式

PDCA(Plan-Do-Check-Act)是戴明环的核心思想,特别适合用于:

  • 复杂系统的渐进式改进:将大目标拆解为小任务

  • 风险可控的迭代验证:每个小步骤都可验证

  • 知识沉淀与持续优化:从单次需求到全局改进

在与AI协作时,PDCA的价值更加明显:

PDCA阶段

人的职责

AI的职责

协作模式

Plan

架构设计、任务拆解、确定路径

提供设计建议、分析技术方案

人主导

,AI辅助

Do

编写核心逻辑、Review代码

生成模板代码、实现细节

结对编程
Check

验证业务逻辑、集成测试

生成单元测试、代码检查

人验证

,AI执行

Act

总结经验、沉淀规则

整理文档、提取模式

共同迭代

三、 实战案例:渠道统一Handler架构重构

3.1 Plan阶段:架构设计与任务拆解

3.1.1 原有架构的痛点分析

重构前,我们的代码结构是这样的:

@Service("kaChannelBusinessStrategy")
publicclassKaChannelBusinessStrategyextendsBaseChannelBusinessStrategy{
public EnquiryPriceResult getEnquiryPrice(...){
// 1. 参数校验(50行)
// 2. 解密验签(30行)
// 3. 获取渠道配置(40行)
// 4. 调用报价服务(60行)
// 5. 计算佣金(50行)
// 6. 组装响应(30行)
// 7. 加密签名(20行)
// ... 总计500+行
    }
public CreateOrderResult createRecycleOrder(...){
// 同样的模式,又是几百行...
    }
}

问题总结:

  1. 职责不清:一个类既处理协议,又处理业务,还管数据

  2. 代码重复:AChannelBusinessStrategy、BChannelBusinessStrategy里有大量相似代码

  3. 难以扩展:新增一个渠道,需要复制粘贴800行代码

  4. 测试困难:依赖过多,mock成本高

3.1.2 新架构设计思路

本次我们的设计,是一个基于责任链模式的新架构:

核心设计点:

  1. 分层解耦

    • Facade层:统一入口,参数校验、异常处理

    • Adapter层:渠道适配,协议转换

    • Handler层:责任链模式,每个Handler职责单一

  2. 可复用的Handler

    DuplicationCheckHandler     → 幂等性检查(通用)
    ChannelConfigHandler        → 渠道配置获取(通用)
    ReportMappingHandler        → 报告映射(通用)
    OrderParamAssemblyHandler   → 参数组装(可定制)
    OrderCreationHandler        → 订单创建(通用)
  3. 灵活的编排机制

    // A渠道:标准流程
    chain.addHandler(duplicationCheck)
         .addHandler(channelConfig)
         .addHandler(reportMapping)
         .addHandler(orderParamAssembly)
         .addHandler(orderCreation);
    // KA渠道:额外增加权限校验
    chain.addHandler(duplicationCheck)
         .addHandler(kaAuthCheck)  // KA特有
         .addHandler(channelConfig)
         .addHandler(reportMapping)
         .addHandler(orderParamAssembly)
         .addHandler(orderCreation);

3.1.3 任务拆解

有了架构设计后,我将重构任务拆解为8个小任务:

任务ID

任务描述

依赖关系

T1

定义责任链上下文数据结构

-

T2

定义IChannelAdapter接口

T1

T3

定义BusinessHandler接口

T1

T4

实现5个通用Handler

T3

T5

实现统一对外接口

T2

T6

实现ChannelAdapter

T2, T4

T7

编写单元测试

T4-T6

T8

集成测试与灰度发布

T7

关键点:每个任务都是独立可验证的,这也为后续与Cursor协作奠定了基础。

3.2 Do阶段:与Cursor协同编码

3.2.1 建立清晰的上下文

在开始编码前,我做了三件事:

1、 用自然语言写了一个详细的架构说明文档

AI更擅长理解结构化信息,为了提升Cursor的代码生成质量,我首先为Cursor量身定制了一份"产品需求文档"(PRD)。有了这份文档,Cursor代码生成的有效率大大提升,大部分时间,我只需要微调业务细节,就可以直接使用它生成的代码。

包含:

  • 架构全景图

  • 核心设计模式(责任链、适配器、模板方法、策略)

  • 数据流转过程(Context如何在Handler间传递)

  • 扩展点说明(如何新增渠道、Handler、Action)

2、 定义好接口和数据结构

/**
 * 渠道上下文
 */
@Data
@Builder
publicclassChannelContext{
private String requestId;        // 请求ID
private String channelCode;      // 渠道编码
private String action;           // 业务动作
private Object bizData;          // 业务数据
private Map<String, Object> handlerResults;  // Handler结果
// ...
}

3、 编写第一个Handler作为示例

我手写了一个DuplicationCheckHandler,作为Cursor的参考模板:

@Component
publicclassDuplicationCheckBusinessHandler
extendsAbstractTypedBusinessHandler<CreateOrderBizData, Boolean> 
{
@Override
protected Boolean handleTyped(CreateOrderBizData input, ChannelContext context){
// 1. 根据outOrderNo查询订单
        RecycleOrderVO existOrder = orderService.queryByOutOrderNo(input.getOutOrderNo());
// 2. 如果订单已存在,返回true(跳过后续Handler)
if (existOrder != null) {
            log.info("订单已存在,跳过创建流程, outOrderNo={}", input.getOutOrderNo());
            context.putHandlerResult("ORDER_EXISTS", existOrder);
returntrue;
        }
returnfalse;
    }
@Override
publicintgetOrder(){
return100;  // 最先执行
    }
}

完成了上述步骤后,我开始与Cursor结对编程。

参考DuplicationCheckBusinessHandler,帮我实现ChannelConfigBusinessHandler,用于获取渠道配置。需要满足:

  1. 从ExternalChannelConfigService获取配置

  2. 从PricedSourceService获取报价源配置

  3. 将结果保存到context的handlerResults中

  4. order设置为200

Cursor生成的代码:

@Component
publicclassChannelConfigBusinessHandler
extendsAbstractTypedBusinessHandler<CreateOrderBizData, ExternalChannelConfig> 
{
@Resource
private ExternalChannelConfigService configService;
@Resource
private PricedSourceService pricedSourceService;
@Override
protected ExternalChannelConfig handleTyped(CreateOrderBizData input, ChannelContext context){
        String channelCode = context.getChannelCode();
// 1. 获取渠道配置
        ExternalChannelConfig channelConfig = configService.getByChannelCode(channelCode);
if (channelConfig == null) {
thrownew ChannelException("CHANNEL_NOT_FOUND", "渠道配置不存在: " + channelCode);
        }
// 2. 获取报价源配置
        PricedSourceBO pricedSource = pricedSourceService.getPricedSource(
            channelConfig.getOrgId(), input.getCategoryId());
// 3. 保存到上下文
        context.putHandlerResult("CHANNEL_CONFIG", channelConfig);
        context.putHandlerResult("PRICED_SOURCE", pricedSource);
        log.info("获取渠道配置成功, channelCode={}, orgId={}", 
            channelCode, channelConfig.getOrgId());
return channelConfig;
    }
@Override
publicintgetOrder(){
return200;
    }
}

可以看到,代码结构完全符合预期,异常处理到位,日志也很规范。

3.2.3 快速迭代的秘诀

在Do阶段,我总结出了几个与Cursor高效协作的技巧:

技巧1:更加明确的提示

不好的提示词:

帮我实现所有的Handler

好的提示词:

先实现DuplicationCheckHandler,用于检查订单是否已存在

技巧2:提供参考代码

参考DuplicationCheckHandler的实现方式,生成ChannelConfigHandler

技巧3:明确约束条件

要求:
1. 继承AbstractTypedBusinessHandler
2. order设置为200
3. 必须包含日志
4. 异常使用ChannelException

技巧4:及时Check

每生成一个Handler,我都会:

  • 检查是否符合接口规范

  • 运行单元测试

  • 代码Review(看命名、异常处理、日志)

3.3 Check阶段:代码审查与验证

3.3.1 多层次的检查机制

在Check阶段,我建立了三层验证机制:

第一层:IDE即时检查

  • Cursor的智能提示会提醒语法错误

  • SonarLint插件实时检查代码质量

第二层:单元测试

我让Cursor帮我生成了单元测试:

为DuplicationCheckHandler生成单元测试,需要覆盖:

  1. 订单不存在的场景

  2. 订单已存在的场景

  3. 查询异常的场景

Cursor生成的测试:

@RunWith(SpringRunner.class)
@ContextConfiguration("classpath:scf-spring-test.xml")
publicclassDuplicationCheckBusinessHandlerTest
{
@Resource
private DuplicationCheckBusinessHandler handler;
@Resource
private IRecycleOrderService orderService;
@Test
publicvoidtestHandle_OrderNotExists(){
// 构建测试数据
        CreateOrderBizData input = CreateOrderBizData.builder()
                .outOrderNo("OUT_ORDER_001")
                .channelCode("TEST_CHANNEL")
                .productId(123456L)
                .build();
        ChannelContext context = ChannelContext.builder()
                .requestId("REQ_001")
                .channelCode("TEST_CHANNEL")
                .action("CREATE_ORDER")
                .bizData(input)
                .build();
// 执行
        Boolean result = handler.handleTyped(input, context);
// 验证
        System.out.println("订单不存在场景测试结果: " + result);
        System.out.println("Context中的ORDER_EXISTS: " + context.getHandlerResult("ORDER_EXISTS"));
    }
@Test
publicvoidtestHandle_OrderExists(){
// 构建测试数据 - 订单已存在的情况
        CreateOrderBizData input = CreateOrderBizData.builder()
                .outOrderNo("OUT_ORDER_002")  // 这个订单号在数据库中已存在
                .channelCode("TEST_CHANNEL")
                .productId(123456L)
                .build();
        ChannelContext context = ChannelContext.builder()
                .requestId("REQ_002")
                .channelCode("TEST_CHANNEL")
                .action("CREATE_ORDER")
                .bizData(input)
                .build();
// 执行
        Boolean result = handler.handleTyped(input, context);
// 验证
        RecycleOrderVO existOrder = (RecycleOrderVO) context.getHandlerResult("ORDER_EXISTS");
        System.out.println("订单已存在场景测试结果: " + result);
        System.out.println("已存在订单信息: " + JsonUtils.toJsonWithoutNull(existOrder));
    }
}

第三层:集成测试

我在测试环境跑了完整的下单流程,验证Handler链的协作:

@RunWith(SpringRunner.class)
@ContextConfiguration("classpath:scf-spring-test.xml")
publicclassChannelUnifiedFacadeTest
{
@Resource
private IChannelUnifiedFacade channelUnifiedFacade;
@Resource
private IRecycleOrderService orderService;
@Test
publicvoidtestCreateOrder_FullProcess(){
// 构建完整的渠道请求
        CreateOrderBizData bizData = CreateOrderBizData.builder()
                .outOrderNo("TEST_OUT_ORDER_" + System.currentTimeMillis())
                .channelCode("KA")
                .productId(123456L)
                .categoryId(1L)
                .skuId(1001L)
                .userId(888888L)
                .picList(Collections.singletonList(
                    Pic.builder().picUrl("https://test.com/pic1.jpg").build()
                ))
                .build();
        ChannelRequest<CreateOrderBizData> request = ChannelRequest.<CreateOrderBizData>builder()
                .requestId("REQ_" + System.currentTimeMillis())
                .channelCode("KA")
                .action("CREATE_ORDER")
                .bizData(bizData)
                .build();
// 执行完整流程
        ChannelResponse<Long> response = channelUnifiedFacade.process(request);
// 打印结果
        System.out.println("=== 集成测试结果 ===");
        System.out.println("请求成功: " + response.isSuccess());
        System.out.println("订单ID: " + response.getData());
        System.out.println("响应码: " + response.getCode());
        System.out.println("响应信息: " + response.getMessage());
// 验证订单确实创建成功
if (response.getData() != null) {
            RecycleOrderVO order = orderService.getById(response.getData());
            System.out.println("订单详情: " + JsonUtils.toJsonWithoutNull(order));
            System.out.println("订单状态: " + order.getOrderState());
            System.out.println("外部订单号: " + order.getOutOrderNo());
        }
    }
}

3.4 Act:规则沉淀与持续优化

3.4.1 沉淀提示词模板

经过多次迭代,我总结出了一套可复用的提示词模板:

模板1:生成Handler

角色:你是一个Java后端工程师,熟悉责任链模式
任务:实现一个BusinessHandler,用于[具体功能]
要求:
1. 继承AbstractTypedBusinessHandler<P, R>
2. 输入类型是[P],输出类型是[R]
3. order值设置为[ORDER_VALUE]
4. 从context中获取[DEPENDENCY]
5. 将结果保存到context.putHandlerResult("[RESULT_KEY]", result)
6. 异常使用ChannelException,格式:new ChannelException(errorCode, message)
7. 添加日志:处理开始、处理成功、处理失败
参考代码:[粘贴参考Handler代码]

模板2:生成Adapter

角色:你是一个Java架构师,熟悉适配器模式和责任链模式
任务:实现[渠道名]ChannelAdapter
要求:
1. 继承AbstractIChannelAdapter
2. 注入以下Handler:[列出Handler列表]
3. 根据action构建不同的Handler链:
   - CREATE_ORDER: [Handler顺序]
   - UPDATE_ORDER: [Handler顺序]
4. 添加@Component注解,value为渠道code,用于自动注入
5. 添加完善的日志
参考代码:[粘贴AChannelAdapter代码]

3.4.2 持续优化

在重构过程中,我发现了一个可以提取的通用模式:参数校验。

最初,每个Handler都自己做参数校验:

// DuplicationCheckHandler
if (StringUtils.isBlank(input.getOutOrderNo())) {
thrownew ChannelException("PARAM_ERROR", "外部订单号不能为空");
}
// ChannelConfigHandler
if (StringUtils.isBlank(input.getChannelCode())) {
thrownew ChannelException("PARAM_ERROR", "渠道编码不能为空");
}

在Act阶段,我提取了一个通用的ParamValidationHandler:

@Component
publicclassParamValidationBusinessHandler
extendsAbstractTypedBusinessHandler<Object, Void> 
{
@Override
protected Void handleTyped(Object input, ChannelContext context){
//.....
returnnull;
    }
@Override
publicintgetOrder(){
return50; 
    }
}

现在,只需要在Handler链中加入这个Handler,就能统一处理参数校验了。

最后的话

这篇文章分享的是我们正在进行的探索,而非一个 "完美的成功案例" 。

我们的重构之旅才走了一小步,还有很多坑要踩,很多问题要解决。但我们选择边做边分享,因为:

真实的经验比完美的故事更有价值。

愿你在AI时代,既能拥抱新工具提升效率,又能保持对代码质量的追求、对架构美感的坚持。

关于作者,于天奇,侠客汇Java开发工程师。 想了解更多转转公司的业务实践,欢迎点击关注下方公众号

想了解更多转转公司的业务实践,欢迎点击关注下方公众号:

跳转微信打开

MyBatis-Plus踩坑血泪史:那些年我们踩过的坑!

2025年11月24日 18:26

原创 朱洪旭 2025-11-24 18:26 北京

前言:我们在生产环境里跑MyBatis-Plus很多年,几乎把能踩的坑都踩过了。每次出事故,都能追溯到我们当初以为“框架会帮忙搞定”的某个细节。于是我们把这些真实经历写下来,用更接地气的方式聊聊根因和解法,帮你少熬几次夜。

1、时代背景与ORM选择

1.1 互联网时代的数据挑战

业务量暴涨,数据也跟着狂飙。百万级数据在几年前还算大,如今动不动就上亿。与此同时,微服务拆分得越来越细,数据访问层变得又厚又复杂。大家一边要追新需求,一边又要兼顾性能稳定。没有趁手的开发工具,根本顶不住节奏。

1.2 MyBatis-Plus的诞生与定位

于是,Java团队开始在ORM世界里不断找平衡。Hibernate太重,原生MyBatis又太多手工活。MyBatis-Plus正是在这种“又想快又想稳”的诉求下出现的。它不是简单的“语法糖”,而是一个为了生产环境而生的增强框架。

MyBatis-Plus的核心价值:

  • 简化开发:CRUD都有封装,少写很多SQL,手更轻

  • 功能增强:逻辑删除、自动填充、乐观锁、多租户、代码生成器等都现成

  • 性能优化:内置分页、性能分析、批量优化、缓存插件,跑得更快

  • 无缝集成:兼容MyBatis,老项目也能慢慢替换,几乎不用重构

这些卖点让MyBatis-Plus迅速走红。不过,功能多并不等于好用。特别是到了生产环境,隐藏的坑一个接一个。


2、生产环境挑战

开发环境里一切都很顺。saveBatch()轻松搞定批量插入,@TableId(type = IdType.ASSIGN_ID)一写就有分布式ID,看起来稳得很。

然而,真正部署上线后问题才暴露出来。

凌晨3点的告警:主键冲突,订单系统停摆。我们发现两个容器实例生成了同一个雪花ID。理论上“不可能发生”的事,就这么发生了。

再往下排查,批量操作乱序、枚举字段写入异常、自动填充失灵……问题一个比一个离谱。

这些事故有个共同点:开发环境一切正常,生产环境却崩成一片。根本原因是单机和分布式、低并发和高并发之间的差异,被框架默认配置无限放大,结果就是“看着没事”的代码在生产里频频掉链子。

我们因此整理出MyBatis-Plus在生产环境最容易暴雷的6大陷阱:

  1. 雪花算法ID生成重复问题

  2. 批量插入乱序问题

  3. 枚举字段存储风险

  4. 驼峰转换错位

  5. 批量操作时自动填充失效

  6. 写入时JSON数据丢失或格式异常

接下来我们把这些问题逐一拆开,聊聊背后的逻辑,再给出实测可行的解法。


雪花算法ID生成重复问题

3.1 问题现象

// 看起来很正常的代码
@TableId(value = "id", type = IdType.ASSIGN_ID)
private Long id;
// 但在生产环境中却出现了这样的错误:
// Duplicate entry '1234567890123456789' for key 'PRIMARY'

“ID怎么还能撞?” 这是我们第一次遇到时的真实反应。

3.2 雪花算法身份证结构

先搞清楚雪花ID里面装了什么,再谈如何防重复。可以把它想成一个超长身份证号:

身份证号码:1234567890123456789
分解结构:
┌─────────┬─────────┬─────────┬─────────┐
│  时间戳  │ 数据中心 │ 机器编号 │ 序列号  │
│ (41位)  │ (5位)   │ (5位)   │ (12位)  │
└─────────┴─────────┴─────────┴─────────┘
  • 时间戳像出生年月日

  • 数据中心ID类似省份

  • 机器ID对应城市

  • 序列号就是同一毫秒的排队号

3.3 问题根源

我们把雪花ID重复的元凶总结成四类。

3.3.1 元凶一:未配置机器ID,所有实例走默认值

很多人以为框架会自动算出唯一的workerId,于是干脆不配。结果大家都走同一个默认流程。

MyBatis-Plus获取机器ID的策略:yBatis-Plus获取机器ID的策略

看似严谨,然而一旦进入第二步,容器环境下“撞车”概率直线上升。

3.3.2 元凶二:容器环境的MAC地址克隆

先看Docker容器MAC地址的规律:

Docker容器MAC地址格式:02:42:ac:11:00:XX
                     ├─────────────┤├─┤
                     固定前缀      变化部分
容器1:02:42:ac:11:00:02
容器2:02:42:ac:11:00:03  
容器3:02:42:ac:11:00:04
...

如果继续依赖“取后两字节再模32”的做法,就会出现下面的情况:

MAC地址计算流程:
1. 提取后2字节 → 00:02, 00:03, 00:04...
2. 位运算处理 → 得到不同的中间值
3. 模32取余 → 问题就出在这里
实际结果:
├─ 容器1-32:机器ID = 0-31 ✅
├─ 容器33:机器ID = 0 ❌
├─ 容器34:机器ID = 1 ❌
└─ 以此类推...

如此可见,只要实例超过32个,就一定有重复。

3.3.3 元凶三:Kubernetes环境的虚拟MAC

再看K8s。Pod里的网络接口本来就是虚拟的,MAC地址由CNI随机分配,还可能拿不到。 Kubernetes Pod网络特点:

  1. 每个Pod都有虚拟网络接口

  2. MAC地址由CNI插件分配

  3. 同一节点的Pod可能模式一致

  4. 某些环境下干脆拿不到MACyBatis-Plus获取机器MAC地址

这种情况下,100个Pod全用workerId=1,冲突直接拉满。

3.3.4 元凶四:时钟回拨

雪花算法非常依赖系统时间。一旦时钟被调回,就会闹出大问题。

雪花ID生成流程如下所示:雪花ID生成流程但是,如何出现时钟回拨,就会出现如下问题时钟回拨

当以下条件同时满足时,重复就无可避免:

相同的机器ID (workerId=1)
相同的数据中心ID (datacenterId=1)  
相同的时间戳 (timestamp=1634567890123)
相同的序列号 (sequence=0)

3.4 解决方案:给每台机器一个专属身份证

方案一:外部获取唯一的分布式ID

@Slf4j
@Component
publicclassIdHelper{
publicstaticlonggetIdc(){
try {
return ZZIdcClient.getInstance().get();
        } catch (Throwable e) {
            log.error("act=getIdc error={}", e.getMessage());
        }
// 兜底逻辑:为了不影响业务,如果从架构拿不到id,就采用IDHelper
// IDHelper有问题,并发情况下可能会生成重复id
        log.info("k=s act=getIdcByIDHelper");
return IDHelper.generator(0);
    }
}

方案二:使用数据库自增ID

package com.baomidou.mybatisplus.annotation;
publicenum IdType {
    AUTO(0),
    NONE(1),
    INPUT(2),
    ASSIGN_ID(3),
    ASSIGN_UUID(4),
/** @deprecated */
@Deprecated
    ID_WORKER(3),
/** @deprecated */
@Deprecated
    ID_WORKER_STR(3),
/** @deprecated */
@Deprecated
    UUID(4);
privatefinalint key;
}
/**
     * 主键ID
     */
@TableId(value = "id", type = IdType.AUTO)
private Long id;

4、批量插入乱序问题

4.1 问题现象

场景1:父子订单批量插入。当子订单准备入库时,父订单还没完成,外键直接挂掉。

// 期望:先插入父订单,再插入子订单
heroPackageService.saveBatch(packages);  // 父订单
heroOrderService.saveBatch(orders);      // 子订单
// 结果:外键约束失败!
// Cannot add or update a child row: a foreign key constraint fails

场景2:远程接口返回一个有序列表,我们存到数据库里,想在后续查询中保持原有顺序,结果还是乱了。

// 期望:远程获取数据之后,存在数据库,后续从数据库获取有序列表的快照
//远程获取外部有序集合
List<HeroPackage> heroPackageList = recycleRpcService.getHeroPackageList(uid)
//将远程获取数据存入数据库
heroPackageService.saveBatch(heroPackageList)
//从数据库获取有序集合数据
List<HeroPackage> heroPackageList = heroPackageService.list(uid);
// 结果:有序集合的顺序被打乱
// 

明明是按顺序调用的,为什么会乱序?

4.2 原理

可以把它想成快递分拣。你按顺序交包裹,分拣中心为了效率会重排路线,于是最终顺序就变了。

4.2.1 MyBatis-Plus的两种批量插入模式

官方其实有两套批量逻辑,差别非常大。

模式一:默认BATCH模式(逐条插入)

MyBatis-Plus默认saveBatch的执行流程:

  1. 接收数据列表

    1. Listpackages (1000条数据)

    2. 默认批次大小:1000

  2. 创建批处理SqlSession

    1. 使用 ExecutorType.BATCH

    2. 逐条执行INSERT

  3. 逐条加入批处理队列

    1. 第1条:INSERT INTO hero_package VALUES (...)

    2. 第2条:INSERT INTO hero_package VALUES (...)

    3. ...

    4. 第1000条:INSERT INTO hero_package VALUES (...)

  4. 达到批次大小后 flushStatements()

特点:

  1. 支持主键回填

  2. 单线程下顺序可控

  3. 多线程+驱动优化后容易乱序

  4. 网络往返次数多,性能一般

模式二:优化批处理模式(合并SQL)

配置方式:要么改全局配置,要么写自定义SQL

执行流程:

  1. 接收列表

  2. foreach拼成一条多值INSERT

  3. 一次性落库

特点:

  1. 单次往返,性能高

  2. 顺序完全可控

  3. 主键需要自己准备

  4. SQL过长时得自行分批

两种模式对比:

特性

默认BATCH模式

优化批处理模式

性能

多次往返,速度一般

单次往返,极快

顺序保证

单线程可控,多线程不稳

完全可控

主键回填

支持

不支持

适用场景

依赖数据库生成主键

自己能生成主键或无主键需求

4.2.2 根本原因二:JDBC驱动的批处理重排序

MySQL JDBC驱动为了提速,会把同表操作合并。原本交错的SQL被重新分组,顺序自然就乱了。

JDBC批处理模式:

模式1:rewriteBatchedStatements=false

  1. 逐条执行

  2. 顺序稳定

  3. 性能一般

模式2:rewriteBatchedStatements=true

  1. 自动合并SQL

  2. 性能飙升

  3. 顺序可能被“优化”

例子:
原始SQL:
INSERT INTO hero_package VALUES (..)
INSERT INTO hero_order VALUES (..)
INSERT INTO hero_package VALUES (..)
INSERT INTO hero_order VALUES (..)
驱动优化后:
INSERT INTO hero_package VALUES (...), (...)
INSERT INTO hero_order VALUES (...), (...)

顺序彻底变了。

4.2.3 根本原因三:数据库层面的执行优化

MySQL优化器也会“帮忙”重排执行计划。同一张表的操作被集中,避免频繁切换表,性能是好了,但依赖顺序的逻辑直接崩。

期望:
Package1 → Order1 → Package2 → Order2
实际:
Package1, Package2 → Order1, Order2
优化器心声:
既然都是INSERT,就分组吧
省得来回切换表         

问题在于,Order引用Package的主键。如果Package还没落库,Order插入必失败。

例如下面的真实案例。两个线程并发创建订单。批处理时队列不保证FIFO,于是订单项和订单的关系全乱套。

期望: 订单A → 订单项A → 订单B → 订单项B

现实: 线程A、线程B同时写入 批处理队列交错 驱动/数据库重排 → 可能先执行线程B的订单项,再执行线程A的 → 外键和业务逻辑全乱

4.3 解决方案:控制批处理节奏

我们常用两个思路:要么“分批+强制刷新”,要么“自定义SQL一次写完”。

方案一:分批次执行,强制刷新

@Transactional
publicvoidcreateOrdersInSequence(List<OrderData> orderDataList){
int batchSize = 100;
for (int i = 0; i < orderDataList.size(); i += batchSize) {
        List<OrderData> batch = orderDataList.subList(i, 
            Math.min(i + batchSize, orderDataList.size()));
// 先插入父订单
        List<HeroPackage> packages = buildPackages(batch);
        heroPackageService.saveBatch(packages);
        sqlSession.flushStatements(); // 强制执行,确保顺序
// 再插入子订单
        List<HeroOrder> orders = buildOrders(batch);
        heroOrderService.saveBatch(orders);
        sqlSession.flushStatements();
    }
}

方案二:自定义SQL,一次性插入

// 使用自定义SQL,完全控制执行顺序
@Insert({
"<script>",
"INSERT INTO hero_package (id, seller_uid, create_time) VALUES ",
"<foreach collection='packages' item='pkg' separator=','>",
"(#{pkg.id}, #{pkg.sellerUid}, #{pkg.createTime})",
"</foreach>",
"</script>"
})
voidinsertPackageBatch(@Param("packages") List<HeroPackage> packages);

5、枚举字段存储风险

5.1 问题现象:枚举字段存储异常

// 枚举定义
publicenum OrderStatus {
    PENDING(1, "待处理"),
    PROCESSING(2, "处理中"),
    COMPLETED(3, "已完成");
privatefinal Integer code;
privatefinal String desc;
}
// 实体类
publicclassHeroOrder{
private OrderStatus orderStatus; // 期望存储code值(1,2,3)
}
// 结果:数据库中存储的是枚举名称("PENDING", "PROCESSING", "COMPLETED")

5.2 深入原理:MyBatis的默认枚举处理

// MyBatis默认的枚举处理器
publicclassEnumTypeHandler<EextendsEnum<E>> extendsBaseTypeHandler<E> {
@Override
publicvoidsetNonNullParameter(PreparedStatement ps, int i, E parameter, JdbcType jdbcType){
// 默认使用枚举的name()方法!
        ps.setString(i, parameter.name()); // 存储"PENDING"而不是1
    }
}

5.3 解决方案:使用@EnumValue注解

publicenum OrderStatus {
    PENDING(1, "待处理"),
    PROCESSING(2, "处理中"),
    COMPLETED(3, "已完成");
@EnumValue// 标记这个字段用于数据库存储
privatefinal Integer code;
privatefinal String desc;
// 构造函数和getter...
}

6、驼峰转换错位

6.1 问题现象

// 数据库字段:seller_uid, buyer_uid, create_time
// 实体类字段:
publicclassHeroPackage{
private Long sellerUid;    // ✅ 正常映射
private Long buyerUID;     // ❌ 映射失败!
private Date createTime;   // ✅ 正常映射
private String XMLData;    // ❌ 映射失败!
}

6.2 原理

MyBatis-Plus的驼峰转换算法对连续大写很无奈。

// 驼峰转换算法(简化版)
publicclassCamelCaseConverter{
public String camelToUnderscore(String camelCase){
        StringBuilder result = new StringBuilder();
for (int i = 0; i < camelCase.length(); i++) {
char c = camelCase.charAt(i);
if (Character.isUpperCase(c)) {
if (i > 0) result.append('_');
                result.append(Character.toLowerCase(c));
            } else {
                result.append(c);
            }
        }
return result.toString();
    }
}
// 转换结果:
// sellerUid -> seller_uid ✅
// buyerUID -> buyer_u_i_d ❌ (期望: buyer_uid)
// XMLData -> x_m_l_data ❌ (期望: xml_data)

6.3 解决方案:明确字段映射

方案一:使用@TableField注解
publicclassHeroPackage{
private Long sellerUid;
@TableField("buyer_uid")  // 明确指定数据库字段名
private Long buyerUID;
private Date createTime;
@TableField("xml_data")
private String XMLData;
}
方案二:统一命名规范
// 推荐的命名规范
publicclassHeroPackage{
private Long sellerUid;     // 驼峰命名,避免连续大写
private Long buyerUid;      // 而不是buyerUID
private Date createTime;
private String xmlData;     // 而不是XMLData
}
方案三:自定义命名策略
@Configuration
publicclassMybatisPlusConfig{
@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor(){
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
// 自定义命名策略
        GlobalConfig globalConfig = new GlobalConfig();
        globalConfig.setDbConfig(new GlobalConfig.DbConfig() {{
// 自定义字段命名策略
            setColumnFormat("`%s`"); // 字段名加反引号,避免关键字冲突
            setTableFormat("`%s`");  // 表名加反引号
        }});
return interceptor;
    }
}

7、批量操作时自动填充失效

7.1 问题现象

// 实体类配置
publicclassHeroOrder{
@TableField(fill = FieldFill.INSERT)
private Date createTime;
@TableField(fill = FieldFill.INSERT_UPDATE)  
private Date updateTime;
@TableField(fill = FieldFill.INSERT)
private Long createBy;
}
// 自动填充处理器
@Component
publicclassMyMetaObjectHandlerimplementsMetaObjectHandler{
@Override
publicvoidinsertFill(MetaObject metaObject){
this.strictInsertFill(metaObject, "createTime", Date.class, newDate());
this.strictInsertFill(metaObject, "createBy", Long.class, getCurrentUserId());
    }
@Override
publicvoidupdateFill(MetaObject metaObject){
this.strictUpdateFill(metaObject, "updateTime", Date.class, newDate());
    }
}
// 问题现象:批量操作时自动填充失效!
List<HeroOrder> orders = buildOrders();
heroOrderService.saveBatch(orders); // createTime和createBy为null!

7.2 原理

// MyBatis-Plus的自动填充机制
publicclassDefaultSqlSession{
publicintinsert(String statement, Object parameter){
// 只有通过MyBatis-Plus的insert方法才会触发自动填充
if (parameter instanceof BaseEntity) {
            metaObjectHandler.insertFill(parameter); // 触发填充
        }
return executor.update(statement, parameter);
    }
publicintupdate(String statement, Object parameter){
if (parameter instanceof BaseEntity) {
            metaObjectHandler.updateFill(parameter); // 触发填充
        }
return executor.update(statement, parameter);
    }
}
// 但是批量操作使用的是JDBC批处理
publicvoidsaveBatch(Collection<T> entityList){
// 直接执行批量SQL,跳过了自动填充逻辑!
    String sql = "INSERT INTO table VALUES (?,?,?)";
    PreparedStatement ps = connection.prepareStatement(sql);
for (T entity : entityList) {
// 没有调用metaObjectHandler.insertFill()
        ps.setObject(1, entity.getId());
        ps.setObject(2, entity.getName());
        ps.addBatch();
    }
    ps.executeBatch();
}

7.3 解决方案:手动填充 + 批量优化

方案一:批量操作前手动填充
@Service
publicclassEnhancedOrderService{
@Autowired
private MyMetaObjectHandler metaObjectHandler;
publicbooleansaveBatchWithFill(Collection<HeroOrder> entityList){
// 手动触发自动填充
        entityList.forEach(entity -> {
            MetaObject metaObject = SystemMetaObject.forObject(entity);
            metaObjectHandler.insertFill(metaObject);
        });
// 然后执行批量保存
return heroOrderService.saveBatch(entityList);
    }
}
方案二:自定义批量保存方法
@Component
publicclassBatchSaveHelper{
public <T> booleansaveBatchWithAutoFill(Collection<T> entityList, 
                                           Class<T> entityClass,
                                           BaseMapper<T> mapper)
{
if (entityList.isEmpty()) {
returntrue;
        }
// 获取当前用户和时间
        Long currentUserId = getCurrentUserId();
        Date now = new Date();
// 反射设置自动填充字段
        entityList.forEach(entity -> {
try {
                setFieldValue(entity, "createTime", now);
                setFieldValue(entity, "updateTime", now);
                setFieldValue(entity, "createBy", currentUserId);
            } catch (Exception e) {
                log.warn("自动填充失败", e);
            }
        });
// 分批保存,避免SQL过长
int batchSize = 1000;
        List<T> list = new ArrayList<>(entityList);
for (int i = 0; i < list.size(); i += batchSize) {
            List<T> batch = list.subList(i, Math.min(i + batchSize, list.size()));
            mapper.insertBatch(batch); // 自定义批量插入方法
        }
returntrue;
    }
privatevoidsetFieldValue(Object obj, String fieldName, Object value)
throws Exception 
{
        Field field = obj.getClass().getDeclaredField(fieldName);
        field.setAccessible(true);
if (field.get(obj) == null) { // 只有为null时才设置
            field.set(obj, value);
        }
    }
}

8、写入时JSON数据丢失或格式异常

8.1 问题现象

// 实体类定义
publicclassHeroPackage{
private Long id;
private String packageName;
// JSON字段存储扩展属性
private Map<String, Object> extendInfo;
private List<String> tags;
}
// 保存数据
HeroPackage pkg = new HeroPackage();
pkg.setExtendInfo(Map.of("color", "红色", "weight", 1.5));
pkg.setTags(Arrays.asList("电子产品", "二手", "9成新"));
heroPackageService.save(pkg);
// 查询结果:extendInfo和tags字段为null!

8.2 原理

// MyBatis默认只能处理基本类型
publicclassDefaultTypeHandlerRegistry{
publicDefaultTypeHandlerRegistry(){
        register(String.class, newStringTypeHandler());
        register(Integer.class, newIntegerTypeHandler());
        register(Long.class, newLongTypeHandler());
// 没有Map和List的处理器!
    }
}
// 复杂对象会被toString()处理
Map<String, Object> map = Map.of("key", "value");
String result = map.toString(); // "{key=value}" - 不是标准JSON!

8.3 解决方案:数据类型规范化处理

我们的共识是:能不用复杂字段就别用。如果必须用,就自己管序列化。

方案一:数据库字段类型规范化
  • 表里尽量只放基本类型

  • Map、List先拆成具体字段,或者转成独立表

  • 复杂场景在业务层处理转换

方案二:手动序列化处理
  • 确实需要存结构化数据时,先序列化成JSON字符串

  • 存入VARCHAR或TEXT

  • 查询时再反序列化

实施建议: 优先走方案一。只有在业务强依赖动态结构时,再考虑方案二,记得封装好序列化逻辑,别把JSON工具散落在业务代码里。


总结与思考

种种案例都在提醒我们:框架默认值是给理想环境准备的,到了生产就得重新审视。如果不了解内部机制,就很容易掉进坑里。

启示一:默认配置靠不住
开发环境通常是单机、低并发,默认配置自然没问题。可一上生产,容器化、分布式、高并发齐聚,默认值瞬间变成隐患。别指望框架“自动”处理所有边角料。

启示二:机制理解少不了
只有搞清楚框架怎么运转,才能提前发现风险;真出事时,也能快速定位。知其然而且要知其所以然。

启示三:方案要服务于环境
你在什么环境里跑,就得配什么策略。容器、K8s、云原生都在挑战旧有假设。没有银弹,只有适配。

关于作者,朱洪旭,侠客汇Java开发工程师。

想了解更多转转公司的业务实践,欢迎点击关注下方公众号:

跳转微信打开

ITCP联盟第五届技术大会【AI基建专场】报名火热开启!

2025年11月19日 15:03

人才发展中心 2025-11-19 15:03 北京

以下文章来源于:Qunar技术沙龙

Qunar技术沙龙

Qunar技术沙龙是去哪儿网工程师小伙伴以及业界小伙伴们的学习交流平台。我们会分享Qunar和业界最前沿的热门技术趋势和话题,为中高端技术同学提供一个自由的技术交流和学习分享平台。

大会介绍 在AI从探索走向深度融合的关键阶段,可靠的基础设施与成功的场景应用已成为推动业务创新的双

大会介绍

      在AI从探索走向深度融合的关键阶段,可靠的基础设施与成功的场景应用已成为推动业务创新的双引擎,越来越多的企业在AI实践中取得了可喜的阶段性成果。

      秉持“近一步,更进一步”的精神,本次ITCP联盟技术大会特设【AI基建专场】与【AI应用专场】,旨在搭建汇聚AI前沿理念与实战经验的交流平台,并携手联盟内各公司,共同展示在AI基础设施建设与应用落地方面的优秀成果与最佳实践。

      本次【AI基建专场】,我们特别邀请了去哪儿旅行、转转、核桃编程的技术专家,他们将详细分享在智能体平台建设、研发流程自动化、强化微调、UI自动化测试系统等AI项目中的具体做法、遇到的挑战以及克服这些挑战的策略,帮助参会者更好地理解AI基建建设中的实践经验与最佳路径。

【时间】11月29日(周六)13:45-17:50

【地点】北京市维亚大厦8F大会议室

报名直通车

报名时间

11月19日-11月25日

报名方式

扫描二维码,提前预定席位

现场席位有限,先到先得呦

精彩预告

大会讲师及主题简介

马阳阳

去哪儿基础平台Java组负责人

负责去哪儿研发效率、质量类平台建设。近年探索 AI Agent 应用,主导自研公司级智能体平台 QMoss,已在内部实现规模化落地。曾担任公司内外多场技术大会明星讲师。

AI 小软件革命:

智能体平台驱动的万级 PD 提效实践

     为解决产运团队在日常工作中面临的大量重复、低价值的任务痛点,我们抓住大模型技术浪潮,探索出“AI 小软件”这一提效新范式。本次分享将阐述我们的核心解决思路:通过构建“智能体平台 + 多维表格”的黄金组合,实现 AI 应用的低门槛、规模化落地。

听众收益:

a、AI Infra 团队-如何建设智能体平台并大规模落地

b、产运团队-掌握 AI 小软件技能,提升工作效率

c、研发团队-AI 落地的场景挖掘思路及一套新研发模式

分享大纲:

1. 从人力到智能:LLM 引爆运营新纪元

2. 打造智能中枢:智能体平台建设实践

3. 业务创新实践:AI 小软件的多场景落地

4. 价值与经验:智能体平台的提效成就

5. 迈向未来:自进化的 AI 小软件生态

车天博

转转算法专家

负责转转大模型算法的后训练、百晓生问答(质检答疑)和智能客服应用,近期探索图文多模态问答。

强化微调(RFT)在转转后训练中的应用

在大模型广泛应用于业务场景的背景下,微调是最常见的优化方法。然而,传统微调在带来性能提升的同时,也会引入诸如通用能力下降(遗忘现象)与生成内容重复(复读机现象)等负面影响。本次分享将聚焦如何通过强化微调(RFT)技术优化模型后训练流程,更深入地挖掘数据潜在规律,并有效抑制上述常见问题,为大模型在业务中的稳定落地提供更可靠的技术路径。

通过本次分享,听众将系统性了解微调中常见问题的成因及应对思路,掌握 RFT 技术方法,并获得一套后训练体系的优化与业务模型效果提升的可借鉴解决方案。

分享大纲:

1. 强化微调(RFT)技术简介

1.1 强化微调训练流程

1.2 强化微调应用场景

2. 强化微调在百晓生(质检答疑)问答中的应用

2.1 百晓生业务简介

2.2 强化微调提升问答准确率

2.3 效果评估与展望

杨洪

核桃编程资深前端开发

主导核桃编程复杂组件库与通用业务模块的设计与实现,负责直播教师端、学生端相关系统、内部业务系统的核心模块开发与重构升级。

喜鹊 AI助手:从需求到上线的“自动驾驶”

在智能研发的浪潮下,如何让研发流程更加高效与智能化成为众多公司关注的核心议题。喜鹊工具应运而生,它覆盖了需求全生命周期,通过 AI 测试用例生成、AI 需求遗漏分析、AI Code Review 等核心能力,实现研发流程的全面智能化,并支持自动拉群、技术方案集中管理、一键回填上线信息、构建信息直达测试等功能。

     依托五大 AI 能力,喜鹊工具实现了全流程的自动化与智能提效,操作零门槛,使研发流程节点人工操作量减少 50%。

听众收益:

a.产品经理:需求文档质量提升,减少反复澄清。

b.开发工程师:提升代码提测质量,将问题前置。

c.测试工程师:测试用例生成节省50%工时。

d.整个团队:沟通成本大幅降低,机器人自动传递关键信息。

分享大纲:

1. 应用场景介绍

2. 可行性方案

3. dify实践与优化

4. 长期演进:由辅助转向主导,自适应迭代

崔宇

去哪儿大前端中心

用户增长负责人

负责去哪儿用户增长前端工作,负责公司 UI 自动化测试系统 TARS 平台及用户行为回溯平台,有多年前端客户端开发经验。

去哪儿TARS AI 自动化测试系统

在 AI 浪潮的推动下,UI 自动化测试作为提升测试效率的重要手段,一直备受业界关注。尽管市面上已出现了众多借助 AI 实现 UI 自动化测试的工具与案例,看似功能完善,但在实际落地过程中仍面临诸多挑战。本次分享将深入介绍去哪儿在推进 AI 自动化测试落地过程中的实际问题与应对经验,带来一线的实践洞察与思考。

分享聚焦真实痛点与实战经验,内容干货满满。听众将不仅能够全面了解 AI 自动化测试方案的整体架构思路,还能掌握实践中常见问题的解决路径,为未来的测试体系建设提供有益参考。

分享大纲:

1. AI 为 UI 自动化测试带来的新机遇

2. 实际落地遇到的问题

3. 去哪儿 UI 自动化测试实践经验

4. 落地场景案例

5. 总结展望

大会流程

汇聚 AI 先锋,共探技术前沿;

这场干货盛宴,等你赴约!

跳转微信打开

❌