铃阅
❌

阅读视图

锋芒再启,智码争先|第二届 Qunar AI Coding 大赛圆满收官

Qunar技术沙龙 2026-10-24 09:53 北京

锋芒再启,智码争先 | 第二届 Qunar AI Coding 大赛圆满收官

主视图.png

Qunar 第二届 AI Coding 大赛圆满落幕。

50支战队、百余位技术伙伴,以 AI 为工具,以代码为载体,在真实业务场景中探索智能编码的更多可能。从前期筹备、线上预热,到极限开发、专家评审,再到成果答辩、颁奖盛典 —— 每一轮比拼都凝聚着技术思考,每一份方案都瞄准业务落地。下面,让我们一起回顾这场迭代升级的 AI 技术盛宴,重温那些思维碰撞、全力攻坚的精彩瞬间。

组队报名

9月16日,大赛线上线下同步宣发。报名通道开启仅一小时,60支战队便快速完成报名集结。各位技术伙伴自由组队、踊跃响应,高涨的参赛热情,为本届赛事拉开精彩序幕。

赛题设计

在赛题设计方面,大赛紧扣业务真实需求:国际酒店、国际机票、大市场研发的三位出题人各设一题,兼顾难度梯度与 AI 技术的实用性,以端到端交付、多端融合、Case 通过率为核心设计评审规则。同时统筹测试环境部署与大模型资源调配,以周密的技术支撑确保赛事全程平稳有序、高效推进。

现场准备

现场1.jpg

赛场就位

赛场整装完毕,静待各路选手登场交锋。

茶歇补给

丰盛茶歇与奖品已就位,为比赛加满能量。

现场3.jpg

火热开赛

10月16日,Qunar AI Coding 巅峰挑战赛如期开赛!现场座无虚席,50支队伍即刻进入状态,全力开启 AI 冲刺模式。

开幕式上,技术中心负责人张宇、技术运营中心负责人孙斌先后登台,为选手们加油打气:预祝大家赛出好成绩,也期待大家借助 AI 编码能力,挖掘业务提效新方案,产出可落地、高价值的技术成果。

赛题发布后,赛场瞬间进入紧张的开发模式。各小组分工协作,高效配合。有人围坐头脑风暴,快速敲定实现思路;有人专注编码调试,反复验证每一段逻辑;有人排查环境问题,保障开发链路稳定;有人持续进行用例测试,排查方案短板。

选手们争分夺秒,即便用餐与茶歇时段,战队成员仍围在一起讨论优化方向,不放过任何提升方案效果的机会。大家专注攻坚的模样,尽显技术人探索 AI 的热忱。

在全程激烈的比赛当中,人才发展中心还邀请了多位神秘嘉宾莅临现场,为参赛选手发放午餐和晚餐,并为他们加油鼓劲。

 干饭时间🍚

期间,来自各业务线的5位负责人也先后为大家送上了鼓励,分别在中午和晚上进行了抽奖互动,为紧张的比赛增添了一丝轻松与惊喜。

抽奖1.jpg

Surprise

赛后评审

10月17日,AI 智能初审围绕端到端交付、多端融合、Case 通过率三大维度对各参赛队伍作品进行综合评估,筛选出晋级队伍进入复审环节。 

10月20日,复审评审团开展严谨全面的评审工作。评委们从端到端交付质量、端到端 AI 协同编程能力、跨栈融合与方案复用性、端到端方案演讲与表达四个方向进行了打分,结合业务视角给出了专业优化建议,帮助参赛作品持续打磨精进。

荣耀颁奖

10月22日,万众期待的颁奖环节如约而至!历经多轮激烈角逐与严谨评审,本届 AI Coding 大赛获奖名单重磅揭晓。获奖队伍登台领奖,接过荣誉,定格属于他们的闪光瞬间。

竞技终有句号,创新永无止境。

本届 Qunar AI Coding 大赛圆满落幕。

相较首届,选手们的 AI 编码能力与方案成熟度实现显著提升,涌现出更多巧思满满的优质作品。期待大家持续探索 AI 边界,把赛场上的创意与成果落地业务场景,用技术创造真实价值,为公司高质量发展注入源源不断的新动能。

向所有参与、助力本次大赛的同学致以诚挚谢意:

  • 感谢三位出题人(马东琳、雷磊、李征)的大赛题目设计;

  • 感谢李佳奇、李倩颖、王鹏、张培、吕波、王辉对大赛的题目支持;

  • 感谢李晓悦、鲁国宁、肖双、朱洪根、崔宇、曹飞广、范锦鹏、张远、宋璐、王岩对大赛流程与环境的保障支持;

  • 感谢张宇、高翔对大赛资源的支持;

  • 感谢16位评委的专业评审&点评(吴昊、于孝航、郑吉敏、沈龙梅、张灿群、李佳奇、张志均、淡新举、李扬、李倩颖、马东琳、雷磊、李征、王鹏、刘洋、李孟航);

  • 感谢行政及IT同学的通力协作与鼎力支持!

END

跳转微信打开

  •  

1024 A!“I” 在呢|致敬永远在线的 Qunar 技术人

Qunar技术沙龙 2026-10-22 18:55 北京

1024 A!“I”在呢

不分前后端

今天都通关

HAPPY  PROGRAMMER'S  DAY

各位旅客朋友们,大家好!

欢迎搭乘Qunar 1024专属列车。

本次列车始发站为节日预热,

沿途经停趣味闯关四大站点,

终点站为领取好礼。

列车即将发车,全程趣味相伴、福利满载。

预祝各位旅客旅途愉快!

始

发

站

节日预热

旅途启程,暖意先行!

本次1024之旅,

从趣味满满的预热活动开始。

我的AI搭子

节日前夕,驼圈上线专属话题!

小驼踊跃分享与AI的协作日常。

提前解锁节日氛围感,

诠释人机协同的全新工作方式。

左右滑动查看

代码送祝福

工区预热点位同步开启!

141名程序员写下专属祝福。 

以代码寄情,用程序员的浪漫

为本次旅途暖心预热。

左右滑动查看

众多小驼积极参与到本次预热活动中,

线上分享经验、线下书写祝福,

以创意与热忱,吹响Qunar 1024列车出发的号角。

途

经

站

趣味闯关

驶过温馨的节日预热站,

列车正式进入本次1024旅途的核心路段。

本次行程依次途经四大闯关站点,

智力挑战、体力考验络绎不绝。

快来跟随列车节奏,

逐站解锁专属旅途精彩!

AI?你知道

本站为AI知识试炼站。

限时趣味答题,

检验大家的AI知识储备。

骑迹能量站

本站为能量补给站。

单车蓄力制美食,

为旅途补足满满活力。

BUG一锅端

本站为BUG清剿站。

精准遮住BUG,

需要程序员手稳眼准。

全栈大闯关

本站为保龄球闯关站。

投球击中目标,

赢取程序员节高光时刻。

终

点

站

领取好礼

前方到站是终点站——领取好礼。

本次1024设置双重福利,

为每一位坚守岗位的技术人送上节日嘉奖。

1024 大红包

本次1024准备了惊喜红包。

现场抽选1名留言锦鲤驼,

送出1024元大大大红包。

同时抽选10名留言幸运驼,

送出102.4元幸运红包。

以实打实的心意致谢坚守。

游戏摊位礼物

预热&现场闯关均设置兑奖区,

参与即可获得对应摊位精美礼品。

集章还可解锁1024限定卫衣。

步步有惊喜,关关有回馈,

沉浸式解锁节日专属暖意。

结语

各位旅客朋友们,

本次QUNAR 1024列车已抵达终点。

再次祝全体程序员节日快乐!

我们明年再会!

未完待续……

跳转微信打开

  •  

AI 大模型如何重构数据库根因分析:从"人找原因"到"AI 找原因"

原创 去哪儿网DBA团队 2026-10-12 11:23 北京

e7aea0b2-cb9f-4322-b3ce-66271860cbe5.png

文章概览

图片

  • 告警排查的真相:不是找不到原因,而是每次都要重新找一遍

  • 整体架构:六层协同的智能诊断引擎

  • 架构选型:为什么是 LangGraph 而不是 LangChain 或 Dify

  • 意图识别:LLM 做理解,代码做计算

  • RCA 根因诊断:从 Pearson 到 Granger 的五层关联度分析

  • 智能问答:三速响应的分层策略

  • 对抗 LLM 的不确定性:速度与准确性的全局优化

  • 人机交互:让 AI 学会"等一等"

  • 安全与并发控制:AI 落地的生产级工程防线

  • 落地效果:DBA 的日常发生了什么变化

  • 总结

作者介绍:

杨赞,2023年加入去哪儿旅行,现任数据库管理员(DBA),负责 MySQL、Redis 的运维与稳定性治理,并主导慢查询分析系统、数据库智能巡检平台的设计与开发。近年来持续关注 AI for DB 领域,聚焦大模型在智能诊断、慢查询根因分析、异常检测等场景的落地实践,探索数据库运维从"经验驱动"走向"数据与智能驱动"。

告警排查的真相:不是找不到原因,而是每次都要重新找一遍

  日常巡检中,当接收到一条告警:"MySQL 实例活跃线程数飙高"。DBA 打开监控面板,开始逐项排查——先看扫描行数变化异常,再看有没有慢查询,再看 TOPSQL 有没有执行次数突增,接着查有没有 DDL 在执行、有没有发布变更……

  这个过程短则几分钟,长则几十分钟。如果同时来多个告警,排查压力会成倍放大。更关键的是,同样的排查思路,每次都要从头执行一遍——问题不在于"有没有办法排查",而在于"排查的经验和知识无法沉淀为自动化的能力"。

  而且,有些低概率诱因在人工排查时极易被遗漏,例如网络瞬时抖动、个别客户端容器资源紧张等,这些隐蔽因素往往需要反复排查多轮才能定位,大幅拉长了问题定位时间。

  这正是 AI 数据库运维 Agent 要解决的核心问题:把 DBA 的专家经验和排查流程,沉淀为一条自动化流水线,让 AI 接管"故障诊断"的场景,从"人找原因"变成"AI 找原因"。我们构建了一个基于 LLM 大模型的数据库智能运维 Agent,它能够自动完成从意图识别、参数提取、数据采集、算法分析、LLM 推理、根因定位到人机交互确认的全链路闭环。这篇文章将深入拆解它的架构设计、核心算法原理和优化思路。

下面是一次真实的诊断对话结果——用户只描述了"哪个实例、什么时段、什么现象",Agent 自动走完上述全链路闭环,最终输出一份结构化的诊断结论。例如用户输入 "x-xxxx.dxx.xx xx 2026-08-05 00:10:35 有流控",Agent 返回:

整体架构:六层协同的智能诊断引擎

在深入具体的技术决策之前,先建立全局视角——这个 Agent 是怎么组织起来的。它的整体架构可以抽象为六个层次,各层职责清晰、松耦合协同。

第一层,用户交互层。负责接收用户的诊断请求和发送回复。用户通过飞书消息发起请求,支持自然语言输入(如"x-xxxx.xx.xx xx  从 18:10-18:30 并发高")和结构化参数输入(由告警模版携带指标、时间、主机等字段)。回复通过飞书流式卡片呈现,支持实时进度更新,让用户感知 Agent 正在执行哪一步。

  第二层,意图识别层。负责任务的入口解析——从用户的自然语言中提取诊断对象(集群名、端口)、时间窗口和诊断意图。采用"LLM 做理解、代码做计算"的理念:大模型只负责语义理解和参数提取,日期计算、范围校验、规则修正全部由代码完成。通过四层流水线(预处理 → LLM 提取 → 后处理计算 → 校验兜底)和轻量 Flash 模型加速,首 token 延迟控制在 0.5 秒以内。详细设计见下一章。

  第三层,编排调度层。这是整个 Agent 的大脑中枢,基于 LangGraph 的 StateGraph 构建了一个包含 10 多个节点的有向图。流程覆盖从初始化、意图识别、参数校验,到按意图类型和数据库类型分流至不同处理节点(MySQL RCA、Redis RCA、智能问答、Redis 内存增长分析等),再到确认回复、HITL 等待、反馈处理,直至结束。每个节点通过显式条件边串联,支持 halt 短路和 interrupt 中断暂停及恢复。

  第四层,算法分析层。这是数学计算的部分——从 Prometheus、ES、MySQL 等数据源拉取监控数据后进行多维度关联分析,产出结构化证据(哪些指标异常、谁和谁高度相关、谁导致谁、异常时间线事件),成为 LLM 推理的输入。这一层的核心思想是"计算与推理分离":数学计算由代码完成,秒级出结果,准确无幻觉;LLM 不做计算,只做逻辑推理。具体算法细节在后续 RCA 章节中展开。

第五层,LLM 推理层。采用两阶段 LLM 调用设计——诊断 LLM 负责根因定位,建议 LLM 负责生成优化建议,两者使用独立的 prompt 和模型配置。分离的考量详见下文 RCA 章节。

第六层,数据采集层。Prometheus(监控时序数据)、Elasticsearch(慢查询日志)、MySQL(实例元数据)、DBA 运维平台 API(发布记录、工单、集群信息、硬件信息)等多源数据统一采集,供给算法层和 LLM 层使用。

这六层架构中,编排调度层是最关键的"大脑"——它决定了各层怎么协同、数据怎么流转、用户怎么参与。这就引出了本项目最核心的架构决策:编排调度层的引擎应该选什么?LangChain 的 Chain?Dify 的可视化画布?还是 LangGraph 的 StateGraph?下一章展开分析这个决策背后的权衡。

架构选型:为什么是 LangGraph 而不是 LangChain 或 Dify

  这是整个项目最关键的架构决策之一。在选型时,我们评估了三种主流方案:LangChain、Dify 和 LangGraph。三者在流程编排上的理念差异巨大,直接决定了 Agent 能否支持"暂停-恢复"的人机交互模式。

对比维度

LangGraph (StateGraph)

LangChain (Chain)

Dify (可视化工作流)

流程编排

显式条件边,每个节点的路由逻辑完全可见可控

固定线性流程,各节点按预定义顺序依次执行,无法根据中间结果动态选择下一节点

拖拽式可视化画布,简单直观,但复杂条件分支难以维护

共享状态

State 中心化管理,TypedDict 定义所有字段,节点只读写自己关心的部分

需手动在节点间传参,参数多时函数签名越来越长

变量节点 + 会话变量,多分支间状态传递能力有限

人机交互

原生 interrupt() + Command(resume=),图暂停后自动落盘 checkpoint

无原生支持,可通过自定义中间件 + 外部状态存储实现,但需自行处理序列化/恢复/超时

原生不支持暂停/恢复,需自行实现轮询或 Webhook 回调

长时间等待

checkpoint 持久化到 Redis,用户几分钟甚至 2 小时后回复仍可断点恢复

线程阻塞不可行,需自己实现状态机

工作流有超时限制,无法直接实现

超时取消

基于 checkpoint 时间戳 + Redis TTL 自动过期清理

需自行实现定时器 + 清理逻辑

平台级超时配置,无断点恢复能力

可观测性

每个节点可打印耗时日志,可随时查看当前图状态

中间状态不透明,调试困难

内置追踪面板和日志,可视化程度高

LangChain 是 LLM 应用开发领域最早成熟的框架之一,生态丰富、社区活跃,在快速搭建原型方面表现优秀。但在数据库运维 Agent 这个场景下,它有三个明显短板。

第一,流程控制不透明。LangChain 的 Chain 把执行流程硬编码为不可打断的线性链路,用户在过程里只能看到"卡片沉默十几秒然后突然蹦出结果",中间发生了什么完全不可见。LangGraph 可以把全流程拆成多个独立节点,节点之间可以插入进度更新,让用户实时感知"正在做什么"。对于耗时较长的节点,还通过后台定时线程每 3 秒刷新飞书卡片,提供秒级进度反馈——这种细粒度的可见性,在 LangChain Chain 的固定流程里根本插不进去。

第二,人机协同中的长时间等待——这是 LangGraph 最核心的差异化能力。数据库诊断不是一次性跑完就结束的:AI 产出结论后需要暂停等用户确认,用户可能几秒回复,也可能二十分钟后才有空看一眼。LangGraph 通过 interrupt() 原生支持暂停-恢复(落地细节详见人机交互章);而 LangChain 的 Chain 本质是一次性执行到底的流水线,要实现同样效果,需要自己动手实现"暂停→序列化→反序列化→恢复"的完整状态机,还要处理超时清理、回复去重、服务重启一致性等工程问题——不是在用框架,而是在框架之上再造一个微型框架。

  第三,多节点间的状态传递。Agent 的共享状态包含 70 多个字段,横跨输入参数、意图路由、飞书卡片上下文、诊断结果等七大类。LangChain Chain 模式下需在节点间手工传递,任一中间节点新增字段,所有下游节点的函数签名都要改。LangGraph 的方案是:所有节点共享 AgentState(TypedDict),每个节点只读写自己关心的字段,新增字段只需在 TypedDict 里加一行,不碰任何调用代码。

  Dify 作为可视化 LLM 应用构建平台,优势在于拖拽式画布简单直观,但在这个场景下有两个短板。第一,复杂流程编排受限 —— 十几个节点加多级条件分支,在画布上连线的可读性和维护性直线下降。第二,也是最致命的—— 原生不支持"暂停-恢复"模式,Agent 的长时间等待确认需求无法直接满足。

  综合来看,LangGraph 的持久化、显式条件边、State 中心化管理和原生 interrupt 机制,同时解决了数据库运维 Agent 的三大核心需求:细粒度的流程可见性与进度反馈、人机协同中的长时间等待与任意时刻恢复、以及多节点间复杂状态的高效共享。

  编排引擎选定了,六层架构的骨架也搭好了。下面进入具体能力的展开—— 首先是 Agent 的第一道关口:意图识别。

意图识别:LLM 做理解,代码做计算

  意图识别是 Agent 的入口关卡 —— 入口不能慢,慢了后面的诊断链路再快也没有意义;入口不能错,错了后面的分析再准也是白费。作为六层架构的第二层,它的核心任务是从用户的自然语言输入中提取结构化参数:诊断对象(哪个集群、哪个端口)、时间窗口(从几点到几点)、诊断意图(RCA 根因分析还是智能问答)。

  这个环节的设计原则是"LLM 做理解,代码做计算":大模型只负责理解语意,从自然语言中提取结构化参数,所有日期加减、范围校验、规则修正全部由代码完成。为什么要这样分工?因为 LLM 在确定性计算上并不可靠 —— 跨午夜日期计算错误率高达 5% 到 10%,而代码做这些运算又快又准。让 LLM 做数学计算,等于用瑞士军刀拧螺丝。

四层流水线:把脏活挡在 LLM 门外

  为了实现精准的意图识别,我们设计了一条四层递进式流水线,每一层解决一类问题。

预处理层 —— 把"脏活累活"挡在 LLM 门外。空输入直接拦截,不浪费后续资源。LLM 在日期偏移计算上容易出错,中文星期表达(如"上上周二")用正则预解析为具体日期,不给 LLM 犯错的机会。

LLM 提取层 —— 结构化信息提取。Prompt 中包含了多个 Few-shot 示例,按意图优先级分层判断:先排除纯 IP、纯 AppCode 等特殊场景归为问答,再判断 RCA 诊断类意图,最后提取时间范围。关键优化是 Prompt 中动态注入当前系统日期,防止 LLM 借用训练数据中的旧日期产生幻觉。

后处理计算层 —— Python 接手所有确定性运算。时间窗口在原始范围基础上前后各扩展 90 分钟和 20 分钟(给异常检测留足上下文),时间跨度超限直接拒绝。端口范围强制校正数据库类型,集群名自动补全实例地址。

校验兜底层 —— 做最后的防线。意图返回空时降级为问答模式,确保用户无论发什么都能得到合理的响应。

速度优化:轻模型 + 关思考 + 零重试

  在四层流水线保证了意图识别的准确性之后,响应速度就成了下一个要优化的目标 —— 意图识别是用户感知到的第一道延迟,必须做到秒级以内出结果。

  从三个维度压榨延迟。

模型选型:小模型干小活。 采用轻量 Flash 模型而非重型 Pro 模型。意图识别本质是结构化信息提取,不需要深度推理,小模型完全够用 —— 用牛刀杀鸡反而是浪费。

关掉思考链:不生成无用的内部推理。 DeepSeek 的 thinking 模式会产生大量内部推理 token,对意图识别这类"提取型"任务毫无增益。直接关闭后,首 token 延迟从约 3 秒降到约 0.5 秒。

零重试策略:一次调用拿全结果。 temperature=0 确保确定性输出,不重试,单次超时兜底,一次调用返回全部结构化字段,防止单字段缺失触发二次调用。

  这四层流水线加三重速度优化的组合,让意图识别既准又快,为后续的编排调度和根因诊断打下可靠的基础。这个环节体现的"LLM 做理解、代码做计算"原则,在接下来的 RCA 算法和智能问答模块中还会以不同形式反复出现—— 它是贯穿全局的设计主线。

RCA 根因诊断:从 Pearson 到 Granger 的五层关联度分析

  意图识别将请求按目的和数据库类型分流后,最核心的一条路径进入 RCA —— Root Cause Analysis,根因分析。这是整个 Agent 最重的能力模块,按诊断对象分为四个层级,覆盖了 MySQL、Redis、主机和 AppCode 的常见异常场景。

  • MySQL 实例级:活跃线程数、并发数、行锁时间、PXC 流控队列、每秒查询数、各 DML 操作速率等。

  • Redis 实例级:内存增长分析、内存分布分析。

  • 主机级:CPU 利用率、内存空闲比例、ping 丢包率。

  • AppCode 级:分析某个 AppCode 请求日志报错和客户端容器压力分布,自动识别异常集中的维度。

  除了以上四类定向诊断,Agent 还提供了一个兜底机制——全量自动检测模式。当用户只反馈"有异常"但未指明具体指标时,Agent 自动遍历所有可检测指标,基于专家经验(指标角色分类、优先级、异常严重程度)选定最可能影响业务的指标,再按正常流程分析。

