本文是《Java 后端 + AI 落地(Spring AI 主线)》系列第 9 篇。前面八篇一直在说"要裁剪历史""要给上下文留预算",但一直没说透一件事:历史到底存在哪、以什么结构存、多实例怎么共享、摘要什么时候生成。 这一篇把这块补上。它讨论的不是"怎么调通多轮对话"------那个第 2 篇已经做完了,
ChatClient加一个messages列表就行;它讨论的是当你的会话从 10 个变成 10 万个、从一个实例变成五个实例、从五分钟变成跨天以后,这套东西会在哪里崩。 系列一第 8 篇从 Agent 的角度讲过三级记忆配置,本篇把同样的东西落到 Java 后端的存储层,并给出可以照抄的 Redis 结构与建表 SQL。
📌 版本声明 :本文基于 Spring AI 2.0.1 (2.0.0 于 2026-06-12 GA)+ Spring Boot 4.1.x (4.1.1 于 2026-08-20 GA)+ Spring Framework 7 + JDK 21 + Redis 7.x + MySQL 8.x 编写;模型侧沿用第 2 篇的通义千问 OpenAI 兼容端点 (qwen-plus)。会话存储层与具体模型供应商无关,切换到其他兼容端点同样适用。注意 Spring Boot 3.5 与 Spring Framework 6.2 已于 2026-06-30 EOL ,Spring AI 1.1.x 与 2.0.x 在消息模型(UserMessage / AssistantMessage / 工具消息)上存在差异,升级前请用官方 Release Notes 复核。文中 token 估算、裁剪比例、TTL 取值与成本数字均为特定业务下的量级参考 ,会随业务形态显著变化,请用自己的一条真实会话做标定。
文章目录
-
- [1️⃣ 为什么"存会话"比想象中难:三个必答的问题](#1️⃣ 为什么"存会话"比想象中难:三个必答的问题)
-
- [1.1 单轮对话和多轮对话差的不是"多一个参数"](#1.1 单轮对话和多轮对话差的不是"多一个参数")
- [1.2 最常见的两个错误](#1.2 最常见的两个错误)
- [1.3 存储介质选型:四种方案的真实取舍](#1.3 存储介质选型:四种方案的真实取舍)
- [2️⃣ 核心概念:四层记忆、生命周期与一致性](#2️⃣ 核心概念:四层记忆、生命周期与一致性)
-
- [2.1 把"记忆"拆成四层,而不是一个列表](#2.1 把"记忆"拆成四层,而不是一个列表)
- [2.2 会话生命周期:一次会话会经历什么](#2.2 会话生命周期:一次会话会经历什么)
- [2.3 上下文预算:会话设计本质上是一道分配题](#2.3 上下文预算:会话设计本质上是一道分配题)
- [2.4 一致性的两个层次:读一致性不需要强,写一致性必须强](#2.4 一致性的两个层次:读一致性不需要强,写一致性必须强)
- [3️⃣ 环境准备](#3️⃣ 环境准备)
-
- [3.1 依赖与版本](#3.1 依赖与版本)
- [3.2 Redis 的数据结构设计](#3.2 Redis 的数据结构设计)
- [3.3 MySQL 全量表:三张表的 DDL](#3.3 MySQL 全量表:三张表的 DDL)
- [4️⃣ 核心实现](#4️⃣ 核心实现)
-
- [4.1 会话模型:先把"状态"和"历史"定义成两个不同的类型](#4.1 会话模型:先把"状态"和"历史"定义成两个不同的类型)
- [4.2 写入路径:追加式写入,落库异步化](#4.2 写入路径:追加式写入,落库异步化)
- [4.3 读取与拼装:token 预算怎么分](#4.3 读取与拼装:token 预算怎么分)
- [4.4 按 token 裁剪:三行代码与三个坑](#4.4 按 token 裁剪:三行代码与三个坑)
- [4.5 摘要:什么时候生成、怎么保证不重复算](#4.5 摘要:什么时候生成、怎么保证不重复算)
- [4.6 长期记忆:写入必须是显式的](#4.6 长期记忆:写入必须是显式的)
- [5️⃣ 进阶与优化](#5️⃣ 进阶与优化)
-
- [5.1 三条"让模型记住历史"的路线与 ROI](#5.1 三条"让模型记住历史"的路线与 ROI)
- [5.2 会话层必须有的四个指标](#5.2 会话层必须有的四个指标)
- [5.3 多实例:还要不要开会话粘性](#5.3 多实例:还要不要开会话粘性)
- [5.4 隐私与合规:四个必须做的动作](#5.4 隐私与合规:四个必须做的动作)
- [6️⃣ 适用边界与风险提示](#6️⃣ 适用边界与风险提示)
-
- [6.1 适用场景](#6.1 适用场景)
- [6.2 不适用场景](#6.2 不适用场景)
- [6.3 版本兼容与升级注意](#6.3 版本兼容与升级注意)
- [6.4 生产建议清单](#6.4 生产建议清单)
- [7️⃣ 总结](#7️⃣ 总结)
-
- [7.1 关键决策点回顾](#7.1 关键决策点回顾)
- [7.2 回到开头](#7.2 回到开头)
- 参考资料

1️⃣ 为什么"存会话"比想象中难:三个必答的问题
1.1 单轮对话和多轮对话差的不是"多一个参数"
第 2 篇的对话接口长这样:接一个字符串,返回一个字符串。要变成多轮,直觉上的改法是"再传一个历史列表进去"。这个改法在演示环境里完全正确,但它把三个问题一起藏了起来。
问题一:历史是"事实"还是"缓存"? 如果历史只存在浏览器内存里,那么用户刷新页面就失忆、换个设备就失忆、后端重启后端也失忆。这意味着"历史"必须是服务端的一等公民,有自己的生命周期、有自己的存储、有自己的过期规则。 很多团队是在用户投诉"换个手机登录,机器人不认识我了"之后才发现这一点的。
问题二:每一轮要读多少、写多少? 单轮请求的读写是 0 和 0,多轮请求变成"读全部历史 + 写两条消息"。当会话有 50 轮时,每一次提问都要把这 50 轮从存储里取出来、拼成 prompt 发出去。 这带来一个很反直觉的结论:存会话最贵的部分不是存储空间,而是"每轮都要把历史重新发一遍"带来的 token 成本与延迟。 存储是几十 MB 的事,token 是每月几万块的事。
问题三:多个实例同时写怎么办? 单实例时你可以用一个 ConcurrentHashMap 糊过去。一旦扩到两个 Pod,内存里的会话就是两份,用户在 A 实例说了上半句、被负载均衡打到 B 实例说下半句,B 完全不知道上半句存在。 更糟的是"双写冲突"------同一个会话的两个请求同时到达,各自读到同一份历史、各自追加一条、后写的覆盖先写的,结果是永久丢一条消息,而且没有任何报错。
这三个问题的共同点是:它们都不会在开发阶段暴露,只会在有真实用户之后暴露。 所以这一篇的写法是反过来------先定存储结构与生命周期,再写对话逻辑。 对话逻辑只有几行,存储设计才是这篇的主体。
1.2 最常见的两个错误
错误一:把"会话状态"和"对话历史"塞进同一个容器。
我见过最典型的实现是:Redis 里存一个 session:{id} 的 String,值是序列化后的消息列表,业务需要的"当前在第几步"从消息列表里反向推断------"上一轮 Assistant 问了'请提供订单号',所以现在应该是等订单号"。
这个做法在流程简单时能跑,但一旦流程有分支就立刻崩。 举一个真实例子:一个报销助手的流程是"问金额 → 问事由 → 问发票 → 提交",中间用户可以随时说"改一下金额"。用"反向推断"实现时,模型的输出必须严格符合预期格式,而模型是会变的------它某天把"请提供订单号"改写成"方便告诉我订单号吗",你的状态机就识别不出来了,表现为"机器人反复问同一个问题"或者"跳过一步直接提交"。
正确做法是把两者彻底分开:
| 维度 | 会话状态(State) | 对话历史(History) |
|---|---|---|
| 内容 | 当前步骤、已收集槽位、临时标记 | 用户与助手的消息列表 |
| 结构 | 强类型、有 schema、字段固定 | 松散的、长度不定 |
| 谁写 | 业务代码写(代码推进流程) | 模型与用户共同产生 |
| 能否从历史推断 | 不能,也不要尝试 | 它本身就是原始记录 |
| 进 prompt 的方式 | 渲染成一段结构化文本(如"当前步骤:等待发票;已填:金额 860 元、事由 交通") | 直接作为消息列表 |
| 典型故障 | 字段缺失导致流程卡死 | 太长导致 token 爆炸 |
这个切分是本篇最重要的一条设计判断,因为它的代价差异极大。 状态是代码的资产,历史是模型的输入。混在一起时,你会被迫用自然语言解析来做流程控制------那等于把确定性逻辑建立在概率输出上,这与第 2 篇 6.2 节"不要用模型做需要确定性的裁决"是同一条纪律。
错误二:按"条数"裁剪历史。
"保留最近 20 条消息"是最常见的写法,也是我认为最危险的一条。因为消息的长度分布极不均匀。
我实测过自己的一个客服会话:20 条消息里,18 条是"好的""收到""谢谢"这种(每条 5~10 token),但有 2 条是用户粘贴的故障日志(每条 4000+ token)。按条数裁到 20 条,实际 token 可能是 2000,也可能是 18000------差 9 倍。 而你给模型留的预算是固定的,按条数裁剪意味着你根本不知道这次请求会发出去多少 token。
结论:裁剪的计量单位必须是 token,不是条数。 这不是"更精确"的偏好问题,而是"能不能保证不超预算"的正确性问题。第 8 篇 5.1 节讲"砍输入能降 TTFT",砍的前提是你知道现在有多少------按条数裁时你连自己有多少都不知道。
1.3 存储介质选型:四种方案的真实取舍
把会话放到哪里,是这个设计里最容易争论的部分。先把四种常见方案摆在一起:
| 方案 | 优点 | 致命短板 | 适用阶段 |
|---|---|---|---|
JVM 内存 (ConcurrentHashMap / Caffeine) |
零依赖、零延迟、实现最快 | 多实例不共享、重启即失忆、无过期管理 | 只有本地开发与单实例演示 |
| Redis(Hash + List) | 亚毫秒读、天然 TTL、多实例共享、结构灵活 | 成本随量线性上涨、无复杂查询能力(不能"查最近七天提到发票的会话") | 主力方案:热数据与状态 |
| MySQL(JSON / 大文本列) | 可查询、可审计、成本低、天然持久 | 单次读写延迟高一个量级、高并发写入压力大、JSON 检索能力有限 | 归档与审计:全量历史、合规留存 |
| 文件 / 对象存储 | 极便宜、容量无上限 | 无并发控制、检索靠扫、不适合在线读 | 冷归档(超过留存期的历史) |
我最终的方案是"Redis 做热、MySQL 做全、对象存储做冷"的三级结构,理由不是"架构好看",而是这三级的访问模式根本不同:
- Redis 存的是"下一轮马上要用"的东西------状态 + 最近 N 轮历史。它的读写频率是"每个请求两次",所以必须亚毫秒,必须能自动过期。
- MySQL 存的是"要能被查、能被合规调取"的东西 ------全量消息、审计记录、会话--用户归属。它的访问频率是"偶尔查一次",所以延迟高一点可以接受;但它必须能按用户、按时间、按业务线做查询,这是 Redis 给不了的。
- 对象存储存的是"大概率永远不会再看,但按合规要求不能删"的东西------通常用于超过留存期但仍在法定保存期内的对话。
这里要强调一个容易被当成"冗余"的设计:Redis 和 MySQL 都存历史,不是重复建设,是两种用途。 如果只存 Redis,你无法回答"这个用户三个月前投诉时到底说了什么";如果只存 MySQL,每个请求都要打一次带 JSON 解析的数据库查询,延迟会从 1 毫秒变成 20 毫秒,而它发生在每个请求的关键路径上。 双写带来的不一致风险,用"先写 Redis 再异步落库 + 对账任务"来控制,具体做法在 4.2 节。
#mermaid-svg-hP0pe5MEVutwyN5K{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-hP0pe5MEVutwyN5K .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-hP0pe5MEVutwyN5K .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-hP0pe5MEVutwyN5K .error-icon{fill:#552222;}#mermaid-svg-hP0pe5MEVutwyN5K .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-hP0pe5MEVutwyN5K .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-hP0pe5MEVutwyN5K .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-hP0pe5MEVutwyN5K .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-hP0pe5MEVutwyN5K .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-hP0pe5MEVutwyN5K .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-hP0pe5MEVutwyN5K .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-hP0pe5MEVutwyN5K .marker{fill:#333333;stroke:#333333;}#mermaid-svg-hP0pe5MEVutwyN5K .marker.cross{stroke:#333333;}#mermaid-svg-hP0pe5MEVutwyN5K svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-hP0pe5MEVutwyN5K p{margin:0;}#mermaid-svg-hP0pe5MEVutwyN5K .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-hP0pe5MEVutwyN5K .cluster-label text{fill:#333;}#mermaid-svg-hP0pe5MEVutwyN5K .cluster-label span{color:#333;}#mermaid-svg-hP0pe5MEVutwyN5K .cluster-label span p{background-color:transparent;}#mermaid-svg-hP0pe5MEVutwyN5K .label text,#mermaid-svg-hP0pe5MEVutwyN5K span{fill:#333;color:#333;}#mermaid-svg-hP0pe5MEVutwyN5K .node rect,#mermaid-svg-hP0pe5MEVutwyN5K .node circle,#mermaid-svg-hP0pe5MEVutwyN5K .node ellipse,#mermaid-svg-hP0pe5MEVutwyN5K .node polygon,#mermaid-svg-hP0pe5MEVutwyN5K .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-hP0pe5MEVutwyN5K .rough-node .label text,#mermaid-svg-hP0pe5MEVutwyN5K .node .label text,#mermaid-svg-hP0pe5MEVutwyN5K .image-shape .label,#mermaid-svg-hP0pe5MEVutwyN5K .icon-shape .label{text-anchor:middle;}#mermaid-svg-hP0pe5MEVutwyN5K .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-hP0pe5MEVutwyN5K .rough-node .label,#mermaid-svg-hP0pe5MEVutwyN5K .node .label,#mermaid-svg-hP0pe5MEVutwyN5K .image-shape .label,#mermaid-svg-hP0pe5MEVutwyN5K .icon-shape .label{text-align:center;}#mermaid-svg-hP0pe5MEVutwyN5K .node.clickable{cursor:pointer;}#mermaid-svg-hP0pe5MEVutwyN5K .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-hP0pe5MEVutwyN5K .arrowheadPath{fill:#333333;}#mermaid-svg-hP0pe5MEVutwyN5K .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-hP0pe5MEVutwyN5K .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-hP0pe5MEVutwyN5K .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-hP0pe5MEVutwyN5K .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-hP0pe5MEVutwyN5K .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-hP0pe5MEVutwyN5K .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-hP0pe5MEVutwyN5K .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-hP0pe5MEVutwyN5K .cluster text{fill:#333;}#mermaid-svg-hP0pe5MEVutwyN5K .cluster span{color:#333;}#mermaid-svg-hP0pe5MEVutwyN5K div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-hP0pe5MEVutwyN5K .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-hP0pe5MEVutwyN5K rect.text{fill:none;stroke-width:0;}#mermaid-svg-hP0pe5MEVutwyN5K .icon-shape,#mermaid-svg-hP0pe5MEVutwyN5K .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-hP0pe5MEVutwyN5K .icon-shape p,#mermaid-svg-hP0pe5MEVutwyN5K .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-hP0pe5MEVutwyN5K .icon-shape .label rect,#mermaid-svg-hP0pe5MEVutwyN5K .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-hP0pe5MEVutwyN5K .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-hP0pe5MEVutwyN5K .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-hP0pe5MEVutwyN5K :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 冷层 · 对象存储
温层 · MySQL 8.x
热层 · Redis 7.x
应用层(无状态,可任意扩缩容)
异步落库 + 对账
异步落库 + 对账
超过留存期
超期清理
实例 A
实例 B
实例 C
state:{sid}
Hash · 结构化状态
TTL 2h
history:{sid}
List · 最近 N 轮
TTL 2h
summary:{sid}
String · 固化摘要
TTL 同会话
chat_session
会话元数据与归属
chat_message
全量消息(append-only)
超留存期归档
按合规要求保存
(图 1:三级存储结构------注意"应用层完全无状态"与"Redis 是唯一被同步读写的层",这两条决定了扩容与一致性策略)
2️⃣ 核心概念:四层记忆、生命周期与一致性
2.1 把"记忆"拆成四层,而不是一个列表
系列一第 8 篇从 Agent 视角讲过三级记忆(工作记忆 / 会话记忆 / 长期记忆),落到 Java 后端的存储层,我把它拆成四层 ,因为其中有一层在 Agent 场景里不显著、但在业务系统里必须有------审计层。
| 层 | 内容 | 介质 | 时间尺度 | 是否进 prompt |
|---|---|---|---|---|
| 结构化状态 | 当前步骤、已收集槽位、临时标记 | Redis Hash | 小时级(TTL 2h) | 进,渲染成一段文本 |
| 对话历史 | 用户与助手消息列表 | Redis List(热)+ MySQL(全) | 小时~天级 | 进,作为消息列表 |
| 摘要 | 早期历史的压缩文本 | Redis String(固化) | 与会话同寿 | 进,拼在历史之前 |
| 长期记忆 | 跨会话的偏好与事实 | MySQL(结构化) | 月~年 | 有条件进(见 4.7) |
| 审计记录 | 谁在什么时候问了什么 | MySQL(append-only) | 按合规要求 | 不进 |
这张表里有三个判断需要解释。
第一,"结构化状态"和"对话历史"的 TTL 可以不同。 状态的有效期由业务决定(一个下单流程可能在 10 分钟内结束,也可能第二天继续),历史的有效期由"用户预期"决定。把两者绑在一个 key 上,就意味着你只能取两者的最小值或用最大值兜底,两种都会出问题:取小值会让"第二天回来继续填表"失败,取大值会让大量早已结束的会话占着内存。
第二,摘要是"固化"的,不是每次现算的。 这一条在 4.5 节会详细讲,因为它是成本与一致性两个问题的交汇点。
第三,审计层单独存在,且不进 prompt。 它的作用对象是"事后查证",不是"模型推理"。把审计记录当成历史的一部分塞进 prompt,是一个既浪费 token 又扩大泄露面的错误------用户问"我刚才说了啥",你没必要把内部的调用日志也发一份给模型。
这四层之间不是简单的包含关系,而是"不同的东西用不同的方式活着"。 我见过把五层压成"一个消息列表"的实现,它在会话短、流程直的时候完全正常,在会话长、有分支、要合规的时候四处漏风。

2.2 会话生命周期:一次会话会经历什么
会话不是"创建后一直存在直到永久",它有明确的状态流转。把生命周期画出来的价值是:每一段流转都对应一个具体的运维动作。
#mermaid-svg-l7iMrskhjBxwzBNm{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-l7iMrskhjBxwzBNm .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-l7iMrskhjBxwzBNm .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-l7iMrskhjBxwzBNm .error-icon{fill:#552222;}#mermaid-svg-l7iMrskhjBxwzBNm .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-l7iMrskhjBxwzBNm .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-l7iMrskhjBxwzBNm .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-l7iMrskhjBxwzBNm .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-l7iMrskhjBxwzBNm .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-l7iMrskhjBxwzBNm .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-l7iMrskhjBxwzBNm .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-l7iMrskhjBxwzBNm .marker{fill:#333333;stroke:#333333;}#mermaid-svg-l7iMrskhjBxwzBNm .marker.cross{stroke:#333333;}#mermaid-svg-l7iMrskhjBxwzBNm svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-l7iMrskhjBxwzBNm p{margin:0;}#mermaid-svg-l7iMrskhjBxwzBNm defs #statediagram-barbEnd{fill:#333333;stroke:#333333;}#mermaid-svg-l7iMrskhjBxwzBNm g.stateGroup text{fill:#9370DB;stroke:none;font-size:10px;}#mermaid-svg-l7iMrskhjBxwzBNm g.stateGroup text{fill:#333;stroke:none;font-size:10px;}#mermaid-svg-l7iMrskhjBxwzBNm g.stateGroup .state-title{font-weight:bolder;fill:#131300;}#mermaid-svg-l7iMrskhjBxwzBNm g.stateGroup rect{fill:#ECECFF;stroke:#9370DB;}#mermaid-svg-l7iMrskhjBxwzBNm g.stateGroup line{stroke:#333333;stroke-width:1;}#mermaid-svg-l7iMrskhjBxwzBNm .transition{stroke:#333333;stroke-width:1;fill:none;}#mermaid-svg-l7iMrskhjBxwzBNm .stateGroup .composit{fill:white;border-bottom:1px;}#mermaid-svg-l7iMrskhjBxwzBNm .stateGroup .alt-composit{fill:#e0e0e0;border-bottom:1px;}#mermaid-svg-l7iMrskhjBxwzBNm .state-note{stroke:#aaaa33;fill:#fff5ad;}#mermaid-svg-l7iMrskhjBxwzBNm .state-note text{fill:black;stroke:none;font-size:10px;}#mermaid-svg-l7iMrskhjBxwzBNm .stateLabel .box{stroke:none;stroke-width:0;fill:#ECECFF;opacity:0.5;}#mermaid-svg-l7iMrskhjBxwzBNm .edgeLabel .label rect{fill:#ECECFF;opacity:0.5;}#mermaid-svg-l7iMrskhjBxwzBNm .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-l7iMrskhjBxwzBNm .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-l7iMrskhjBxwzBNm .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-l7iMrskhjBxwzBNm .edgeLabel .label text{fill:#333;}#mermaid-svg-l7iMrskhjBxwzBNm .label div .edgeLabel{color:#333;}#mermaid-svg-l7iMrskhjBxwzBNm .stateLabel text{fill:#131300;font-size:10px;font-weight:bold;}#mermaid-svg-l7iMrskhjBxwzBNm .node circle.state-start{fill:#333333;stroke:#333333;}#mermaid-svg-l7iMrskhjBxwzBNm .node .fork-join{fill:#333333;stroke:#333333;}#mermaid-svg-l7iMrskhjBxwzBNm .node circle.state-end{fill:#9370DB;stroke:white;stroke-width:1.5;}#mermaid-svg-l7iMrskhjBxwzBNm .end-state-inner{fill:white;stroke-width:1.5;}#mermaid-svg-l7iMrskhjBxwzBNm .node rect{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-l7iMrskhjBxwzBNm .node polygon{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-l7iMrskhjBxwzBNm #statediagram-barbEnd{fill:#333333;}#mermaid-svg-l7iMrskhjBxwzBNm .statediagram-cluster rect{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-l7iMrskhjBxwzBNm .cluster-label,#mermaid-svg-l7iMrskhjBxwzBNm .nodeLabel{color:#131300;}#mermaid-svg-l7iMrskhjBxwzBNm .statediagram-cluster rect.outer{rx:5px;ry:5px;}#mermaid-svg-l7iMrskhjBxwzBNm .statediagram-state .divider{stroke:#9370DB;}#mermaid-svg-l7iMrskhjBxwzBNm .statediagram-state .title-state{rx:5px;ry:5px;}#mermaid-svg-l7iMrskhjBxwzBNm .statediagram-cluster.statediagram-cluster .inner{fill:white;}#mermaid-svg-l7iMrskhjBxwzBNm .statediagram-cluster.statediagram-cluster-alt .inner{fill:#f0f0f0;}#mermaid-svg-l7iMrskhjBxwzBNm .statediagram-cluster .inner{rx:0;ry:0;}#mermaid-svg-l7iMrskhjBxwzBNm .statediagram-state rect.basic{rx:5px;ry:5px;}#mermaid-svg-l7iMrskhjBxwzBNm .statediagram-state rect.divider{stroke-dasharray:10,10;fill:#f0f0f0;}#mermaid-svg-l7iMrskhjBxwzBNm .note-edge{stroke-dasharray:5;}#mermaid-svg-l7iMrskhjBxwzBNm .statediagram-note rect{fill:#fff5ad;stroke:#aaaa33;stroke-width:1px;rx:0;ry:0;}#mermaid-svg-l7iMrskhjBxwzBNm .statediagram-note rect{fill:#fff5ad;stroke:#aaaa33;stroke-width:1px;rx:0;ry:0;}#mermaid-svg-l7iMrskhjBxwzBNm .statediagram-note text{fill:black;}#mermaid-svg-l7iMrskhjBxwzBNm .statediagram-note .nodeLabel{color:black;}#mermaid-svg-l7iMrskhjBxwzBNm .statediagram .edgeLabel{color:red;}#mermaid-svg-l7iMrskhjBxwzBNm #dependencyStart,#mermaid-svg-l7iMrskhjBxwzBNm #dependencyEnd{fill:#333333;stroke:#333333;stroke-width:1;}#mermaid-svg-l7iMrskhjBxwzBNm .statediagramTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-l7iMrskhjBxwzBNm :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 用户发出首条消息
每轮读写并滑动续期
超过 idleThreshold 无新消息
用户返回,从 Redis 恢复
历史超过 summaryThreshold,生成摘要
用户返回,摘要 + 最近 N 轮重建上下文
Redis TTL 到期
Redis TTL 到期
仅 MySQL 可查
超过留存期,按合规转归档或物理删除
活跃
空闲
已压缩
冷归档
(图 2:会话生命周期状态机------三段流转对应三件运维工作:续期、摘要、清理)
三段流转对应三件事:
- 活跃 → 空闲 :这里要定一个
idleThreshold(多久没消息算空闲)。它和 TTL 不是一回事:空闲是"业务视角下这轮对话结束了",TTL 是"存储视角下可以回收了"。TTL 必须显著大于 idleThreshold,否则会出现"用户还没觉得聊完,数据先没了"。 - 空闲 → 已压缩 :这是摘要生成的时机之一。注意它是"空闲时"而不是"每轮都做",理由是摘要要花一次模型调用,放在每轮关键路径上既增延迟又增成本。
- 冷归档 → 终态 :这一步是合规动作,必须由业务规则驱动而不是技术驱动 。技术上"永不过期"最省事,但会话里可能含个人信息,"技术上一辈子不删"往往就是合规上的风险敞口。
2.3 上下文预算:会话设计本质上是一道分配题
四层记忆里前面三层都要进 prompt,而 prompt 的长度上限是硬的。所以会话管理的核心问题可以一句话概括:在有限的上下文窗口里,怎么分配预算。
我用的分配方式是把窗口切成四块,每块有自己的配额与优先级:
| 配额块 | 占比参考 | 是否能被裁剪 | 裁剪顺序 |
|---|---|---|---|
| 系统提示(含工具与规则) | 10%~15% | 不能(这是行为约束) | 最后才动 |
| 检索片段(RAG,第 4 篇) | 20%~30% | 可(减条数、减长度) | 第 2 顺位 |
| 摘要(早期历史) | 10%~20% | 可(重新压缩) | 第 3 顺位 |
| 最近对话(原始历史) | 30%~50% | 可(按 token 从旧到新丢) | 第 1 顺位 |
注意"最近对话"排在裁剪第 1 顺位,这是反直觉的。 直觉上"最近说的话最重要,应该最后裁",但实际上"最近对话"是唯一可以持续丢弃而不损失信息的部分------因为丢掉的旧消息会被摘要吸收。而系统提示一旦被裁,模型的行为约束就失效了(第 5 篇讲过的工具选择会立刻退化)。
所以裁剪顺序应表达为"从最旧的对话开始丢,丢到够为止;如果丢光了还不够,再压摘要;还不行才减检索片段;系统提示绝不动"。 这个顺序把"损失"按可恢复性排序,而不是按直觉的重要性排序。
还有一个必须显式处理的边界:如果裁剪后仍然放不下怎么办? 这是真实存在的------用户粘贴了一份 30 万 token 的日志,你怎么裁都不够。正确做法是在进入模型之前就拒绝,并给出可理解的提示 ("您粘贴的内容过长,请精简后重试,或分段发送"),而不是让它打到模型侧返回一个报错。这一条和限流的设计原则相同:快速失败比慢速失败对用户更友好。
2.4 一致性的两个层次:读一致性不需要强,写一致性必须强
多实例部署时,会话存储会同时面对两类一致性问题,而它们的答案完全相反。
读一致性可以放松。 极端情况下,用户在 A 实例刚说完一句话,下一句被路由到 B 实例,而 B 读到的还是上一轮的历史------这最多导致"这一轮模型少看到一条消息",用户体验上表现为轻微的上下文不连贯,不会造成数据错误。 用 Redis 做共享存储时,这个窗口通常在毫秒级,实际上很难被感知。所以不要在读路径上加分布式锁,那会把延迟从 1 毫秒抬到 10 毫秒,换来一个用户根本感知不到的收益。
写一致性必须严格。 前面 1.1 节提到的"丢一条消息"就是写冲突。它的成因很具体:
Redis 实例 B 实例 A 用户(连点两次 / 双设备) Redis 实例 B 实例 A 用户(连点两次 / 双设备) #mermaid-svg-xhp9rBokwvNM2yZy{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-xhp9rBokwvNM2yZy .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-xhp9rBokwvNM2yZy .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-xhp9rBokwvNM2yZy .error-icon{fill:#552222;}#mermaid-svg-xhp9rBokwvNM2yZy .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-xhp9rBokwvNM2yZy .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-xhp9rBokwvNM2yZy .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-xhp9rBokwvNM2yZy .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-xhp9rBokwvNM2yZy .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-xhp9rBokwvNM2yZy .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-xhp9rBokwvNM2yZy .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-xhp9rBokwvNM2yZy .marker{fill:#333333;stroke:#333333;}#mermaid-svg-xhp9rBokwvNM2yZy .marker.cross{stroke:#333333;}#mermaid-svg-xhp9rBokwvNM2yZy svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-xhp9rBokwvNM2yZy p{margin:0;}#mermaid-svg-xhp9rBokwvNM2yZy .actor{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-xhp9rBokwvNM2yZy text.actor>tspan{fill:black;stroke:none;}#mermaid-svg-xhp9rBokwvNM2yZy .actor-line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);}#mermaid-svg-xhp9rBokwvNM2yZy .innerArc{stroke-width:1.5;stroke-dasharray:none;}#mermaid-svg-xhp9rBokwvNM2yZy .messageLine0{stroke-width:1.5;stroke-dasharray:none;stroke:#333;}#mermaid-svg-xhp9rBokwvNM2yZy .messageLine1{stroke-width:1.5;stroke-dasharray:2,2;stroke:#333;}#mermaid-svg-xhp9rBokwvNM2yZy #arrowhead path{fill:#333;stroke:#333;}#mermaid-svg-xhp9rBokwvNM2yZy .sequenceNumber{fill:white;}#mermaid-svg-xhp9rBokwvNM2yZy #sequencenumber{fill:#333;}#mermaid-svg-xhp9rBokwvNM2yZy #crosshead path{fill:#333;stroke:#333;}#mermaid-svg-xhp9rBokwvNM2yZy .messageText{fill:#333;stroke:none;}#mermaid-svg-xhp9rBokwvNM2yZy .labelBox{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-xhp9rBokwvNM2yZy .labelText,#mermaid-svg-xhp9rBokwvNM2yZy .labelText>tspan{fill:black;stroke:none;}#mermaid-svg-xhp9rBokwvNM2yZy .loopText,#mermaid-svg-xhp9rBokwvNM2yZy .loopText>tspan{fill:black;stroke:none;}#mermaid-svg-xhp9rBokwvNM2yZy .loopLine{stroke-width:2px;stroke-dasharray:2,2;stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);}#mermaid-svg-xhp9rBokwvNM2yZy .note{stroke:#aaaa33;fill:#fff5ad;}#mermaid-svg-xhp9rBokwvNM2yZy .noteText,#mermaid-svg-xhp9rBokwvNM2yZy .noteText>tspan{fill:black;stroke:none;}#mermaid-svg-xhp9rBokwvNM2yZy .activation0{fill:#f4f4f4;stroke:#666;}#mermaid-svg-xhp9rBokwvNM2yZy .activation1{fill:#f4f4f4;stroke:#666;}#mermaid-svg-xhp9rBokwvNM2yZy .activation2{fill:#f4f4f4;stroke:#666;}#mermaid-svg-xhp9rBokwvNM2yZy .actorPopupMenu{position:absolute;}#mermaid-svg-xhp9rBokwvNM2yZy .actorPopupMenuPanel{position:absolute;fill:#ECECFF;box-shadow:0px 8px 16px 0px rgba(0,0,0,0.2);filter:drop-shadow(3px 5px 2px rgb(0 0 0 / 0.4));}#mermaid-svg-xhp9rBokwvNM2yZy .actor-man line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-xhp9rBokwvNM2yZy .actor-man circle,#mermaid-svg-xhp9rBokwvNM2yZy line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;stroke-width:2px;}#mermaid-svg-xhp9rBokwvNM2yZy :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 两个实例拿到同一份快照 后写的覆盖先写的 m4_X 永久丢失,且无任何报错 请求 1(提问 X) 1 请求 2(提问 Y) 2 GET history:{sid} 3 GET history:{sid} 4 m1, m2, m3 5 m1, m2, m3 6 本地追加 m4_X 7 本地追加 m4_Y 8 SET history:{sid} = m1..m3, m4_X 9 SET history:{sid} = m1..m3, m4_Y 10 模型回复 rx 11 模型回复 ry 12
(图 3:写冲突的时序------"读-改-写"这个模式在分布式会话存储里是根本错误的)
根因是"读-改-写"(read-modify-write)这个操作序列本身不具备原子性。 三种解法,代价依次上升:
| 解法 | 做法 | 代价 | 我的取舍 |
|---|---|---|---|
| 改成追加式 | 用 Redis List 的 RPUSH 追加单条消息,不再整体覆盖 |
几乎为零 | 首选,解决了 90% 的场景 |
| 乐观锁 | WATCH + MULTI,提交时若历史被改过就重试 |
需要处理重试,冲突高时可能忙等 | 用于"必须整体替换"的场景(如摘要重写历史) |
| 串行化 | 按 sessionId 加分布式锁(Redisson) | 引入锁依赖,锁超时会导致请求排队 | 仅当同会话并发是业务常态时 |
"改成追加式"这个方案的价值被严重低估。 它的本质是把"覆盖一个列表"换成"往列表里追加" ,而追加操作在 Redis 里是天然原子的单命令。代价是你要放弃"整体替换历史"的便利------但回头想,一个对话历史本来就不应该被整体替换,它是一条只增不改的日志。 只有摘要生成和合规删除才需要整体改,那两个场景用乐观锁就够了。
所以这一节的结论是一句可以当规范用的话:会话历史的写入只允许追加,不允许覆盖;需要覆盖时,说明你正在做一件应该单独设计的事。
3️⃣ 环境准备
3.1 依赖与版本
| 组件 | 版本 | 用途 | 备注 |
|---|---|---|---|
| Spring Boot | 4.1.x(4.1.1 GA / 2026-08-20) | 应用底座 | 与第 2 篇保持同一基线 |
| Spring AI | 2.0.1 | 模型调用与消息模型 | 2.0 的消息类型与 1.1.x 有差异 |
| Spring Data Redis | 随 Boot 4.1 的 BOM | 会话存取 | 用 Lettuce 连接池 |
| Redis | 7.x(建议 7.2+) | 热层存储 | pipeline 与 EXPIRE 边界行为更符合直觉 |
| MySQL | 8.x | 全量历史与审计 | 必须支持 JSON 列(utf8mb4) |
| JDK | 21 | 运行与虚拟线程 | 4.1 的虚拟线程可用于落库异步化 |
xml
<!-- pom.xml 关键依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-starter-model-openai</artifactId>
<version>2.0.1</version>
</dependency>
<!-- JDBC + 连接池:用于全量历史与审计落库 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
为什么 Redis 连接池的配置在这里比别处更重要? 因为会话存储的访问模式是"每个请求固定两次读 + 一至两次写",连接池的大小直接等于你能承载的并发请求数上界的一部分。 一个常见错误是把 max-active 设成默认的 8,然后在压测时发现"QPS 上不去、Redis 的 CPU 却很低"------瓶颈在连接池排队,不在 Redis。 我的取值是"预期峰值并发 × 1.2",并配合 max-wait 设一个明确的超时,让连接池耗尽时快速失败而不是无限等待(与限流同一条纪律)。
yaml
spring:
data:
redis:
host: ${REDIS_HOST}
port: 6379
timeout: 800ms # 命令级超时:宁可失败,不要拖住请求线程
lettuce:
pool:
max-active: 64 # 峰值并发 × 1.2,按自己压测值调整
max-wait: 200ms # 排队上限:超过就快速失败,避免雪崩
min-idle: 8
3.2 Redis 的数据结构设计
会话存储的结构设计比"用哪个 key"重要得多。我用的三个 key:
| Key | 类型 | 内容 | TTL |
|---|---|---|---|
chat:state:{sid} |
Hash | step、slots(JSON)、updatedAt |
2h(滑动) |
chat:history:{sid} |
List | 单条消息的 JSON(role / content / ts / msgId) |
2h(滑动) |
chat:summary:{sid} |
String | 摘要文本 + coveredUpTo(已覆盖到哪条消息) |
与会话同寿 |
三个设计决定需要解释。
第一,历史用 List 而不是 String。 这正是 2.4 节"只允许追加"的落地:RPUSH 追加一条,天然原子。如果用一个 String 存整个 JSON 数组,每次追加都要读出来反序列化、追加、再序列化写回------既慢又危险。
第二,摘要用 String 加一个 coveredUpTo 游标。 这个游标是关键:它记录"摘要已经覆盖了历史里的哪一条消息"。没有游标,你就无法回答"摘要是不是已经包含了这条消息",实践中会退化成"摘要和历史各带一份重复内容",白烧 token。 游标我用消息的 msgId 而不是索引,因为历史会被裁剪,索引会漂移。
第三,每条消息带 msgId 与 ts。 msgId 用于去重(客户端重试可能发两条一样的)与游标定位;ts 用于按时间回溯和审计关联。这两个字段的存储成本可以忽略,但缺了它们,后面的所有功能都要绕路。
3.3 MySQL 全量表:三张表的 DDL
全量历史与审计的表结构,是整个方案里最值得照抄的部分。
sql
-- 会话主表:会话的"户口本",记录归属与生命周期
CREATE TABLE chat_session (
id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
session_id CHAR(36) NOT NULL COMMENT '对外会话标识,UUID 防枚举',
tenant_id VARCHAR(64) NOT NULL COMMENT '租户/业务线,权限与配额隔离的依据',
user_id VARCHAR(64) NOT NULL COMMENT '归属用户,读会话必须校验',
biz_type VARCHAR(32) NOT NULL COMMENT '业务类型:客服/报销/工单...,决定状态 schema',
channel VARCHAR(16) NOT NULL DEFAULT 'web' COMMENT '来源渠道',
state_json JSON NULL COMMENT '会话结束时的最终结构化状态快照',
summary MEDIUMTEXT NULL COMMENT '最终摘要,供人工查看',
msg_count INT UNSIGNED NOT NULL DEFAULT 0,
total_tokens INT UNSIGNED NOT NULL DEFAULT 0 COMMENT '累计 token,用于成本归集',
started_at DATETIME(3) NOT NULL,
last_msg_at DATETIME(3) NOT NULL,
closed_at DATETIME(3) NULL,
PRIMARY KEY (id),
UNIQUE KEY uk_session (session_id),
KEY idx_user_time (user_id, last_msg_at),
KEY idx_tenant_time (tenant_id, last_msg_at)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='会话主表';
-- 消息表:append-only,只增不改
CREATE TABLE chat_message (
id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
session_id CHAR(36) NOT NULL,
msg_id CHAR(36) NOT NULL COMMENT '消息唯一标识,供摘要游标与去重',
role VARCHAR(16) NOT NULL COMMENT 'user / assistant / system / tool',
content MEDIUMTEXT NOT NULL,
tokens INT UNSIGNED NOT NULL DEFAULT 0 COMMENT '该条消息的 token 估算',
tool_calls JSON NULL COMMENT '助手发起的工具调用(第 5 篇)',
created_at DATETIME(3) NOT NULL,
PRIMARY KEY (id),
UNIQUE KEY uk_msg (msg_id),
KEY idx_session_time (session_id, created_at)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='会话消息表(append-only)';
-- 审计表:与业务历史解耦,独立留存
CREATE TABLE chat_audit (
id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT,
session_id CHAR(36) NOT NULL,
user_id VARCHAR(64) NOT NULL,
action VARCHAR(32) NOT NULL COMMENT 'send / delete / export / admin_view',
detail JSON NULL COMMENT '动作详情,不含消息正文',
client_ip VARCHAR(45) NULL,
created_at DATETIME(3) NOT NULL,
PRIMARY KEY (id),
KEY idx_user_time (user_id, created_at)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='会话审计表';
这张 DDL 里有三处刻意的设计,每一处都对应一个真实故障。
第一,session_id 是 CHAR(36) 的 UUID,不是自增 ID。 会话 ID 会出现在前端 URL 或请求参数里,如果它是自增的,任何人把 1 改成 2 就能读到别人的全部对话。 我见过的真实案例是某系统用自增 sessionId,被爬虫按序遍历,泄露了数万条客服对话。 UUID 解决"不可枚举",但不解决"越权访问" ------读取时必须校验 session_id 与当前 user_id 是否匹配,这一点与第 4 篇讲 RAG 权限时是同一条纪律:归属校验必须在服务端做,且必须在取数据之前做。
第二,chat_message 没有 updated_at,只有 created_at。 这是"append-only"在表结构上的表达:这张表不支持修改。 需要"编辑消息"这类功能时,做法是追加一条新消息并把旧标记为失效(新增一个 voided 列),而不是 UPDATE 原行。理由是审计完整性------如果历史可以被改写,那它作为证据的价值就没了。
第三,chat_audit 的 detail 明确写了"不含消息正文"。 这是刻意的:审计表会被更广泛的人查阅(运维、合规、甚至排障),把消息正文放进去等于把会话内容的可访问范围放大了一圈。 审计要记录的是"谁、在何时、做了什么动作",而不是"说了什么内容"。
4️⃣ 核心实现
4.1 会话模型:先把"状态"和"历史"定义成两个不同的类型
2.1 节讲了两者必须分开,落到代码上就是两个不共享父类的类型 。这个细节很重要:如果它们共用一个基类或者共用一个"会话对象",迟早会有人图省事把字段塞进另一个里。
java
/** 结构化会话状态:强类型、字段固定、由业务代码推进 */
public record SessionState(
String sessionId,
String bizType,
String step, // 当前步骤,由状态机枚举约束,不用自然语言
Map<String, String> slots, // 已收集槽位:orderNo / amount / reason ...
Set<String> visitedSteps, // 已走过的步骤,用于防重复提问
long updatedAt
) {
/** 渲染成一段给模型看的结构化文本------不是 JSON 直接塞,见下 */
public String renderForPrompt() {
return """
当前流程状态(仅供你判断进度,不要在回复中逐字复述):
- 当前步骤:%s
- 已收集:%s
- 尚未收集:%s
""".formatted(step,
slots.isEmpty() ? "无" : slots.entrySet().stream()
.map(e -> e.getKey() + "=" + e.getValue())
.collect(java.util.stream.Collectors.joining("、")),
String.join("、", bizType.equals("expense")
? java.util.List.of("amount", "reason", "invoice")
: java.util.List.of()));
}
}
/** 一条对话消息:不可变,只追加 */
public record ChatMessage(
String msgId, // UUID,摘要游标与去重的依据
String sessionId,
Role role, // USER / ASSISTANT / SYSTEM / TOOL
String content,
int tokens, // 写入时就算好,避免读取时反复估算
long createdAt
) {
public enum Role { USER, ASSISTANT, SYSTEM, TOOL }
public boolean isChatTurn() { // 只有这两类计入"最近 N 轮"
return role == Role.USER || role == Role.ASSISTANT;
}
}
为什么 renderForPrompt() 不是简单地序列化成 JSON? 两个原因。一是字段名对模型没有意义 ------{"step":"WAIT_INVOICE"} 里的枚举值模型需要额外推理,而"当前步骤:等待上传发票"是直给的。二是JSON 的括号与引号会占用 token 且干扰模型的注意力 ,一段 8 行的说明文本比一段 20 行的 JSON 更省 token 也更少歧义。这个转换只在渲染时做一次,存的时候仍然存结构化的 Hash,不要存渲染后的文本------否则提示词版本升级时,你连历史状态都改不动。
tokens 字段在写入时就算好,是一个刻意的取舍。 它的代价是写入路径多一次估算(可以用 jtokkit 之类的本地分词库,或按字符数 × 系数粗估),收益是读取时不需要对每条历史重新计算长度。 考虑到读取路径在每个请求上都会跑、而写入只跑一次,这个交换是值的。更重要的是:只有把每条消息的 token 记下来,你才能回答"这条会话到底花了多少 token"这种成本问题(第 2 篇强调的用量埋点,落到会话维度就是这个字段)。
4.2 写入路径:追加式写入,落库异步化
写入路径要同时满足三个约束:对用户快(不能等数据库)、写入原子(不能丢消息)、可追溯(数据库最终一致)。 这三条决定的顺序是:先写 Redis(快且原子)→ 立刻回复用户 → 异步落库。
java
@Service
public class SessionWriter {
private final StringRedisTemplate redis;
private final ChatMessageRepository mysqlRepo; // 全量落库
private final TokenCounter tokenCounter;
private static final Duration HOT_TTL = Duration.ofHours(2);
/**
* 追加一条消息。
* 关键:使用 RPUSH 追加,绝不 GET-改-SET------这是 2.4 节"只允许追加"的落地。
*/
public ChatMessage append(String sessionId, ChatMessage.Role role, String content) {
String historyKey = "chat:history:" + sessionId;
String stateKey = "chat:state:" + sessionId;
ChatMessage msg = new ChatMessage(
UUID.randomUUID().toString(), sessionId, role, content,
tokenCounter.count(content), System.currentTimeMillis());
// 一次 pipeline 完成三件事:追加消息、刷新两个 key 的 TTL
// 这三条命令之间不需要事务------追加本身原子,TTL 刷新失败只会让数据提前过期,
// 不会造成数据错误,属于可接受的部分失败。
redis.executePipelined((RedisCallback<Object>) conn -> {
byte[] hk = historyKey.getBytes(StandardCharsets.UTF_8);
byte[] sk = stateKey.getBytes(StandardCharsets.UTF_8);
conn.listCommands().rPush(hk, Json.write(msg)); // 原子追加
conn.keyCommands().expire(hk, HOT_TTL); // 滑动续期
conn.keyCommands().expire(sk, HOT_TTL);
return null;
});
// 异步落库:不阻塞用户请求。失败交给对账任务(见下)
persistAsync(msg);
return msg;
}
/** 落库走虚拟线程,避免占用业务线程池 */
private void persistAsync(ChatMessage msg) {
Thread.ofVirtual().name("persist-", 0).start(() -> {
try {
mysqlRepo.insertIgnore(msg); // msgId 唯一索引 + INSERT IGNORE = 天然幂等
} catch (Exception e) {
// 不抛出:写入热点存储已经成功,落库失败只影响可查询性
// 记入对账队列,由定时任务补写
log.warn("落库失败,进入对账队列 msgId={}", msg.msgId, e);
reconciliationQueue.add(msg);
}
});
}
}
这段代码有三个判断值得展开。
第一,INSERT IGNORE 配合 msgId 唯一索引,让落库天然幂等。 因为"异步落库失败 → 对账任务重试"这条路径一定会导致重复写入,幂等不是优化而是一致性的前提。 这里不需要分布式事务,不需要两阶段提交------加一个唯一索引,问题就消失了。 这是我在会话存储里最推荐的一个"低成本高收益"技巧。
第二,落库失败不抛出,而是进对账队列。 理由在于这四种失败的影响面完全不同 :Redis 写失败会导致用户看不到自己的消息(必须让用户重试);MySQL 写失败只影响"以后能不能查到"(用户完全无感)。把影响面不同的失败分开处理,是设计异步路径的第一原则。 如果这里直接抛出,结果是"数据库抖动导致用户看到报错"------用户重试后又因为 Redis 已经写成功而出现重复消息。
第三,pipeline 里没有开事务(MULTI)。 这一点容易被质疑。理由是:三条命令里,RPUSH 是原子的、TTL 刷新失败只是让数据早过期。把它们放进 MULTI 只会增加一次网络往返与一段锁时间,换来的原子性覆盖的是"一个不影响正确性的场景"。 需要 MULTI 的是 4.5 节的摘要重写(那是真正的"读-改-写"),不是这里。
异步落库的时序:
MySQL(温层) 虚拟线程 Redis(热层) 会话服务 用户 MySQL(温层) 虚拟线程 Redis(热层) 会话服务 用户 #mermaid-svg-c5oY5ZTCDpr3RbMi{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-c5oY5ZTCDpr3RbMi .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-c5oY5ZTCDpr3RbMi .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-c5oY5ZTCDpr3RbMi .error-icon{fill:#552222;}#mermaid-svg-c5oY5ZTCDpr3RbMi .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-c5oY5ZTCDpr3RbMi .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-c5oY5ZTCDpr3RbMi .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-c5oY5ZTCDpr3RbMi .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-c5oY5ZTCDpr3RbMi .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-c5oY5ZTCDpr3RbMi .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-c5oY5ZTCDpr3RbMi .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-c5oY5ZTCDpr3RbMi .marker{fill:#333333;stroke:#333333;}#mermaid-svg-c5oY5ZTCDpr3RbMi .marker.cross{stroke:#333333;}#mermaid-svg-c5oY5ZTCDpr3RbMi svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-c5oY5ZTCDpr3RbMi p{margin:0;}#mermaid-svg-c5oY5ZTCDpr3RbMi .actor{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-c5oY5ZTCDpr3RbMi text.actor>tspan{fill:black;stroke:none;}#mermaid-svg-c5oY5ZTCDpr3RbMi .actor-line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);}#mermaid-svg-c5oY5ZTCDpr3RbMi .innerArc{stroke-width:1.5;stroke-dasharray:none;}#mermaid-svg-c5oY5ZTCDpr3RbMi .messageLine0{stroke-width:1.5;stroke-dasharray:none;stroke:#333;}#mermaid-svg-c5oY5ZTCDpr3RbMi .messageLine1{stroke-width:1.5;stroke-dasharray:2,2;stroke:#333;}#mermaid-svg-c5oY5ZTCDpr3RbMi #arrowhead path{fill:#333;stroke:#333;}#mermaid-svg-c5oY5ZTCDpr3RbMi .sequenceNumber{fill:white;}#mermaid-svg-c5oY5ZTCDpr3RbMi #sequencenumber{fill:#333;}#mermaid-svg-c5oY5ZTCDpr3RbMi #crosshead path{fill:#333;stroke:#333;}#mermaid-svg-c5oY5ZTCDpr3RbMi .messageText{fill:#333;stroke:none;}#mermaid-svg-c5oY5ZTCDpr3RbMi .labelBox{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-c5oY5ZTCDpr3RbMi .labelText,#mermaid-svg-c5oY5ZTCDpr3RbMi .labelText>tspan{fill:black;stroke:none;}#mermaid-svg-c5oY5ZTCDpr3RbMi .loopText,#mermaid-svg-c5oY5ZTCDpr3RbMi .loopText>tspan{fill:black;stroke:none;}#mermaid-svg-c5oY5ZTCDpr3RbMi .loopLine{stroke-width:2px;stroke-dasharray:2,2;stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);}#mermaid-svg-c5oY5ZTCDpr3RbMi .note{stroke:#aaaa33;fill:#fff5ad;}#mermaid-svg-c5oY5ZTCDpr3RbMi .noteText,#mermaid-svg-c5oY5ZTCDpr3RbMi .noteText>tspan{fill:black;stroke:none;}#mermaid-svg-c5oY5ZTCDpr3RbMi .activation0{fill:#f4f4f4;stroke:#666;}#mermaid-svg-c5oY5ZTCDpr3RbMi .activation1{fill:#f4f4f4;stroke:#666;}#mermaid-svg-c5oY5ZTCDpr3RbMi .activation2{fill:#f4f4f4;stroke:#666;}#mermaid-svg-c5oY5ZTCDpr3RbMi .actorPopupMenu{position:absolute;}#mermaid-svg-c5oY5ZTCDpr3RbMi .actorPopupMenuPanel{position:absolute;fill:#ECECFF;box-shadow:0px 8px 16px 0px rgba(0,0,0,0.2);filter:drop-shadow(3px 5px 2px rgb(0 0 0 / 0.4));}#mermaid-svg-c5oY5ZTCDpr3RbMi .actor-man line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-svg-c5oY5ZTCDpr3RbMi .actor-man circle,#mermaid-svg-c5oY5ZTCDpr3RbMi line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;stroke-width:2px;}#mermaid-svg-c5oY5ZTCDpr3RbMi :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 定时任务重扫,msgId 唯一索引保证不重复 alt 落库成功 落库失败或超时 关键:用户感知的写入早已完成 数据库只是"可查询性"的最终保障 发送消息 X 1 估 token、生成 msgId 2 pipeline RPUSH history, EXPIRE×2 3 OK 4 立即返回(不落库不阻塞) 5 提交异步落库任务 6 INSERT IGNORE chat_message 7 affected = 1 8 进入对账队列 9
(图 4:写入路径时序------注意"用户返回"发生在落库之前,所以落库的任何失败都不能影响用户)
4.3 读取与拼装:token 预算怎么分
读取路径要做四件事:取状态 → 取历史 → 取摘要 → 按预算拼装。 其中前三件是 IO,最后一件是算法,而最容易出问题的是最后一件。
java
@Service
public class ContextAssembler {
/** 上下文总预算:必须小于模型窗口,留出输出空间与安全余量 */
private static final int WINDOW = 32_000;
private static final int RESERVE_FOR_OUTPUT = 4_000; // 输出配额,必须预留
private static final int SAFETY_MARGIN = 1_000; // 估算误差余量
public int inputBudget() {
return WINDOW - RESERVE_FOR_OUTPUT - SAFETY_MARGIN; // 27000
}
public List<Message> assemble(String sessionId, String userInput, String sysPrompt) {
SessionState state = loadState(sessionId); // 结构化状态
List<ChatMessage> history = loadHistory(sessionId); // 最近历史(已截断)
Optional<Summary> summary = loadSummary(sessionId); // 固化摘要
int budget = inputBudget();
// 按固定优先级扣减:系统提示 → 状态 → 摘要 → 最近历史 → 当前输入
// 顺序不能乱:越是"行为约束",越要先占位
int sysTokens = tokenCounter.count(sysPrompt);
int stateTokens = tokenCounter.count(state.renderForPrompt());
int inputTokens = tokenCounter.count(userInput);
int remainForCtx = budget - sysTokens - stateTokens - inputTokens;
if (remainForCtx < 0) {
throw new InputTooLongException("输入超出可处理长度,请精简后重试");
}
// 摘要先占位,但最多占 20%------避免摘要过长把最近对话挤没
int summaryBudget = Math.min((int) (budget * 0.20), summary.map(Summary::tokens).orElse(0));
int historyBudget = remainForCtx - summaryBudget;
// 从最新往旧取,直到预算用完
List<ChatMessage> recent = trimToBudget(history, historyBudget);
List<Message> messages = new ArrayList<>();
messages.add(new SystemMessage(sysPrompt));
messages.add(new SystemMessage(state.renderForPrompt()));
summary.ifPresent(s -> messages.add(new SystemMessage("以下是更早对话的摘要:\n" + s.text())));
recent.forEach(m -> messages.add(toSpringAi(m)));
messages.add(new UserMessage(userInput));
return messages;
}
}
这段拼装逻辑里有四个不可调换的顺序与配额判断。
第一,"当前输入"必须先扣预算,而不是最后加。 如果先按预算装历史、最后再追加用户输入,当输入本身很长(用户粘贴日志)时,总长度会超出窗口 ------因为历史已经占满了。先给输入占位,再去装历史,才能保证"历史的裁剪考虑了本次输入的长度"。这是最容易写错的一处。
第二,系统提示与状态也先占位。 理由在 2.3 节讲过:它们是不可裁剪的行为约束。如果让它们参与"被裁剪",某次长输入就会把工具定义挤掉,表现为"模型突然不会用工具了"------一个看起来像模型退化的现象。
第三,摘要的预算是硬上限(20%),不是"有多少放多少"。 因为摘要本身也是模型生成的,它可以长到失控 ------如果某次摘要做得特别详细,它会把最近对话挤到只剩两三轮,用户会发现"机器人只记得住上一句"。给摘要设上限,是在保护"最近对话"这个最不可替代的部分。
第四,超预算时抛业务异常,而不是截断输入。 这一条与 2.3 节呼应:把超长输入打到模型侧,得到的是一个供应商特有的报错(第 2 篇的分层排错表里那类),用户看不懂、你也无法给出可执行的建议。在进入模型前拒绝,并告诉用户"请精简或分段",才是可用的失败方式。
预算分配的完整决策流:
#mermaid-svg-FJWooIDD2zt0oOUB{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-FJWooIDD2zt0oOUB .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-FJWooIDD2zt0oOUB .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-FJWooIDD2zt0oOUB .error-icon{fill:#552222;}#mermaid-svg-FJWooIDD2zt0oOUB .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-FJWooIDD2zt0oOUB .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-FJWooIDD2zt0oOUB .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-FJWooIDD2zt0oOUB .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-FJWooIDD2zt0oOUB .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-FJWooIDD2zt0oOUB .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-FJWooIDD2zt0oOUB .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-FJWooIDD2zt0oOUB .marker{fill:#333333;stroke:#333333;}#mermaid-svg-FJWooIDD2zt0oOUB .marker.cross{stroke:#333333;}#mermaid-svg-FJWooIDD2zt0oOUB svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-FJWooIDD2zt0oOUB p{margin:0;}#mermaid-svg-FJWooIDD2zt0oOUB .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-FJWooIDD2zt0oOUB .cluster-label text{fill:#333;}#mermaid-svg-FJWooIDD2zt0oOUB .cluster-label span{color:#333;}#mermaid-svg-FJWooIDD2zt0oOUB .cluster-label span p{background-color:transparent;}#mermaid-svg-FJWooIDD2zt0oOUB .label text,#mermaid-svg-FJWooIDD2zt0oOUB span{fill:#333;color:#333;}#mermaid-svg-FJWooIDD2zt0oOUB .node rect,#mermaid-svg-FJWooIDD2zt0oOUB .node circle,#mermaid-svg-FJWooIDD2zt0oOUB .node ellipse,#mermaid-svg-FJWooIDD2zt0oOUB .node polygon,#mermaid-svg-FJWooIDD2zt0oOUB .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-FJWooIDD2zt0oOUB .rough-node .label text,#mermaid-svg-FJWooIDD2zt0oOUB .node .label text,#mermaid-svg-FJWooIDD2zt0oOUB .image-shape .label,#mermaid-svg-FJWooIDD2zt0oOUB .icon-shape .label{text-anchor:middle;}#mermaid-svg-FJWooIDD2zt0oOUB .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-FJWooIDD2zt0oOUB .rough-node .label,#mermaid-svg-FJWooIDD2zt0oOUB .node .label,#mermaid-svg-FJWooIDD2zt0oOUB .image-shape .label,#mermaid-svg-FJWooIDD2zt0oOUB .icon-shape .label{text-align:center;}#mermaid-svg-FJWooIDD2zt0oOUB .node.clickable{cursor:pointer;}#mermaid-svg-FJWooIDD2zt0oOUB .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-FJWooIDD2zt0oOUB .arrowheadPath{fill:#333333;}#mermaid-svg-FJWooIDD2zt0oOUB .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-FJWooIDD2zt0oOUB .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-FJWooIDD2zt0oOUB .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-FJWooIDD2zt0oOUB .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-FJWooIDD2zt0oOUB .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-FJWooIDD2zt0oOUB .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-FJWooIDD2zt0oOUB .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-FJWooIDD2zt0oOUB .cluster text{fill:#333;}#mermaid-svg-FJWooIDD2zt0oOUB .cluster span{color:#333;}#mermaid-svg-FJWooIDD2zt0oOUB div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-FJWooIDD2zt0oOUB .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-FJWooIDD2zt0oOUB rect.text{fill:none;stroke-width:0;}#mermaid-svg-FJWooIDD2zt0oOUB .icon-shape,#mermaid-svg-FJWooIDD2zt0oOUB .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-FJWooIDD2zt0oOUB .icon-shape p,#mermaid-svg-FJWooIDD2zt0oOUB .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-FJWooIDD2zt0oOUB .icon-shape .label rect,#mermaid-svg-FJWooIDD2zt0oOUB .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-FJWooIDD2zt0oOUB .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-FJWooIDD2zt0oOUB .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-FJWooIDD2zt0oOUB :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 是
否
否
是
是
否
是
否
收到用户输入
输入 token
是否已超过预算 50%?
快速拒绝
提示精简或分段
不进入模型
占位:系统提示
(不可裁剪)
占位:结构化状态
(不可裁剪)
占位:本次用户输入
剩余预算 > 0?
占位:摘要
上限 total×20%
填充:最近历史
从新到旧,直到预算用尽
历史是否仍超长?
丢弃最旧若干轮
(损失可被摘要吸收)
拼装消息列表
摘要游标
是否落后过多?
异步触发摘要压缩
不阻塞本次请求
调用模型
(图 5:读取与拼装的预算分配流程------两处"快速拒绝"是防止超长输入打到模型侧的关键)

4.4 按 token 裁剪:三行代码与三个坑
裁剪算法本身很简单,难的是它周围的三个边界。
java
/** 从最新往旧累计,直到预算用尽;保证至少保留最后 2 轮 */
private List<ChatMessage> trimToBudget(List<ChatMessage> history, int budget) {
LinkedList<ChatMessage> kept = new LinkedList<>();
int used = 0;
int turns = 0;
for (int i = history.size() - 1; i >= 0; i--) { // 从新到旧
ChatMessage m = history.get(i);
if (!m.isChatTurn()) continue; // 跳过 tool/system 消息
if (used + m.tokens() > budget && turns >= 2) break; // 至少保住最后 2 轮
kept.addFirst(m);
used += m.tokens();
turns++;
}
return kept;
}
坑一:工具消息与助手消息必须成对保留。 第 5 篇讲过,一次工具调用会产生"助手发起调用 + 工具返回结果 + 助手最终回答"三到四条消息,它们之间有依赖关系。 如果裁剪时把"助手发起调用"丢了、只留下"工具返回结果",某些模型会直接报错(tool 消息找不到对应的调用),某些会默默忽略但行为异常。 所以裁剪的单位不是"消息"而是"轮"------一轮 = 用户消息 + 该用户消息引发的全部后续消息(直到下一条用户消息)。 上面代码里跳过了 TOOL 与 SYSTEM,实际工程中应是"按轮成组裁剪",我这里简化了。
坑二:"至少保留最后 2 轮"是一个必要的兜底。 纯按预算裁剪时,如果最后一条消息本身就是 3 万 token(用户粘贴的日志),预算会在第一条就被判定超限,结果是历史全空。 那模型就完全失去了上下文。保底策略是"无论如何保留最后 1~2 轮",超出的部分靠 4.3 节的输入长度检查提前拒绝。 这两个机制是一对:兜底保证不出现"零上下文",前置检查保证不会"兜底后仍然超窗口"。
坑三:裁剪结果不落库。 裁剪是读取时的视图 ,不是对存储的修改。如果裁剪结果被写回 Redis,你就永久性地丢掉了历史 ,摘要也无从生成------因为摘要的输入正是那些被裁掉的部分。"热存储里保留多少"和"这次请求发多少"是两个独立的参数,把它们混起来是设计上的混乱。
4.5 摘要:什么时候生成、怎么保证不重复算
摘要是整个会话设计里唯一会"重写历史"的操作,所以它的复杂度也最高。要同时处理四个问题:什么时候触发、输入取哪一段、结果怎么固化、失败怎么办。
触发时机:不是每轮都判断。 每轮都算一次摘要会带来两个后果------成本上每个请求多一次模型调用,一致性上同一段历史可能被压缩两次得到不同结果。 我用的触发条件是三个的"与":
java
/** 是否需要生成/更新摘要 */
public boolean needSummary(String sessionId) {
return loadHistoryTokens(sessionId) > summaryThreshold // ① 历史超过阈值
&& summaryCoolDownExpired(sessionId) // ② 距上次摘要已过冷却期
&& !isActiveWithin(sessionId, Duration.ofSeconds(30)); // ③ 当前不活跃(避免打断连续对话)
}
三个条件缺一不可。 只有①会让"一段很长的会话每轮都触发摘要";只有①②会让摘要"打断用户正在进行的连续对话"(表现为某轮回答突然变得上下文不连贯);只有①③则会因为用户始终活跃而永远不触发,结果是历史一直涨到超窗口被强制裁剪,而摘要一次都没生成过。
输入取"未被摘要覆盖的最早一段",而不是"全部历史"。
java
/**
* 摘要生成:幂等 + 覆盖游标推进
* 关键:输入是 [summary.coveredUpTo, 冻结线) 这一段,绝不重复压缩已覆盖部分
*/
public Summary refreshSummary(String sessionId) {
List<ChatMessage> all = loadHistory(sessionId);
Optional<Summary> old = loadSummary(sessionId);
// 1. 找起点:摘要已覆盖到哪一条
int start = old.map(s -> indexOf(all, s.coveredUpTo()) + 1).orElse(0);
// 2. 找终点:留出最近 K 轮不动(它们在热历史里,不压缩)
int end = Math.max(start, all.size() - KEEP_RECENT_TURNS);
if (end - start < MIN_SUMMARIZE_MESSAGES) {
return old.orElse(null); // 可压缩的太少,不动
}
List<ChatMessage> segment = all.subList(start, end);
String newText = chatClient.prompt()
.system(SUMMARY_SYSTEM_PROMPT) // 固定提示词,带版本号
.user(renderForSummary(old.map(Summary::text).orElse(null), segment))
.call().content();
Summary merged = new Summary(
newText,
segment.get(segment.size() - 1).msgId(), // 游标推进到本段最后一条
tokenCounter.count(newText),
SUMMARY_PROMPT_VERSION); // 记录版本,便于回溯
// 3. 用乐观锁写入:只在摘要未被他人改动时提交
// 这是 2.4 节表格里的"必须整体替换"场景
boolean ok = writeSummaryWithWatch(sessionId, merged);
if (!ok) {
// 并发冲突:说明另一个实例刚更新过摘要,本次结果丢弃即可
// 丢弃是安全的------摘要不是精确数据,重新计算的结果同样可用
log.info("摘要并发冲突,本次结果丢弃 sessionId={}", sessionId);
return old.orElse(null);
}
return merged;
}
这段代码有三个刻意的设计。
第一,"冻结线"(KEEP_RECENT_TURNS)把最近几轮排除在压缩之外。 原因是摘要是最后一次才被读的部分 ,而最近几轮是最先被读、且最需要精确 的部分。把最近几轮也压进摘要,等于用"有损压缩"替换掉"无损原文",用户会立刻感到"它记不住我刚才说的细节"。 我的取值是保留最近 6~10 轮原文不压缩。
第二,并发冲突时"丢弃本次结果"而不是重试。 这与常见做法相反(一般会倾向重试)。理由是摘要的性质:它不是精确数据,而是一段可以重新生成的文本。 两个实例同时生成摘要时,两者的结果都可用,没必要为了保证"某一次特定结果"而引入重试与忙等。 判断标准很简单:如果重新计算能得到同样可用的结果,那么冲突时丢弃比重试更优。 摘要、缓存、预计算报表都属于这一类;而"用户刚发的消息"不属于。
第三,摘要提示词带版本号并落库。 这一点经常被忽略,但它是排查"摘要质量突然变差"的唯一手段------提示词改了、模型换了,都会让摘要风格变化,而记录版本号才能把变化归因到具体改动。 这与第 7 篇的"提示词版本化"是同一条纪律。
摘要触发的完整决策:
#mermaid-svg-JUCXv6o85EFyjCQi{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-JUCXv6o85EFyjCQi .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-JUCXv6o85EFyjCQi .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-JUCXv6o85EFyjCQi .error-icon{fill:#552222;}#mermaid-svg-JUCXv6o85EFyjCQi .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-JUCXv6o85EFyjCQi .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-JUCXv6o85EFyjCQi .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-JUCXv6o85EFyjCQi .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-JUCXv6o85EFyjCQi .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-JUCXv6o85EFyjCQi .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-JUCXv6o85EFyjCQi .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-JUCXv6o85EFyjCQi .marker{fill:#333333;stroke:#333333;}#mermaid-svg-JUCXv6o85EFyjCQi .marker.cross{stroke:#333333;}#mermaid-svg-JUCXv6o85EFyjCQi svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-JUCXv6o85EFyjCQi p{margin:0;}#mermaid-svg-JUCXv6o85EFyjCQi .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-JUCXv6o85EFyjCQi .cluster-label text{fill:#333;}#mermaid-svg-JUCXv6o85EFyjCQi .cluster-label span{color:#333;}#mermaid-svg-JUCXv6o85EFyjCQi .cluster-label span p{background-color:transparent;}#mermaid-svg-JUCXv6o85EFyjCQi .label text,#mermaid-svg-JUCXv6o85EFyjCQi span{fill:#333;color:#333;}#mermaid-svg-JUCXv6o85EFyjCQi .node rect,#mermaid-svg-JUCXv6o85EFyjCQi .node circle,#mermaid-svg-JUCXv6o85EFyjCQi .node ellipse,#mermaid-svg-JUCXv6o85EFyjCQi .node polygon,#mermaid-svg-JUCXv6o85EFyjCQi .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-JUCXv6o85EFyjCQi .rough-node .label text,#mermaid-svg-JUCXv6o85EFyjCQi .node .label text,#mermaid-svg-JUCXv6o85EFyjCQi .image-shape .label,#mermaid-svg-JUCXv6o85EFyjCQi .icon-shape .label{text-anchor:middle;}#mermaid-svg-JUCXv6o85EFyjCQi .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-JUCXv6o85EFyjCQi .rough-node .label,#mermaid-svg-JUCXv6o85EFyjCQi .node .label,#mermaid-svg-JUCXv6o85EFyjCQi .image-shape .label,#mermaid-svg-JUCXv6o85EFyjCQi .icon-shape .label{text-align:center;}#mermaid-svg-JUCXv6o85EFyjCQi .node.clickable{cursor:pointer;}#mermaid-svg-JUCXv6o85EFyjCQi .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-JUCXv6o85EFyjCQi .arrowheadPath{fill:#333333;}#mermaid-svg-JUCXv6o85EFyjCQi .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-JUCXv6o85EFyjCQi .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-JUCXv6o85EFyjCQi .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-JUCXv6o85EFyjCQi .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-JUCXv6o85EFyjCQi .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-JUCXv6o85EFyjCQi .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-JUCXv6o85EFyjCQi .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-JUCXv6o85EFyjCQi .cluster text{fill:#333;}#mermaid-svg-JUCXv6o85EFyjCQi .cluster span{color:#333;}#mermaid-svg-JUCXv6o85EFyjCQi div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-JUCXv6o85EFyjCQi .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-JUCXv6o85EFyjCQi rect.text{fill:none;stroke-width:0;}#mermaid-svg-JUCXv6o85EFyjCQi .icon-shape,#mermaid-svg-JUCXv6o85EFyjCQi .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-JUCXv6o85EFyjCQi .icon-shape p,#mermaid-svg-JUCXv6o85EFyjCQi .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-JUCXv6o85EFyjCQi .icon-shape .label rect,#mermaid-svg-JUCXv6o85EFyjCQi .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-JUCXv6o85EFyjCQi .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-JUCXv6o85EFyjCQi .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-JUCXv6o85EFyjCQi :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 否
是
否
是
是
否
否
是
成功
冲突
是
否
定时任务 / 会话空闲事件
历史 token
> summaryThreshold?
不处理
距上次摘要
是否已过冷却期?
跳过:避免频繁压缩
会话当前是否活跃?
30 秒内有新消息?
跳过:不打断连续对话
未覆盖段
是否够长?
跳过:可压缩内容太少
取 summary.coveredUpTo
到冻结线之间的片段
调用模型生成新摘要
(固定提示词 + 版本号)
乐观锁提交
是否成功?
游标推进
覆盖被压缩的历史
丢弃本次结果
摘要非精确数据,无需重试
被压缩段
是否仍留在热历史?
从热历史中移除
(它已被摘要吸收)
结束
(图 6:摘要触发决策树------三轮"跳过"是成本与体验的平衡点,冲突丢弃是幂等的体现)

4.6 长期记忆:写入必须是显式的
长期记忆(跨会话记住"这个用户是财务部的""他偏好简洁回复")价值很高,但它是这一篇里唯一有"污染风险"的部分。
什么是污染? 如果允许模型自动把对话里的任意内容写进长期记忆,你会得到这样的记录:用户随口说了一句"我最近在考虑换工作",被记成"该用户正在求职";用户替同事问了一个问题,被记成"该用户负责这个模块"。这些错误的记忆是跨会话累积的,一旦写进去,用户在任何一次对话里都会被它影响,而你很难发现原因。
所以长期记忆的写入必须满足三条:
- 由业务规则判定要不要写,不由模型自由决定。 让模型判断内容、但由代码决定"哪类内容有资格成为长期记忆"(例如"用户明确说'以后都这样'""用户填写的部门字段")。
- 必须能溯源。 每条长期记忆记录它来自哪次会话、哪条消息。没有来源的记忆无法纠错------用户投诉"你为什么觉得我是财务部的",你查不到它是怎么来的。
- 必须可删除,且删除要真的生效。 用户有权清空自己的长期记忆。"删除"必须是物理删除或标记为失效并被所有读取路径过滤,而不是"标记了但读取时忘了过滤"。
还有一个常被忽视的成本问题:长期记忆会挤占上下文。 一个用了半年的用户可能积累两百条记忆,全塞进 prompt 是灾难性的。 我的做法是"按相关性召回 + 上限条数"------把长期记忆当成一个小型 RAG 来用(第 4 篇的方法),而不是当成一段固定前缀来拼。 这带来一个设计上的一致性:长期记忆和知识库检索用的是同一套向量检索能力,没必要为它单独造一套机制。
5️⃣ 进阶与优化
5.1 三条"让模型记住历史"的路线与 ROI
到这里其实有三条不同的技术路线都能实现"多轮记忆",它们的成本与效果差异极大,而且适用于完全不同的会话形态。
| 路线 | 做法 | 每轮额外成本 | 适合的会话形态 | 我实测的结论 |
|---|---|---|---|---|
| 保留原文 + 裁剪 | 保留最近 N token 的原文,丢最旧的 | 极低(无额外调用) | 单次会话、轮数少(< 20 轮) | 成本最低,短会话体验最好 |
| 摘要压缩 | 把旧历史压成一段文本 | 中(每次压缩一次模型调用) | 长会话、跨天、有连续上下文依赖 | 长会话的必需品,注意别频繁触发 |
| 历史 RAG 化 | 把历史向量化,每轮按问题检索相关历史 | 中高(每轮一次向量检索,可选一次重排) | 超长会话、需要跨很远取信息(如客服半年记录) | 效果好但工程量大,只在会话确实很长时才值得 |
这三条不是替代关系,而是按会话长度依次启用的。 我的实际组合是:前 20 轮走裁剪,超过后启用摘要,摘要 + 裁剪仍不够时才启用历史 RAG。 判断依据是一个简单的观测------统计"用户提问里有多大概率需要 20 轮以前的信息"。这个比例低于 5% 时,摘要就够了;高于 20% 时(典型是"技术支持类"长会话,用户会突然说"就是上次那个报错"),才需要历史 RAG。
还有一个成本上的反直觉结论:摘要不是"越早做越省"。 直觉是"早点压缩能省 token",但摘要本身要花一次模型调用,如果会话在第 3 轮就结束了(这其实是大多数会话的真实分布------大量会话只有 1~3 轮),你为它做的摘要是纯浪费。 所以我的阈值设得比较保守(历史超过 8000 token 才触发),接受"少数长会话多花一点",换取"大多数短会话零额外开销"。
5.2 会话层必须有的四个指标
会话存储的问题有一个共同特征:它们不报错,只是"慢慢变差"。 所以只能靠指标发现。
| 指标 | 定义 | 它暴露的问题 | 告警阈值参考 |
|---|---|---|---|
| 平均上下文 token | 每轮实际发出去的 input token | 静默上涨说明裁剪策略失效或摘要没触发 | 环比上涨 > 30% |
| 裁剪触发率 | 触发裁剪的请求占比 | 长期接近 100% 说明预算分配过紧 | 持续 > 80% |
| 摘要覆盖率 | 已进摘要的 token / 总历史 token | 过低说明摘要从未触发;过高说明摘要过长 | < 30% 或 > 70% |
| 会话恢复率 | 空闲后再次活跃的会话占比 | 骤降说明 TTL 太短(用户第二天回来失忆了) | 环比下降 > 20% |
第一个指标是我最看重的,因为它是一个"成本与质量同时恶化"的先行指标。 平均上下文 token 的上涨通常不是线性的------它会在某个时点开始加速(因为历史越长,摘要也越长,而摘要又进上下文)。当它环比涨 30% 以上时,往往还没到用户投诉的程度,但成本已经开始显著偏离预算。
第四个指标(会话恢复率)是最容易被忽略的一个,因为它表面上是"用户行为"。 但它其实是 TTL 配置正确性的唯一验证方式。TTL 设错的表现不是报错,而是"用户第二天回来发现机器人不认识他了",然后用户就走了------你不会收到任何一条告警,只会看到活跃用户缓慢下降。 所以我坚持把 TTL 变更和会话恢复率联动观察:改 TTL 必须同时看这个指标。
5.3 多实例:还要不要开会话粘性
这是一个经常被问的问题:既然状态已经在 Redis 里了,还需要负载均衡的会话粘性(session affinity)吗?
我的答案是"不需要粘性,但需要接受一个细微的体验差异"。
不需要粘性的理由很直接:应用层已经完全无状态,任何实例都能从 Redis 恢复完整上下文 ,包括结构化状态、历史与摘要。开了粘性反而会带来副作用------某个实例重启或被杀时,粘到它上面的所有会话都要重新路由;而粘性还会让负载不均(长会话集中在一个实例上)。
需要接受的差异是:用户在 A 实例刚发完消息、下一条请求打到 B 实例时,B 读到的是 Redis 的最新数据,所以内容上是一致的 ;但如果两条请求几乎同时到达(用户连点),会出现 2.4 节讨论的并发写场景。这个场景需要靠"追加式写入"来保证不丢数据,而不是靠粘性来避免。 粘性只能减少并发概率,不能消除它。把正确性建立在"概率上不会同时发生"上是不成立的,这是本节的结论。
唯一值得考虑开粘性的场景是"本地有昂贵缓存" :例如你缓存了某个会话的向量化结果或大对象,重建成本很高。这时粘性会显著提升命中率。但即便如此,也应该把"粘性失效"当成常态来设计,而不是把它当成正确性依赖。
5.4 隐私与合规:四个必须做的动作
会话内容几乎必然包含个人信息、业务数据甚至敏感信息,而且它比一般的业务数据更难管控------因为它以纯文本形式存在着。 四个动作我认为是底线:
第一,日志里绝不打印消息正文。 这是我认为最容易被违背、也最危险 的一条。开发时为了调试方便打一行 log.debug("request: {}", messages),上了生产就变成了"把全部会话内容写进日志系统"。而日志系统通常有更宽的访问权限、更长的保留期、更多的导出渠道。 我见过的最典型的泄露事故是:排障时把日志打包发给了外部支持团队,包里带着几万条用户对话。正确做法是只打印元信息 (sessionId、消息条数、token 数、耗时),需要正文时走一次性的、有审计的临时开关。
第二,"删除我的对话"必须真的删。 用户提出删除请求时,要删除的至少有四处:Redis 热数据、MySQL 消息表、摘要、以及长期记忆。只删 Redis 是自欺欺人 ------用户看不到,但数据还在;只标记不删是另一种自欺欺人 ------标记字段一旦在某个读取路径上被漏掉过滤,数据就重新可见了。我的做法是"物理删除消息正文 + 保留审计记录(不含正文)",既满足删除要求,也保留可追溯性。
第三,会话 ID 的归属校验必须在服务端做,且必须在读取之前。 这一点在第 3.3 节已讲过(自增 ID 被遍历的案例),这里补充一点:校验位置必须在"取数据之前",而不是"取出来之后再判断能不能返回"。 后者会让越权数据进入应用内存并可能进入日志,与第 4 篇 RAG 的权限过滤是同一条纪律。
第四,留存期要写进配置,而不是"技术上一辈子不删"。 会话的留存期通常由业务与合规共同决定。技术上实现"永不过期"是最省事的,但它把合规风险变成了默认值。 我倾向于把留存期做成显式配置项,并在过期清理时留下日志------这样至少能证明"清理是设计了并且执行了"。
#mermaid-svg-xdWddBWebysalgGu{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-xdWddBWebysalgGu .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-xdWddBWebysalgGu .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-xdWddBWebysalgGu .error-icon{fill:#552222;}#mermaid-svg-xdWddBWebysalgGu .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-xdWddBWebysalgGu .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-xdWddBWebysalgGu .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-xdWddBWebysalgGu .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-xdWddBWebysalgGu .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-xdWddBWebysalgGu .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-xdWddBWebysalgGu .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-xdWddBWebysalgGu .marker{fill:#333333;stroke:#333333;}#mermaid-svg-xdWddBWebysalgGu .marker.cross{stroke:#333333;}#mermaid-svg-xdWddBWebysalgGu svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-xdWddBWebysalgGu p{margin:0;}#mermaid-svg-xdWddBWebysalgGu .label{font-family:"trebuchet ms",verdana,arial,sans-serif;color:#333;}#mermaid-svg-xdWddBWebysalgGu .cluster-label text{fill:#333;}#mermaid-svg-xdWddBWebysalgGu .cluster-label span{color:#333;}#mermaid-svg-xdWddBWebysalgGu .cluster-label span p{background-color:transparent;}#mermaid-svg-xdWddBWebysalgGu .label text,#mermaid-svg-xdWddBWebysalgGu span{fill:#333;color:#333;}#mermaid-svg-xdWddBWebysalgGu .node rect,#mermaid-svg-xdWddBWebysalgGu .node circle,#mermaid-svg-xdWddBWebysalgGu .node ellipse,#mermaid-svg-xdWddBWebysalgGu .node polygon,#mermaid-svg-xdWddBWebysalgGu .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-xdWddBWebysalgGu .rough-node .label text,#mermaid-svg-xdWddBWebysalgGu .node .label text,#mermaid-svg-xdWddBWebysalgGu .image-shape .label,#mermaid-svg-xdWddBWebysalgGu .icon-shape .label{text-anchor:middle;}#mermaid-svg-xdWddBWebysalgGu .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-xdWddBWebysalgGu .rough-node .label,#mermaid-svg-xdWddBWebysalgGu .node .label,#mermaid-svg-xdWddBWebysalgGu .image-shape .label,#mermaid-svg-xdWddBWebysalgGu .icon-shape .label{text-align:center;}#mermaid-svg-xdWddBWebysalgGu .node.clickable{cursor:pointer;}#mermaid-svg-xdWddBWebysalgGu .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-xdWddBWebysalgGu .arrowheadPath{fill:#333333;}#mermaid-svg-xdWddBWebysalgGu .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-xdWddBWebysalgGu .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-xdWddBWebysalgGu .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-xdWddBWebysalgGu .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-xdWddBWebysalgGu .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-xdWddBWebysalgGu .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-xdWddBWebysalgGu .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-xdWddBWebysalgGu .cluster text{fill:#333;}#mermaid-svg-xdWddBWebysalgGu .cluster span{color:#333;}#mermaid-svg-xdWddBWebysalgGu div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-xdWddBWebysalgGu .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-xdWddBWebysalgGu rect.text{fill:none;stroke-width:0;}#mermaid-svg-xdWddBWebysalgGu .icon-shape,#mermaid-svg-xdWddBWebysalgGu .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-xdWddBWebysalgGu .icon-shape p,#mermaid-svg-xdWddBWebysalgGu .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-xdWddBWebysalgGu .icon-shape .label rect,#mermaid-svg-xdWddBWebysalgGu .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-xdWddBWebysalgGu .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-xdWddBWebysalgGu .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-xdWddBWebysalgGu :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;} 否
是
合规要求长期保存
无需长期保存
是
否
会话结束,Redis TTL 到期
热层数据自动过期
无需人工介入
温层:MySQL 全量历史
按留存期继续保留
是否超过留存期?
留存策略判定
脱敏后转对象存储归档
物理删除消息正文
保留不含正文的审计记录
用户是否行使删除权?
四处同时删除:
Redis / MySQL / 摘要 / 长期记忆
按归档策略到期后清理
写审计日志(不含正文)
证明删除动作已执行
(图 7:留存期、归档与删除权的闭环------"删除必须落在四处"与"审计只记动作不记正文"是两条硬约束)
6️⃣ 适用边界与风险提示
6.1 适用场景
- 多轮、有流程的业务助手 :报销、下单、工单、开户这类需要"记住走到哪一步"的场景,结构化状态带来的收益最大,因为流程控制必须确定。
- 客服与会话式查询 :会话长度中等、跨天回来继续的比例较高,热层 + 全量的双存结构最匹配。
- 需要合规留存的对话系统 :审计表与留存期设计是必需项,早做比晚补容易得多(数据已经产生后再补审计,历史数据永远补不回来)。
- 多实例部署的在线服务 :应用层无状态是本方案的核心收益,扩容时不需要考虑会话迁移。
6.2 不适用场景
- 单轮调用(分类、摘要、翻译等批处理) :根本不需要会话存储,第 7 篇那套"任务表 + 结果表"才是正确形态。给批处理加会话层,只会带来一次无意义的 Redis 与 MySQL 双写。
- 超长会话且需要检索很早信息 :纯"摘要 + 最近 N 轮"会丢掉很远的细节,这类场景必须上历史 RAG,否则用户会反复抱怨"它不记得我上次说的"。
- 会话量极小(日活几十)的内部工具 :Redis + MySQL 的双层结构是过度设计,直接用一个带 JSON 列的数据库表就够了 。架构复杂度应该与会话量匹配,而不是与"未来可能的量"匹配。
- 强一致、要求"读到刚才那条"的场景 :如果你的业务要求"下一次请求必须看到上一次刚写的消息"(例如实时协作),那需要额外的读后写一致性保证(如强制读主库 / 版本号校验),本文的最终一致模型不满足这个要求。
6.3 版本兼容与升级注意
- Spring AI 1.1.x → 2.0.x 的消息类型有变化 (
AssistantMessage的工具调用字段、SystemMessage的构造方式)。会话历史是"存储格式"的一部分,升级时历史数据不会自动迁移。 如果按本文做法存的是"自定义的ChatMessage再转换成 Spring AI 类型",这个问题就不存在------这正是"存自己的模型、只在拼装时转换"的另一个好处,它顺带解耦了框架升级。 - Redis 7.0+ 在
EXPIRE的边界行为上更符合直觉,示例建议 6.2+,生产建议 7.x。 Lettuce共享连接与连接池的区别 :Lettuce默认共享单连接(多路复用),这与"连接池耗尽"是两种不同的瓶颈。压测时如果发现 Redis 命令延迟正常但吞吐上不去,先确认你用的是连接池还是共享连接。- MySQL 8.0 的 JSON 列支持函数索引 ,但不要指望用 JSON 列做消息检索(需要全文检索时应另建索引或走对象存储 + 检索引擎)。
6.4 生产建议清单
- 结构化状态与对话历史用两个独立的 key,TTL 分别设定,不要绑在一起。
- 历史写入只允许追加 (
RPUSH),禁止"读出-修改-写回"。 - 裁剪的计量单位是 token,不是条数;裁剪是读取视图,不落库。
- 摘要输入带覆盖游标 ,避免重复压缩;并发冲突时丢弃而非重试。
- 摘要提示词带版本号并落库,用于归因"摘要质量变化"。
msgId唯一索引 +INSERT IGNORE让异步落库天然幂等。- 落库失败不抛给用户,进对账队列由定时任务补写。
- 读取会话必须校验归属,且校验在取数据之前。
- 日志只打元信息,永不打印消息正文;调试开关必须是一次性且有审计的。
- TTL 变更必须联动观察"会话恢复率",它是 TTL 配置正确性的唯一验证方式。
- 超长输入在进入模型之前拒绝,并给出可执行的建议(精简 / 分段)。
- 留存期做成显式配置,清理动作留日志,别让"永不过期"成为默认值。
7️⃣ 总结
7.1 关键决策点回顾
| 决策点 | 选择 | 核心理由 |
|---|---|---|
| 状态与历史是否分开存 | 分开,且用不同类型 | 流程控制必须确定,用自然语言解析做状态机等于把确定性建立在概率上 |
| 裁剪的计量单位 | token | 按条数裁剪时你根本不知道这次请求会发出多少 token,长度分布可差 9 倍 |
| 历史写入方式 | 只追加,不覆盖 | "读-改-写"在分布式下必然丢数据,且不报错 |
| 热层介质 | Redis(Hash + List) | 亚毫秒读 + 天然 TTL + 多实例共享,是唯一同时满足三者的方案 |
| 全量历史介质 | MySQL,append-only | 需要可查询、可审计,而这两点 Redis 给不了 |
| 落库方式 | 异步 + 幂等 + 对账 | 落库失败只影响可查询性,不应影响用户体验 |
| 摘要触发 | 历史超阈值 + 冷却期 + 空闲 三者同时满足 | 少任何一条,要么频繁压缩,要么永不触发,要么打断对话 |
| 摘要并发冲突 | 丢弃本次结果 | 摘要非精确数据,重算结果同样可用,没必要为特定结果引入重试 |
| 长期记忆写入 | 业务规则判定 + 可溯源 + 可删 | 自动写入会产生跨会话累积的"记忆污染",且难以发现与纠正 |
| 是否开会话粘性 | 不开 | 应用层已无状态,粘性只降低并发概率、不消除它,正确性不能建立在概率上 |
| 日志打印范围 | 只打元信息 | 日志系统的访问范围与保留期都比业务库更宽,是最典型的泄露途径 |
7.2 回到开头
回到 1.1 节那三个问题:历史是事实还是缓存、每轮读多少写多少、多实例怎么保证不丢。
"历史是事实"这一条决定了整个架构 ------它是服务端的一等公民,所以要有 Redis 与 MySQL 两层、要有生命周期、要有留存期。"读多少写多少"决定了成本模型 ------最贵的不是存储,是每轮重新发送历史带来的 token 与延迟,所以裁剪与摘要不是锦上添花而是必需品。"多实例不丢"决定了写入协议------只能追加、不能覆盖,且落库的失败必须与用户的失败分开处理。
这三条其实指向同一个更抽象的原则:会话存储是一个"有生命周期的、只增不改的日志"。 一旦接受这个定位,很多设计选择就自然确定了------日志要能追加、要能按时间截断、要能归档、不能被改写。而它最危险的错误也都来自违反这个定位:把它当成一个可以随意改写的对象、把不同生命周期的东西绑在一个 key 上、把日志当成业务状态来用。
还有一个跨篇一致的结论值得单独说:这一篇里几乎没有一个问题是"报错型"的。 丢消息不报错、TTL 太短不报错、裁剪策略失效不报错、摘要频繁触发不报错、日志泄露正文不报错。它们全部表现为"慢慢变差"或者"某个用户投诉了一句奇怪的话"。 这也是为什么本篇花了大量篇幅讲指标与监控------在这个领域里,没有指标就等于没有正确性。
参考资料
- Spring AI Reference Documentation · Chat Memory(
ChatMemory、MessageWindowChatMemory与内存实现的行为边界):https://docs.spring.io/spring-ai/reference/api/chat-memory.html - Spring AI Reference Documentation · Chat Client(消息类型与
ChatClient的会话参数覆盖):https://docs.spring.io/spring-ai/reference/api/chatclient.html - Spring AI Reference Documentation · Advisors(
MessageChatMemoryAdvisor等记忆型 Advisor 在链上的位置与顺序约束):https://docs.spring.io/spring-ai/reference/api/advisors.html - Spring AI GitHub · Chat Memory 相关实现源码与 2.0 变更(
ChatMemoryRepository抽象与持久化实现):https://github.com/spring-projects/spring-ai - Spring Framework Reference · Spring Data Redis / Lettuce(连接池与共享连接两种模式、
RedisTemplate与 pipeline 语义):https://docs.spring.io/spring-data/redis/reference/ - Redis Documentation ·
RPUSH/LRANGE/EXPIRE/ Transactions(追加式写入的原子性与WATCH/MULTI乐观锁语义):https://redis.io/docs/latest/commands/ - Redis Documentation · Client-side caching and connection pooling considerations(连接池耗尽与延迟抖动):https://redis.io/docs/latest/develop/clients/
- MySQL 8.0 Reference Manual · JSON Data Type 与 Indexing(JSON 列的能力边界与函数索引限制):https://dev.mysql.com/doc/refman/8.0/en/json.html
- OpenJDK JEP 444 · Virtual Threads(用于异步落库的虚拟线程模型与其阻塞语义):https://openjdk.org/jeps/444
- OpenTelemetry Documentation · Semantic Conventions for GenAI(会话与消息相关的属性约定,用于会话级指标建模):https://opentelemetry.io/docs/specs/semconv/gen-ai/
- 阿里云百炼 · 通义千问上下文长度与计费说明(上下文窗口上限与 input/output token 计费口径):https://help.aliyun.com/zh/model-studio/