关联度算法原理:计算与推理分离

  在进入 LLM 推理之前,先由代码层完成数学计算,产出结构化证据。为什么不让 LLM 直接看原始监控数据?每次根因分析涉及几十条监控曲线,每条曲线在诊断窗口内上百个数据点,全量传入意味着上千个时间戳和数值对,token 量轻松破万,LLM 推理时间动辄十几分钟。更致命的是,LLM 的本质是语言模型而非计算引擎 —— 它在数值比较、趋势判断、统计显著性检验上并不可靠,把原始数据直接丢给它做数学运算,不是它的专长。

  反过来说,LLM 真正的优势是逻辑推理和数据库领域知识串联。它不需要自己去"算"两个指标是否相关,只需要根据我们告诉它的结论 —— "活跃线程数与慢查询扫描行数的 Pearson 系数为 0.92,Granger 因果检验 p 值 0.003" —— 结合 MySQL 内核原理去判断因果链:到底是慢查询拖累了活跃线程,还是活跃线程高只是并发压力的表象,根因另有其人。这种"代码做计算、LLM 做推理"的分工,让 token 量从十万级骤降到千级,推理时间从十几分钟降到分钟级,同时彻底消灭了数学计算中的幻觉风险。这正是"计算与推理分离"理念的集中体现,基于这个理念,我们采用了五层递进式的关联度分析策略。

  第一层,时间对齐与异常检测。多个指标的数据采集粒度可能不同(有的 30 秒一个点,有的 60 秒一个点),需要先对齐到统一的时间粒度。代码将每个指标的数据转为 pandas 中的时间序列,按时间戳对齐后,针对不同指标类型采用不同的缺失值填充策略:普通监控指标用前向填充(缺失点通常与上一个点值相近),慢查询和 TOPSQL 等稀疏指标用 0 填充(没有数据意味着值为 0,不应向前蔓延)。异常检测采用滚动中位数加 MAD(中位绝对偏差)的稳健统计方法,对每个点用其前 N 个点建立基线,若当前值显著偏离基线则判定为异常。判定条件为双重门限:稳健 z-score 超过 k 倍,且相对基线变化幅度超过阈值。支持同时检测上升沿和下降沿,便于后续关联异常的开始与结束。

  第二层,Pearson 相关系数(记作 r)。通俗地说,Pearson 适合衡量线性相关的指标——它要的是"两条曲线一起上下晃":指标 1 涨,指标 2 也跟着涨;指标 1 降,指标 2 也跟着降。这种场景下关联系数就高。从严谨的角度来说,它衡量的是两个指标变化趋势的线性相关程度,r 的取值范围是 [-1, 1],绝对值越接近 1 线性相关性越强。同时输出 p 值判断统计显著性,p < 0.05 认为显著。r 和 p 值衡量的是两个不同维度:r 的绝对值回答"关联强不强",p 值回答"关联可不可信"——即使 r 很高,如果 p 值很大,这个强关联也可能是巧合;反之 r 很低时 p 值显著,也只说明"确实存在微弱关联"。只有 r 绝对值大且 p 值小,才意味着既有实际意义又统计可靠。但 Pearson 在实际落地中有两个局限性:第一,它只能描述"同步变化",不能判断"谁导致谁";第二,对于稀疏型指标(如慢查询数量,大部分时间为零)和低基线突发型指标(如 TOPSQL 扫描行数,异常时暴涨几十倍但只持续几个数据点),全序列 Pearson 系数会被大量正常点稀释,趋近于零,原本存在因果关联的指标反而无法通过相关性阈值筛选,被错误排除。

  第三层,数据模式识别与补充关联。Pearson 计算是对所有指标一视同仁的,但第二层提到的问题意味着:部分指标无法通过阈值筛选,不是因为它们和报警指标真的无关,而是它们的全序列 Pearson 系数被正常点稀释了。这时候需要换一把尺子重新审视 —— 把那些被 Pearson "误杀"的指标捞回来,用另一种方式再关联一次。

  怎么识别?不是看指标名称,而是看数据本身。我们不预先规定"慢查询用时间关联、TOPSQL 用时间关联" —— 这种硬编码方式脆弱且无法泛化,新接入一个未知指标就失效了。实际做法是:对每个未通过 Pearson 阈值筛选的指标,自动分析其数值在时间窗口内的分布特征,归为以下三种模式:

  1. 稀疏型:大部分时间值为 0,偶有非零值出现。

  • 典型场景:每分钟的慢查询数量,在 240 个时间点中可能只有 2 到 3 个点有值,其余全是 0。

  • 自动判定:零值占比 ≥ 50%。

  • Pearson 失效原因:序列中 98% 以上的点都是 0,即使慢查询的每次异常瞬间都精准伴随着活跃线程数的暴涨,全序列相关系数也趋近于 0。

2. 低基线突发型:平时在小数值范围平稳波动,异常时数值暴涨几十倍,但只持续极短的时间。

  • 典型场景:TOPSQL 扫描行数,平时在 1000 左右浮动,异常瞬间飙到 100000 以上,只维持 3 到 5 个采集点后回落。

  • 自动判定:存在超过中位数 30 倍的值,且这类突发点占比 ≤ 10%。

  • Pearson 失效原因:序列中 90% 以上的点是"小范围正常波动",少数突发的剧烈变化信号被统计平均数吞没。

3. 普通型:不满足以上两种特征,数据呈现常规的连续波动。

  • 典型场景:并发数、CPU 利用率、InnoDB 扫描行数等标准监控指标。

  • 处理方式:Pearson 结果即最终结论,不再补充。这类指标的 Pearson 系数本身就能有效捕捉变化趋势的线性关联。

  归为稀疏型或突发型的指标,意味着 Pearson 这把尺子量不准它们,需要换一把尺子 —— 时间窗口关联分析。核心思路是降维:不再关心"整条曲线的数值是否同步变化",而是关心"异常事件是否在时间上接近"。具体来说:对相关指标的每个异常点,在报警指标的异常点中寻找时间差在 60 秒以内的最近匹配。时间窗口关联会产出两个方向上的匹配率,分别回答不同的问题 —— 下面以"CPU 利用率报警"为例,CPU 是报警指标,慢查询是相关指标。

相关指标匹配率,回答的问题是:"这个慢查询的突增,有多少引起了 CPU 异常?"具体来说,它是慢查询异常点中匹配上 CPU 异常点的比例。例如慢查询有 8 个异常点,其中 5 个在 CPU 异常附近出现,匹配率就是 5/8 = 0.625。这个比率高,说明慢查询的大部分突增都和 CPU 飙高时间接近,意味着"只要慢查询异常,CPU 就跟着异常",是强因果信号。

报警指标匹配率,回答的是另一个方向的问题:"CPU 的异常,有多少是这个慢查询导致的?"它是 CPU 异常点中匹配上慢查询异常点的比例。例如 CPU 有 5 个飙高点,其中只有 1 个和慢查询异常时间接近,匹配率就是 1/5 = 0.2。这个比率高,说明 CPU 大部分异常都能用这个慢查询解释,意味着慢查询可能是唯一原因。这个比率低(比如 0.2),说明 CPU 的异常可能还有其他来源 —— 其他 TOPSQL、系统负载、IO 瓶颈等,不全是这个慢查询导致的。

  两个比率从不同角度衡量关联性,对比来看很清晰:相关指标匹配率从"原因看结果",分母是慢查询异常点总数,高意味着慢查询是原因,低意味着不相关;报警指标匹配率从"结果看原因",分母是 CPU 异常点总数,高意味着慢查询是唯一原因,低意味着 CPU 异常有其他原因。

  这个设计的本质思想是:Pearson 打头阵全覆盖,模式识别做兜底补漏。对连续波动型指标,Pearson 的结论直接可用;对稀疏突发型指标,自动识别出来后用时间关联补上。整个过程中,指标是稀疏、突发还是普通,完全由数据分布特征决定,不依赖任何指标名称的硬编码规则 —— 这才是能规模化落地的方案。

  第四层,时间窗口关联的细节优化。上一层的补充关联逻辑看起来简单直接,实际落地时有一个容易踩的坑:异常点太多导致关联度被稀释。稀疏指标用滚动中位数加 MAD 做异常检测时,如果基线全为 0、MAD 也为 0,任何非零值都会被判定为异常 —— 一个慢查询指标有 43 个非零点,就会产生 43 个"异常",但真正有业务意义的峰值可能只有 3 个。大量微弱异常点参与时间匹配后,分母膨胀,匹配率被严重拉低。解决方法是峰值匹配:只取该指标非零值中最大的 N 个异常点参与时间窗口匹配,忽略其余微弱波动,确保关联度不会被无关紧要的小幅抖动稀释。

  第五层,Granger 因果检验。前面几层已经回答了两个问题:"这两个指标波动趋势像不像"(Pearson 相关性) 和"它们的异常时间点碰不碰得上"(时间窗口关联)。但还缺关键一环 —— "谁先动,谁后动"。慢查询先涨、CPU 后涨,和 CPU 先涨、慢查询后涨,处理方案完全不同。Granger 检验就是专门回答方向性问题的。

  怎么判断方向?一种直觉式的思路是"抢先看":如果慢查询的历史数据能帮我们更准地预测 CPU 的未来走势,就说明慢查询"抢跑"了。Granger 检验把这个直觉变成了严格的统计检验。具体做法是分两步走:

第一步,比预测能力。 先用 CPU 自己的历史数据预测 CPU 当前值,记下预测误差;再把慢查询的历史数据也加进来一起预测,看误差有没有显著缩小。如果加入慢查询后预测明显变准了,就说明慢查询的历史承载了 CPU 自己历史之外的信息 —— 这就是"慢查询 Granger-cause CPU"的统计证据。这个过程走一遍还不够,因为影响可能有延迟。比如慢查询突增,可能要过 3 个采样周期 CPU 才飙起来。所以我们不是只试一个滞后阶数,而是从 1 阶(只看上一个点)一直试到最大阶(比如 5 阶,意味着假设影响最多滞后 5 个周期),取所有阶数里 p 值最小的那个。p < 0.05 判定存在 Granger 因果,同时也就锁定了最佳滞后阶数。

第二步,算影响力和方向。Granger 检验告诉我们"有没有影响,但没告诉我们"影响有多大"和"正向还是反向"。这就要用 VAR(向量自回归)模型来量化。具体方法是:先对数据做一阶差分消除趋势干扰,确保序列平稳,再把差分后的慢查询和 CPU 序列一起扔进 VAR 模型,让模型自己"学"出慢查询每变化一个单位,CPU 会相应变化多少。具体来说,模型会给出每个滞后阶数对应的系数,比如慢查询 t-1 时刻的系数是 +0.3,t-2 时刻是 +0.2,把所有系数累加起来就是总效应。正数说明同向变化(慢查询涨,CPU 涨),负数说明反向变化(慢查询涨,CPU 反而降),绝对值越大影响越强。

  Granger 检验也不是万能的,它有一个重要局限需要清醒认识:它证明的是"统计上的预测因果",不是"物理上的实际因果"。举个例子:InnoDB 读取行数和活跃线程数可能通过 Granger 检验 —— 前者历史值确实能预测后者变化。但真实原因可能是某个慢查询同时导致了两者增长,它们之间并没有直接因果链,只是被同一个幕后黑手驱动。算法只能告诉你"它们看起来有关系",但"这关系是真的还是巧合"需要懂数据库内核原理的逻辑推理来判断。这就是为什么 LLM 在这个系统里不是用来跑数学公式的 —— 数学交给算法,LLM 拿到统计结论后,结合自己对 MySQL 内核的理解,判断这条因果链在数据库场景下是否说得通。

  回顾整个 RCA 算法流程,五层算法完整呈现了"计算与推理分离"的设计原则。代码计算层的五步 —— 时间对齐与异常检测、Pearson 相关系数、数据模式识别与补充关联、时间窗口关联优化、Granger 因果检验 —— 全部由代码完成,秒级出结果,准确无幻觉。算法产出的结构化证据 —— 哪些指标异常、谁和谁高度相关、谁导致谁 —— 成为 LLM 推理的输入。LLM 拿到这些证据后不做数学计算,只做逻辑推理,结合 DBA 专家知识判断因果链。

  在 LLM 推理环节内部,还有一个关键设计:诊断 LLM 与建议 LLM 职责分离。下面展开这个决策背后的考量。

诊断与建议的 LLM 职责分离

  五层算法产出了完整的结构化证据,接下来进入 LLM 推理环节。这里有一个关键的设计决策:为什么要把诊断和建议拆成两次 LLM 调用,而不是一次搞定?直接原因是两类任务对数据的需求严重不对称。诊断需要的是"信号" —— 哪些指标异常、关联度多高、事件时间线是怎样的,这些信息轻量且聚焦,追求的是推理速度和判断准确性。建议需要的是"上下文" —— 表统计信息、索引分布、硬件配置、历史变更记录,这些信息详尽但冗长,追求的是方案的专业性和可操作性。如果把两种数据全部塞进一次 LLM 调用,诊断推理会被大量"虽然有用但不是现在该看"的信息干扰,既拖慢速度又稀释注意力。拆开之后各取所需,两头的效率和质量才都能保住。

  更深层的原因是职责分离。诊断和建议是两个性质完全不同的任务:诊断是"医生看病",需要的是因果推理和领域知识,输入要精炼、推理要快、结论要确定;建议是"开药方",需要的是完整的上下文信息和优化规则,信息不全会导致建议不专业。如果混在一次调用中,LLM 既要处理大段表信息,又要做逻辑推理,注意力会被无关信息稀释 —— 就像让医生一边看病历一边翻砖头厚的教科书,诊断效率大打折扣。拆开后,诊断 LLM 的 prompt 长度缩减近一半,推理速度大幅提升;建议 LLM 拿到完整的表统计信息、工单信息、备份历史等数据,生成的建议也更专业可靠。两者使用独立的 System Prompt、独立的输出格式约束、甚至独立的模型配置,互不干扰。

  RCA 是 Agent 的"核心引擎",但 Agent 的能力不止于此。意图识别层还有另一条重要的分流路径 —— 当用户的目的不是诊断而是查询时,请求会进入智能问答分支。下面展开这条同样体现"计算与推理分离"设计理念的能力线。

智能问答:三速响应的分层策略

智能问答是意图识别层中与 RCA 并列的另一条分流路径。当意图被判定为"问答"时,请求进入智能问答节点 —— 这里追求的是"一问即答",响应速度是第一优先级。

日常运维中有大量高频查询:查 IP 归属、问操作流程、确认集群负责人。用 LLM 处理至少 4 到 6 秒,太慢;完全不用 LLM,硬匹配又无法覆盖千变万化的提问方式。于是我们设计了三速响应的分层策略:零延迟通道、快速通道、LLM 通道,按速度从快到慢逐级降级,在覆盖率与响应速度之间找到最优平衡。

零延迟通道:正则拦截,0 次 LLM

  纯 IP 查询是能在意图识别阶段就被拦截的通道 —— 入口处正则检测到纯 IP,直接跳过 LLM 意图识别和 QA 节点的 LLM 调用,全程 0 次。代码层正则提取 IP、去重、并行查询后端 API,秒级返回结果。

快速通道:子串 + Bigram,1 次 LLM

  零延迟通道拦住了格式上就能判断的请求,但"如何申请离线库"和"怎么申请离线库"格式不一样、问的却是同一件事 —— 高频 FAQ 场景。这类"确定性问题 + 确定答案"不需要 LLM 推理,用 LLM 反而有三个代价:慢、贵、不稳定。

  我们用两层确定性匹配拦截。子串匹配:输入归一化后,直接与 FAQ 知识库做子串包含检查,命中即返回。Bigram 匹配:处理近精确匹配 —— "怎么"和"如何"在子串上对不上,但字符级二元组的 Jaccard 相似度高达 0.67,远超阈值 0.55。这个阈值经过校准:太低会把"怎么申请"和"怎么查看"误匹配,太高则覆盖不了"怎么/如何/怎样"的变体。两层匹配命中后直接返回,既省 token 又保一致性。上游意图识别仍需 1 次 LLM。

LLM 通道:一次调用,两项任务,2 次 LLM

前两级都匹配不上的问题(如"查一下 xx.xx.xx.xx 这台机器"),LLM 才介入,但一次调用完成两件事:FAQ 语义匹配 + 工具调用决策。System Prompt 嵌入 FAQ 知识库和同义映射表,LLM 先判断是否命中 FAQ,命中直接返回答案;未命中再决策调用哪些工具(查 IP、查集群负责人等),在单次推理中走完"理解 → 匹配 → 决策",无需多轮交互。

三个工程优化保障稳定性。工具去重:代码层按工具名和参数签名去重,防止 LLM 重复调用同一工具。并行执行:线程池最多 5 并发,总耗时约等于最慢那一次调用。结果不二次加工:工具返回值直接展示,不经过 LLM 润色 —— 润色既无增值又可能篡改事实。

  与 RCA 意图识别不同,QA 场景的 LLM 调用开启 thinking 模式。意图识别属于结构化提取,不需要推理链;但 QA 语义匹配需要推理"这个问法和 FAQ 里哪条是同一个意思",不开 thinking 可靠性会大幅下降。同一模型,不同场景,差异化配置。

  智能问答的三级分层,与意图识别的"代码预计算 + LLM 语义理解"、RCA 的"算法计算 + LLM 推理"同出一源 —— 都是让确定性的事交给代码,不确定性才交给 LLM。下一章将这套理念背后的工程防线统一梳理。

对抗 LLM 的不确定性:速度与准确性的全局优化

前面三个模块分别展开了意图识别、RCA 算法和智能问答的设计细节。细心的读者可能已经注意到,这些模块中散落着大量同类的优化手段 —— 意图识别的"关思考、零重试",RCA 的"诊断建议拆分、字段裁剪",智能问答的"快速通道、结果不二次加工"。这些孤立的手段背后,其实有两条贯穿全局的优化主线:速度优化和准确性保障。这一章把它们统一梳理,形成一套可复用的方法论。

响应速度优化:对抗 LLM 的注意力漂移

  大模型有一个天生的弱点 —— 注意力漂移。当 prompt 越来越长,模型对关键信息的关注度会逐渐稀释,就像一个同时盯着十块屏幕的人,最终哪块都看不清。这个现象在学术上叫"Lost in the Middle",大段文本中间的信息往往被模型忽略。我们的速度优化策略,本质上就是给 LLM 做"信息减负":让它只看到必须看到的内容,屏蔽一切噪音。

  这个思路在前文各模块中已有多次落地的实例,这里不再复述细节,只点明它们背后的共性规律。意图识别的 Flash 模型选型和诊断节点的 thinking 关闭 —— 本质都是"不同任务匹配不同算力";诊断与建议的 LLM 职责分离和字段裁剪 —— 本质都是"当前阶段不看当前阶段不需要的信息"。把这些分散的手段放在一起回看,共性只有一个:LLM 的注意力是稀缺资源,每一段不必要的信息都是在跟真正重要的信号抢关注度。 下面展开几个未被前文覆盖、但同样贯彻这一原则的优化手段。

按需注入,而非全量投喂。 以行锁告警为例,LLM 需要理解 InnoDB 行锁的持有机制、锁等待队列、DML 与 SELECT 的行锁差异等内核原理,才能做出准确判断。但如果是 CPU 飙高或 QPS 突增,这些行锁知识就是纯粹的噪音 —— 不仅浪费 token,还会把 LLM 的注意力从真正的关键指标上引开。我们的做法是把行锁原理章节从 System Prompt 中抽离为独立模板,通过占位符动态替换。命中行锁告警时注入完整原理,非行锁告警时替换为空字符串,每次节省数百 token 的同时,让 LLM 的注意力始终聚焦在当前告警类型最相关的信息上。

指标名规范化,降低认知负荷。 所有速率类指标统一加后缀标记,让 LLM 一眼就能区分"每秒值"和"累计值",避免把 `Innodb_rows_read`(累计值)误解为瞬时速率。这看似是一个小优化,但实际效果显著 —— LLM 在长 prompt 中容易被相似名称误导,清晰命名能大幅降低误判概率。

链接拼接后置,不让 LLM 做填空题。 监控链接、工单链接等,本质上是模板拼接 —— 把 IP、端口、时间范围填入 URL 模板即可。如果让 LLM 来生成这些链接,需要在 prompt 中塞入 20 多种链接模板规则,轻松膨胀数千 token,而且 LLM 还可能拼错参数。我们的做法是代码层根据根因类型自动匹配链接模板并生成完整 URL,LLM 输出中只需放占位符,后处理阶段统一替换。不仅节省 token,链接格式也 100% 正确。

二次精简:算法产出几万字符,LLM 只需几百。 算法层产出的完整数据包含每个异常点的精确时间戳和数值,但 LLM 不需要知道"15:03:30 活跃线程数 = 172"这种细粒度明细。精简策略很明确:只传异常时间范围不传每个采样点、只传强相关指标忽略弱相关、只传有 Granger 因果关系的指标。精简后提示词从数万字符压缩到几千字符,减少 70% 到 80%,让 LLM 的注意力集中在真正有因果关系的候选指标上。

这些优化手段合在一起,从模型选择、推理策略、输入裁剪、输出后处理四个维度协同作用 —— 它们并非各自为战,而是围绕同一个目标:把 LLM 的注意力集中在当前任务最关键的信息上,其余一律靠边。 但快还不够 —— 快且错,等于零。下面展开另一个维度:怎么保证 LLM 不乱说。

准确性保障:多层防御对抗幻觉

LLM 的本质是概率模型,输出天然带有不确定性。在数据库故障诊断场景中,这种不确定性的代价可能是把 DBA 引向完全错误的方向。我们的策略不是让 AI 变得"确定" —— 它的本质决定了做不到 —— 而是在 AI 周围构建一圈确定性的工程防线,从输入端到推理过程再到输出端,层层设防。

第一道防线:输入防御性校验。 LLM 看到用户输入之前,代码层已经完成了多层校验。纯数字拦截——如果用户输入只有数字没有任何自然语言,直接跳过 LLM,避免 LLM 把裸数字幻想为 Redis 端口去发起分析。System Prompt 中的日期占位符在运行时动态替换为当前系统日期,防止 LLM 借用训练数据中的旧日期。

第二道防线:预检查前置,把事实和推理分开。 在 LLM 介入之前,代码层先做完一轮确定性检查:是否有 truncate/drop 等 DDL 命令、系统日志中是否有网卡 down 或 OOM 记录、MySQL 错误日志中是否有 PXC 事务超限。这些信息如果直接丢给 LLM 让它自己判断"有没有 DDL,LLM 可能遗漏或误判。但用代码做确定性检查后,结果以"已确认的事实"的身份传给 LLM,LLM 的工作从"判断有没有"变成"结合已知事实做推理" —— 前者是计算,LLM 不擅长;后者是推理,LLM 擅长。

第三道防线:关掉随机性。所有 LLM 调用统一设置 temperature=0,让模型每次面对相同输入时坚定选择概率最高的输出。这一点看似简单,但对诊断结论的一致性至关重要 —— 同样的异常指标组合,不应该因为随机采样而得到不同的诊断结论。数据库故障诊断不是创意写作,不需要"换个说法",需要的是"同一组症状,同一个结论"。

第四道防线:Pydantic 约束输出格式。 对于不支持 json_schema 的模型,无法在模型层面直接约束输出结构。我们用 Pydantic 在代码层做"外挂模具" —— 字段类型、必填/可选、中文别名全部预定义,LLM 输出后由 Pydantic 二次校验,脏数据不会流入下游。

第五道防线:硬性排除清单,规则压倒统计。 相关性算法会产生大量"高相关但非根因"的候选指标。比如活跃线程数飙高时,慢查询数量也会跟着涨 —— 但只是因为并发高了执行次数多,SQL 本身并不慢。如果 LLM 仅凭 Pearson 系数 0.95 和 Granger 因果显著就判定为根因,就会把"被影响的后果"误判为"原因"。

我们在 prompt 中植入了多条硬性排除规则,要求 LLM 在分析每个候选根因时必须逐一检查。例如扫描行数均值小于阈值的直接排除,即使 Pearson 为 1.0、Granger 因果显著、时间完全重合,也不得列为根因。DDL 命令执行时间与异常增高时间差超过 2 分钟直接排除。行锁告警时 SELECT 类型的慢查询必须排除 —— SELECT 不持有行锁,这是 MySQL 内核原理,数学关联不等于因果关系。

第六道防线:反例教学,堵住 LLM"找理由保留"的倾向。 LLM 有一种惯性 —— 当它看到某个指标的关联度很高时,会倾向于"找理由"把它保留为根因。仅仅告诉它"扫描行数不达标就排除"是不够的,它在推理链中会自己绕过去。我们在 prompt 中嵌入了具体数值的反例:"即使扫描行数总和 = 85836、即使 Pearson r = 1.0、即使时间滞后 0 秒,只要平均扫描行数 = 354(< 6000),就必须排除。sum 达标也救不回来。"用具体数字堵住 LLM 的"找补"空间,比抽象规则有效得多。

第七道防线:输出后校验与补全。 LLM 推理完成后,代码层还会做一轮后处理。LLM 可能漏填 sql_id、数据库名、AppCode 等可选字段,代码从原始指标名中自动提取并回填。LLM 输出的链接占位符,代码统一替换为真实 URL。智能问答章节中提到的问候语兜底检测也在此处统一拦截,确保 LLM 的"客气话"不会伪装成正式答案。

这七道防线的背后有两条贯穿始终的原则。第一,"确定性的事交给代码,概率性的事交给 LLM"。 判断字段该显示在主机维度还是实例维度、资源使用率的红色高亮阈值、跨午夜的时间加减运算、监控链接的拼接 —— 这些逻辑由代码硬编码,LLM 只管它擅长的推理,不碰它不擅长的计算。第二,"无数据,不编造"。 当报警指标是行锁耗时,但慢查询和 TOPSQL 中都没有 DML 语句(只有 SELECT)时,LLM 必须返回"未定位到原因",严禁推测"可能是某条 UPDATE"或"可能是某条 DELETE"。数据真实性是底线 —— 宁可说不知道,也不能编造一个看起来很合理的答案。

  七道防线加两条原则的本质理念是一致的:不要期望 LLM 变完美,而是设计一个能让不完美的 LLM 稳定产出的系统。 这才是 Agent 工程化的核心思维。

RCA 的算法、智能问答的分层、速度与准确性的防线 —— 这三章覆盖了 Agent "怎么分析"和"怎么保证质量"。但还有一个能力维度没有展开:AI 如何在需要用户参与决策时优雅地"停下来"和"等一等"。下一章,我们展开人机协同调度这一设计。

人机交互:让 AI 学会"等一等"

在大多数 AI 应用中,交互模式是"一问一答" —— 你发消息,AI 回复,对话结束。数据库运维场景则复杂得多。以 Redis 内存增长分析为例:用户问"xxx 集群 63xx 端口的内存为什么涨了",AI 不能直接给答案,因为它不知道用户想对比哪两个时间点。它必须先停下来问"我这里有 10 个备份时间点,请选起始时间",等用户选完,再问"结束时间点选哪个?可选当前时间"。两轮交互后,才能开始真正的工作。

  这种"工作到一半暂停,等用户回复后再继续"的模式,在工程上远比"一问一答"复杂。它需要的不是"无状态"的 API 调用,而是一个能够在任意时刻完整保存执行现场、并在用户回复后精确恢复的有状态执行引擎。这正是架构选型中 LangGraph 所具备的核心能力。

checkpoint:把 AI 的执行进度"存档"

  LangGraph 的 checkpoint 机制是支撑这一切的基石。当图执行到需要用户交互的节点时,调用 interrupt() 暂停,LangGraph 自动将完整的图状态(包括所有变量、当前节点位置)序列化为一个快照,写入 Redis。用户回复后,飞书回调触发恢复函数,图从快照中精确还原,interrupt() 返回用户的回复内容,后续节点继续执行,就像从未中断过一样。

  这个机制有三个关键优势。长时间等待容忍:用户可能几分钟回复,也可能两小时后才回复,checkpoint 持久化到 Redis 后,Agent 不会有任何内存开销。超时自动清理:checkpoint 设置 TTL 为 180 分钟,超时后 Redis 自动删除,无需额外定时任务,用户回复时系统提示"会话已过期,请重新发起诊断"。天然支持重试:如果恢复过程中某个节点执行失败,可以从最近的 checkpoint 重新恢复,而不是从头开始。

双存储:把"执行进度"和"会话索引"分开

HITL 机制涉及两个存储系统,各司其职。checkpointer(RedisSaver)存储完整的图执行进度 —— 每个节点执行后自动写一个快照,约 200KB。它给 LangGraph 内部恢复用,读写开销大,不适合频繁查询。HitlStore 存储轻量级的会话索引 —— 记录 thread_id 与用户的映射关系,约 0.5KB。它给飞书回调做快速定位用:用户回复时,飞书回调需要根据用户 ID 快速找到对应的 thread_id,然后才能从 checkpointer 中恢复图状态。

  两者分离的好处很明确:checkpointer 是"重型仓库",存的是一整箱完整的执行快照;HitlStore 是"目录索引",只存一行映射关系。飞书回调每秒可能触发多次,每次都去反序列化 200KB 的完整快照太浪费,区区 0.5KB 的索引查询就能完成定位。

多轮交互:一个节点内暂停两次

  Redis 内存增长分析最有意思的设计挑战是:同一个节点需要暂停两次。用户选择起始时间点是一轮交互,选择结束时间点是另一轮。这带来了一个棘手的问题—— LangGraph 的 interrupt() 在恢复时返回的是 Command(resume=...) 的值,但如果同一个节点内调用了两次 interrupt(),第二次调用时恢复传入的值可能被第一次的 interrupt() 错误消费。

  我们的解决方案是用 Redis 做"中间结果缓存"。每次 interrupt() 返回的用户选择值,立即写入一个 Redis 键,并设置防重入标志防止节点重执行时重复写入。这样即使节点因某种原因重执行,也不会重复向用户提问。同时,resume_rca_graph() 在恢复前会检查 checkpoint 是否处于暂停状态、HitlStore 是否存在对应记录,双重确认后才会执行恢复操作,防止用户误发消息触发无效恢复。

安全与并发控制:AI 落地的生产级工程防线

一个 AI Agent 从 Demo 到生产级,安全与并发是绕不开的两道坎 —— 权限设计决定"谁能用",并发控制决定"能用多久不倒"。

权限:意图驱动的分级授权

  传统的权限控制通常放在入口处 —— 用户发起请求,先校验权限,不通过直接拒绝。但我们的 Agent 同时服务两类场景:智能问答和根因诊断。如果入口统一拦截,问答用户连基础问题都查不了,体验很差。

我们的方案是权限校验后置到意图识别之后。LLM 先判断出意图类型,再做分级鉴权:问答意图零门槛放行;`rca` 及 Redis 内存分析仅限 DBA 和管理员;检查appcode覆盖 DBA 加研发,权限稍宽。问答用户零门槛,敏感操作在意图明确后才细粒度拦截 —— 既有安全感又不影响体验。

并发:两级锁加单任务限制

  并发控制分层解决三个不同层面的问题。

全局并发数限制管控系统容量。一次 RCA 诊断涉及 Prometheus、ES、LLM 等多源调用,同时跑太多后端扛不住。通过信号量限制并行诊断总数,超限排队等待,飞书卡片实时显示"前面还有 N 个任务",最长等待 90 秒后友好退出。

每用户并发限制保障状态一致性。同一用户同时只允许 1 个诊断执行,且锁在 HITL 暂停期间保持不释放 —— 否则用户在等 Redis 时间点选择时再发起 MySQL 诊断,两个状态会互相串。锁 TTL 设为 1 小时作为进程崩溃的兜底,同时设计了主动死锁检测:锁创建超过 30 分钟判定过期,自动清除重试;服务重启时清空残留锁。

单任务并发限制保护被管理的外部系统。例如 Redis RDB 文件下载,单主机最多 2 个并行任务,避免大流量冲击带宽。核心原则是:AI 不能为了完成任务而伤害被管理的系统本身。

到这里,我们从架构选型一路走到生产级防线 —— Agent 的骨架、大脑、能力和护甲都已经展开完毕。接下来,我们从一个告警的生命周期来看,这些设计最终给 DBA 的日常工作带来了什么变化。

落地效果:DBA 的日常发生了什么变化

排查速度:从"跑断腿"到"等结论"。 DBA 不再需要像开头描述的那样一个个系统挨个翻数据。现在只需要用自然语言说一句"这个实例从几点到几点并发高",剩下的交给 Agent:几十条监控曲线自动分析对比、慢查询自动关联、变更和工单自动匹配。Agent 平均耗时 1 到 2 分钟即可产出诊断结论。DBA 的工作从"到处翻数据"变成了"审视证据、确认结论"。

覆盖度:从"看经验"到"不会忘"。 以前,排查哪些指标、查哪些日志,全看 DBA 的个人习惯和当天状态 —— 时间一紧,隐蔽诱因极易被遗漏,导致告警反复、多轮排查。现在,每一条告警自动完成全量预检查,该扫的日志、该查的记录一个不落,排查覆盖度不再因人而异。

知识复用:从"看人下菜"到"标配上阵"。 以前,同一个告警在不同 DBA 手里结论可能天差地别 —— 差距不在工具,而在"先查什么、后查什么、什么情况该排除什么因素"的排查思路。现在,专家思路被固化为统一流水线,排查质量和效率不再因人而异。

准确率:从"碰运气"到"可参考"。 Agent 上线后,RCA 根因诊断的准确率达到 70%。即便未命中主因,产出的异常指标关联图谱和事件也能大幅缩小 DBA 的人工排查范围,让二次定位有据可依。

总结

  回顾整个 Agent 的设计,三条原则贯穿始终。

原则一:计算归代码,推理归 LLM。 Pearson 相关系数、Granger 因果检验、基于 MAD 的鲁棒异常检测 —— 这些有数学公式的东西,由代码精确完成,产出的结构化证据再喂给 LLM。LLM 不碰数值计算,只做它擅长的事:结合 MySQL 运维知识,从证据链中推断因果逻辑。各司其职,各取所长。这条原则在意图识别的"LLM 做理解、代码做计算"、智能问答的"零延迟通道和快速通道"、准确性防线的"预检查前置、链接拼接后置"中反复落地 —— 它不是某一章的结论,而是全文的工程主线。

原则二:给 LLM 足够正确的上下文。 这不是一句口号,而是工程实践。相关性低于 0.6 的指标直接过滤,DDL 时间距异常窗口超过 2 分钟的裁剪掉,慢查询的大段信息诊断阶段不传 —— 所有喂给 LLM 的输入都经过代码精心筛选。给 LLM 的信息里,有效信号占比越高,推理就越准。这一点和日常使用 AI 的道理相通:不要丢一堆杂乱内容指望它能猜中重点,你得替它把路铺好。

原则三:人机协同闭环,人始终持有最终决策权。 以 Redis 内存增长分析为例:AI 查询完 RDB 备份列表后不会自己拍板选时间点,而是列出选项、暂停执行、等待用户回复。用户选定起始和结束时间点后,AI 才继续工作。整个过程 AI 是"建议者",人是"决策者" —— 生产环境的每一步关键操作都由人确认后再执行,这不是对 AI 的不信任,而是对生产系统的敬畏。

  这三条原则背后是一个更本质的认知:做 AI 业务架构师,而非 AI 使用者。 判断哪些环节适合交给 AI、哪些必须人来做,设计人机协作的流程,评估 AI 输出的质量并做最终决策 —— 这才是 AI 时代工程师的核心竞争力。把重复劳动交给 AI,把精力留给需要判断力和经验的环节;每次协作后检查 AI 输出有没有错误和遗漏,发现问题及时纠正——这不是在"调试 AI",而是在持续训练它更好地配合你。

  从"人找原因"到"AI 找原因",这条路的核心不是 LLM 本身有多强,而是怎么把 LLM 用对地方 —— 该计算的计算、该推理的推理、该让人拍板的必须让人拍板。一个合格的 AI 业务架构师,懂得的不只是"AI 能做什么",更是"什么该让 AI 做,什么必须人来做"。

跳转微信打开

  •  

去哪儿网:AI Coding驱动大型核心系统重构实践

原创 张培&薛锦泽 2026-08-17 11:43 北京

文章概览前言大型重构的难点,是系统级不确定性AI Coding 重构工程化方法论重构实践案例总结作者介绍:张培

e7aea0b2-cb9f-4322-b3ce-66271860cbe5.png

文章概览

图片

  • 前言

  • 大型重构的难点,是系统级不确定性

  • AI Coding 重构工程化方法论

  • 重构实践案例

  • 总结

作者介绍:

张培,2017年加入去哪儿旅行,国内机票报价技术负责人 / AI 研发 SIG 负责人。主要负责国内机票报价系统技术架构、稳定性与性能优化, 覆盖报价核心搜索系统等 P1 核心服务; 2025 起负责国内机票 AI Coding 从 0 到 1 建设, 推动技术中心 AI Coding 从个人提效走向端到端工程交付。

薛锦泽,2022年加入去哪儿旅行,目前在国内机票-主站报价与自营-国内报价团队,主要负责国内机票主流程搜索以及国内机票供应平台的基建与日常维护。

前言:AI Coding 不只适合小需求

过去一段时间,AI Coding 已经逐渐进入日常研发流程。对于目标清晰、范围集中的小需求,AI 往往可以快速完成代码修改、测试补充和问题修复,研发同学也很容易通过几轮交互形成闭环。

但这次我们想讨论的不是一次普通的小需求开发,而是一次 15 万行高并发核心系统重构:主流程强依赖、链路复杂、对性能和稳定性要求极高,任何不可控改动都可能带来线上风险。

这篇文章尝试回答三个问题:

  • AI Coding 能不能从“辅助写代码”,升级为“驱动大型重构的工程化执行系统”?

  • 在长上下文、大影响面、高风险场景下,如何让 AI 的执行过程可控、可验证、可回滚?

  • 一次大型重构真正可复用的经验,究竟是提示词、工具链,还是背s后的工程约束和质量闭环?

在这次实践中,我们最终拿到了一组结果:

维度

结果

交付效率

总工时:约 100PD → 30PD

性能收益

搜索主流程 P50 / P90 耗时均下降约 70%

资源收益

机器资源成本节省约 45%

上线结果

无 QA 介入,顺利上线无故障

相比结果本身,更值得讨论的是这套方法背后的工程化思路:先把大型重构变成目标可拆解、边界可约束、过程可验证、风险可回滚的执行系统,再让 AI 在这个系统里持续推进、反馈和沉淀证据。

一、大型重构的难点,是系统级不确定性

1、从局部功能交付到系统行为控制

小需求开发与大型系统重构的差异

小需求开发和大型系统重构的差异,不只是代码量从几十行变成几万行。更关键的变化,是目标从“局部功能交付”变成了“系统行为控制”。小需求只要改对一个功能点,并通过相对明确的测试路径,就能形成闭环;大型重构则必须证明一整条主链路在改造前后仍然行为一致,并且异常、性能、资源和副作用都在可控范围内。

这也是为什么大型重构不能简单套用小需求 AI Coding 的方式。两类任务看起来都是“让 AI 改代码”,但它们对上下文、验证和风险控制的要求完全不同。小需求里,AI 的局部理解偏差通常可以通过几轮交互快速修正;大型重构里,同样的偏差可能会被放大成系统级风险。

2、四类不确定性会决定重构成败

大型重构真正难的地方,不是某个类怎么改、某段逻辑怎么搬,而是重构完成后系统行为是否仍然可信。这个可信度来自对不确定性的持续消除。

  • 行为不确定。重构前后的请求、响应、异常语义是否一致,是否会在边界场景、历史配置或特殊数据路径下出现隐性差异。

  • 影响不确定。改动是否只影响目标链路,还是会误伤主流程、分支流程、缓存、配置逻辑或外部依赖。

  • 验证不确定。靠人工测试和少量回归用例,是否足以覆盖线上真实流量里的复杂组合场景。

  • 风险不确定。一旦线上出现差异,能否快速发现、定位、止损,并在必要时回滚到原流程。

如果这些不确定性没有被显式处理,AI 的执行就很容易变成“看起来完成了代码改造”,但团队无法判断它是否真的满足上线条件。大型重构最危险的不是 AI 不会写代码,而是在边界不清、验证不足时,它会用自己的隐含假设补齐缺失信息。

3、为什么传统重构成本高

传统重构之所以成本高,也正是因为这些不确定性需要大量人工消化。工程师要靠经验梳理系统结构、调用链路和隐性风险,要靠人工测试判断核心功能是否正常,还要在推进过程中持续记录分析结论、改造记录和验证结果。

传统痛点

在大型重构中的表现

带来的风险

工时投入大

代码梳理、逻辑迁移、测试回归依赖大量人工投入

推进周期长,过程容易被局部问题拖慢

系统认知不完整

系统结构、历史逻辑和隐性依赖依赖少数人的经验

容易遗漏边界场景和非主干链路

测试验证覆盖不足

人工测试通常优先覆盖核心功能,难以覆盖真实流量组合

上线后才暴露一致性或性能问题

过程沉淀不足

分析结论、改造记录、验证证据分散在不同会话或文档里

复盘困难,后续任务难以接续推进

任何一个环节缺失,都会让重构进入“代码改完了,但没人能证明它真的安全”的状态。对于主流程核心系统来说,这种状态本身就是风险。

4、AI Coding 的前提,是先把不确定性变成工程约束

让 AI 完成系统重构前必须补齐的四个工程条件

所以,让 AI 参与大型重构的前提,不是给它更长的上下文,也不是让它一次性理解完整系统,而是先把这些不确定性转化成工程约束:目标可拆解、边界可限定、验证可自动化、失败可回滚。只有先把执行环境设计清楚,AI Coding 才可能从“写代码工具”升级为“可持续推进重构的执行系统”。

换句话说,大型重构要解决的不是“让 AI 多写代码”,而是让 AI 在长上下文、大范围、高风险下仍然可控。下一步要讨论的,就是这套可控执行环境应该如何设计。

二、AI Coding 重构工程化方法论

第一章讨论的是大型重构为什么难:它面对的不是单点代码修改,而是系统级不确定性。要让 AI Coding 进入这种场景,核心不是给 AI 更大的自由度,而是先搭建一套可执行、可验证、可回滚的工程闭环。AI 在闭环里持续推进,人负责关键判断和风险控制。

1、先理解两个关键词:Harness 和 Loop

Harness 负责约束边界,Loop 负责反馈推进

在这套方法里,最重要的两个关键词是 Harness 和 Loop。Harness 解决的是“AI 能在什么边界内行动”,Loop 解决的是“AI 每一轮执行后如何反馈和继续”。两者结合后,AI 才不是在开放空间里自由发挥,而是在目标、边界、工具、验证和停止条件都明确的环境中执行。

  • Harness 是约束系统。它定义目标、边界、上下文、规则、可用工具和停止条件,决定 AI 可以做什么、不能做什么、遇到什么情况必须停下来。

  • Loop 是反馈系统。它让每次执行都经历计划、修改、验证、分析、记录和判断,决定下一步是继续推进、重试修复,还是升级给人工确认。

没有 Harness,AI 很容易在边界不清时自动补齐假设;没有 Loop,自动执行就容易变成失控的连续改动。大型重构需要的是二者共同工作:先把行动空间收敛,再让执行过程有反馈。

2、四阶段闭环:从目标到上线证据

AI Coding 驱动系统重构的四阶段闭环

有了 Harness 和 Loop 之后,重构流程需要被组织成可持续推进的阶段闭环。我们把大型重构拆成规划、设计、执行、验收四个阶段,只有执行阶段真正进入高频 AI Coding,前面的规划和设计主要用来把目标、边界、方案和验证条件对齐清楚。

  • 规划阶段。明确重构目标、扫描系统链路、建立指标基线,先回答“为什么改、改到什么程度算成功”。

  • 设计阶段。完成技术方案、里程碑拆解、Phase / Task 规划和依赖关系梳理,先回答“怎么改、按什么顺序改”。

  • 执行阶段。按照 Task 逐步执行 AI Coding,每次改动都要验证、记录和判断,失败后进入分析和修复流程。

  • 验收阶段。汇总测试结果、Diff 结论、指标效果和发布证据,判断是否具备进入下一阶段或上线收口的条件。

这个流程的重点不是把步骤画得更复杂,而是让每一步都有明确输入、输出和判断标准。AI 可以承担大量高频执行,但它不能替代流程本身。

3、人机分工:人负责判断,AI 负责高频执行

人负责方向与风险判断,AI 负责高频执行与沉淀

大型重构里,人和 AI 的分工必须清楚。AI 适合做信息整理、代码执行、测试反馈、Diff 分析和文档沉淀;人必须负责目标定义、边界判断、架构取舍、风险接受和上线决策。否则,AI 很容易在缺少判断标准的情况下,把执行效率变成风险放大器。

角色

主要职责

不能交出去的部分

人

目标定义、边界划定、架构判断、风险接受、上线决策

方向判断、方案取舍、是否继续推进

AI

代码扫描、方案辅助、代码修改、测试执行、Diff 分析、报告沉淀

不能替代人确认业务目标和风险边界

这意味着人的工作不是退到流程之外,也不是每一步都手写代码,而是在关键节点做判断、设边界、看证据。AI 的价值则体现在高频执行和沉淀上,把大量重复、细碎、可验证的工作持续推进下去。

4、任务拆解:先里程碑,再 Task

从重构目标拆到 AI 可稳定执行的 Task

大型重构不能直接把“大目标”交给 AI。目标越大,隐含假设越多,AI 越容易在不确定的地方自行补齐。更稳妥的做法,是先把重构目标拆成里程碑,再拆成 Phase,最后拆到 AI 可稳定执行的 Task。

  • 里程碑用于表达阶段性业务目标,例如先保证行为一致,再做性能优化,最后做灰度收口。

  • Phase用于表达一组有共同验收目标的任务集合,便于阶段性 Go / No-Go 判断。

  • Task是 AI 可稳定执行的最小工程单元,最好接近一次小需求改动,并且能独立验证、独立回滚。

一个合格的 Task 不能只有一句“实现某能力”。它至少要说明输入、输出、修改范围、不修改内容、验收标准、风险点和回滚方案。Task 越清楚,AI 的执行空间越稳定,后续验证和排障也越容易。

5、Task 文件:先约束输入,再沉淀证据

Task 文件必须定义执行输入、验证标准和风险出口

Task 是 AI 可稳定执行的最小工程单元。但要让 AI 稳定执行,Task 文件不能只写一句“实现某能力”。它必须提前定义执行输入、验证标准和风险出口,让 AI 知道该改什么、不能改什么、做到什么程度算完成,以及遇到什么情况必须停下来。

  • 做什么。写清任务目标、业务背景、交付物和成功状态,避免 AI 只理解局部代码改动,却忽略这次改动服务的阶段目标。

  • 改哪里。写清影响范围、涉及模块、代码改动清单、依赖关系和预期输出,让执行边界足够具体。

  • 不改哪里。写清不能触碰的链路、接口语义、配置项、外部副作用和历史兼容逻辑,减少“顺手优化”带来的系统风险。

  • 怎么验。写清编译、单测、自动化测试、Diff、回归和性能指标等验证标准,让 Task 是否通过有明确证据。

  • 失败怎么办。写清回滚方案、失败策略、Human Gate 和停止条件,让 AI 不会在异常状态下继续扩大改动范围。

Task 文件的作用不是“给 AI 一段需求描述”,而是把一次改动约束成可执行、可验证、可恢复的小闭环。Task 写得越清楚,AI 的自由发挥空间越小,后续排障和复盘成本也越低。

产物沉淀:

Task 执行完成后,还必须沉淀执行证据。代码写完不代表 Task 完成,真正完成的标准是执行文档、执行记录、验证结果和判断结论都可以被后续任务复用。

沉淀产物

记录内容

作用

Task 执行记录

修改文件、修改原因、改动摘要、不修改内容

让每次 AI Coding 都能被追溯和复盘

验证结果

编译、单测、自动化测试、Diff 分析、性能数据

证明本次 Task 是否具备进入下一步的条件

风险判断

遗留风险、失败原因、是否需要人工确认

控制 Loop 的下一步方向,避免盲目继续执行

产物链接

方案文档、代码变更、测试报告、部署记录

支持跨会话恢复上下文,也方便后续任务复用

6、项目总览文件与自动化执行

项目总览文件是 AI 项目的执行入口和状态源

当 Task 数量变多后,单轮对话不可能承载全部上下文。大型 AI Coding 项目需要一个项目总览文件,作为文档导航页、状态页、上下文恢复入口和自动化执行入口。

  • 项目定义。记录背景、目标、范围边界、关键约束和最终验收标准。

  • 过程产物链接。聚合方案、架构、任务拆解、Task graph、验证文档和部署记录。

  • 执行状态。记录每个里程碑、Phase、Task 的进度、通过情况、阻塞原因和下一步动作。

  • 上下文恢复。让 AI 在新会话里能快速定位当前项目状态,而不是重新从头理解整套系统。

自动化执行不是让 AI 一直跑,而是让 AI 按项目总览和 Task graph 找到下一个可执行任务,进入 Harness + Loop 执行;完成后,再把执行记录、验证结果和产物链接回写到总览文件。这样项目即使跨会话、跨阶段,也能持续推进。

项目总览文件本质上是大型 AI Coding 项目的状态源。它把“人脑记住的项目进度”变成“机器可读取、团队可复查、任务可接续”的工程资产。

7、发布级质量控制

Task 通过不等于可以直接全量上线。Task 级验证只能证明单次改动在局部范围内可控,发布级验证要证明新流程在真实流量下行为一致、指标稳定、异常可回退。

  • 影子双跑。新旧流程同时运行,用 Diff 对比核心结果,先在不影响线上行为的情况下收集差异。

  • 灰度切流。逐步提高新流程真实流量占比,避免一次性全量切换带来的不可控风险。

  • 监控放量。持续观察成功率、耗时、错误率、资源消耗和核心业务指标,判断是否满足继续放量条件。

  • 异常止损。指标超过阈值时自动切回原流程,并保留排障证据,保证问题可定位、可恢复。

发布级质量控制把“开发正确”推进到“生产可控”。只有当真实流量下的行为一致性、性能指标和回退能力都满足要求,大型重构才具备上线收口条件。

三、重构实践案例

第二章讨论的是工程闭环本身:如何用 Harness 约束边界,用 Loop 推动执行,用 Task 和项目总览文件承载上下文。第三章进入真实案例,看这套方法如何落到一次主流程核心系统重构中。

这不是一次边缘工具改造,而是一次涉及搜索和填单页链路的核心系统重构。它的关键挑战不只是代码量大,而是必须在高并发、强依赖、性能敏感的真实生产环境里证明行为一致、指标稳定、异常可回退。

1、模型选择:

AI Coding 模型:业界主流Coding大模型

2、这是一次什么级别的重构

近15w代码、高并发系统重构

这个风险等级决定了后续写法:我们不能只讲“AI 写了多少代码”,而要先交代系统复杂度、业务痛点、重构目标和验证条件。只有把这些背景说清楚,后面的里程碑拆解和发布控制才有上下文。

本次重构涉及多个主流程核心应用。系统经历了长期业务迭代,承担了更多业务支持的关键能力,既有历史逻辑复杂,也有高 QPS 和性能约束。

系统定位

约束

搜索引擎系统

约 10.5 万行,QPS 10k,IO + CPU 密集

包装系统

约 4.9 万行,QPS 1.6k,CPU 密集

预定系统

稳定性要求高,QPS 80

系统当前存在的问题:

问题与痛点

影响

不同系统各自维护三方数据源,系统业务逻辑高度耦合

数据口径不一致,业务一致性难以保障

核心业务高速迭代,加速系统腐化,导致后续需求迭代成本高

影响业务推进速度,测试维护困难

系统传输报文数据传输大,qps高

系统IO压力大,导致单机问题出现频繁

系统问题也不是单一维度的“代码老化”。不同业务方在系统中各自维护数据源,数据口径容易分散;原本独立的系统随着业务演进逐渐形成强耦合,跨系统调用带来维护和测试成本;计算量与报文量持续增长,也让远程调用链路暴露出性能瓶颈。

重构目标:

  1. 合并搜索核心链路系统

  2. 三方数据源统一,解跨系统业务口径策略不一致问题

  3. 整体规划流程系统性能优化,搜索P50耗时190ms->120ms, 节省30%服务器资源

3、里程碑拆解:先一致、再优化、后收口

重构里程碑划分

确定目标和边界后,下一步不是立刻写代码,而是决定推进顺序。大型重构的拆解顺序,不能只按“哪个模块好改”来排,而要按“风险能否逐步收敛”来排。

这个顺序背后的原则是:先保证行为一致,再优化结构和性能,最后灰度收口。也就是说,收益不是第一优先级,先让系统行为可信,才有资格继续推进性能优化和旧链路退场。

4、先框定 M1 的目标和边界

在整体里程碑中,我们先展开 M1。M1 的目标不是一次性完成全部系统合并,而是先让选举系统具备本地包装能力,并通过一致性验证证明新旧链路行为可对齐。

目标明确之后,更重要的是边界明确。大型重构不是让 AI 自由改系统,而是先限定可改路径、不可改代码和验收证据,再把可执行部分交给 AI。

  • 修改范围护栏。只改 相关链路和实现承接,其他搜索、缓存、选举流程代码不动。

  • 行为语义护栏。请求、响应、异常语义保持不变,核心链路差异必须通过 Diff 收敛。

  • 运行安全护栏。通过影子双跑、灰度切流和自动止损控制发布风险,不做一次性全量替换。

  • 副作用护栏。影子链路不写 MQ、Redis 或外部系统,新增验证不能影响主流程稳定性。

5、执行路线:9 个 Phase、34 个 Task

M1 被拆成 9 个 Phase、34 个 Task,按依赖关系逐步推进。

在 M1 内部,我们继续把工作拆成 9 个 Phase、34 个 Task。这里不直接平铺 34 个 Task,而是在 Task 之上增加 Phase,是为了让路线更容易理解,也便于按阶段设定验收条件。

  • Phase表达一组有共同目标的任务集合,可以作为阶段性推进和验收单元。

  • Task表达 AI 可稳定执行的最小工程单元,每个 Task 都有独立目标、边界、验收和回滚方式。

  • Task 类型区分为 MANUAL、CODE、CONFIG、VERIFY,其中 CODE 是主要进入 AI Coding 的部分,MANUAL 和关键 VERIFY 需要人工判断。

  • 执行顺序按 Task 依赖关系推进,而不是让 AI 随机挑选任务执行。

这样拆解后,AI 执行的不再是一个模糊的大型重构目标,而是一系列接近小需求粒度、可以逐步验证的小闭环。项目总览文件负责记录当前进度、任务依赖和执行状态,自动化执行则按总览文件找到下一个可执行 Task。

项目总览文件汇总背景目标、方案产物、Phase / Task 进度和执行状态

路线图只能说明“任务怎么拆”,项目总览文件负责说明“项目跑到哪里”。它把仓库、背景目标、方案产物、Phase / Task 状态和执行记录汇总在一起,成为跨会话恢复上下文的入口;而到单个 Task 层面,还需要继续沉淀执行记录,避免代码改动和验证证据散落在不同会话里。

Task 执行记录沉淀代码变更、测试结果、部署信息和风险判断

6、Diff 闭环:真实流量差异是下一轮修复输入

线上 Diff 进入拉取日志、聚类分析、问题定位、修复方案和人工确认闭环。

在这个项目里,Diff 不是问题结论,而是下一轮修复的输入。影子双跑可以把新旧流程放到真实流量下对比,但 Diff 出现之后,真正重要的是让差异进入“聚类、定位、修复、复验”的闭环。

  • 拉取 Diff 日志。根据 traceId、时间、环境补足上下文,避免只看单条差异就下结论。

  • 聚集性分析。把相似差异归类,识别高频异常和集中出现的场景。

  • 问题定位。结合模块、配置和代码路径判断可能根因。

  • 生成修复方案。由 AI 辅助给出改动建议和补充验证建议。

  • 人工确认后执行。是否采用、如何灰度、是否回滚必须由人确认,再交给 AI Coding 进入下一轮修复。

这也是 AI Coding 在大型重构里的另一个价值:它不只写代码,也能参与线上差异分析和修复方案生成。但排障边界必须清楚,AI 可以辅助聚类、定位和建议,关键风险判断仍然由人拍板。

7、结果验证:效率、性能、资源收益

维度

结果

效率收益

整体工时节省: 100PD → 30PD,提效约 70%

性能收益

核心链路响应降低:P50 191ms → 59ms,P90 644ms → 195ms,下降约 70%

资源收益

资源成本节省约 45%

上线结果

无 QA 介入,顺利上线无故障

最终结果需要回到证据本身。大型重构的收益不能只看交付速度,还要同时看行为一致、发布可控、性能改善和资源收敛。

这些结果成立的前提,是前面的行为一致性验证和发布级质量控制。效率、性能和资源收益只有在系统行为可信、线上风险可控的前提下,才真正有工程价值。

四、总结:AI Coding 的价值不止是写代码

回到这次重构本身,AI Coding 真正带来的变化,不只是让 AI 多写了一些代码,而是把一个高风险、长周期、强依赖验证的系统工程,拆进了可以持续推进的工程闭环里。

对于大型系统重构来说,最难的部分往往不是某一段代码怎么改,而是这些问题能不能被持续控制住:目标是否清楚,边界是否明确;任务是否能拆成可执行、可验收的单元;每次修改是否有自动化验证和执行证据;线上风险是否能通过 Diff、灰度、监控和回滚机制收敛。

1、AI 负责高频执行,人负责关键判断

在这个过程中,AI 更适合承担高频、重复、上下文明确的执行工作,例如代码迁移、接口适配、测试补充、日志分析和文档沉淀;而人仍然需要负责目标判断、方案取舍、风险识别和最终确认。

这也是大型重构中比较重要的一点:不是把决策完全交给 AI,而是让 AI 在清晰的工程约束里工作。约束越清楚,AI 的产出越稳定;验证越充分,团队对自动化执行的信任越容易建立。

2、把复杂问题拆成可验证的 Task

从实践看,Task 是 AI Coding 能否稳定运行的关键单元。一个好的 Task 不只是“要改什么”,还应该说明为什么改、改到哪里、如何验证、风险是什么、完成后留下什么证据。

当 Task 足够清楚时,AI 的执行就不再依赖某一次对话里的临场发挥,而是依赖结构化输入、自动化验证和持续沉淀。对于大型重构,这比单次生成代码更重要。

3、最终沉淀的是团队能力

一次重构结束后,真正值得保留下来的不只是代码本身,还包括任务拆解方式、项目总览文件、验证脚本、Diff 分析流程、发布检查项和风险处理经验。

这些资产沉淀下来之后,下一次面对类似的大型改造,团队就不需要从零开始摸索,而是可以复用一套更成熟的工作方式:先把不确定性变成工程约束,再把工程约束交给 AI 和自动化流程反复执行、验证和修正。

因此,AI Coding 在大型系统重构中的价值,可以概括为一句话:它不是替代工程治理,而是把工程治理变得更细、更连续、更容易被执行。

跳转微信打开

  •  

风起山野,梦向远方 | 2026Qunar产研应届生素质拓展圆满结束!

Qunar技术沙龙 2026-07-20 16:39 北京

风起山野,梦向远方 | 2026Qunar产研应届生素质拓展圆满结束!

与驼友相伴

与盛夏相拥

2026Qunar产研户外素质拓展

为帮助职场萌新快速融入、平稳过渡,人才发展中心为产运&技术应届生们安排了一场元气满满的素质拓展活动,接下来一起奔赴这场“向往的生活”之旅吧!

01.欢乐出发,趣味破冰!

7月17日集结号正式吹响,2026届产研应届生乘坐大巴从公司出发。一小时的车程满载期待与欢声笑语,转眼间大家便抵达营地,此次“向往的生活”之旅正式开启!

趣味分组

捏捏肩,拍拍背,同事姓名要记对。分组抱团快反应,组员同行才会赢。

经典拼图的趣味游戏帮助大家迅速熟络起来,同时确认分组。找对组员,后面的竞赛才能事半功倍!

默契互动

热身之后,竞赛才刚刚开始。新组建的村庄选出村长后,需要一起完成掰棒谷、五谷丰登、草帽翻盘三项任务。各村庄凝心聚力、配合默契,全员斗志昂扬,全力以赴向着胜利冲刺!

鱼与鸡鹅不可兼得!村民们分工合作,在草地抓鸡采蛋,在栅栏内套大鹅,或在池塘中浑水摸鱼,感受智力和体力的双重考验。

竞赛优胜小队能收获专属金币,将成为后续食材竞拍的关键筹码。满怀期待的新小驼们全员奋力冲刺,丝毫不敢松懈!

02.上得职场,下得厨房!

刺激竞拍

终于迎来本次活动的重头戏,也是新小驼们最期待的环节——食材竞拍!

用竞赛换来的金币竞拍食物,紧张又刺激,为了抢到心仪的食物,叫价声此起彼伏。这场拍卖可不只是金币的豪赌,更是一场决策和统筹的智慧比拼。

✦✦

厨王争霸

心仪的食材到手,大家都投入到紧张刺激的晚餐筹备中,但这不是简单的烹饪,而是获得“厨王”称号的机会。每一个团队都全力以赴,分工明确,势必要拿到“厨王”称号!

评比全程公平公正,评委逐道细品各组拿手好菜,审慎选择心目中的“厨王”,最终究竟花落谁家呢?

答案揭晓!黄队凭借一道色泽浓郁、香辣诱人的特色小炒拔得头筹,全队收获专属彩票奖品,实至名归拿下厨王称号!

03.载歌载舞,青春永驻!

温馨聚餐

夕阳西下,忙碌了一天的小驼们也迎来了放松时间。大家坐在一起,品尝自己制作的美味佳肴,分享一整天的快乐,在欢声笑语间,大家的距离更近了。

左右滑动查看更多

篝火晚会

活动接近尾声,但大家的热情不减,恰如熊熊燃烧的篝火越燃越旺。大家手拉手,跟随教练的口号跳着青春洋溢的舞步。最后,在大家的注视下,绚烂的烟火直上云霄,为本次活动画上圆满的句号。

结语

途有友而不觉远,一场难忘的素拓活动,将每一位Qunar新成员凝聚在一起,相信在今后的工作中他们也能协同合作、互帮互助,以更加昂扬的姿态并肩前行,共同逐梦向往的生活!

-END-

跳转微信打开

  •  

去哪儿网-ES分片运维实战:从原理到十万级分片治理

原创 许睿哲 2026-06-09 15:30 北京

e7aea0b2-cb9f-4322-b3ce-66271860cbe5.png

文章概览

图片

  • 工作背景

  • 分片管理核心原理

  • 分片恢复核心参数与调优实践

  • 分片重平衡参数与性能优化

  • 分片策略最佳实践

  • 分片治理生产案例

  • 分片运维高频实操命令

  • 分片使用运维总结

  • 参考文献

作者介绍:

许睿哲,2020年12月加入去哪儿网-数据平台团队,目前主要负责公司ESAAS云服务与实时日志ELK平台的开发、维护与优化工作。主导了ES平台的SLA规则制定与开发,并负责容灾架构设计、实时日志集群构建与拆分重构等项目。

一、工作背景

在日常ES集群运维工作中,我们发现相当大比例的集群稳定性问题、性能瓶颈、扩容故障,核心问题都集中在分片规划不合理、分片恢复参数默认化、重平衡机制不熟悉这三点上。

此文从相关原理展开并结合生产实践(十万级分片治理),阐述ES分片的使用与实践方案。可以作为日常使用与运维参考。

二、分片管理核心原理

2.1 主分片与副本分片核心机制

ES 集群由多个索引构成,索引由多个分片构成。单个索引的数据会被拆分多份,分散存储在集群不同节点上,以此实现海量数据存储、读写负载分担和高可用容灾。

一般来说,分片分为主分片和副本分片两类,分工明确,缺一不可。

ES集群索引分片分布图

主分片(Primary Shards):集群写操作的唯一核心执行者,索引的新增、修改、删除请求,都会先在主分片执行成功,再同步数据至对应副本分片,保障集群数据一致性。

注:索引创建后,主分片数量无法修改。若规划失误,只能通过重建索引或Reindex迁移数据解决。

副本分片(Replica Shards):主分片的完整数据备份,不参与任何写请求,核心作用有两个:

1.高可用容灾:当主分片所在节点宕机、离线,副本分片会自动晋升为主分片,避免数据丢失、服务中断;

2.分担读压力:所有查询、检索请求并行命中主、副本分片,大幅提升集群查询吞吐量。

注:主分片只能有一份,副本分片可以设置0到多份。生产环境禁止配置0副本,否则存在丢数据风险。

2.1.1 生产分片分配核心原则

ES 有内置的分片分配策略(自动动态调整的),也是线上需要了解的分配策略:

  • 核心定律:同一主分片和自身的副本分片绝对不会分配在同一个节点,避免单节点宕机导致分片整体丢失。

  • 负载优先:集群会自动将分片分配到分片数较少、 CPU/内存/磁盘负载更低的节点,以均衡集群压力。

  • 整体均衡:自动调整各节点分片数量,避免单节点分片过多引发资源耗尽或查询超时。

注:ES自带的分配策略不一定是最优的,有时必须人工干预。例如:日志集群新增3个节点后创建次日索引,大量分片会倾斜给新节点。若不干预,势必导致新节点压力飙高甚至宕机。

2.2 分片恢复与重平衡机制

当集群发生扩缩容、节点故障重启、索引创建时,ES 会自动触发分片恢复与重平衡(Rebalance)操作,该阶段也是集群抖动的高发期。只有深入理解底层机制,才能做到精准调参、有效规避故障。

2.2.1 分片恢复机制

当节点故障离线、集群新增节点后,集群中会出现大量未分配分片,ES 会自动将这些分片恢复、迁移至正常节点,恢复分片副本,保障数据高可用。

2.2.2 分片重平衡机制

当集群拓扑发生变化(节点新增、离线、故障)导致分片分布不均衡时,ES会自动执行重平衡,跨节点迁移分片以保证整体负载均匀。

注:中小集群重平衡利好,但十万级大集群的自动重平衡往往是故障根源。

2.2.3 生产常见分片状态解读

日常运维排查故障,重点关注这5种分片状态,快速定位问题:

  • STARTED:分片初始化完成,正常运行、可读写,无异常。

  • UNASSIGNED:分片未分配到任何节点,属于异常状态,需及时排查原因(磁盘不足、分配规则限制、节点故障等)。

  • INITIALIZING:分片正在初始化,节点重启、分片新建后常见临时状态。

  • RECOVERING:分片正在从其他节点同步恢复数据,扩容、重启后高频出现。

  • RELOCATED:分片正在跨节点迁移,重平衡过程中的临时状态。

三、分片恢复核心参数与调优实践

分片恢复参数是集群运维的核心重点,默认参数适配性低,集群扩容、节点重启后,极易出现恢复速度过慢、长时间卡在恢复中,或者恢复并发过高打满磁盘、带宽的问题。合理调整参数对集群恢复正常运维是至关重要的。

3.1 核心恢复参数详解(业务集群使用)

以下参数均支持集群全局配置,适配ES主流版本,包括默认参数与生产建议值:

集群参数恢复参数配置示例:

    PUT /_cluster/settings
    {
      "persistent": {
        "cluster.routing.allocation.node_concurrent_recoveries": 8,
        "cluster.routing.allocation.node_concurrent_incoming_recoveries": 8,
        "cluster.routing.allocation.node_concurrent_outgoing_recoveries": 8,
        "cluster.routing.allocation.node_initial_primaries_recoveries": 8,
        "indices.recovery.max_bytes_per_sec": "200mb"
      }
    }

    注:如果集群同时配置了transient和persistent,通常 transient会覆盖后者,但重启后会丢失。修改配置前请务必确认两者是否冲突,不一致时系统以transient为准。

    3.2 分片恢复过程监控命令

    扩容、重启、故障恢复期间,需实时监控分片恢复进度和节点负载:

    # 1. 监控分片恢复详细进度、耗时、源目标节点
    GET /_cat/recovery?v=true&h=i,s,t,ty,shost,thost,f,fp,b,bp
    # 2. 查看集群整体健康状态,定位分片异常
    GET /_cluster/health
    # 3. 查看节点磁盘、堆内存负载,防止恢复过程资源打满
    GET /_cat/nodes?v&h=name,diskUsed,diskAvail,heapUsed,heapMax

    四、分片重平衡参数与性能优化

    重平衡机制是一把双刃剑:默认自动均衡能保证分片均匀,但频繁、大规模重平衡会占用带宽和磁盘IO,导致业务查询超时。

    4.1 重平衡核心参数详解

    4.1.1 重平衡开关控制

    cluster.routing.rebalance.enable:控制集群分片迁移、重平衡的权限,生产运维高频使用,支持4种配置:

    • all:默认值,允许所有分片迁移、全量重平衡。

    • primaries:仅主分片允许重平衡,副本禁止迁移。

    • replicas:仅副本分片允许重平衡,主分片禁止迁移。

    • none:关闭所有分片重平衡。维护、重启、扩容期间必备配置。

    注:cluster.routing.rebalance.enable 和 cluster.routing.allocation.enable 容易搞混,以下是整理的区别:

    1. cluster.routing.rebalance.enable:控制「已分配的分片要不要迁移均衡」(重平衡)有效值:all、primaries、replicas、none。

    2. cluster.routing.allocation.enable:控制「新分片能不能分配、恢复」(分片分配)有效值:all、primaries、new_primaries、none。

    4.1.2 重平衡并发控制

    cluster.routing.allocation.cluster_concurrent_rebalance:控制集群全局同时执行的重平衡数量,默认2。高配集群可按需调大以加速均衡。

    4.1.3 实操配置命令

      # 1. 集群维护、节点重启:禁用所有分片迁移
      PUT /_cluster/settings
      {
        "transient": {
          "cluster.routing.rebalance.enable": "none"
        }
      }
      # 2. 仅允许主分片移动
      PUT /_cluster/settings
      {
        "transient": {
          "cluster.routing.rebalance.enable": "primaries"
        }
      }
      # 3. 维护完成,恢复默认重平衡规则
      PUT /_cluster/settings
      {
        "transient": {
          "cluster.routing.rebalance.enable": "all",
          "cluster.routing.allocation.cluster_concurrent_rebalance": 2
        }
      }

      4.2 重平衡配套优化策略

      磁盘水位线是控制分片迁移的关键参数,生产环境必须提前配置:

        PUT /_cluster/settings

        {

          "persistent": {

            "cluster.routing.allocation.disk.watermark.low": "85%",

            "cluster.routing.allocation.disk.watermark.high": "90%",

            "cluster.routing.allocation.disk.watermark.flood_stage": "95%"

          }

        }


        参数说明:

        low(85%~90%):ES停止向该节点分配新分片,已有分片正常读写。

        high(90%~95%):ES 会主动把当前节点上已有的分片迁移到其他空闲节点,逐步清空该节点压力。

        flood_stage(95%):节点上的所有索引被强制设为只读,无法写入。

        注:磁盘空间需配置告警,提前预警并及时处理,避免达flood_stage 影响业务。

        五、分片策略最佳实践

        5.1 分片数量规划规范

        分片数量是前期规划的重中之重,一旦创建无法修改,不合理的分片数会长期拖累集群性能。统一的生产标准:

        • 单分片最优大小: 业务索引10-30GB,日志索引可达50GB左右。过小浪费资源,过大影响恢复和查询。

        • 分片数量上限: 单索引总分片数不超过集群数据节点数的2倍。

        • 集群分片总数: 建议不超过10万。

        • 节点分片总数: 默认不超过1000,最大建议不超过3000。过多会影响元数据和master稳定性,导致节点脱离集群。

        分片规格常规推荐方案

        分片数调整方案

        主分片数创建后无法直接修改,只能通过重建索引调整:

        5.1.1 常规分片重构(停服方式)

          # 1. 新建目标分片数的索引

          PUT /new-index

          {

            "settings": { "number_of_shards": 3 },

            "mappings": { "properties": {} }

          }

          # 2. 全量迁移数据

          POST /_reindex

          {

            "source": { "index": "my-index" },

            "dest": { "index": "new-index" }

          }

          # 3. 删除原始索引并回写

          DELETE my-index

          POST /_reindex

          {

            "source": { "index": "new-index" },

            "dest": { "index": "my-index" }

          }

          注:Reindex重构成本高,需停写与补数。若不接受停服,推荐使用下方别名方式。


          5.1.2 生产推荐分片重构(零停机别名切换)

          按照上述的索引名称:

          • 旧索引:my-index(主分片不能改)

          • 新索引:my-index-v2(新索引可以设置需要的新分片数)

          • 业务使用别名:my-index-alias

            # 1. 给旧索引绑定别名(业务统一使用别名访问)

            POST /_aliases

            {

              "actions": [{ "add": { "index": "my-index", "alias": "my-index-alias" } }]

            }

            # 2. 创建新索引(设置新的主分片数)

            PUT /my-index-v2

            {

              "settings": { "number_of_shards": 3, "number_of_replicas": 1 },

              "mappings": { "properties": { ... } }

            }

            # 3. 异步Reindex迁移数据

            POST /_reindex?wait_for_completion=false

            {

              "source": { "index": "my-index" },

              "dest": { "index": "my-index-v2" }

            }

            # 4. 查看进度:

            GET _tasks/task_id

            # 5. 无缝切换别名(原子操作,0停服)

            POST /_aliases

            {

              "actions": [

                { "remove": { "index": "my-index", "alias": "my-index-alias" } },

                { "add": { "index": "my-index-v2", "alias": "my-index-alias" } }

              ]

            }

            # 6. 验证

            GET my-index-alias/_alias

            # 确认别名指向 my-index-v2 即为切换成功

            注:后续业务代码、查询、写入全部使用别名 my-index-alias,切勿直接使用真实索引名。


            5.2 副本数配置规范

            • 高可用生产集群:默认配置1个副本,兼顾容灾与资源消耗。

            • 高查询、低写入场景:适当增加副本数分担读压力(需更多节点支撑)。

            • 离线归档/日志数据:可配置0副本节省空间(需接受丢数据风险)。

            5.3 单节点分片数限制配置

            通过参数限制单节点最大分片数量,避免分片集中堆积,导致单节点负载过载:

              PUT /_cluster/settings

              {

                "persistent": {

                  "cluster.routing.allocation.shards_per_node": 2

                }

              }

              注:如集群6个数据节点、索引6个分片,可设置shards_per_node: 2,保证主副分片均衡落入每个节点。


              六、分片治理生产案例

              6.1 案例一:集群扩容后分片负载不均问题

              问题背景:5节点ES集群扩容至10节点后,旧节点负载过高,新节点闲置,业务查询卡顿。

              解决方案:

              1. 优化分片恢复参数,提升迁移效率,避免长时间卡顿

                PUT /_cluster/settings

                {

                  "persistent": {

                    "cluster.routing.allocation.node_concurrent_recoveries": 8,

                    "cluster.routing.allocation.node_concurrent_incoming_recoveries": 8,

                    "cluster.routing.allocation.node_concurrent_outgoing_recoveries": 8,

                    "cluster.routing.allocation.node_initial_primaries_recoveries": 8,

                    "indices.recovery.max_bytes_per_sec": "200mb"

                  }

                }


                2. 开启重平衡并调高并发

                  PUT /_cluster/settings

                  {

                    "transient": {

                      "cluster.routing.rebalance.enable": "all",

                      "cluster.routing.rebalance.cluster_concurrent_rebalance": 8

                    }

                  }


                  3. 全程监控分片分布与节点负载。

                  4.对重要索引配置 shards_per_node 保证节点分片均衡。

                  复盘最佳实践:扩容必须分步操作,禁止一次性批量加节点;扩容前提前调优恢复参数,扩容后监控均衡进度。

                  6.2 案例二:十万级分片超大集群治理实战

                  集群背景:Qunar-实时日志平台目前采用的是ELK架构方案,承载全司实时日志,集群节点规模达到数百节点,全局总分片最高突破10万,日均写入数据量数百TB级,属于典型的海量分片、高吞吐、低延迟稳态运行集群。长期以来面临诸多挑战,此案例也是将痛点风险一一拆解并给出实际生产运维方案。

                  ELK日志架构示意图

                  ES日志集群规模图

                  核心痛点梳理如下:

                  1、海量分片导致集群元数据体量巨大:master节点频繁处理分片状态变更、元数据同步,CPU、线程池长期高负载,偶发集群状态更新超时、轻微脑裂风险;

                  2、分片分配不均衡:每周批量创建索引(周维度),面临索引分片分配不均衡,原生分片分配机制将新分片优先分配至空闲节点,导致新旧节点分片数量与负载严重分层,高负载节点频繁脱离集群;同时加重 master 元数据管理压力,进而引发更大范围的节点崩溃。

                  3、集群加减节点导致分片同步压力大:节点滚动重启、增减节点、或者小规模扩容时,默认自动重平衡触发数百甚至上千分片同时同步,磁盘IO直线上升,影响读写,甚至消费堆积波动;

                  4、超大分片导致读写不均衡:个别大索引的分片数分配不合理,会导致单个分片超大(大于100G甚至150G),平衡时间长。也有日志索引分片条数多,导致很快达到21.47 亿条(ES 单分片文档数上限为 2,147,483,519),超过最大限额无法写入。

                  5、节点存储规格不同导致小存储节点更易先写满:集群配置有9t、14t、18t、20t多种规格(同时也有ssd和非ssd磁盘),小的存储更容易写满,触发磁盘水位线继而引发写入终止。

                  6、索引未提前创建、mapping统一更新导致集群pending task上升和消费堆积:索引如果未提前创建(新周期),在新周期统一写入时创建,会有大量任务导致集群卡死,消费堆积。提前创建索引也会因为大索引的mapping更新导致pending task上升,继而加剧消费堆积。

                  区别于中小集群轻量化运维,超大集群治理核心是锁死稳态参数、禁用原生自动重平衡机制、人工可控调度,以下是实际生产运维调优的方案:

                  6.2.1 全局恢复参数固化(杜绝默认参数隐患)

                  ES默认并发、限速、磁盘水位参数仅适配千级分片小集群,十万级分片场景下,要么恢复过慢堆积大量未分配分片,我们通过持久化参数统一固化分片恢复相关配置,长期生效不丢失,完整DSL如下:

                    // ==================== 分片恢复参数说明 ====================


                    // node_concurrent_recoveries:单节点分片恢复并发,适配高负载大集群


                    // node_concurrent_incoming_recoveries:入向/出向恢复并发差异化管控,避免单向流量打爆


                    // node_initial_primaries_recoveries:节点重启后主分片初始化并发,加速主分片恢复效率


                    // max_bytes_per_sec:万兆网卡SSD集群提速分片传输,减少恢复时间


                    PUT /_cluster/settings


                    {


                      "persistent": {


                        "cluster.routing.allocation.node_concurrent_recoveries": 20,


                        "cluster.routing.allocation.node_concurrent_incoming_recoveries": 10,


                        "cluster.routing.allocation.node_concurrent_outgoing_recoveries": 10,


                        "cluster.routing.allocation.node_initial_primaries_recoveries": 20,


                        "indices.recovery.max_bytes_per_sec": "200mb"


                      }


                    }





                    6.2.2 磁盘水位线调整

                      PUT /_cluster/settings

                      {

                        "persistent": {

                          "cluster.routing.allocation.disk.watermark.low": "92%",

                          "cluster.routing.allocation.disk.watermark.high": "95%",

                          "cluster.routing.allocation.disk.watermark.flood_stage": "98%"

                        }

                      }


                      注:统一调高三类水位线,延迟触发各项风险,可以将磁盘利用率达到最大化。

                      6.2.3 永久禁用全局自动重平衡(从根源杜绝集群抖动)

                      自动重平衡对于小集群(节点小于100,或者分片数低于10000的)稳定高效,对大集群而言则是稳定性灾难:

                        // ==================== 禁用自动重平衡参数说明 ====================

                        // rebalance.enable: 彻底关闭所有场景自动重平衡,禁止已分配分片自动迁移

                        // cluster_concurrent_rebalance: 全局重平衡并发置0,作为兜底防护防止误开启后触发大规模迁移

                        PUT /_cluster/settings

                        {

                          "persistent": {

                            "cluster.routing.rebalance.enable": "none",

                            "cluster.routing.allocation.cluster_concurrent_rebalance": 0

                          }

                        }


                        注:关闭重平衡后,在节点扩容、重启、离线时,避免了集群节点成百上千分片跨节点同步,避免集群整体抖动,磁盘io打满等风险。

                        6.2.4 增加delayed_timeout时间

                          // ==================== delayed_timeout参数说明 ====================

                          // log_test-2026.21为示例索引,实际使用时请替换为目标索引名

                          PUT log_test-2026.21/_settings

                          {

                            "index.unassigned.node_left.delayed_timeout": "50m"

                          }


                          注:默认 delayed_timeout 为 1 分钟,节点短暂脱离后极易触发大规模分片重分配与恢复,加剧集群负载。将其调整为 50m,可为节点重启或网络抖动预留充足的自愈窗口,避免无效的跨节点数据搬迁,保障集群稳定。

                          注:不同索引分片大小不同,delayed_timeout 可有所偏差(分片大的适当延长,分片小的适当缩短)。全量索引均需设置此参数,生产中通过索引模板统一管理,禁止逐索引手动修改。

                          6.2.5 索引提前创建机制与配置模板管理

                          时序性日志索引需提前批量创建,并通过独立模板实现个性化配置,具体措施如下:

                          1.模板管理

                          对于索引创建一个通用模板log_default,存储通用 settings 与 mappings,类似如下:

                            {

                              "order": 1,

                              "index_patterns": [

                                "log_*"

                              ],

                              "settings": {

                                "index": {

                                  "routing": {

                                    "allocation": {

                                      "total_shards_per_node": "1"

                                    }

                                  },

                                  "refresh_interval": "60s",

                                  "number_of_shards": "12",

                                  "translog": {

                                    "durability": "async"

                                  },

                                  "number_of_replicas": "0"

                                }

                              },

                              "mappings": {

                                "dynamic_templates": [

                                  {

                                    "strings": {

                                      "mapping": {

                                        "norms": false,

                                        "ignore_above": 256,

                                        "type": "keyword"

                                      },

                                      "match_mapping_type": "string",

                                      "match": "*"

                                    }

                                  }

                                ],

                                "properties": {

                                  "@timestamp": {

                                    "type": "date"

                                  },

                                  "log_name": {

                                    "ignore_above": 256,

                                    "type": "keyword"

                                  },

                                  "content": {

                                    "norms": false,

                                    "type": "text"

                                  }

                                }

                              },

                              "aliases": {}

                            }

                            注:统一模板匹配log_*全量日志索引,可以覆盖新索引和老索引,新业务索引也会有默认mapping与分片配置,保证结构一致性,默认的12个分片也可以保证写入顺畅,不至于超过分片限额。


                            对于具体索引采用个性化模板,每个索引一个模板,模板中只写独特的settings,mappings。

                            每周任务进行索引mappings、settings的更新,主要针对于以下几个:

                            mappings:主要针对于当前索引的mappings相较于通用模板的mappings新增字段,如有,则更新。

                            settings:针对分片数、total_shards_per_node进行调整(下方具体阐述)。

                            2.索引创建调度任务

                            主要做以下几件事:

                            • 分析索引的存储量:分析当前周索引的存储量,并增加一定比例buffer(因为是提前创建),作为索引下周存储量级。

                            • 规范分片大小:按照30~50GB大小为基准来计算分片数,统一更新到索引对应的模板。

                            • total_shards_per_node调整:为了避免多分片集中在某个节点上,提前算出每个索引的per_node,保证分片的均衡分布(计算方式:math.ceil(分片数/节点数))。

                            • 索引提前创建:每周固定时间提前2天低峰创建次周索引(取用最新分片数信息)

                            实际例子的模板调整案例:

                            log_test-2026.21索引(存储量40TB,节点数550):

                              // ==================== 索引模板更新说明(个性化覆盖) ====================

                              // order: 99 高优先级,用于覆盖通用模板 log_default 中的同名配置

                              // total_shards_per_node: 【更新】由通用模板默认值调整为2,适配当前550节点规模下的分片均衡

                              // number_of_shards: 【更新】按单分片50GB基准重新计算,由原值调整为820

                              // reqSize: 【新增字段】long类型,用于记录请求体大小

                              // gid: 【新增字段】keyword类型,ignore_above=256,用于全局追踪标识

                              PUT _template/log_test_template

                              {

                                "order": 99,

                                "index_patterns": [

                                  "log_test-*"

                                ],

                                "settings": {

                                  "index": {

                                    "routing": {

                                      "allocation": {

                                        "total_shards_per_node": "2"

                                      }

                                    },

                                    "refresh_interval": "90s",

                                    "number_of_shards": "820",

                                    "number_of_replicas": "0"

                                  }

                                },

                                "mappings": {

                                  "properties": {

                                    "reqSize": {

                                      "type": "long"

                                    },

                                    "gid": {

                                      "ignore_above": 256,

                                      "type": "keyword"

                                    }

                                  }

                                },

                                "aliases": {}

                              }


                              注:这个DSL涵盖了新增的字段mappings,更新的分片数(按照50g计算)、均衡total_shards_per_node(820/550取2),每个节点最多有2个分片,也保留了一定冗余,同时避免分片倾斜。

                              6.2.6 自研离线分片调度体系(替代原生实时均衡,可控负载)

                              禁用自动均衡后,放弃ES原生实时调度,采用凌晨低峰批量调度方案,自动/人工可控实现集群负载均衡。

                              核心实操逻辑:

                              自研离线分片调度涵盖了索引创建均衡、迁移与磁盘均衡,具体如下:

                              第一步:新索引(提前生成的)提前均衡分片

                              主要是分析新创建的总索引的分片数,计算出节点平均分片数,将高负载迁移到低负载。

                              新索引创建均衡流程图

                              注:其中对于ssd和非ssd节点也做区分,前者分配更多分片,后者分配少量分片。

                              第二步:索引(当前索引或者历史索引)低峰均衡调度

                              低峰调度有两种情况:

                              1. 调度load高节点到低load节点

                              对于当前load较高的节点,将其对应的当前写的分片迁移到load低的节点上。

                              主要的DSL方式如下:

                                POST /_cluster/reroute

                                {

                                  "commands": [

                                    {

                                      "move": {

                                        "index": "target-log-index",

                                        "shard": 0,

                                        "from_node": "高负载节点",

                                        "to_node": "空闲节点"

                                      }

                                    }

                                  ]

                                }

                                通过定时脚本自动化执行以上逻辑,实现无感知、低压力、零抖动的分片均衡,完全替代原生激进均衡机制。


                                1. 调度高存储占比节点的历史索引到低存储占比节点

                                尤其是9t,14t等低存储节点在当周写到周三周四会有存储压力,需要提前几天低峰进行历史索引的同步。

                                将上一周(已经不写的索引)同步到低存储压力节点。历史索引读写量小,低峰同步不影响集群整体性能,可以整体控制磁盘使用量。

                                落地优化效果

                                1. master负载大幅回落:集群元数据同步频次大幅降低,彻底解决了master CPU高负载、线程池阻塞及集群状态超时问题,master节点长期使用率可控制在10%以内。

                                2. 集群节点变化零抖动:永久禁用自动重平衡后,扩容、滚动重启、节点上下线等运维操作,不再触发大规模分片迁移,节点压力大导致的消费延迟问题得以避免。

                                3. 节点磁盘利用率达到最大化且可控:整合现有不同规格的磁盘节点,利用低峰期批量迁移高存储分片,最大化提升磁盘利用率,同时结合新的水位线参数实现磁盘利用率的精细化管控。

                                4. 故障恢复效率翻倍:集群分片恢复卡顿、超时问题彻底解决,单批次分片恢复耗时缩短60%。

                                复盘总结

                                1. ES集群运维存在明显的规模分水岭:千级分片以内的中小集群,依赖原生自动均衡、默认参数即可稳定运行;

                                2. 万级以上海量分片超大集群,原生机制、通用特性,反而会成为集群最大隐患,需转为人工标准化管控。

                                3. 通过生产环境持续迭代验证与参数调优,逐步逼近集群最佳状态与性能上限。

                                七、分片运维高频实操命令

                                7.1 集群监控命令

                                  # 查看全量分片分布状态

                                  GET /_cat/shards

                                  # 查看未分配分片及异常原因

                                  GET /_cat/shards?v&h=index,shard,prirep,state,unassigned.reason


                                  7.2 手动分片迁移命令

                                    # 1. 手动迁移指定分片

                                    POST /_cluster/reroute

                                    {

                                      "commands": [{

                                        "move": {

                                          "index": "my-index", "shard": 0,

                                          "from_node": "node1", "to_node": "node2"

                                        }

                                      }]

                                    }




                                    # 2. 手动分配副本分片

                                    POST /_cluster/reroute

                                    {

                                      "commands": [{

                                        "allocate_replica": {

                                          "index": "my-index", "shard": 0, "node": "node3"

                                        }

                                      }]

                                    }

                                    八、分片使用运维总结


                                    分片是ES分布式集群的核心基础,所有运维操作的本质都是平衡性能、稳定性与资源成本。

                                    1. 前期规划: 严格遵守单分片业务10-30GB、日志30-50GB标准,控制总分片数,合理配置副本。

                                    2. 日常调优: 常态化配置恢复并发、传输限速、磁盘水位线,适配硬件。

                                    3. 变更管控: 扩容/重启/变更前必须关闭重平衡,完成后逐步开启。

                                    4. 常规监控: 重点关注主/副本分片数、UNASSIGNED Shard数、节点负载、磁盘使用率。

                                    5. 大规模集群: 百级节点或万级分片以上的集群必须禁用重平衡,自研分片调度策略。

                                    九、参考文献

                                    [1] Elastic. Size your shards[EB/OL] 

                                    [2] Elastic. Modules-cluster cluster setting[EB/OL] 

                                    [3] Elastic. Cluster reroute API[EB/OL] 

                                    [4] 微信公众号. ES分片运维实战[EB/OL] 

                                    [5] CSDN博主. Elasticsearch分片分配原理详解[EB/OL] 

                                    [6] Elastic. 分片内部原理[EB/OL] 

                                    [7] Elastic. 索引别名[EB/OL] 

                                    [8] 腾讯云开发者. Elasticsearch分片规划最佳实践[EB/OL]

                                        长按识别二维码,查看全部文献完整原文链接⬆️

                                        跳转微信打开

                                        •  

                                        从Demo到上线:我们如何让数字人直播真正“跑起来”

                                        原创 王涛&黄哲 2026-04-08 16:50 北京

                                        e7aea0b2-cb9f-4322-b3ce-66271860cbe5.png

                                        文章概览

                                        图片

                                        • 引言

                                        • 数字人直播架构

                                        • 数字人推流端对接

                                        • SRS生产环境搭建与调优

                                        • 多平台分发与合规接入

                                        • 容灾架构与成本控制

                                        • 避坑指南

                                        • 结语:数字人直播的下一站

                                        作者介绍:

                                        王涛,2023年9月加入去哪儿旅行,目前在技术中心酒店主站团队,主要负责国内酒店主站相关业务以及酒店AIGC相关项目落地。

                                        黄哲,2020年9月加入去哪儿旅行,目前在技术中心酒店研发主站团队,主要负责国内酒店主站相关业务以及agent平台基建和日常维护工作。

                                        引言

                                        去年我们团队完成了数字人形象克隆和实时渲染引擎的接入,当我们自信满满地把渲染画面接入客户端,推到APP测试——结果当场翻车:直播延迟10秒、卡顿掉帧、几小时后直播中断。更惨的是,当我们要同时开50个直播间时,推流服务直接卡死。

                                        数字人直播的后端,远比想象中复杂。

                                        与真人直播不同,数字人直播有几个致命特点:

                                        • 直播10小时必断流

                                        • 打开首屏,必卡5s以上

                                        • 端到端延迟稳定在10秒以上

                                        • 日志里满是内存泄漏和推流超时

                                        我们这才清醒:让一个数字人动起来是技术演示,让一百个数字人7×24小时稳定卖货是系统工程。

                                        一、数字人直播架构

                                        众所周知,直播就像电视台实时转播:主播是"前方记者"把画面传回电视台(推流),电视台接收处理后播出(直播服务),观众打开电视收看(拉流);技术上推流是将音视频数据压缩编码后通过网络协议上传到服务器,直播服务负责转码、分发和调度,拉流则是观众端从服务器请求数据流并解码播放,三者构成了从内容生产到消费的全链路实时传输系统。

                                        1.1 直播系统选型

                                        基于通用的直播架构,通常包含三个部分:推流、直播服务、拉流。

                                        下面我们将详细介绍下我们的直播架构是如何选型的。

                                        1.1.1 编码推流选型

                                        我们知道真人直播大多使用带界面的 OBS 推流。但面对几百个 7×24 小时运行的数字人矩阵,OBS 高昂的资源开销和极差的自动化支持简直是灾难。

                                        我们需要的是无头化、免人工干预的底层进程。因此,我们果断选择了 FFmpeg + RTMP。它就像个没有感情的“后台打工人”,资源占用极低,天生适合脚本批量调度;更能像手术刀一样,将商品弹出数据精准到帧(SEI)注入视频流,完美满足数字人自动化带货的严苛诉求。

                                        以下为常用方案对比:

                                        1.1.2 直播服务选型

                                        如果直接买大厂的商用云直播,500 个直播间 7×24 小时跑满的账单堪称天价;如果用老牌开源的 Nginx-RTMP,它的并发能力和多协议转换(特别是对 WebRTC 的原生支持)又显得力不从心。

                                        最终,我们锁定了开源流媒体神器——SRS。它不仅免费,更是个单进程就能扛住数千路并发的“性能怪兽”,完美契合我们的低成本、云原生(Docker)部署。最绝的是它极强的“翻译”能力:稳稳接住推来的流后,能瞬间分发出 RTMP、HLS 和 WebRTC 等多种信号,成了我们直播底座的定海神针。

                                        结论:SRS是当前开源流媒体服务器的首选方案,特别适合需要低延迟、多协议、云原生部署且预算有限的场景。

                                        1.1.3 拉流协议栈选型

                                        提到拉流,技术圈言必称 WebRTC 的毫秒级零延迟。但数字人是按产品脚本单向播报的,根本不存在真人互动的“物理延迟”,晚个两三秒观众完全无感。

                                        因此我们没有盲从,而是打出了一套分场景组合拳:对外,主推稳定抗造的 RTMP + 兼容性极佳的 HLS,确保观众端流畅不卡顿;对内,我们将 WebRTC 作为内部巡查的“特供路线”——运营人员需同屏监看 50 个直播间,利用 WebRTC 原生 <video> 标签拉流,能省下海量的浏览器内存,直接拯救了随时可能崩溃的监控大屏。

                                        关键决策
                                        • 推流用RTMP:数字人画面是程序化生成,不存在"摄像头采集延迟",RTMP的1秒延迟可接受,但稳定性远超WebRTC

                                        • WebRTC仅用于监看:运营人员需要同时看50个直播间画面,用WebRTC的<video>标签比FLV更省浏览器资源

                                        • HLS: 直播脚本本身是基于产品介绍,需要完整播完,本身就会有延迟,整合文字回复+视频回复,保证用户体验。

                                        1.2 落地架构拓扑设计

                                        分层逻辑
                                        • 源:数字人引擎推流、数字人视频

                                        • Edge层:地域就近接入,降低公网传输延迟

                                        • Origin层:源站集群汇聚,统一转推,提供拉流

                                        • 分发层:通过SRS Forward功能转推

                                        二、数字人推流端对接

                                        首先是编码推流("前方记者"把画面传回电视台),数字人渲染引擎需要把画面推送到SRS,最稳定的方式是FFmpeg管道推流。我们使用了以下配置:

                                        2.1 编码推流

                                        1. 编码器选择:

                                          • libx264:CPU编码,质量好,适合云主机(GPU留给渲染)

                                          • h264_nvenc:如果渲染节点GPU有剩余算力,可用硬件编码

                                        2. GOP设置:

                                          • 数字人画面变化小,设置-g 50(2秒一个关键帧)

                                          • 平台通常要求2-4秒GOP,太短浪费带宽,太长延迟高

                                        3. 断线重连:

                                          • FFmpeg遇到网络抖动会直接退出,需要外层脚本监控重启:

                                          //java
                                          while(true)
                                             exec ffmpeg

                                          2.2 实时、合规信息添加(SEI)

                                          通常需要在直播间实时显示合规、商品信息(准确、及时)。

                                          SEI实现动态信息嵌入

                                          SRS支持SEI(Supplemental Enhancement Information)插入:

                                            # FFmpeg推流时插入SEI信息
                                            ffmpeg ... -c:v libx264 -sei_side_data on -metadata comment="ProductId=1" -f flv rtmp://srs/live/stream

                                            直播商品信息嵌入

                                            通过javacv实现sei的动态编码,保证当前播放的视频与商品信息强一致。

                                            三、SRS生产环境搭建与调优

                                            接下来处理的是我们的直播服务(电视台);搭建SRS集群不是"复制粘贴配置文件"那么简单。我们在前几次部署中踩过的坑包括:直播延迟高、多路推流时系统崩溃。这一章我会详细解释每一个关键决策背后的技术权衡。

                                            3.1 基础环境准备

                                            服务器配置

                                            针对I/O密集型 且 大流量 专项配置(/etc/sysctl.conf):
                                            • 高吞吐量,针对网络缓冲区大小设置(128MB,非常大的缓冲区)

                                            • 实时性,使用bbr协议实现拥塞控制

                                            • 突发流量,调高backlog值,避免瞬间爆发的流量导致的数据包丢失

                                            • 高并发,设置文件句柄,系统级、进程级限制均提升到200w左右

                                              #网络缓冲区大小(针对高吞吐量)
                                              net.core.rmem_max = 134217728
                                              net.core.wmem_max = 134217728
                                              #单个连接在高延迟网络上也能维持高吞吐量,最大128MB
                                              net.ipv4.tcp_rmem = 4096 87380 134217728
                                              net.ipv4.tcp_wmem = 4096 65536 134217728
                                              net.core.netdev_max_backlog = 5000
                                              #BBR是Google开发的算法,通过实时估算网络的瓶颈带宽和往返延迟来决定发送速度。当网络出现短暂抖动时,BBR能保持更稳定的发送速率,从而减少视频卡顿,降低延迟。
                                              net.ipv4.tcp_congestion_control = bbr  
                                              #文件句柄限制(应对高并发连接)
                                              fs.file-max = 2097152
                                              fs.nr_open = 2097152

                                              3.2 SRS Edge节点配置(边缘推流接入)

                                              • 边缘节点rtmp推流到origin节点,配置origin节点地址(核心能力)

                                              • 配置flv、WebRTC 协议实现实时监控(实时监控)

                                              • 配置快速失败超时时间(可用性、防止阻塞)

                                              edge.conf:

                                                # RTMP推流转发到源站
                                                vhost __defaultVhost__ {
                                                    mode            remote;        
                                                    origin          *:1935 *:1935;  # Origin集群地址


                                                    # 快速失败
                                                    forward_timeout 5s;
                                                    # flv
                                                    http_remux {
                                                        enabled     on;
                                                        mount       [vhost]/[app]/[stream].flv;
                                                        hstrs       on;
                                                    }


                                                    # WebRTC播放
                                                    rtc {
                                                        enabled     on;
                                                        rtmp_to_rtc on;
                                                    }
                                                }

                                                3.3 SRS Origin节点配置(源站汇聚+转推)

                                                • play配置主要用于rtmp协议降低延迟、增强抗抖动能力

                                                • hls为主要的拉流协议,保存1小时,2s切片(实时性)

                                                • forward转推其他平台,例如抖音、b站等(第三方平台)

                                                origin.conf(核心配置):

                                                  # SRS Origin
                                                  listen                1935;
                                                  max_connections     5000;
                                                  worker_threads      8;            # 绑定8核CPU
                                                  play {
                                                      # 关闭GOP缓存
                                                      gop_cache       off;
                                                      # 队列长度控制(缓冲10帧)
                                                      queue_length    10;
                                                      # 减少发送间隔抖动
                                                      reduce_sharp_duration 100;
                                                  }
                                                  vhost __defaultVhost__ {
                                                      # HLS
                                                      hls {
                                                          enabled         on;
                                                          hls_path        /data/recordings;
                                                          hls_fragment    2;          # 2秒切片
                                                          hls_window      3600;       # 保留1小时
                                                      }


                                                      # 转推其他平台
                                                      forward         {
                                                          enabled         on;
                                                          destination     rtmp://xxxxxx/live/stream_key;
                                                      }
                                                  }

                                                  3.4 SRS性能调优:从10秒延迟到3秒的实战

                                                  3.4.1 延迟优化三板斧

                                                  第一斧:推流gop设置 50,2s一个关键帧

                                                  gop设置不合理,播放器就需要等待下一个Idr帧才能播放.默认10s会导致前端基本打开就卡住。

                                                  影响:首屏加载从10s变为毫秒级,基本实现秒开

                                                  第二斧:启用低延迟模式

                                                    # srs.conf全局配置
                                                    publish {
                                                        mr            off;        # 合并写关闭,立即转发
                                                        min_latency   on;         # 启用最低延迟模式
                                                        srt_to_rtmp   on;         # SRT转RTMP低延迟路径
                                                    }
                                                    第三斧:前端播放器配合

                                                    提前预加载拉流地址,进入后直接拉流,避免进入直播页面才获取直播拉流地址。

                                                    3.4.2 高并发下的srs优化

                                                      # srs.conf
                                                      listen              1935;
                                                      max_connections     10000;        # 理论最大值
                                                      worker_threads      8;           # 等于CPU核心数
                                                      # 日志控制(高并发时日志是性能杀手)
                                                      srs_log_level       warn;         # 警告
                                                      srs_log_tank        console;      # 直接输出,不写文件(或关闭)

                                                      3.4.3 监控指标与告警

                                                      SRS自带统计API

                                                        # 查看当前推流统计
                                                        curl http://srs-origin:1985/api/v1/summaries
                                                        # 关键指标:
                                                        # - system.cpu_percent: CPU占用(>80%告警)
                                                        # - system.mem_ram_kbyte: 内存占用
                                                        # - system.net_sockets: 当前连接数
                                                        # - system.net_recv_bytes/ send_bytes: 带宽
                                                        Prometheus + Grafana监控+飞书报警

                                                          # 部署srs-exporter采集指标
                                                          scrape_configs:
                                                            - job_name: 'srs'
                                                              static_configs:
                                                                - targets: ['srs-origin:1985']
                                                              metrics_path: '/api/v1/metrics'

                                                          关键告警规则:

                                                          • 推流断开:某路流active状态变为false

                                                          • 延迟过高:帧率<20fps持续30秒

                                                          • 带宽打满:出网流量>阈值(如8Gbps)

                                                          四、多平台分发与合规接入

                                                          4.1 SRS Forward多路转推

                                                          核心需求:一路数字人流,同时推送到抖音、视频号、淘宝。

                                                          方案对比:

                                                          4.2 SRS Forward配置

                                                            vhost __defaultVhost__ {
                                                                # 动态转推(通过HTTP API控制)
                                                                forward {
                                                                    enabled         on;
                                                                    # 目标平台地址(实际需通过脚本动态获取推流码)
                                                                    destination     rtmp://push.example.douyin.com/live/xxx;
                                                                    destination     rtmp://push.example.shipinhao.com/live/xxx;
                                                                }
                                                            }

                                                            4.3 动态推流码管理

                                                            各平台推流码有有效期,需要中间服务动态获取:

                                                              # Python示例:获取平台推流地址后更新SRS配置import requests
                                                              def update_srs_forward(stream_key, platform_urls):
                                                                  """
                                                                  通过SRS HTTP API动态添加转推目标
                                                                  """
                                                                  srs_api = "http://srs-origin:1985/api/v1/clients"# 先查询当前流ID
                                                                  r = requests.get(f"{srs_api}?count=100")
                                                                  clients = r.json()['clients']# 找到对应stream_id,发送forward命令
                                                                  for client in clients:
                                                                      if client['name'] == stream_key:# 通过publish命令触发forward(SRS 6.0+支持)
                                                                          requests.post(f"{srs_api}/{client['id']}/forward", json={"destinations": platform_urls})

                                                              五、容灾架构与成本控制

                                                              5.1 高可用设计

                                                              推流端双活

                                                                # 数字人端同时推两路流到不同Edge节点# 
                                                                Stream_001 → SRS-Edge-A (10.0.1.10)
                                                                Stream_001 → SRS-Edge-B (10.0.1.11) 
                                                                # Origin层根据健康检查选择主源

                                                                SRS热升级

                                                                  # SRS支持SIGUSR2信号热重启(不中断连接)
                                                                  # 验证新版本正常后,优雅关闭旧进程
                                                                  killall -s SIGUSR2 srs

                                                                  降级预案

                                                                  当SRS集群故障时,关闭直播入口。

                                                                  5.2 成本优化

                                                                  单路数字人直播成本对比:

                                                                  节省关键点

                                                                  • 带宽成本:使用cdn一次回源,减少机房宽带费用

                                                                  • 计算成本:K8s HPA根据推流数自动扩缩容

                                                                  • 存储成本:录制文件直接转存冷存储(华为云对象存储低频访问)

                                                                  六、避坑指南

                                                                  6.1 离线视频动态切换推流ffmpeg

                                                                  • 目标:7*24h直播,推送视频列表需要动态可调整,支持用户问答与商品视频动态插播。

                                                                  • 现状与冲突:concat基于本地文件协议实现动态插入视频比较复杂,需要自己监控推流进度,动态更改下一个推流文件,滤镜、管道等也需要自己感知推流进度,实现不精准。

                                                                  • 解决与结论:化被动为主动,基于Javacv 使用http实现下一个文件动态切换

                                                                  • 结果:使用简单方案实现动态推流,感知上一个视频是否推完,并可以动态监控异常视频,同时记录并报警。

                                                                  6.2 srs流服务器的一些坑

                                                                  坑1:WebRTC播放黑屏

                                                                  • 现象:数字人画面在WebRTC播放器黑屏,但RTMP正常

                                                                  • 原因:编码Profile为High,浏览器解码器不支持

                                                                  • 解决:FFmpeg强制-profile:v baseline -level 3.1

                                                                  坑2:长时间推流内存泄漏

                                                                  • 现象:SRS运行48小时后内存占用从2G涨到20G

                                                                  • 原因:SRS 5.0以下版本的DVR模块有泄漏

                                                                  • 解决:每日定时SIGUSR2重启

                                                                  坑3:多路推流卡顿

                                                                  • 现象:单节点推50路流,后半段出现卡顿

                                                                  • 原因:SRS默认chunk_size 60000太小,TCP包碎片化

                                                                  • 解决:srs.conf中设置chunk_size 128000

                                                                  坑4:音视频不同步

                                                                  • 现象:数字人说话口型对不上

                                                                  • 原因:Unity渲染帧率波动,音频固定44.1kHz采样

                                                                  • 解决:SRS端配置aac_sync on,或使用-async 1强制同步

                                                                  结语:数字人直播的下一站

                                                                  基于SRS自建直播服务,让我们在数字人赛道上获得了成本、延迟、可控性的三重优势。但技术永远在演进:

                                                                  • 协议层:SRT正在替代RTMP成为推流标准,SRS 6.0已原生支持

                                                                  • 编码层:AV1编码比H.264省30%带宽,但编解码延迟仍需优化

                                                                  • 架构层:WebTransport over HTTP/3可能重塑低延迟直播架构

                                                                  技术栈清单:

                                                                  • 流媒体服务器:SRS 6.0

                                                                  • 容器编排:K8s

                                                                  • 监控:Prometheus + Grafana

                                                                  • 推流端:FFmpeg 6.0 + Unity/Unreal

                                                                  • 平台接入:SRS Forward + 动态推流码服务

                                                                  跳转微信打开

                                                                  •  

                                                                  去哪儿网 C 端研发 AI Coding 探索及落地

                                                                  原创 赵苗&amp;杨翀&amp;赵翔 2026-02-10 18:02 北京

                                                                  e7aea0b2-cb9f-4322-b3ce-66271860cbe5.png

                                                                  文章概览

                                                                  • 背景

                                                                  • C端落地中遇到的难题

                                                                  • 解决方法

                                                                  • 总结

                                                                  保障数据情况

                                                                  作者介绍:

                                                                  赵苗,2019年7月加入去哪儿旅行,目前在大前端中心国内机票团队,主要负责机票后服务相关业务以及代码生成平台基建和日常维护工作。

                                                                  杨翀,2023年加入去哪儿旅行,大前端中心FTC成员,目前在大前端国内机票团队,主要负责机票前端业务开发以及代码生成平台基建和日常维护工作。

                                                                  赵翔,2021年7月加入去哪儿旅行,大前端中心FTC成员,目前主要负责机票相关业务以及Serverless平台、朱雀代码生成平台的基建与日常维护。

                                                                  一、背景

                                                                  在前端开发领域,根据业务受众和交互逻辑的不同,通常划分为 B 端 与 C 端 两大领域。虽然两者都在追求研发效能的提升,但在 AI Coding 浪潮下,由于业务特性的鸿沟,其落地方案正走向截然不同的路径:

                                                                  • B 端开发:普遍依托成熟的 UI 组件库,UI 还原度较易得到保障,业务逻辑相对标准化,AI 仅需结合 “原型图 + 高级指令”,便能生成具备基础功能性的代码,研发流程相对顺畅;

                                                                  • C 端开发:一方面,UI 层面要求 100% 像素级还原,组件需由各业务线高度定制化开发,且要满足复杂布局设计与极端性能指标;另一方面,C 端直接面向海量用户,业务逻辑高度复杂,需应对多样化场景与频繁迭代,这些特性让 C 端成为 AI Coding 领域中极具攻克价值的 “深水区”。

                                                                  我们的 C 端 AI 研发探索始于 UI 代码生成(D2C),先后开展两轮技术尝试,但均未实现理想效果:

                                                                  1. 过往纯 AI 模型尝试,“图片+提示词”直接给AI进行代码生成,生成的 UI 代码还原度差,无法满足像素级还原要求,与设计稿偏差明显,难以直接投入使用;

                                                                  2. 后续 “稿件解析 + 规则算法” 尝试,转而通过成熟的规则算法搭建基础体系,优先保障 UI 还原度。

                                                                  两轮尝试后,C 端 AI 研发仍面临多重核心瓶颈:

                                                                  • 代码可用性不足:规则算法生成的代码多为冗余 “div 海”,缺乏语义化标签,不符合组件化要求,需大量手动重构才能复用;

                                                                  • 逻辑代码生成能力缺失:仅能覆盖 UI 代码生成,无法延伸至逻辑代码(交互、状态、路由等)生成,难以形成 “设计稿 + 需求文档” 到完整代码的闭环;

                                                                  • 协同体验割裂:代码生成平台与 IDE 分离,开发人员需频繁切换,打断研发流程连贯性。

                                                                  恰逢 LLM(大语言模型)技术持续成熟,我们针对性构建了一套覆盖 D2C 智能生成(聚焦 UI 代码生成还原度与可用性双重提升)、P2C 需求解析(聚焦逻辑代码生成效率与可执行性)、IDE 插件统一体验(聚焦全流程协同效率优化)的智能研发新模式,全面破解 C 端 AI 研发在 UI 生成、逻辑代码生成、协同流程三大环节的痛点,推动 C 端 AI 研发从 “单一功能实现” 向 “全链路高效协同 + 优质输出” 的升级。

                                                                  二、C端落地中遇到的问题

                                                                  1. D2C(设计到代码)核心问题:「像素级还原」与「代码语义化」的双重诉求难以兼顾

                                                                  C 端对 D2C 的核心诉求是 “既要 100% 像素级还原设计细节,又要代码语义化、组件化可直接复用,可迭代性高”,但现有方案的短板恰好与这两个诉求形成对冲,导致难点突出:

                                                                  • 像素级还原:要求精准复刻设计稿的尺寸、间距、颜色、层级等所有视觉细节,需极强的样式复刻稳定性,这只有规则算法能部分满足,但规则算法生成的代码无语义、无组件化结构,完全违背 “可直接复用” 诉求;

                                                                  • 代码语义化:要求代码具备语义化标签、合理组件拆分、适配项目技术栈与规范,这是纯 AI 模型的优势方向,但纯 AI 模型缺乏精准的样式把控能力,无法达到 C 端要求的像素级还原标准;

                                                                  D2C 的核心难点并非单一技术问题,而是 “视觉精准性” 与 “代码语义化” 的天然对冲:规则算法的优势是还原精准,却无复用价值;纯 AI 模型的优势是复用适配,却无还原精度。单一方案无法同时破解两个核心诉求,如何让 “像素级还原” 不牺牲代码规范,让 “高效复用” 不大幅降低还原标准,成为 D2C 落地的核心症结。

                                                                  2. P2C (需求文档生成逻辑代码)的核心问题

                                                                  在 D2C 已解决页面结构与 UI 还原后,我们继续推进将 PRD(需求文档)自动生成逻辑代码。在模型具备基础代码生成能力的前提下,这一阶段更大的挑战在于,如何持续地为其提供完整、稳定、可执行的需求输入。在真实业务环境中,PRD 往往分散在不同文档空间,由不同角色维护,存在访问范围受限、表达方式不统一等问题。当需求信息无法被完整获取与对齐时,逻辑生成天然会变得不稳定。

                                                                  因此,需求文档生产逻辑代码遇到的核心问题,并不只是模型能不能生成代码,而是在现实组织约束下,如何把分散、不稳定的需求信息,整理成模型可以稳定执行的输入。

                                                                  P2C 的关键难点

                                                                  沿着需求 → 逻辑代码流程,主要存在三类核心阻塞:

                                                                  • PRD 既缺乏结构化表示,又受限于飞书文档权限体系

                                                                    在实际环境中,PRD 内容分散在不同权限域的飞书文档中,且以自然语言与表格混合表达,模型在无法稳定获取和解析完整文档时,生成的逻辑代码容易出现条件、状态或依赖关系缺失。

                                                                  • PRD 体量和复杂度上升后,单次生成难以稳定覆盖全部逻辑

                                                                    当页面数量、交互流程和业务规则增多时,模型容易出现理解偏差、上下文丢失或生成深度不一致的问题。

                                                                  • 缺乏真实内部上下文,导致生成的 API 与 SDK 调用不可直接使用

                                                                    在没有内部文档约束的情况下,模型往往依赖语义猜测生成接口和参数,代码表面合理但实际无法运行

                                                                  3. 平台使用和代码编写流程割裂

                                                                  • 原代码生成平台处于网页端,开发人员使用时会在平台与 IDE 之间进行切换,造成工作流程割裂。

                                                                  三、解决方案

                                                                  1. D2C :规则算法与AI融合架构

                                                                  基于 “规则算法强在精准、AI 模型强在意图” 的互补特性,我们摒弃了 “非此即彼” 的单一方案,探索出 “规则 + AI” 的融合架构:让规则算法发挥数据处理的精准优势,为 AI 提供标准化、高质量的输入;让 AI 模型承接意图理解的核心任务,生成语义化、组件化的优质代码,通过两者协同实现 “形神兼备” 的 D2C 落地效果。

                                                                  1.1 高还原度保障:数据规则解析处理

                                                                  Figma 原始 API 返回的 JSON 数据包含大量冗余字段(如混合模式、渲染边界等),结构复杂、嵌套层级深,直接输入 AI 会影响处理效率和生成质量。规则系统的核心任务就是对这些数据进行 “瘦身” 与 “优化”。

                                                                  数据简化与清洗

                                                                  • 冗余字段剔除:删除 Web 开发中极少使用的 blendMode、与核心信息重复的 absoluteRenderBounds 等约 60 个冗余字段,字段数量减少 75%;

                                                                  • 核心信息提炼:聚焦样式、结构、上下文等关键数据,将嵌套层级从最深 6 层精简至 3 层,大幅提升数据可读性。

                                                                  关键信息转换与布局优化

                                                                  将 Figma 专属数据格式转换为 AI 易理解、代码可直接使用的标准格式:

                                                                  • 颜色值:从 {r: 0.22, g: 0.48, b: 1, a: 1} 转换为十六进制 #3878FF;

                                                                  • 样式属性:将rectangleCornerRadii: [8,8,8,8] 转化为 CSS 属性 border-radius: 8px,阴影效果转化为标准 box-shadow 语法;

                                                                  • 布局信息:统一整合 padding、margin 等布局属性,形成结构化的 layout 字段。

                                                                  通过规则算法的精准数据处理,实现了 “原始数据 → 精简数据 → 标准化数据” 的转化:既保留了设计稿尺寸、间距、颜色、层级等所有核心视觉细节,又解决了原始数据格式不兼容、信息杂乱的问题,为后续 AI 生成代码提供了 “精准、干净、易解析” 的数据基础,直接保障了 UI 代码的像素级还原能力,同时提升了 AI 处理效率与生成代码的稳定性。

                                                                  1.2 代码语义化保障:结合AI 模型进行代码生成

                                                                  基于预处理后的高质量数据,我们通过以下五个环节,确保 AI 生成的代码 “好用、能用、符合规范”。

                                                                  环节一:模板化提示词系统,标准化生成逻辑

                                                                  • 预处理数据AI优化:基于我们第一步预处理后的数据使用AI进行进一步布局优化,结构调整,输出效果更好的FigmaJson,我们在进行规则算法计算的时候,有的因为设计稿设计的偏差、元素嵌套的问题,flex属性计算偏差的问题较多,比如一个模块设计,稍微左右间距不一致或者多套了一层壳子,就会flex属性处理为flex-start + padding,ai结合图片来优化就明显知道直接用flex:center 去掉padding就可以,还有定位元素的识别,也存在计算误差,包括说层级结构的多余不合理的地方,现在经过结合图片以及数据前置优化,这一类的问题就大大减少了。

                                                                  • 分技术栈适配:覆盖 React、React Native、Taro、Shark 等框架,每个技术栈配置专属模板;

                                                                  • 强约束规范:明确 95% 以上像素级还原要求,强制使用<button>``<nav>等语义化标签,禁止 “div 海”;

                                                                  • 结构化设计:用 XML 标签定义角色、目标、工作流程,注入技术栈专属规则(如 React 用className、RN用StyleSheet.create());

                                                                  • 质量保障:包含布局规范、单位转换(100px=1rem)、响应式适配、代码检查等强制要求。

                                                                  环节二:全链路资源处理:实现代码直接复用

                                                                  针对图片、Icon 等资源,构建从识别到引用的完整处理流程:

                                                                  • 图片处理:自动识别设计稿图片→精准裁剪优化→CDN 上传→生成稳定访问链接;

                                                                  • Icon 处理:识别 Unicode 图标字符→生成专属字体文件→缓存去重→代码中自动注入@font-face规则;

                                                                  • 资源引用替换:生成代码时直接替换为 CDN 链接,无需开发手动处理。

                                                                  环节三:组件与 DesignToken 深度适配:让代码贴合设计系统规范

                                                                  • 组件适配器:开发 Button、Checkbox、CustomAlert 等组件专属适配器,精准解析 Figma 组件的属性、状态(如禁用 / 悬停),映射为语义化组件代码;

                                                                  • Design Token 设计变量智能转化CSS属性:从 Figma 中同步颜色、字体、间距、圆角等设计变量,支持 DesignToken 版本管理与本地缓存。将这些设计变量自动转换为 CSS 变量,与基础样式智能合并(如边框宽度 + 颜色合并为 border 属性),确保生成的代码完全遵循品牌设计规范,避免样式偏差。

                                                                  环节四:工程化上下文注入:贴合项目实际需求

                                                                  为避免生成的代码与项目规范脱节,我们支持注入工程化上下文信息:

                                                                  • 项目技术栈配置:适配目标项目的框架版本、编码规范;

                                                                  • 代码模板信息:同步 Git 仓库中的项目代码结构与命名约定;

                                                                  • 组件库信息:识别项目依赖的组件库,确保生成的代码可直接对接现有组件资源。

                                                                  通过这一机制,AI 生成的代码能够完全融入项目现有架构,无需额外调整即可落地使用。

                                                                  环节五:AI 生成与后处理:提升代码质量与稳定性

                                                                  • 模型选型:采用 Gemini Pro 2.5 模型,调用接口生成代码;

                                                                  • 结果解析:提取 JSON 格式响应中的实际代码文件(realCodeFiles)与预览文件(previewCodeFiles);

                                                                  • 后处理优化:代码格式化、资源引用修正、Redis 缓存存储,同时提供 AI 生成失败的降级策略。

                                                                  1.3 D2C 效果展示

                                                                  生成效果展示

                                                                  设计稿&生成效果

                                                                  生成代码展示

                                                                  代码按业务模块 + 复用性完成了组件拆分,符合前端组件化开发的最佳实践:

                                                                  • 按功能边界拆分:将 “头部”“航班信息”“票价选项” 拆分为独立组件(HeaderComponent/FlightInfoCard/FareOptionCard),既匹配设计稿的模块划分,也满足后续复用需求(比如FareOptionCard可复用于其他航班页);

                                                                  • 数据与 UI 解耦:通过fareOptionsData将票价数据与FareOptionCard组件分离,符合 “数据驱动视图” 的前端开发逻辑,后续修改票价规则只需调整数据,无需重构组件。

                                                                  • 语义化结构清晰:用FlightInfoCard等语义化组件名替代冗余标签,开发能直接理解模块功能;

                                                                  • 适配工程化流程:代码基于 React Native 规范编写,整合了FlatList(列表渲染)、StyleSheet(样式管理)等框架原生能力,与实际研发流程无缝衔接,省去了 “规则生成→手动适配框架” 的中间环节。

                                                                  总的来说,这段代码生成的核心价值是从 “规则翻译设计样式” 升级为 “理解设计意图并输出工程化代码”,既还原了设计稿的视觉表现,又契合前端开发的语义化、组件化需求,真正实现了 “形似 + 神似” 的落地效果。

                                                                  Cursor体验对比

                                                                  总结

                                                                  通过 “规则 + AI” 的融合架构,我们的代码生成能力实现了根本性提升:

                                                                  • 代码可用性飞跃: AI 模型能够综合分析节点的样式、层级、命名和周边上下文,更精准地推断出元素的语义角色,直接输出符合最佳实践的高质量、语义化的代码(如使用 <button> 而非 <div>),从冗余的 “div 海” 升级为语义化、结构清晰的组件化代码,可维护性大幅提升。

                                                                  • 开发效率提升:生成的代码结构合理,减少 80% 以上的手动重构工作,同时覆盖多技术栈需求;

                                                                  • 精确性与智能性的平衡: 规则系统确保数据提取的准确性,AI 模型提供意图理解和代码优化能力,两者协同实现了 “高还原度”与“优质代码” 的双重保障。

                                                                  2. P2C:语义解析与知识增强的逻辑

                                                                  在明确了阻塞 P2C 的核心矛盾后,我们并未尝试用单一策略一步解决所有问题,而是沿着难点拆解出的链路,从 输入 → 处理 → 生成 → 可执行 四个环节逐层补齐能力,使逻辑代码生成从能写真正走向能落地。

                                                                  2.1 解决方案

                                                                  2.1.1 前置文档解析:让 PRD 变成可被理解的输入

                                                                  文档授权:由于飞书的文档有很多权限,不同的团队知识库有不同的权限,因此我们设计了一套飞书的权限授权系统。核心分为两个阶段:

                                                                  1. 阶段一:定时任务与通知 系统每周通过定时任务从PMO系统拉取数据,解析出文档链接和产品ID后,通过飞书机器人向相关产品发送按钮式交互提醒,等待授权确认。

                                                                  2. 阶段二:授权回调与数据处理 当产品点击同意授权后,触发回调函数启动流程,我们的飞书机器人将带着用户的权限去读取文档内容,提取并解析关键信息(背景、工时、详情等字段),最终将结构化数据持久化到数据库中。

                                                                  表格序列化:在解析 PRD 时,我们不只是提取文本,而是针对“需求详情”等表格进行了 Key-Value 映射。

                                                                  • 将表格的每一行视为一个对象。

                                                                  • 将列名作为 Key,单元格内容作为 Value。

                                                                  • Map 格式的存储(存入数据库),完美保留了需求的结构化特征,为后续Agent 分析提供了高质量的上下文

                                                                  格式与图片保留:除表格结构以外,其余内容也 保持完整信息。

                                                                  • 文本格式(无序 / 有序列表、加粗、斜体、删除线等)会统一在解析阶段转换为 Markdown 语义结构存储,用于保留内容层次与语义关系,使模型能够基于原始格式推断逻辑。

                                                                  • 图片会在解析阶段被下载并重新上传到内部服务,并在文档结构中以 Markdown 的格式展示。

                                                                  最终效果:

                                                                  {
                                                                  "title":"春运产品需求文档",
                                                                  "background":"一、需求背景\n为充分承接春运流量红利,提升各业务板块的销售与用户活跃度,特策划本次**平台级大促活动**,xxxxxxxxxxx",
                                                                  "detail":[
                                                                  [
                                                                  [
                                                                  "场景\n **进入活动页-未登录**\n\n",
                                                                  "demo\n ![image](https://qimgs.qunarzz.com/wpf_newmpic_001/xxxxxxxxxxx.png)\n",
                                                                  "说明\n APP弹窗需更新背景图\n\n"
                                                                  ],
                                                                  [
                                                                  "场景\n **网络异常/请求后端异常等活动兜底页面**\n\n",
                                                                  "demo\n ![image](https://qimgs.qunarzz.com/wpf_newmpic_001/xxxxxxxxxxx.png)\n",
                                                                  "说明\n     1. 【驾马闯关】主按钮显示“剩余?次”\n    2. 点击【驾马闯关】、【我的奖品】、【次数+1】、【马上验证】按钮:\n    - 如果未登录弹窗登录弹窗。\n    - 如果网络异常或者请求后端接口失败提示\"小驼开小差了,请稍后重试”\n\n"
                                                                  ],
                                                                  [
                                                                  "场景\n **活动已结束**\n\n",
                                                                  "demo\n ![image](https://qimgs.qunarzz.com/wpf_newmpic_001/xxxxxxxxxxx.png)\n\n",
                                                                  "说明\n xxxxxxxxxxx"
                                                                  ]
                                                                  ],
                                                                  [
                                                                  [
                                                                  "状态\n 初始\n\n",
                                                                  "demo\n ![image](https://qimgs.qunarzz.com/wpf_newmpic_001/xxxxxxxxxxx.png)\n",
                                                                  "说明\n 固定3个关卡,关卡奖励状态为待解锁\n\n"
                                                                  ],
                                                                  [
                                                                  "状态\n 关卡进度\n\n",
                                                                  "demo\n ![image](https://qimgs.qunarzz.com/wpf_newmpic_001/xxxxxxxxxxx.png)\n\n",
                                                                  "说明\n     1. 进度条计算逻辑:xxxxxxx  9. 关卡状态:待解锁、已解锁\n其余为固定数据\  - 点击【我知道了】关闭弹窗\n"
                                                                  ]
                                                                  ]
                                                                  ]
                                                                  }

                                                                  2.1.2 智能分片与并发生成:解决长文档与复杂逻辑瓶颈

                                                                  当面对长文档和复杂业务逻辑时,由于大模型的上下文窗口有限,如果直接将完整内容交给 AI 理解并输出,往往会丢失大量关键细节。尤其是在存在多种业务 case 的场景下,例如同一产品在不同条件下需要输出不同的文案,AI 在直接总结时很容易给出模糊、抽象的结论,比如简单地概括为“在不同情况下输出不同文案”,而无法保留具体差异和规则。

                                                                  为了解决上下文受限和细节丢失的问题,我们引入了 多 Agent 并发架构,通过拆分、聚焦和协同处理复杂信息,确保关键规则和细节能够被完整理解和准确表达:

                                                                  动态启动与语义分片:

                                                                  系统根据 PRD 复杂度(如表格个数或字符数)动态决策是否启动多 Agent 模式。然后按语义(如“埋点”、“API”)或业务模块进行分片(Chunk)。

                                                                   chunks示例:

                                                                  {{
                                                                    "pages": [
                                                                      {{
                                                                        "page_name": "模块名称",
                                                                        "page_description": "模块的简要描述",
                                                                        "related_chunks": [1, 2],
                                                                        "main_functions": ["主要功能1", "主要功能2"]
                                                                      }}
                                                                    ]
                                                                  }}

                                                                  两阶段并发生成:

                                                                  LLM 首先进行模块级路由,建立 Module -> Chunks 的映射。然后,系统并发启动多个 Sub Agent,每个 Agent 仅关注自己负责的页面数据,流式生成逻辑代码。

                                                                  生成提示词示例:

                                                                    相关内容:
                                                                    {page_content}


                                                                    **前端关注重点**:
                                                                    - 只关注前端交互和数据展示,业务逻辑由后端处理
                                                                    - 专注于该页面的用户交互、UI状态、页面跳转、数据展示
                                                                    - 所有数据来源统一表述为"后端返回"或"接口返回"


                                                                    **严格输出要求**:
                                                                    请严格按照以下结构输出,不要添加任何额外说明:


                                                                    # {page_name}


                                                                    ## 用户交互操作
                                                                    [从用户进入该页面开始,描述完整的交互流程和操作]


                                                                    ## 页面状态和UI更新
                                                                    [描述该页面的UI状态变化和更新逻辑]


                                                                    ## 跳转和路由逻辑
                                                                    [描述从该页面的跳转逻辑和路由处理]


                                                                    ## 埋点和实验(如有就展示,没有就不展示)
                                                                    [如有埋点或实验需求,描述该页面相关的实现]

                                                                    2.1.3 知识库增强:解决 API 幻觉

                                                                    背景:逻辑正确,但代码不可用

                                                                    在未接入真实内部上下文之前,P2C 生成的逻辑代码普遍存在一个问题:看起来对,但用起来错。模型能够基于 PRD 描述生成基本合理的页面逻辑与交互流程,但在涉及内部 SDK 调用时,完全依赖语义猜测。例如在实现登录能力时,模型可能生成 auth.login(),而实际可用接口却是 user.login({...})。  这种偏差在参数层面更加明显:必填字段缺失、参数结构不符合规范,甚至引入只存在于公共 SDK 中的字段。最终结果是代码可读性尚可,但无法直接运行,开发仍需反复对照文档手动修正,严重拖慢了整体迭代效率。

                                                                    为什么抛弃向量知识库RAG?

                                                                    在尝试解决 API 幻觉问题时,我们抛弃了原有的向量知识库方式的RAG 方案,主要原因是向量知识库不适用于这一具体场景,主要原因包括:

                                                                    • PRD 的业务语义与 SDK 的技术结构关联度过低

                                                                      PRD 中使用的是产品与业务语言,很难通过检索准确命中对应的 SDK 接口说明,容易产生误召回或召回不相关内容。

                                                                    • 内部 SDK 体量有限,构建检索链路性价比不高

                                                                      相比构建切片、向量化与召回流程,将完整 SDK 文档直接提供给模型的成本更低、实现更简单。

                                                                    • 模型上下文能力已足以承载完整 SDK 文档

                                                                      现代大模型在上下文管理与信息吸收能力上已显著提升,可以稳定理解整套 SDK 定义,而不会被信息量淹没。

                                                                    在这一前提下,RAG 反而引入了额外复杂度,却无法从根本上解决 API 准确性问题。

                                                                    最终方案:引入 MCP + 飞书知识库,提供真实可用上下文

                                                                    针对模型SDK全靠猜的问题,我们最终选择引入 MCP + 飞书知识库,在代码生成前为模型提供真实、完整的内部 SDK 定义。 在实际实现中,我们根据不同语言和技术栈加载对应的内部文档,使模型在生成逻辑代码时,始终基于真实接口而非语义推断。

                                                                    这样带来的变化非常直接:

                                                                    • 模型调用的 API 源自真实文档,而非基于语料推断。

                                                                    • 参数结构、字段命名与内部规范完全一致。

                                                                    • 输出代码可直接运行,大幅降低人工校对成本。

                                                                    2.2 生成代码效果

                                                                    • 代码可执行性显著提升: 结合私有知识库后,模型使用的 API、参数结构、字段命名与内部文档完全一致,生成的代码可直接运行,大幅减少人工校对成本。

                                                                    • 逻辑生成准确: AI 能基于我们提供的参数、使用示例及需求描述,生成正确的页面跳转函数以及使用内部 SDK 的埋点代码。

                                                                    • 生成质量更稳定: 多 Agent 并发确保长文档也能逐块精细生成,输出深度保持一致。

                                                                    生成效果示例:基于D2C生成的页面 再去结合需求文档的内容实现跳转功能:

                                                                    3. 开发IDE插件,实现IDE内AI辅助和平台出码的无缝衔接

                                                                    为了解决原平台和IDE开发之间的流程割裂问题,我们决定将平台放置在IDE中,以插件的形式提供服务,以实现流程的无缝衔接。

                                                                    3.1 整体架构设计

                                                                    在插件整体设计上,我们采取了如下架构:

                                                                    • 物料层:准备出码所需的全部信息到本地,如UI设计稿解析成结构化信息、按模块拆分的需求文档。

                                                                    • 规范层:自动匹配不同项目、不同框架所需的出码规范。

                                                                    • 拓展能力层:下发的 MCP 能力,如图片内容读取、需求文档关键信息匹配、代码预览等等。

                                                                    • 提示词编排层:针对不同框架匹配不同的代码出码模版,并进行物料和规范信息的注入。

                                                                    • 交互层:用于选择设计稿及进行本地需求文档内容的二次修改,还支持用户进行自定义的规范配置,用户自定义的规范会被作为最高优先级的规范提示词来使用。

                                                                    3.2 关键实现:流程化出码

                                                                    实际的需求文档中,存在以下几个现象:

                                                                    • 需求文档里常有不精确的 UI 描述(与设计稿冲突)。

                                                                    • 部分需求逻辑依赖 UI 批注。

                                                                    • 文档可能包含多个页面,而用户只需要生成其中一个页面,其他页面的内容其实并不需要。

                                                                    为了避免UI信息和需求信息的相互干扰,不使用多余的需求信息占用上下文,实际在出码时,我们会分步完成,先生成UI代码,再在此基础上,匹配对应的需求内容,继续生成逻辑代码。

                                                                    3.2.1 分步式出码流程控制:

                                                                    我们使用初始prompt来进行流程控制,MCP来完成关键流程实现,处理方式大致如下:

                                                                    这样,在初始的时候prompt中除了规范就只有流程以及UI相关的信息,在此基础上可以较好的生成UI代码,不受需求文档内容的干扰。

                                                                    接着在后续的工具调用中,MCP读取需求文档,可在生成的UI代码产物基础上,通过文本和图片信息内容,找到最相近的需求内容进行逻辑代码的生成,避免有其余不必要的需求内容浪费我们宝贵的上下文。

                                                                    那么IDE在调用MCP时,是如何得到本地插件中的需求文档内容的呢(初始的prompt中并没有描述到这些信息)。

                                                                    3.2.2 IDE获取插件中的数据

                                                                    为了让MCP tool能拿到插件中留存的信息,我们采用在插件中启动一个本地服务的方式,来处理MCP的调用。

                                                                    这样,由于MCP服务为本地服务,本地服务运行在插件中,IDE便可以在调用MCP tool时,与插件共享同一上下文,获取并操作插件中的可用数据了。

                                                                    3.2.3 插件向IDE chat框提交信息的trick

                                                                    对于现存的一些IDE,大多数是不提供向chat聊天框设置信息的命令的。

                                                                    但大多的IDE,一定会有fix the error的快捷指令:当IDE提示有错误时,选中目标错误,错误就会被发到chat聊天框:

                                                                    fix the bug

                                                                    ===

                                                                    {错误内容}

                                                                    ===

                                                                    相应的,我们可以利用这一点,通过插件自行定义一个错误,并调用fix the error的快捷指令,那么被发送到chat聊天框的内容就可以变成这样:

                                                                    fix the bug

                                                                    ===

                                                                    Oh sorry, this is not an error. Here is the request:

                                                                    {你实际想给AI的prompt内容}

                                                                    ===

                                                                    在完成信息的注入后,我们可以调用发送指令将需求发送给AI。依由这一点,插件与IDE整体的信息交互就完成了闭环。

                                                                    四、总结

                                                                    通过深度结合AI,我们解决了传统D2C在复杂UI布局还原上的难题,还完成了根据需求文档生成高质量逻辑代码的实践,开发人员coding的工作,从以往0到1的完整开发,变为了可基于ai生成产物,从0.7到1的部分开发,大大提升了开发效率。

                                                                    展望未来,我们致力于建设具备“工程心智”的智能体,通过感知环境上下文,完成代码的效果审查、逻辑迭代以及问题修复,实现从0.7到1的coding自动化,让开发人员从coding中解放出来,在业务中发现可能的机会点,创造更多的业务价值。

                                                                    阅读原文

                                                                    跳转微信打开

                                                                    •  

                                                                    2025【技术原创文章】大汇总|内含福利

                                                                    原创 人才发展中心 2026-01-12 18:02 北京

                                                                    时光荏苒,Qunar技术沙龙陪伴大家又走过一年技术探索的征程。这一年,我们向大家分享了近二十篇高质量的技术文章,覆盖AI应用实践、数据库、中间件、系统/架构优化和运维方面等领域。

                                                                    在这一年的旅程中,感谢每一位读者的真诚相伴,你们每一次的阅读与反馈都让我们备受鼓舞。

                                                                    在此辞旧迎新之际,小编特地为大家汇总了2025年的技术文章,向大家呈现这一年来所探索的“技术地图”。(点击文章标题即可阅读哦)

                                                                    //

                                                                    AI应用实践

                                                                    作者:姚佳梅

                                                                    概要:去哪儿网结合AI与D2C技术,实现前端代码自动生成并显著提升开发效率。

                                                                    作者:李杰

                                                                    概要:OpenAI Agents SDK详解:多智能体协作与可视化追踪,轻松构建可靠AI应用。

                                                                    作者:王松

                                                                    概要:基于Multi-Agent智能体架构,去哪儿网实现白盒漏洞AI自动化审核,准确率高达97.36%。

                                                                    作者:陈力

                                                                    概要:深度优化提示词五步法,让机票客服AI精准理解用户意图,告别答非所问!

                                                                    作者:王朋朋

                                                                    概要:从单智能体到多智能体协作:用LangGraph4j实战Supervisor模式,构建企业级智能体系统!

                                                                    去哪儿网端智能架构设计和实践

                                                                    作者:陈军

                                                                    概要:端侧AI毫秒级决策:去哪儿网实战揭秘如何用智能架构精准预测用户流失。

                                                                    //

                                                                    数据库

                                                                    如何实现 Redis 高并发缓存?架构设计、实战案例与优化策略全解析

                                                                    作者:冷正磊

                                                                    概要:Redis高并发缓存如何设计?架构师带你揭秘热Key、雪崩等核心难题的实战解决方案!

                                                                    去哪儿StarRocks实践

                                                                    作者:任志民

                                                                    概要:去哪儿网如何用StarRocks统一OLAP架构?带你了解高并发查询从5.7秒优化至2.4秒的实战路径!

                                                                    数据库监控的进化之路:去哪儿网的指标采集与智能告警实践

                                                                    作者:钱芳园

                                                                    概要:去哪儿网数据库监控升级:智能告警与自愈系统实现精准故障定位与自动化运维。

                                                                    数据库巡检进入智能时代:异常检测算法的落地实践

                                                                    作者:杨赞

                                                                    概要:去哪儿网数据库巡检迈入智能时代:三大算法精准识别数据库异常趋势,让隐患无所遁形!

                                                                    //

                                                                    中间件

                                                                    去哪儿 KAFKA 再度优化-提升服务上限35%

                                                                    作者:王克礼&余东

                                                                    概要:通过优化filebeat攒批策略,提高了压缩比例,降低kafka集群35%总流量,有效应对流量高峰。

                                                                    //

                                                                    系统/架构优化

                                                                    双向驱动与反馈模型:构建实时准确的酒店报价缓存系统

                                                                    作者:谢欢

                                                                    概要:双向驱动+智能决策:高并发酒店报价缓存系统的实时精准之道。

                                                                    去哪儿营销实践-魔方营销画布

                                                                    作者:施黎明

                                                                    概要:可视化营销画布:拖拽式配置+多阶段执行,让复杂营销活动1小时快速上线。

                                                                    去哪儿酒店搜索排序模型的演进

                                                                    作者:杨旭

                                                                    概要:去哪儿网如何通过LambdaDNN与多目标模型迭代,持续优化酒店搜索排序效果?

                                                                    //

                                                                    运维

                                                                    去哪儿网一次JVM OOM问题的深度解码与治理实践

                                                                    作者:闫宏英

                                                                    概要:深度解码JVM OOM:无界队列引发内存泄漏,有界队列+降级开关根治隐患。

                                                                    去哪儿高峰期资源保障之智能扩缩容

                                                                    作者:刘丹

                                                                    概要:去哪儿网如何通过智能扩缩容系统,精准预测流量高峰并自动保障资源稳定?

                                                                    以上就是Qunar技术沙龙2025年的精华文章,感谢大家一直以来的支持与陪伴,愿这次汇总能给每位读者以新的灵感与思考。

                                                                    2026年,Qunar技术沙龙会继续陪伴大家在技术领域深耕,也欢迎各位小驼踊跃投稿,为大家分享更多一线实战经验与前沿思考!

                                                                    祝大家在新的一年里心有所愿,行有所成!

                                                                    ( 新年好礼)

                                                                    HAPPY NEW YEAR

                                                                    值此新年之际,小编也为各位读者准备了新年福利!

                                                                    月野钛行杯

                                                                    月野运动包

                                                                    参与方法:关注“Qunar技术沙龙”公众号,私信回复“2026新年好礼”,系统将抽取10位幸运读者送上新年礼物~

                                                                    温馨提醒:“2026新年好礼”活动截止日期为2026年1月19日18点(抽完即止)。中奖后请详细填写收件地址,我们将尽快寄出~

                                                                    阅读原文

                                                                    跳转微信打开

                                                                    •  

                                                                    1端开发6端复用:去哪儿RN转QTaro实战经验分享

                                                                    原创 刘亮亮 2026-01-08 18:02 北京

                                                                    e7aea0b2-cb9f-4322-b3ce-66271860cbe5.png

                                                                    文章概览

                                                                    • 项目背景及目标

                                                                    • 技术选型

                                                                    • 项目筹备

                                                                    • 迁移实战

                                                                    • 项目复盘

                                                                    • 结语

                                                                    保障数据情况

                                                                    作者介绍:

                                                                    刘亮亮,2019年加入去哪儿旅行火车票团队,火车票前端技术委员会成员,主要负责火车票/汽车/船票营销和辅营相关业务开发。

                                                                    一、项目背景及目标

                                                                    随着公司业务持续拓展,多端实现相同功能的需求日益凸显。与此同时,多端独立开发的弊端逐渐显现:

                                                                    1. 人力成本上升,开发人员需掌握多种技术栈,学习成本高、负担重;

                                                                    2. 维护成本增加,问题修复与迭代升级周期延长,效率降低。

                                                                    为解决上述问题,火车票大前端团队启动“统一前端技术栈”项目,旨在通过一套代码实现多端复用。

                                                                    项目目标:

                                                                    1. 实现一套React Native(RN)代码在iOS、Android、Harmony、支付宝小程序、微信小程序及H5共6端复用;

                                                                    2. 转换工具的代码复用度>80%

                                                                    二、技术选型

                                                                    1. 考量因素

                                                                    • 当前火车票前端需求以RN开发为主,需将RN项目高效转化为多端应用,提升产品体验一致性。

                                                                    • QTaro是大前端中心基础框架团队基于Taro打造的多端解决方案,支持小程序、H5与RN项目同步开发。其在原生Taro生态基础上,提供了公司内部多端开发工具、业务扩展库及开发规范,能有效降低业务前端开发成本。QTaro还提供RN代码转换、运行时支持及项目发布能力,与火车票项目诉求高度契合。

                                                                    • 尽可能保留原有RN开发习惯,降低团队学习成本。

                                                                    整体方案:依托QTaro的跨平台能力,联合基础框架团队打通QTaro与QRN,基于QTaro实现业务跨端落地,最终将QRN运行于多端,从而降低学习成本、提升开发效率、减少人力投入。

                                                                    2. 方案挑战

                                                                    • 组件与属性差异大:涉及RN/QRN/第三方库组件与API约82处,CSS 属性差异30余处,如何抹平差异实现无缝衔接是关键。

                                                                    • 业务逻辑层多端差异:页面路由、登录、支付等功能需各端独立实现。

                                                                    • 多端性能优化:转换后代码在各端的性能表现需持续优化。

                                                                    • 请求接口统一:如何实现各端网络请求接口的统一封装。

                                                                    三、项目筹备

                                                                    项目分两期推进:

                                                                    • 一期目标:完成订单详情页从RN到QTaro的转换,并上线微信小程序版本。选取该页是因为其UI组件丰富、交互相对简单,适合作为技术验证切入点。

                                                                    • 二期目标:完成火车票所有RN项目的转换并全端上线。

                                                                    四、迁移实战

                                                                    1.转换工具设计

                                                                    1.1 整体流程

                                                                    1.1.1 方案选型

                                                                    • 方案一: RN转多端。以RN项目为开发起点,隐藏中间转换项目,保持RN开发习惯,实现RN→多端单向转换,学习与开发成本最低。

                                                                      • RN转换成QTaro中间项目

                                                                      • 中间项目转多端(WX小程序/H5/ALI小程序)的方式,是RN单向转换,最小的开发成本就可实现RN代码一拖六

                                                                    • 方案二: QTaro转多端。以QTaro中间项目为起点,实现QTaro→6端转换,转换工具实现复杂,且需遵循RN样式约束,开发成本较高。

                                                                      综合评估后,选择方案一:RN转多端。兼顾开发效率、开发成本、学习成本,以及减少对当前RN项目的影响。

                                                                      • 从QTaro中间项目作为开发起点,转RN。必须按照规范《 React Native 端开发前注意》开发,涉及6端的转换, 转换工具实现复杂;

                                                                      • 按照QTaro的RN规范开发,本质是以RN的样式管理约束。在样式上统一多端,木桶效应,短板对齐(向最弱的RN对齐);

                                                                      • 在灵活的QTaro项目下开发,还要施加RN的样式约束,不如直接以RN项目开发更顺畅;

                                                                      • QTaro->RN可能存在诸多问题,对当前RN项目影响大(线上出故障的概率变高)而且增加维护成本。

                                                                    1.1.2 中间项目说明

                                                                    • 中间项目是临时&隐藏项目,  位置在当前项目.taroCache/project目录下。开发者不需要关心.taroCache,可以认为它不存在。

                                                                    • 中间项目符合QTaro框架规范的要求。

                                                                    • 开发者使用rn2QTaro cli命令行进行操作,内部调用Taro命令对中间项目进行构建。

                                                                    • 经过Taro build的处理之后,中间项目将会生成目标平台产物。

                                                                    1.1.3 一套代码6端复用的思路

                                                                    • RN项目->转换工具->QTaro中间项目->ALI小程序/WX小程序/H5  3端

                                                                    • RN项目->Metro->IOS/Adr/Harmony  3端

                                                                    1.2 转换工具流程图

                                                                    转换流程说明:

                                                                    1.2.1 初始化中间项目

                                                                    1. rn2QTaro拉取模板项目。模板项目是最小化的QTaro Js项目,承载转换后的JS代码。

                                                                    2. 根据当前项目中rn2QTaro.config.js配置项,安装中间项目的依赖文件以及RN多端库。

                                                                    1.2.2 转换过程

                                                                    1. 转换工具遍历项目所有JS文件,根据配置项,将RN/QRN等相关库映射为替换库。

                                                                    2. 删除RN项目中所有propTypes。

                                                                    1.3 RN库映射多端库

                                                                    1.3.1 架构图说明

                                                                    1. 转换工具根据配置文件,把项目中使用的RN库映射为对应的多端库。

                                                                    2. 多端库通过QTaro的MultiPlatformPlugin引用对应平台实现的组件和API。

                                                                    1.3.2 架构亮点

                                                                    1. 多端库的代码结构设计,利用QTaro已有的多端能力(MultiPlatformPlugin)进行多平台切换,简单高效。

                                                                    2. 通过封装QTaro抽象层的组件和API构建的RN等效多端库,可以随QTaro的扩展而动态支持更多平台。

                                                                    1.4 抹平组件属性差异

                                                                    1.4.1 方案选择

                                                                    方案分析:

                                                                    • RN和其他端相同功能的组件,例如: View, Text等,  默认属性差异大, 且style属性多为动态赋值,用babel处理非常复杂。例如: 为CSS样式width属性添加'PX'单位。期望将width: 20转义为width: "20PX",但实际项目多是动态赋值:

                                                                    • babel转义难以完成。

                                                                    • 选用运行时方案,仅需封装各端的组件和API,修改接口或属性向RN对齐,即可完成。

                                                                    • 在RN项目中,多采用import进行引用,而import语句本身是静态的,在转义阶段就已确定,因此import路径的替换必须放在转义时进行。

                                                                    方案确认:

                                                                    1. 通过babel AST完成RN库映射为多端库。

                                                                    2. 在运行时抹平各组件CSS样式差异,抹平样式模块封装在基类组件中。

                                                                    1.4.2 行内样式 & 样式文件

                                                                    RN使用JS对象来定义样式,并通过StyleSheet.create方法来创建样式表。

                                                                      //styles.js
                                                                      const styles = StyleSheet.create({
                                                                        container: {
                                                                          flex: 1,
                                                                          backgroundColor: '#F5FCFF',
                                                                        }
                                                                      });


                                                                      //App.js
                                                                      <Viewstyle={styles.container}>
                                                                      </View>

                                                                      当RN转QTaro,使用react开发时,同样支持使用JS对象定义样式。保持RN原有的CSS-in-JS样式是比较简单的处理方式。

                                                                      另一个问题是react中没有StyleSheet.create方法。

                                                                      解决方法2种:

                                                                      1. babel AST转为

                                                                        //styles.js
                                                                        //babel转义: 把StyleSheet.create的入参,直接赋值给styles
                                                                        const styles = {
                                                                          container: {
                                                                            flex: 1,
                                                                            backgroundColor: '#F5FCFF',
                                                                          }
                                                                        };


                                                                        //App.js
                                                                        <Viewstyle={styles.container}>
                                                                        </View>

                                                                        2. 自己实现StyleSheet.create

                                                                          const StyleSheet = {
                                                                              create(styles) {
                                                                                  const result = {};
                                                                                  Object.keys(styles).forEach(key => {
                                                                                      result[key] = styles[key]
                                                                                  });
                                                                                  return result;
                                                                              }
                                                                          };

                                                                          1.4.3 行内样式style兼容

                                                                            //RN中style支持样式数组,QTaro中不支持
                                                                            <Viewstyle={[styles.container,extraStyle]}>
                                                                            </View>

                                                                            解决方法:

                                                                            1. 自己实现StyleSheet.flatten,递归地展平数组中的每个样式对象,并将它们合并成一个单一的样式对象。

                                                                            2. 样式处理

                                                                            3. 方式1: babel 转义

                                                                              //RN中style支持样式数组,QTaro中不支持
                                                                              <Viewstyle={StyleSheet.flatten([styles.container,extraStyle])}>
                                                                              </View>

                                                                              方式2: 在兼容组件的入口,调用StyleSheet.flatten转为单一样式对象

                                                                              1.4.4 更多样式问题

                                                                              1. 尺寸单位 

                                                                              RN中许多样式属性是不带单位的。因为RN的样式系统是基于弹性布局(Flexbox)设计的,它在不同的平台(iOS 和 Android)上会自动进行适配。 

                                                                              但是在QTaro中,建议使用px、%作为尺寸单位,其默认会根据平台对单位进行转换,不希望做默认转换需要设置为"PX"。 

                                                                              我们评估RN代码转QTaro,大多数需求场景设置"PX"较为合理,实际项目测试的结果也符合预期。 

                                                                              常见的width, height, margin, bottom等,约有60多个。
                                                                              可参考文档: 《Layout Props · React Native》

                                                                              2. 阴影

                                                                                //RN代码 shadow样式
                                                                                StyleSheet.create({
                                                                                    myView: {
                                                                                        shadowRadius: 5,
                                                                                        shadowOpacity: 0.5,
                                                                                        shadowOffset: {x: 2, y: 2},
                                                                                        shadowColor: 'gray'
                                                                                    }
                                                                                })
                                                                                //转为 react boxShadow样式
                                                                                StyleSheet.create({
                                                                                    myView: {
                                                                                        boxShadow: `2PX 2PX 5PX 0PX gray`
                                                                                    }
                                                                                })

                                                                                3. 动画 

                                                                                将RN的transform属性转换为Web的transform属性。 

                                                                                rn支持的转换:

                                                                                1. rotate系列:rotate, rotateX, rotateY, rotateZ

                                                                                2. scale系列:scale, scaleX, scaleY,scaleZ

                                                                                3. translate系列:translate, translateX, translateY, translateZ

                                                                                4. skew系列:skew, skewX, skewY

                                                                                  //RN的 transform
                                                                                  {
                                                                                          transform: [  
                                                                                              { rotateZ: '-60deg' },  
                                                                                              { translateY: -8 },  
                                                                                              { translateY: 4 }  
                                                                                          ]
                                                                                  }


                                                                                  //react的 transform
                                                                                  {  
                                                                                       transform: 'rotateZ(-60deg) translateY(-8PX) translateY(4PX)'  
                                                                                  } 

                                                                                  4. 样式替换 

                                                                                  例如: RN的marginStart需要替换为marginLeft, marginHorizontal需要替换为marginLeft, marginRight。

                                                                                    //RN属性
                                                                                    {
                                                                                            marginHorizontal: 10
                                                                                    }


                                                                                    //转换后代码
                                                                                    {
                                                                                        marginLeft: 10PX,
                                                                                        marginRight: 10PX
                                                                                    }

                                                                                    5. 默认样式差异

                                                                                    • display:

                                                                                      • RN: 组件的display属性是flex,所有的布局都是基于Flexbox。

                                                                                      • CSS: 组件的display属性是block,类似于HTML中的div元素。

                                                                                    • flex和flexDirection:

                                                                                      • RN: 在View上默认display: flex和 column。子组件垂直排列

                                                                                      • CSS: 如果设置为flex布局,默认值是row。子元素水平排列

                                                                                    • box-sizing:

                                                                                      • RN: 默认值为border-box且只支持这种

                                                                                      • CSS: 默认值是content-box

                                                                                    • 更多默认样式差异可参考:

                                                                                    2. 实现RN多端库

                                                                                    实现UI组件及API库,替换RN/QRN/第三方RN库中对应的UI组件及API。RN多端库是抹平多端差异的核心库,  具有通用性,适用于各RN项目。

                                                                                    2.1 已实现多端库

                                                                                    还包括qunar-react-native, react-native-keyboard-aware-scroll-view, react-native-render-html, react-native-WebView等共14个RN多端库, 不再详细列举。

                                                                                    RN标准库中组件和API实现已覆盖80%(因平台差异, 无法实现组件占位留空)。

                                                                                    火车票项目中组件和API覆盖86%,和平台关联较大的部分组件(截屏、QP包管理、日历、通知等)已被降级处理。

                                                                                    2.2 组件实例接口差异

                                                                                    RN中组件节点的实例方法与QTaro组件库存在差异 

                                                                                    常见的有:

                                                                                    1. this.viewRef.current.measureLayout测量视图布局

                                                                                    2. this.qVideoRef.current.play/pause/seek视频播放等操作

                                                                                    3. this.textInputRef.current.blur/isFocused判断焦点操作

                                                                                    通过自定义组件实例的外部接口,确保多端库组件实例方法与RN组件接口一致。

                                                                                    下面以View组件为例,添加可供外部调用的方法measureLayout,和RN View接口保持一致。

                                                                                    3. 业务代码多端适配方案

                                                                                    RN转QTaro框架, 不仅要适配RN/QRN/三方RN组件,还需处理平台相关的业务逻辑差异。

                                                                                    深入分析每个差异功能后,发现业务逻辑差异是因使用RN原生插件引起,以NativeModules为切入点可以做到隐藏差异。

                                                                                    主要差异功能:登录、支付、页面路由、网络请求

                                                                                    以Network为例,说明业务代码的多端适配图

                                                                                    3.1 架构说明

                                                                                    以NativeModules为切入点,业务开发同学不需要关心平台差异,同时可以对NativeModules扩展,后续支持更多平台。

                                                                                    3.2 NativeModules多平台切换

                                                                                    @taro/NativeModules实现了一套和火车业务RN原生插件接口一致的类。

                                                                                    • RN平台通过@taro/NativeModules/index.js引用react-native的 NativeModules

                                                                                    • WX平台通过

                                                                                      @taro/NativeModules/index.weapp.js引入weapp多端库实现。

                                                                                    以接口请求Network.js为例说明:

                                                                                    • 多端适配前

                                                                                      //RN插件 NativeModules.TRNQunarNetwork 发送请求  
                                                                                      import { NativeModules } from 'react-native';

                                                                                      • 多端适配后

                                                                                        //路径替换,引用多端文件  
                                                                                        import NativeModules from '@taro/NativeModules';

                                                                                        • RN平台@taro/NativeModules/index.js

                                                                                          //RN平台直接导出 react-native 的 NativeModules。外部通过 NativeModules.TRNQunarNetwork 获取原生请求插件  
                                                                                          import { NativeModules } from 'react-native';  
                                                                                          export default NativeModules;
                                                                                          • WX平台

                                                                                            @taro/NativeModules/index.weapp.js

                                                                                            //微信小程序平台导出自定义 NativeModules, 对外接口和RN平台保持一致。外部通过 NativeModules.TRNQunarNetwork 获取WX平台请求接口  
                                                                                            const NativeModules = {    
                                                                                              TRNQunarNetwork,//封装了WX端实现类  
                                                                                            }   
                                                                                            export default NativeModules; 

                                                                                            3.3 方案总结

                                                                                            该方案进一步封装了业务逻辑的多端差异,把NativeModules作为多平台切换的入口点,在各个平台封装一组与原生RN插件等效的功能类(例如 TRNQunarNetwork, TRNNavigator),并确保功能类对外接口在各平台完全一致。

                                                                                            可以完美和react-native的NativeModules数据结构契合,做到各端平滑切换。涉及业务代码的多平台差异被隐藏在NativeModules中,后续产品需求开发时,开发同学仅需聚焦到业务逻辑即可。

                                                                                            4. 项目的难点

                                                                                            4.1 RN转微信小程序严重超Size问题

                                                                                            4.1.1 背景

                                                                                            小程序总包剩余空间不足, 产品需求开发已严重受限。

                                                                                            RN转QTaro项目面临的最大难题是要解决Size问题,如果不能上线微信小程序,多端复用也就失去意义。

                                                                                            4.1.2 解决方案

                                                                                            把所有的RN页面利用QTaro框架转为H5,通过WebView方式加载。

                                                                                            WebView加载方式选择:

                                                                                            4.1.2.1 MPA面临的问题

                                                                                            1. 不能共享内存实例对象:  global上注册了很多功能类和数据类,包括共享的ABTest数据,QConfig等。这些数据在各H5页面间不同步。

                                                                                            2. 事件订阅和通知无效: 页面通过EventCenter注册事件订阅,监听某个页面的数据变化。页面无法监听其他页面触发的事件。

                                                                                            解决方法 : 难以修复。火车项目页面>100个,MPA下修复共享实例问题,需要改动的代码量巨大,将会严重阻塞项目进度。

                                                                                            4.1.2.2 SPA面临的问题

                                                                                            1. 多个RN项目是单独打包出多个H5产物。同一个H5产物,页面之间可以共享对象实例,但不同的H5产物之间仍无法共享数据。

                                                                                            解决方法:多个RN项目合并打包,打出一个H5产物。

                                                                                            4.1.2.3 MPA和SPA共同面临的问题

                                                                                              1. 修改WebView的hash方式传参,H5页面被重新reLaunch,页面栈丢失。

                                                                                              解决方法:同域名可以通过local storage传参,跨域下通过后端接口共享数据。

                                                                                              2. 小程序和H5登录态不同步问题

                                                                                              解决方法:外部登录态通过URL传入WebView,保存在WebView的cookie中。

                                                                                              3. 首次资源下载问题过大

                                                                                              解决方法:通过webpack文件分割优化后,首次下载资源1.7M,后续页面下载平均200K。

                                                                                              综合考虑以上因素,选择SPA方案能够更好地解决项目中的问题。SPA在内存对象共享、页面流畅度以及资源利用效率等方面具有优势,且能解决项目中面临的关键问题。

                                                                                              五、项目复盘

                                                                                              5.1 项目的成果

                                                                                              5.1.1 转换工具代码复用度87%

                                                                                              针对所有涉及的RN项目,分别获取起始和结束时的git commit hash(版本提交哈希值),然后进行git diff操作,计算得出两次提交之间代码行数的变化量与总代码行数的比值为13%。

                                                                                              粗略估计转换工具可以节省RN转换整体工作量的 75%。

                                                                                              5.1.2 一套代码多端复用

                                                                                              UI样式效果微信小程序H5对比Adr-RN:

                                                                                              UI样式和功能向RN端看齐, 减少用户多端切换时的学习成本,保证用户各端功能体验一致。

                                                                                              5.1.3 节约人力成本>50%

                                                                                              以3端为例:

                                                                                              • 接入QTaro方案,节省(300%-160%)/300% =47%

                                                                                              • 业务差异封装后,  节省(300%-100%)/300% =67%

                                                                                              • 覆盖的端越多,每端成本越小

                                                                                              以业务线投入4人到非RN端开发计算,统一多端后,年化节约人力 4*235pd( 每人每年pd数 ) = 940pd。

                                                                                              5.1.4 突破小程序Size限制

                                                                                              通过加载单页面H5,解决了RN转WX小程序严重超Size的问题。

                                                                                              转H5后,车次列表页TTI-P90对比如下:

                                                                                              安卓手机,微信原生和微信H5对比

                                                                                              IOS手机,微信原生和微信H5对比

                                                                                              结论:

                                                                                              在IOS/Adr系统上,H5的TTI-P90基本优于微信小程序原生代码。

                                                                                              在解决微信小程序Size问题上,目前取得了阶段性的成功。火车票前端正在深入分析原因,尝试通过加载流程优化,资源预加载等策略进一步提升用户体验。

                                                                                              5.2 不足与展望

                                                                                              5.2.1 组件兼容性

                                                                                              例如: RN部分组件/API在平台兼容性方面存在问题,其中较为棘手的是Animated、PanResponder等与动画手势相关的组件。

                                                                                              H5多端库动画问题, 可以参考开源库 https://github.com/necolas/react-native-web进一步完善。

                                                                                              WX多端库动画问题:

                                                                                              • WX动画是通过API createAnimation实现,  而RN的Animated由3-4个API配合使,考虑到调用方式以及动画与组件的关联,完全模拟较为复杂。

                                                                                              • wx.createAnimation依赖于小程序的JS运行环境,受限于小程序的性能和资源分配,尤其是在低端设备上,容易出现卡顿。

                                                                                              解决思路:可以使用CSS动画实现。但CSS不能动态调整动画参数,不适合作为通用的多端库组件,因此需要在平衡动画流畅性和通行性上做取舍

                                                                                              5.2.2 转换工具覆盖度

                                                                                              多端库组件和API,目前主要适配火车RN的项目,未来可扩展支持更多RN生态组件。

                                                                                              5.2.3 样式边缘情况

                                                                                              组件适配的边缘情况的处理不够完善。在抹平组件属性差异的过程中,个别属性差异可能导致特定设备或浏览器上显示异常,需持续测试与完善。

                                                                                              六、结语

                                                                                              本项目提供了一套将RN项目转换为QTaro框架的完整解决方案,涵盖转换工具、多端兼容库与业务差异封装,显著提升开发效率与多端一致性。在迁移过程中,团队积累了丰富的跨端适配经验,也深刻认识到协作与沟通在复杂项目中的关键作用。

                                                                                              未来,火车票前端将持续跟进QTaro框架演进,进一步优化性能与体验,为业务赋能提供更强支撑。

                                                                                              阅读原文

                                                                                              跳转微信打开

                                                                                              •  
                                                                                              ❌