软件架构设计
CHAPTER 01 · 架构基础

什么是软件架构

一句话总览:架构不是画图,而是一组难以撤销的关键决策——决定系统怎么拆、组件怎么协作、质量目标怎么取舍;一切架构工作最终都落在「权衡」二字上。
🏙️
生活化类比
盖楼时,刷什么颜色的墙随时能改(=写代码),承重墙在哪、楼梯开几个口浇筑完就动不了(=架构决策)。架构师干的就是在浇筑前想清楚:这块地将来住 100 人还是 10 万人?消防通道留多宽?类比边界:软件比楼幸运——好的架构可以「渐进改造承重墙」(演进式架构),但代价依然远高于改代码,所以决策前必须算清账。

1.1 架构、设计、代码的分界

层次回答的问题改动成本例子
架构系统拆成哪些部分?如何通信?极高(伤筋动骨)单体还是微服务?同步调用还是消息队列?
设计模块内部怎么组织?中(局部重构)用策略模式还是 if-else?类怎么分层?
代码这一行逻辑怎么写?低(随时改)变量命名、循环写法、边界判断

经典定义(Martin Fowler):架构 = 那些重要且难以改变的东西。所以判断一件事是不是架构问题的试金石是:「改主意的代价有多大?」

架构决策的核心循环:需求 → 权衡 → 决策 → 验证
需求与约束 功能 + 质量属性 + 团队 权衡 Trade-off 没有免费午餐 架构决策 拆分 / 通信 / 存储 / 部署 验证与演进 压测 / 反馈 / 调整 现实反馈不断修正决策——架构是持续过程,不是一次性文档
为什么架构没有「标准答案」:同一个需求,团队规模、预算、时间不同,最优决策就不同。

1.2 架构师每天在决策什么

  • 拆分:按什么维度切模块/服务?(业务能力、变更频率、团队边界)
  • 通信:同步 RPC 还是异步消息?谁依赖谁?
  • 数据:共享库还是每服务一库?强一致还是最终一致?
  • 质量目标:可用性要几个 9?P99 延迟多少毫秒?这些直接决定成本。
⚠ 高频陷阱:简历驱动架构(Resume-Driven Development)
错误姿势:日活 500 的内部系统上来就微服务 + K8s + 消息队列 + 事件溯源 → 后果:3 个人的团队维护 20 个服务,一次联调跨 5 个仓库,故障排查靠猜,交付速度反而暴跌。正确姿势:从模块化单体起步,把边界画清楚,等规模真的到了再拆——拆是演进,不是起点。
✓ 记忆口诀
「架构 = 难改的决策,决策 = 有代价的取舍」。听到任何方案先问一句:它牺牲了什么?答不出牺牲的方案,多半没想清楚。

1.3 随堂自测

QUIZ 1
按「改动成本」判断,下面哪个属于架构级决策?
数据库归属决定了服务间的数据耦合方式,日后想改要迁移数据、重写事务逻辑,属于「难以撤销」的决策。A/B/D 都是局部改动,随时可逆,属于代码/设计层面。
QUIZ 2
3 人团队要做一个内部审批系统(预计几百用户),最合理的起步架构是?
模块化单体保留了清晰边界(未来可拆),又不承担分布式的运维成本,规模匹配。B 是为不存在的需求付真实成本;C 放弃了边界,未来想拆无从下手;D 本末倒置。
CHAPTER 02 · 架构基础

架构视图与 C4 模型

一句话总览:一张图画不下整个系统——架构要按受众和抽象层级拆成多张视图;C4 模型用「上下文 → 容器 → 组件 → 代码」四层缩放,是目前最实用的画法。
🗺️
生活化类比
看地图:找国家用世界地图(Context),找小区用城市地图(Container),找楼栋用小区平面图(Component),找房间用户型图(Code)。你不会在世界地图上标厕所位置——每张图只回答一个缩放层级的问题。类比边界:地图层级是地理固定的,C4 的「容器」边界由你的架构决策决定,画之前得先想清楚。

2.1 经典 4+1 视图:按「谁关心什么」拆

视图回答的问题受众常用图
逻辑视图功能怎么划分成模块/对象?开发类图、模块图
开发视图代码仓库、包、构建怎么组织?开发/配置管理包图、目录结构
进程视图运行时有哪些进程?怎么并发通信?集成/运维时序图、活动图
物理视图软件部署到哪些机器/节点?运维部署图
+1 场景关键用例如何串起以上四张图?所有人用例 + 时序

2.2 C4:四层缩放,一层一图

C4 四层:像地图一样逐级放大(以外卖系统为例)
L1 上下文 Context 系统是个黑盒 谁用它?依赖哪些外部系统? 例:用户/商家/骑手 ↔ 外卖平台 ↔ 支付 L2 容器 Container 打开黑盒:可独立部署的单元 Web 应用 / API 服务 / 数据库 / App 例:订单服务 + 订单库 + 消息队列 L3 组件 Component 打开某个容器:内部模块 控制器 / 应用服务 / 领域 / 仓储 例:OrderController → OrderService L4 代码 Code 类图 / 具体实现 通常不手画 按需生成,别维护 日常沟通 90% 只用 L1 + L2;L3 给接手模块的人看;L4 基本交给 IDE 反模式:把四层内容塞进一张图 → 谁都看不懂,谁都不维护 图上每个框都应标注:名字 + 职责一句话 + 关键技术选型;每条箭头标注:做什么 + 用什么协议
为什么分层:图的目的是沟通,受众关心的抽象层级不同,混层等于没说。
✓ 画图三件套
每个框写「名字 + 一句话职责 + 技术栈」,每条线写「干什么 + 什么协议」(如「下单 / HTTPS」「订单事件 / Kafka」)。没标注的箭头 = 无效信息。
⚠ 高频陷阱:架构图与代码脱节
错误姿势:花两周画精美大图,之后代码狂改图不动 → 后果:新人按图索骥找到的全是不存在的模块,图沦为「考古文物」。正确姿势:只维护 L1/L2 这种低频变化的图;把图当代码放进仓库(如 Structurizr DSL / Mermaid),改架构的 PR 必须顺手改图。

2.3 随堂自测

QUIZ 1
「订单服务(Node.js)通过 Kafka 向库存服务发送扣减消息」——这句话描述的关系最适合画在 C4 哪一层?
订单服务、库存服务、Kafka 都是可独立部署/运行的单元,属于容器级。L1 里整个系统是黑盒不拆服务;L3 是单个服务内部的模块;L4 是类级别。
QUIZ 2
给非技术的业务方讲「我们系统和微信支付、短信平台的关系」,应该拿哪张图?
业务方只关心「系统边界内外有谁、发生什么业务关系」,正是 L1 的抽象层级。ER 图/类图/部署图都陷入了对方不关心的实现细节——视图选择的第一原则是受众。
CHAPTER 03 · 架构基础

质量属性与权衡

一句话总览:功能决定系统「能干什么」,质量属性决定它「干得多好」——性能、可用性、可扩展性、可维护性彼此冲突,架构设计的本质就是给它们排优先级并量化。
🏎️
生活化类比
造车:马力大(性能)就费油(成本),装甲厚(安全/容错)就笨重(延迟),座位多(扩展性)就跑不快。F1 赛车、装甲车、大巴车没有谁「更先进」,只有谁更匹配用途。类比边界:车出厂后属性基本固定,软件的质量属性可以随演进调整——但每调一项都要付重构成本。

3.1 核心质量属性速查

属性问的问题常用度量典型手段
性能响应多快?扛多少量?P99 延迟、QPS/TPS缓存、异步、索引、池化
可用性坏没坏?坏多久?年度可用率(几个 9)冗余、故障转移、限流熔断
可扩展性加机器能线性提升吗?扩容后吞吐增幅无状态、分片、水平拆分
可维护性改需求疼不疼?变更影响面、上线频率模块化、低耦合、测试覆盖
安全性会不会被偷/被改/被瘫?漏洞数、审计合规鉴权、加密、最小权限
一致性各处数据一样吗?不一致窗口时长事务、共识协议、对账补偿
ℹ 为什么看 P99 而不是平均值
100 个请求里 99 个 10ms、1 个 5s,平均只有 60ms「看起来很美」,但那 1% 的用户体验是灾难,且高并发下长尾会被放大。P99 = 99% 的请求都快于这个值,它衡量的是「最差的大多数」。

3.2 可用性「几个 9」的真实代价

可用率全年允许宕机直观感受典型投入
99%(2 个 9)3.65 天每月坏几小时单机 + 备份重启
99.9%(3 个 9)8.76 小时每季度坏一小会儿双机热备 + 监控告警
99.99%(4 个 9)52.6 分钟全年几乎无感多可用区 + 自动故障转移
99.999%(5 个 9)5.26 分钟电信级异地多活 + 专职 SRE 团队

每多一个 9,成本大约翻数倍。给内部打卡系统上 5 个 9,等于给自行车装航空发动机。

质量属性跷跷板:按下这头,翘起那头
加缓存 → 性能 ↑ 代价:一致性 ↓(读到旧数据) 拆微服务 → 独立扩展 ↑ 代价:可维护性 ↓(分布式复杂度) 同步复制 → 一致性 ↑ 代价:延迟 ↑ 可用性 ↓(等副本) 正确做法:把质量目标写成可验收的数字(架构效用树) 例:「下单接口 P99 < 300ms,峰值 2000 QPS;订单数据不一致窗口 < 5s;全年可用性 ≥ 99.9%」
每个「提升」都有代价清单;不量化目标,权衡就变成了拍脑袋。
⚠ 高频陷阱:用形容词当需求
错误姿势:需求写「系统要高性能、高可用、易扩展」→ 后果:无法验收、无法权衡,团队各自理解,最后互相甩锅。正确姿势:逼自己写出数字和场景——「多少 QPS 下 P99 多少 ms」「挂一台机器后多久恢复」「扩展到 10 倍数据要改哪里」。写不出数字,就去问业务方拿。
✓ 记忆口诀
「功能是本分,质量是取舍;形容词不算数,数字才算数。」

3.3 随堂自测

QUIZ 1
接口平均延迟 20ms,但 P99 延迟 3s。最准确的解读是?
P99=3s 意味着 99% 的请求快于 3s、最慢的 1% 超过 3s。平均值被大量快请求稀释,掩盖了长尾。D 把 P99 理解反了;长尾常见诱因:慢查询、GC 停顿、锁竞争、缓存未命中。
QUIZ 2
给商品详情页加 Redis 缓存,主要提升哪个属性、牺牲哪个属性?
缓存挡掉大部分数据库读,延迟和吞吐显著改善;但缓存与数据库之间存在更新窗口,读到过期数据是一致性代价。所以详情页(容忍秒级旧数据)适合缓存,扣款余额(不容忍)要慎重。
CHAPTER 04 · 架构基础

单体与架构演进

一句话总览:单体不等于烂架构,微服务不等于先进——模块化单体是绝大多数系统的最佳起点,拆分的信号是「组织与变更频率撑不住了」,而不是「技术潮流到了」。
🏠
生活化类比
单间配套(大泥球单体):吃喝拉撒全在一屋,一个人住挺爽,来了室友互相踩脚。分室户型(模块化单体):还是一套房,但卧室厨房卫生间有墙有门——互不打扰,水电共摊。独栋小区(微服务):每人一栋房,隐私拉满,但串门要修路(网络调用)、每栋都要单独交水电(独立运维)。类比边界:房子隔墙隔音是物理保证,单体里的「模块墙」靠纪律和工具(依赖检查)维持,一偷懒就穿透。

4.1 演进四阶段

从大泥球到微服务:每一跳都由「痛点」驱动,而不是由「先进」驱动
大泥球单体 无边界,全耦合 改一处崩三处 模块化单体 ★起点 一个部署单元 内部模块边界清晰 服务化(少量拆分) 只拆最痛的部分 如:独立扩容的网关/计算 微服务 按业务能力全面拆 团队自治 + 独立部署 痛点:改动互相踩踏 痛点:某模块需独立扩容/发布 痛点:多团队并行,发布排队 康威定律:系统结构 ≈ 组织沟通结构。团队没拆,服务先拆 = 自找麻烦
为什么要「痛点驱动」:每一跳都引入新成本(网络、运维、一致性),没痛点就跳 = 白付钱。

4.2 单体 vs 微服务:一张表看清代价

维度模块化单体微服务
调用进程内函数调用,纳秒级、不会失败网络调用,毫秒级、会超时/丢包
事务本地 ACID 事务,一行注解跨服务只能 Saga/最终一致(见第 13 章)
部署一次全量,简单但「一荣俱荣一损俱损」各服务独立发布,需 CI/CD 与契约管理
扩容整体复制,浪费但简单按热点精准扩容
排错单进程断点/日志一条龙分布式链路追踪,跨服务拼线索
团队适合 ≤ 2 个小队适合多团队自治、各有明确业务域
⚠ 高频陷阱:分布式大泥球(Distributed Monolith)
错误姿势:拆了 8 个服务,但共享一个数据库、改一个需求要 5 个服务同时发版 → 后果:拿到微服务全部的成本,没拿到任何好处,比单体还惨。正确姿势:拆分前先确认「这块业务能否独立变更、独立部署、独占自己的数据」,三个都做不到就别拆。
✓ 记忆口诀
「先把单体的墙砌好,再考虑把墙换成路。」模块边界清晰的单体,拆微服务是水到渠成;边界稀烂的单体,拆完只是把烂泥摊得更开。

4.3 随堂自测

QUIZ 1
哪条是「该拆微服务了」的最可靠信号?
拆分的核心收益是「组织自治 + 独立变更部署」,D 正是这个收益对应的痛点。A/B 是技术偏好,C 行数不说明耦合——10 万行边界清晰的模块化单体可能非常好维护。
QUIZ 2
两个服务共用同一个数据库、必须同步发版,这种架构叫什么问题?
共享库 + 同步发版意味着两者无法独立变更与部署,微服务的核心收益全部落空,却背上了网络调用的成本。这正是「先拆服务不改边界」的典型恶果。
CHAPTER 05 · 架构风格与模式

分层架构与依赖倒置

一句话总览:分层的精髓不是「摆几层」,而是依赖方向一律指向业务核心——整洁/六边形架构靠「依赖倒置」让数据库、框架、UI 都变成可插拔的外设。
🔌
生活化类比
电脑主机不关心你插什么牌子的显示器——它只定义 HDMI 接口(端口),显示器厂商负责做符合接口的线(适配器)。换显示器不用改主板。整洁架构同理:业务核心定义 OrderRepository 接口,MySQL/Redis/Mock 各自实现它——换存储不用改业务。类比边界:HDMI 是行业统一标准,你的仓储接口是自己设计的,接口设计得烂(泄漏 SQL 细节)照样换不动。

5.1 传统三层 vs 依赖倒置后的分层

依赖箭头方向:传统分层「一路向下」,整洁架构「全部向内」
传统三层:业务被数据库绑架 表现层(Controller/UI) 业务逻辑层(Service) 数据访问层(DAO/SQL) 业务 import 了 DAO → 换库/测试都要动业务 整洁架构:核心零外部依赖 领域核心 实体+规则+接口 用例层(应用服务) 外层:Controller / DB / MQ / 框架 DB 适配器实现核心定义的接口 外层依赖内层;内层不知道外层存在
为什么箭头必须向内:变化最多的是外设(框架/库/UI),最稳定的是业务规则——让易变者依赖稳定者。

5.2 依赖倒置的最小代码

ports-and-adapters.ts
// ── 内层:领域核心自己定义「我需要什么」(端口)──
interface OrderRepository {          // 核心说:我要能存取订单
  findById(id: OrderId): Promise<Order | null>;
  save(order: Order): Promise<void>; // 注意:没有一行 SQL 术语
}

// ── 内层:用例只依赖接口,不知道 MySQL 存在 ──
class CancelOrder {
  constructor(private repo: OrderRepository) {}   // 注入接口
  async execute(id: OrderId) {
    const order = await this.repo.findById(id);
    if (!order) throw new Error('订单不存在');
    order.cancel();                  // 业务规则在实体里,不在 SQL 里
    await this.repo.save(order);
  }
}

// ── 外层:适配器实现接口(可以被随便替换)──
class MySQLOrderRepo implements OrderRepository { /* SQL 细节 */ }
class InMemoryOrderRepo implements OrderRepository { /* 测试用,零数据库 */ }
✓ 依赖倒置一句话
「谁稳定谁定接口,谁易变谁做实现」。业务规则最稳定 → 接口归核心;数据库/框架易变 → 它们来适配。这就是 DIP(依赖倒置原则)在架构尺度的用法。
⚠ 高频陷阱:接口泄漏实现细节
错误姿势:核心接口写成 findBySql(sql: string) 或返回 ResultSet → 后果:接口虽然「倒置」了,但语义仍是数据库的,换存储照样重写业务,测试照样要起真库。正确姿势:接口用业务语言(findById / save / findOverdueOrders),参数与返回值都是领域对象。

5.3 随堂自测

QUIZ 1
整洁架构中,「订单仓储接口 OrderRepository」应该定义在哪一层?
接口表达的是「业务需要什么样的存取能力」,属于稳定的内层;数据库实现是易变的外层。定义在外层就回到了「业务依赖数据库」的老路,依赖倒置失效。
QUIZ 2
依赖倒置带来的最直接工程收益是?
核心不依赖具体外设,测试时注入 InMemory 实现即可毫秒级跑完用例,无需起库;换 ORM/数据库只改适配器。运行性能与代码行数不因此改善,SQL 还是要写——只是被隔离在外层。
CHAPTER 06 · 架构风格与模式

前端架构:MVC 到状态流

一句话总览:前端架构演进的主线是「谁有权改状态」越来越收敛——从 MVC 的人人可改,到 MVVM 的双向绑定,再到 Flux/Redux 的单向数据流:状态只有一条修改通道,UI 只是状态的投影。
📺
生活化类比
MVC 时代:家里电视谁都能拿遥控器按,画面乱了不知道谁按的(多个组件随意改共享状态)。单向数据流:全家只有一个「值班遥控器」,换台必须喊一声「我要换到 5 台」(dispatch action),值班员统一操作(reducer),电视画面自动跟着变(UI = f(state))。出了问题查值班记录(action 日志)就知道谁干的。类比边界:电视状态简单,前端状态是嵌套大树,所以还需要「不可变更新」来让变更可追踪。

6.1 三个 MV* 模式对比

模式核心角色View 与逻辑的关系代表
MVCController 接收输入,改 Model,通知 ViewView 可直接读 Model,容易互相纠缠早期 Web 后端、Backbone
MVPPresenter 全权代理,View 完全被动View 只有接口,逻辑全在 Presenter,好测但样板多早期 Android
MVVMViewModel 暴露可观察状态,绑定自动同步声明式绑定,少写胶水代码Vue、Angular、WPF

6.2 单向数据流:现代前端的共识

单向数据流闭环:UI = f(state),改状态只有一条路
View(组件树) 只渲染 + 发事件 Action 「发生了什么」的纯描述 Reducer / Store (旧state, action) → 新state dispatch 新 state 订阅推送 → View 重新渲染(UI = f(state)) ✗ 禁止:组件绕过 Action 直接改共享状态
为什么收敛写入口:状态变更全部留痕(action 序列),bug 可回放、可时间旅行调试。
mini-store.ts(30 行看懂 Redux 本质)
type Action = { type: 'add' } | { type: 'reset' };

function reducer(state: number, action: Action): number {
  switch (action.type) {
    case 'add':   return state + 1;   // 纯函数:不副作用,返回新值
    case 'reset': return 0;
    default:      return state;
  }
}

function createStore(reducer: (s: number, a: Action) => number, init: number) {
  let state = init;
  const listeners: Array<() => void> = [];
  return {
    getState: () => state,
    dispatch(action: Action) {
      state = reducer(state, action);          // 唯一改状态的通道
      listeners.forEach(fn => fn());           // 通知所有订阅者(UI)
    },
    subscribe(fn: () => void) { listeners.push(fn); }
  };
}

const store = createStore(reducer, 0);
store.subscribe(() => console.log('UI 渲染:', store.getState()));
store.dispatch({ type: 'add' });   // UI 渲染: 1 —— 变更有据可查
⚠ 高频陷阱:把「什么都塞全局 store」当架构
错误姿势:输入框每个 keystroke、弹窗开关、hover 状态全进 Redux → 后果:一次输入触发全量订阅计算,页面卡顿 + 样板代码爆炸。正确姿势:先分类——服务端数据交给查询缓存(React Query 类),跨页共享的客户端状态才进全局 store,组件局部状态留在组件里。全局状态是稀缺资源,不是垃圾桶。
✓ 记忆口诀
「UI 是状态的函数,Action 是唯一的门。」排查前端状态 bug:别盯着组件看,先查 action 流水——谁在什么时候改了什么,一目了然。

6.3 随堂自测

QUIZ 1
单向数据流中,组件想修改购物车数量,正确做法是?
A 走唯一写通道,变更可追踪。B 绕过 reducer 破坏可预测性(且原地突变让依赖不可变比较的优化失效);C 制造隐式耦合;D 渲染期间改状态会引发循环渲染。
QUIZ 2
MVVM 相比 MVP 的核心差异是?
MVP 中 Presenter 持有 View 接口逐个 set;MVVM 用绑定机制让状态变化自动映射到 UI,省掉大量胶水代码。两者都有逻辑层,都跨平台,性能取决于实现而非模式本身。
CHAPTER 07 · 架构风格与模式

事件驱动与消息队列

一句话总览:消息队列用「先收件、后处理」换来三大收益——解耦、削峰、异步;代价是消息可能丢、重、乱序,消费端必须按「至少一次投递」设防。
📮
生活化类比
没有快递柜时,快递员必须当面把包裹塞你手里(同步调用):你不在家他就干等(阻塞),双十一他直接瘫掉(雪崩)。有了快递柜(MQ):他投柜就走(异步),你有空再取(削峰),他根本不需要认识你(解耦)。类比边界:快递柜会「柜满」(积压)、「取件码发重了」(重复投递)——所以取件时要核对单号(幂等),柜满了要有兜底策略。

7.1 同步调用 vs 事件驱动

下单之后:同步链条一环卡全卡,事件驱动投完即走
同步:总耗时 = 所有环节之和,短信挂了下单也挂 订单服务 库存 200ms 积分 150ms 短信 超时 5s ✗ 整条链路被拖死 事件驱动:核心落库即返回,其余订阅者各自消费 订单服务 MQ(持久化缓冲) OrderCreated 事件 库存消费者 积分消费者 短信(挂了也不影响别人) 5ms 新增订阅者 零改订单代码
为什么解耦:订单服务只声明「发生了什么」(事实),不关心「谁要干什么」(命令)。

7.2 三大收益与三大代价

收益机制对应代价对策
解耦生产者不认识消费者消息丢失(broker 宕机/未刷盘)持久化 + 发送确认 + 本地消息表
削峰洪峰先积压在队列,消费端按自己节奏拉消息重复(重试/重平衡导致至少一次)消费幂等:唯一业务键去重
异步主链路只做核心事务乱序(多分区/多消费者并行)同业务键路由同一分区;或版本号防旧盖新
idempotent-consumer.ts(幂等消费的最小骨架)
async function onOrderCreated(msg: { eventId: string; orderId: string }) {
  // 至少一次投递 ⇒ 同一条消息可能来两遍,先查重
  const seen = await dedupTable.exists(msg.eventId);
  if (seen) return;                       // 已处理过:直接确认,什么都不做

  await db.transaction(async (tx) => {
    await tx.insert(dedupTable, { eventId: msg.eventId }); // 去重记录
    await tx.update(points, { orderId: msg.orderId, add: 10 }); // 业务
  });                                     // 两步同一事务:要么都成,要么都不成
}
// 关键:去重表写入与业务变更必须原子,否则「记了没做」或「做了没记」
⚠ 高频陷阱:把「发出去了」当「办成了」
错误姿势:订单落库和发 MQ 两步走,落库成功后进程崩了没发出去 → 后果:订单存在但库存永远不扣,静默数据不一致。正确姿势:本地消息表 / 事务性发件箱(Outbox)——事件先和业务写进同一个本地事务,再由后台任务可靠投递;或直接用支持事务消息的 MQ。
✓ 记忆口诀
「事件说事实,命令提要求;投递至少一次,消费必须幂等。」事件命名用过去式(OrderCreated),代表不可撤销的事实。

7.3 随堂自测

QUIZ 1
MQ 承诺「至少一次投递」,消费端最必须做的防御是?
至少一次意味着重复不可避免(重试、消费者重平衡都会引发)。幂等让「加 10 积分」执行两遍效果仍是一遍。端到端「恰好一次」在分布式下极难纯靠 MQ 保证,最终仍落到消费端幂等。
QUIZ 2
秒杀开始瞬间 10 万请求涌入,下游处理能力只有每秒 2000。MQ 在这里的作用是?
MQ 是缓冲区不是放大器:总量不变,把「瞬时到达」摊成「匀速处理」,代价是尾部请求要排队等待(延迟上升)。它不会提升下游能力,默认也不丢消息——积压超限才需要限流/拒绝策略兜底。
CHAPTER 08 · 架构风格与模式

微服务拆分与边界

一句话总览:微服务成败在边界不在数量——按业务能力/限界上下文切、数据私有、通过契约协作;切错了边界的微服务比单体更痛苦。
🏢
生活化类比
公司分部门:好的划分是采购、生产、销售(各管一摊业务,各有自己的台账),部门间靠单据(API 契约)协作。坏的划分是「填表部、盖章部、存档部」——办任何一件事都要跨三个部门跑(按技术步骤切服务),盖个章要三方会签(分布式事务)。类比边界:公司部门可以开会临时协调,服务间协调要靠代码和协议,边界错了改起来贵得多。

8.1 怎么切:三种刀法对比

刀法例子评价
按业务能力 / 限界上下文 ✓订单、库存、支付、用户业务内聚、变更同频,绝大多数变更只动一个服务
按技术分层 ✗Controller 服务、Service 服务、DAO 服务一个需求穿透全部服务,同步发版,纯负收益
按数据表 ✗每张表一个 CRUD 服务业务逻辑无处安放,散落在调用方,形成面条调用网
ℹ 判断边界好坏的黄金标准
拿最近 20 个真实需求来「沙盘推演」:如果 80% 的需求只需要改 1 个服务,边界大概率是对的;如果多数需求要同时改 3+ 个服务并一起发版,边界切错了——它们本该是一个上下文。

8.2 数据私有与协作契约

每服务一库:别人的数据只能通过「门」拿,不能翻墙进库
订单上下文 订单 API 订单私有库 OrderCreated 事件发布 库存上下文 库存 API 库存私有库 订阅订单事件 维护本地副本 ✓ 契约:API / 事件 ✗ 禁止:库存服务直连订单库查表(共享库=隐形耦合)
为什么数据必须私有:表结构是服务的「内脏」,让别人直连你的库 = 你的每次改表都会炸到别人。
  • 同步要数据:调对方 API(注意超时/熔断,见第 15 章)。
  • 异步同步副本:订阅对方事件,在自己库里维护一份「只读投影」(如库存服务存商品名称快照)。
  • 跨服务业务流程:不用分布式事务硬锁,用 Saga 编排 + 补偿(见第 13 章)。
  • 入口统一:API 网关做路由/鉴权/限流;BFF 为不同端(App/Web)裁剪聚合接口。
⚠ 高频陷阱:契约随手改
错误姿势:订单服务把字段 amount 改名 totalAmount 直接上线 → 后果:下游三个服务解析失败,线上静默丢单。正确姿势:契约变更走兼容性规则(只加不删不改义)+ 消费者驱动契约测试(Pact 类)+ 版本化;破坏性变更必须新旧并行过渡。
✓ 记忆口诀
「按业务切、数据私有、契约说话。」数量不是目标——能独立变更部署的最小业务单元才是服务的合理粒度。

8.3 随堂自测

QUIZ 1
下面哪种拆分最可能形成「分布式大泥球」?
按技术分层拆,任何一个业务需求都要穿透三个服务、三方同步发版——把进程内调用变成网络调用,却没换来任何独立性。A/C/D 都以「独立变更」为导向。
QUIZ 2
库存服务需要展示商品名称(归商品服务管),最符合微服务原则的做法是?
D 是「事件驱动的数据副本」:数据所有权仍归商品服务,库存只持有投影,解耦且高性能。A 破坏数据私有;B 双写必然冲突;C 是 N+1 网络调用,性能灾难。
CHAPTER 09 · 战略设计

战略设计:限界上下文

一句话总览:DDD 战略设计回答「系统怎么划地盘」——先用子域分清业务主次,再用限界上下文给每个模型划定「术语有效范围」,上下文之间用显式映射关系协作。
🗣️
生活化类比
「客户」这个词:销售部指「签合同的甲方」,客服部指「打进电话的人」(可能是甲方员工),财务部指「开票主体」。同一个词,三个部门三种含义——硬要全公司共用一张「客户表」,字段就会膨胀成 80 列的怪物。限界上下文 = 部门方言区:区内「客户」含义唯一(统一语言),跨区交流要「翻译」(上下文映射)。类比边界:部门方言靠人脑翻译,软件里翻译要写成代码(防腐层),而且必须自动化测试保住。

9.1 子域:先分清「哪里值得砸钱」

子域类型定义电商例子投入策略
核心域赚钱的差异化竞争力推荐算法、定价策略、履约调度最强的人 + 精细建模,绝不外包
支撑域业务必需但不构成竞争力商品目录、订单管理认真做但可以简单些
通用域谁家都一样登录鉴权、短信、支付通道能买就买、能用开源就用
ℹ 子域 vs 限界上下文
子域是「问题空间」的划分(业务本来就长这样),限界上下文是「解空间」的划分(你决定模型和代码的边界)。理想情况一个子域对应一个上下文,但遗留系统里一个子域可能被迫切成多个上下文——别把两者当同义词。

9.2 上下文映射:边界之间怎么相处

上下文地图:同一个「商品」,三个上下文三个模型 + 显式协作关系
商品目录上下文 Product: 标题/详情/类目/图文 关心:怎么把商品「讲清楚」 上游:发布 ProductUpdated 事件 订单上下文 OrderItem: 商品ID/名称快照/单价 关心:成交那一刻的事实 名称价格存快照,不随商品改价而变 仓储物流上下文 Sku: 条码/重量/体积/库位 关心:这箱货怎么搬 根本不关心商品详情文案 常见映射关系:客户-供应商(上游优先满足下游)|防腐层 ACL(下游翻译上游模型,隔离污染) 开放主机服务 OHS(上游发布标准协议)|共享内核(共用一小块模型,改动需双方同意——慎用) 反模式:全系统一个「大一统 Product 类」→ 80 个字段,谁改都怕炸到别人
为什么允许「同名不同模型」:模型为各自业务服务,强行统一反而让每个上下文都背上别人的包袱。
anti-corruption-layer.ts(防腐层:把上游模型翻译成自己的语言)
// 上游遗留系统返回的「商品」:字段脏、命名怪、含义漂移
type LegacyGoods = { goods_no: string; goods_nm: string; prc_fen: string; st: number };

// 防腐层:唯一允许「知道上游长什么样」的地方
class GoodsAcl {
  toCatalogItem(g: LegacyGoods): CatalogItem {
    return {
      id: g.goods_no,
      name: g.goods_nm.trim(),
      price: Money.fromFen(Number(g.prc_fen)), // 字符串分 → 值对象
      onSale: g.st === 1                       // 魔法数字翻译成业务语义
    };
  }
}
// 上游哪天改字段,只改这一个类;核心模型 CatalogItem 一个字母都不用动
⚠ 高频陷阱:让上游模型长驱直入
错误姿势:核心业务直接 import 遗留系统的 LegacyGoods 类型并在几十个文件里使用 → 后果:上游改一个字段,你的核心域全线编译爆炸,等于把别人的不稳定性焊进自己心脏。正确姿势:边界处放防腐层,进来先翻译成自己的模型;核心永远只说自己的统一语言。
✓ 记忆口诀
「一个上下文一本词典;跨上下文先翻译。」判断该不该拆上下文:问「这个词在这两处的含义和生命周期一样吗?」不一样,就是两个上下文。

9.3 随堂自测

QUIZ 1
订单里的商品名称要求「下单时是什么就是什么」,即使商品后来改名。这说明了什么?
订单关心「成交时刻的事实」,目录关心「当前展示」——生命周期与含义都不同,正是限界上下文的分界依据。快照不是冗余失误,而是刻意的模型分离;级联更新反而会篡改历史事实。
QUIZ 2
防腐层(ACL)的核心职责是?
ACL 是模型翻译层,不是安全或备份组件。D 恰恰是 ACL 要反对的——共享实体让上游变化直接穿透核心。判断 ACL 是否合格:上游改接口时,你的改动是否被限制在这一个翻译类里。
CHAPTER 10 · 战术设计

战术设计:实体、值对象与聚合

一句话总览:实体靠ID识别、值对象靠属性值识别;聚合是「必须一起保持正确」的一致性边界,聚合根是唯一入口——一个事务只改一个聚合,聚合之间只用 ID 引用。
💵
生活化类比
实体 = 人:张三改名、整容、换工作,还是同一个张三(靠身份证号识别)。值对象 = 一张 100 元纸币的金额概念:你手里这张和我手里那张「100 元」完全等价,没必要区分(靠值识别),破了就换张新的(不可变,修改=替换)。聚合 = 一份合同 + 附件:改条款必须整套一起改、一起盖章生效,不能只改附件不改主文(不变量)。类比边界:纸币其实有冠字号(物理实体),但「金额」这个业务概念是值对象——建模看业务关心什么,不看物理形态。

10.1 实体 vs 值对象

维度实体 Entity值对象 Value Object
相等判断ID 相同即同一个(属性可全变)所有属性相等即等价
可变性有生命周期,状态随时间变不可变:要改就造新对象整体替换
例子订单、用户、账户金额 Money、地址 Address、日期区间
建模信号业务要「追踪它是谁」业务只关心「它是什么值」
money-and-order.ts(值对象 + 聚合根的最小实现)
class Money {                              // 值对象:不可变 + 自校验 + 值相等
  private constructor(readonly fen: number) {
    if (!Number.isInteger(fen) || fen < 0) throw new Error('金额必须是非负整数分');
  }
  static of(fen: number) { return new Money(fen); }
  add(o: Money) { return Money.of(this.fen + o.fen); }  // 修改=返回新对象
  equals(o: Money) { return this.fen === o.fen; }
}

class Order {                              // 聚合根:唯一对外入口
  private items: OrderItem[] = [];
  private status: 'draft' | 'paid' = 'draft';
  addItem(skuId: string, price: Money, qty: number) {
    if (this.status !== 'draft') throw new Error('已支付订单不可加购'); // 不变量①
    if (this.items.length >= 50) throw new Error('单笔最多50种商品');   // 不变量②
    this.items.push(new OrderItem(skuId, price, qty));
  }
  total(): Money { return this.items.reduce((s, i) => s.add(i.subtotal()), Money.of(0)); }
  pay() { if (!this.items.length) throw new Error('空订单不可支付'); this.status = 'paid'; }
}
// 外界永远不直接碰 items —— 所有修改走聚合根方法,不变量才守得住

10.2 聚合边界怎么划

聚合 = 事务一致性边界:内部强一致,之间 ID 引用 + 最终一致
Order 聚合(一个事务边界) Order 聚合根 OrderItem ×N Address 值对象 总额=明细之和:同事务内立刻成立 Inventory 聚合(另一个事务) Stock 聚合根 skuId: string 只存 skuId 事件/最终一致 ✗ 禁止:Order 直接持有 Stock 对象并在同一事务里改它
为什么一事务一聚合:跨聚合强一致 = 大锁 + 大事务,并发一高就死锁排队;真正必须强一致的才圈进同一聚合。
⚠ 高频陷阱:巨型聚合
错误姿势:把 User 设成聚合根,下挂订单列表、地址簿、收藏、积分,改任何一处都加载并锁整个 User → 后果:一个用户万级订单,改个昵称加载 2MB 数据,热点用户并发操作互相锁死。正确姿势:问「哪些对象必须同一瞬间保持一致?」订单和用户不需要(下单后用户改昵称不影响订单),所以 Order 独立成聚合,只存 userId。
✓ 记忆口诀
「实体认 ID,值对象认值;聚合尽量小,事务只进一个门;跨聚合,发事件。」能拆成两个聚合的就别合成一个——聚合越小,并发越好。

10.3 随堂自测

QUIZ 1
收货地址 Address 在订单系统里最适合建模为?
订单里的地址只关心「值是什么」,不追踪「它是哪个地址」;订单改地址应整体替换快照,而不是改一条被多订单共享的地址记录(那会篡改历史订单)。独立的「地址簿」功能里地址才可能是实体——同一概念在不同上下文建模不同。
QUIZ 2
「订单总额必须等于明细之和」这条不变量,靠什么守住?
不变量需要「同一瞬间成立」,所以明细与总额必须同聚合、同事务,且写入口收敛到聚合根。前端计算可被篡改;跑批是事后补救不是保证;外键管引用完整性,管不了金额求和。
CHAPTER 11 · 战术设计

仓储、应用服务与领域事件

一句话总览:落地 DDD 的分工是——实体管规则,应用服务管编排(取→改→存→发),仓储管存取(一个聚合一个仓储),领域事件管跨聚合协作;业务规则一旦漏进 Service 或 SQL,就退化回贫血模型。
🍳
生活化类比
餐厅出菜:菜谱和火候标准在厨师脑子里(实体/领域模型管规则),传菜单只写「做什么菜、几号桌」(应用服务只编排流程:取食材→交给厨师→装盘上桌),仓库管理员负责按单取料入库(仓储),菜做好了广播一声「3 号桌菜好了」,服务员和收银各自响应(领域事件)。类比边界:传菜员偶尔会忍不住自己炒两下(Service 里写业务规则)——这正是最常见的腐化路径,代码评审要专盯这个。

11.1 各角色职责清单

角色该做不该做
实体/聚合根业务规则、不变量、状态迁移调数据库、发 HTTP、读配置
应用服务开事务、取聚合、调方法、存回、发事件写 if-else 业务规则(该下沉到实体)
领域服务跨多个聚合的纯计算(如转账定价)变成什么逻辑都装的垃圾桶
仓储按聚合整存整取,接口在领域层暴露 SQL/分页游标等实现细节给核心
领域事件宣告已发生的事实,驱动跨聚合/上下文反应当同步 RPC 用、要求对方立刻回滚
cancel-order-app-service.ts(应用服务的标准五步)
class CancelOrderAppService {
  constructor(
    private orders: OrderRepository,   // 接口定义在领域层(第 5 章 DIP)
    private events: EventBus,
    private uow: UnitOfWork            // 工作单元:统一事务边界
  ) {}

  async execute(cmd: { orderId: string; reason: string }) {
    await this.uow.begin();
    const order = await this.orders.findById(cmd.orderId);   // ① 取聚合
    if (!order) throw new Error('订单不存在');
    order.cancel(cmd.reason);        // ② 规则在实体里:能不能取消它说了算
    await this.orders.save(order);   // ③ 整聚合存回
    await this.uow.commit();         // ④ 事务提交(事件经 Outbox 同事务落库)
    this.events.publish(order.pullEvents()); // ⑤ OrderCancelled → 退款/回库存订阅
  }
}
// 注意:这里没有一行「if 状态==已发货 then ...」——那是 order.cancel() 的内政
一次取消订单的完整协作:规则内聚,协作靠事件
Controller 参数校验/鉴权 应用服务 事务 + 编排五步 Order 聚合根 cancel(): 规则+事件在这里 仓储实现 整聚合存取(SQL) 退款上下文 订阅 OrderCancelled 库存上下文 订阅后回补库存 最终一致
为什么规则必须待在聚合里:换个入口(定时任务/管理后台/消息触发)复用同一聚合,规则天然一致。
⚠ 高频陷阱:贫血模型 + 上帝 Service
错误姿势:Order 类只有 getter/setter,OrderService.cancel() 里 300 行 if-else 判断状态、算退款、改库存 → 后果:同一规则在「App 取消」「客服取消」「超时取消」三处复制三份,改一处漏两处,线上行为不一致。正确姿势:规则收进 order.cancel(),三个入口都调它;Service 瘦成五步编排。
✓ 记忆口诀
「实体管能不能,服务管先做啥后做啥,仓储管放哪取哪,事件管告诉别人。」评审时看 Service:出现业务 if-else,就是味道不对。

11.2 随堂自测

QUIZ 1
「已发货的订单不能取消」这条规则最应该写在哪里?
规则属于聚合的不变量,写进 cancel() 后所有入口(API/定时任务/客服后台)自动共享同一约束。B/C 每个入口都要复制一份,必漏;D 只能表达单行字段约束,且把业务语义埋进 DB 难以维护与测试。
QUIZ 2
关于仓储(Repository)的正确说法是?
仓储面向聚合而非表:OrderRepository.save 会一并处理 OrderItem。接口归领域层(DIP),实现归外层。DAO 面向表/行,粒度和语义都不同;按表建仓储会把聚合拆散,不变量没人守。
CHAPTER 12 · 战术设计

CQRS 与事件溯源

一句话总览:CQRS 把「改状态的模型」和「查数据的模型」分开各建各的;事件溯源更激进——不存当前状态,只存发生过的事件,状态是事件重放算出来的。两者可独立使用,都不是银弹。
🏦
生活化类比
银行账户:存折流水(+5000 工资、-200 话费、-1500 房租…)是事件溯源——只追加、不涂改,余额是流水累加的结果;手机银行首页的余额大字是读模型/投影——为「看一眼」优化,可以稍晚几秒刷新。审计员查账翻流水(事件日志天然审计),你日常只看余额(读模型)。类比边界:银行流水错账会「冲正」(追加一笔反向记录)而不是删改——事件溯源同理,纠错也是新事件,历史永不可变。

12.1 CQRS:读写模型分家

维度写模型(Command)读模型(Query)
目标守不变量、执行规则查得快、拼得爽
结构聚合(规范化、小事务)宽表/搜索索引/缓存(反规范化随便冗余)
数据源业务主库 / 事件存储由事件或变更流异步刷新的投影库
一致性事务内强一致落后写侧一小段(最终一致)
事件溯源 + CQRS 全景:写侧追加事件,读侧订阅投影
命令 Command PayOrder(id) 聚合校验规则 重放历史→当前态→决策 事件存储(只追加) Created→ItemAdded→Paid 追加 投影:订单列表宽表 给「我的订单」页用 投影:营收统计 给报表用 投影:搜索索引 给全文检索用 异步订阅,秒级延迟 重放(Replay):从头消费事件即可重建任意时刻的状态 性能兜底:快照(每 N 个事件存一次状态,重放从最近快照开始) 代价:读侧最终一致 + 事件结构演进难 + 心智负担大 —— 只在审计/追溯/多视图是硬需求时用
为什么「不存状态存事件」:状态会覆盖历史,事件保留全部因果——审计、纠错、新增报表都能从历史重算。
event-sourced-cart.ts(事件重放的最小实现)
type CartEvent =
  | { type: 'ItemAdded'; sku: string; qty: number }
  | { type: 'ItemRemoved'; sku: string }
  | { type: 'CheckedOut' };

function replay(events: CartEvent[]): Map<string, number> {
  const cart = new Map<string, number>();
  for (const e of events) {            // 状态 = 折叠(初始态, 事件序列)
    switch (e.type) {
      case 'ItemAdded':
        cart.set(e.sku, (cart.get(e.sku) ?? 0) + e.qty); break;
      case 'ItemRemoved': cart.delete(e.sku); break;
      case 'CheckedOut':  cart.clear(); break;
    }
  }
  return cart;                         // 没有任何 UPDATE:历史只追加
}
// 想加「弃购分析」报表?写个新投影函数重放同一份事件即可,零改历史
⚠ 高频陷阱:写完立刻读,读到旧数据当 bug 修
错误姿势:支付成功后跳转详情页,读模型还没刷出来,显示「未支付」,于是加分布式事务把读写强行绑死 → 后果:CQRS 收益归零还引入大锁。正确姿势:承认最终一致——写侧返回命令结果让前端乐观展示,或详情页「读己之写」走写侧/带版本号等待投影追上。
✓ 记忆口诀
「写侧讲规则,读侧讲速度;事件是账本,状态是余额。」CQRS ≠ 事件溯源:可以只做读写分离(普通库+投影),不上事件存储——大多数系统止步 CQRS 就够了。

12.2 随堂自测

QUIZ 1
事件溯源系统中发现某笔订单金额记错了,正确的纠错方式是?
事件日志不可变是事件溯源的根基(审计与重放的可信前提)。纠错如银行冲正:追加新事件。A/C 破坏历史,重放结果与审计全乱;D 只改了缓存视图,下次重建投影又会回到错误值。
QUIZ 2
什么信号最支持引入「事件溯源」而不是普通 CRUD?
事件溯源的独特收益是「完整因果历史 + 可重放」,D 正是它的适用画像(金融账务、合规审计)。简单 CRUD 用它纯属自虐;事件只增不减反而更占磁盘(需快照与归档策略)。
CHAPTER 13 · 分布式与实战

CAP 与分布式一致性

一句话总览:网络分区(P)是分布式系统的必答题不是选择题,CAP 真正让你选的是分区发生那一刻:保一致(C,拒绝服务)还是保可用(A,容忍旧数据);跨服务业务一致靠 Saga 补偿而非分布式大事务。
🏪
生活化类比
连锁店两家分店共用「会员余额」,总部电话线断了(网络分区):顾客在 A 店要消费——保 C:「联系不上总部,暂停刷卡」(拒绝服务,防止两边各刷一次余额刷穿);保 A:「先记账让他刷,回头对账」(可能两边同时刷导致透支,事后补偿)。电话线好的时候也有取舍:每笔都打电话确认(同步复制,慢)还是先斩后奏(异步复制,快但短暂不一致)——这就是 PACELC 补的后半句。类比边界:分店可以人工对账兜底,系统必须把「对账+补偿」写成自动化代码。

13.1 CAP 的正确打开方式

分区发生时二选一:CP 拒绝写 vs AP 先写后合
节点 A(余额=100) 收到扣款 80 的请求 节点 B(余额=100) 也收到扣款 80 的请求 ✗ 网络分区:无法互通 选 C(CP 系统) 「无法确认对方,拒绝本次扣款」 例:ZooKeeper/etcd、银行核心账务 选 A(AP 系统) 两边都扣成功 → 余额 -60,事后对账补偿 例:DNS、购物车、点赞数、Dynamo 类 PACELC:没分区(Else)时还要选——同步复制保一致但延迟高(L↑),异步复制低延迟但短暂不一致(C↓)
为什么说「三选二」是误读:P 不由你选(网络一定会断),你只能选断网时的态度;且同一系统可不同数据不同策略。

13.2 跨服务一致性:别硬上分布式事务

方案机制代价适用
2PC/XA协调者两阶段提交,全体锁定等资源同步阻塞、协调者单点、吞吐差传统金融库内跨库,互联网慎用
TCCTry 预留资源 → Confirm/Cancel每个服务写三个接口,侵入大资金类高一致短流程
Saga ✓一串本地事务,失败则按逆序执行补偿中间态可见(最终一致),补偿要幂等订单-库存-支付类长流程标配
本地消息表/Outbox业务+事件同事务落库,异步可靠投递只保证「事件必达」,下游自理事件驱动的最终一致基座
saga-checkout.ts(Saga:正向一步步,失败倒着补)
const steps = [
  { do: () => inventory.reserve(sku, qty),  undo: () => inventory.release(sku, qty) },
  { do: () => payment.charge(userId, total), undo: () => payment.refund(userId, total) },
  { do: () => order.confirm(orderId),        undo: () => order.markFailed(orderId) },
];

async function runSaga() {
  const done: typeof steps = [];
  for (const s of steps) {
    try { await s.do(); done.push(s); }          // 每步都是独立的本地事务
    catch (e) {
      for (const d of done.reverse()) await d.undo(); // 逆序补偿,且必须幂等
      throw e;                                    // 用户看到失败,数据回到业务等价原点
    }
  }
}
// 注意:补偿≠回滚。退款是「新交易」,中间态(已扣款未确认)外界短暂可见
⚠ 高频陷阱:把补偿当回滚,忘了中间态
错误姿势:Saga 扣款成功、确认订单失败,补偿退款要 30 秒到账,期间用户看到「已扣款但订单失败」就投诉/重复下单 → 后果:客诉与重复扣款。正确姿势:产品层面承认中间态——展示「处理中」状态、按钮防重、补偿幂等可重试、对账兜底。最终一致是技术+产品的联合设计。
✓ 记忆口诀
「分区必选 C 或 A;跨服务不上大事务,Saga 补偿加对账。」钱的场景:宁可 CP 拒绝服务,也别 AP 刷穿余额。

13.3 随堂自测

QUIZ 1
「CAP 三选二」最常见的误解是?
网络分区在分布式系统里必然发生(光缆挖断、交换机故障、甚至 GC 停顿导致的假死都等效分区),P 不可放弃。「CA 系统」实际是单机系统。CAP 的 C 是线性一致性,A 是每个请求都得到非错响应。
QUIZ 2
下单流程跨订单/库存/支付三个服务,互联网高并发场景的主流一致性方案是?
Saga 无全局锁、各步独立提交,吞吐与可用性适合高并发;代价是中间态需产品配合。2PC 同步锁定扛不住峰值;C 是分布式大泥球老路;D 把技术债转成运营事故。
CHAPTER 14 · 分布式与实战

缓存架构

一句话总览:缓存的本质是「用一份可能过期的副本,换数据库的命」——标准姿势是 Cache-Aside(读:先缓存后库回填;写:更新库后删缓存),三大敌人是穿透、击穿、雪崩,各有对症解法。
📚
生活化类比
图书馆:前台热门书架(缓存)放最常借的 20 本,地下书库(数据库)全量但取书慢。管理员找不到就去书库搬一本顺手放前台(读回填);书出了新版就把前台旧版撤掉而不是当场换(写后删缓存,下次借的人触发搬新版)。三大事故:有人专借根本不存在的书,每次都白跑书库(穿透);某爆款书刚下架的瞬间一百人同时催管理员去书库(击穿);前台书架整层同时到期清空,所有请求砸向书库(雪崩)。类比边界:图书管理员只有一个会排队,缓存重建是几百个并发线程同时冲库——所以要「只放一个人进去」(互斥重建)。

14.1 Cache-Aside 标准读写

cache-aside.ts
async function getProduct(id: string) {
  const hit = await cache.get(`p:${id}`);
  if (hit !== null) return JSON.parse(hit);      // ① 命中直接回
  const row = await db.query('SELECT ... WHERE id=?', id); // ② 未命中查库
  if (row) await cache.set(`p:${id}`, JSON.stringify(row), { ex: 300 }); // ③ 回填+TTL
  return row;
}

async function updateProduct(id: string, patch: object) {
  await db.update(id, patch);                    // ① 先更新数据库
  await cache.del(`p:${id}`);                    // ② 再删缓存(不是改缓存!)
}
// 为什么删而不是更新:并发写时「更新缓存」可能把旧值写在后头盖掉新值;
// 删除让下一次读走库回填,天然拿到最新值(懒加载思想)

14.2 动手演示:请求到底走了哪条路

HANDS-ON DEMO
缓存读路径模拟器
场景:热门商品 P1 已在缓存。点按钮观察三种请求的路径与数据库压力;试试连点「幽灵商品」,再开启防御对比效果。

14.3 三大敌人对症表

问题现象根因解法
穿透查「不存在的数据」每次都打库缓存与库都没有 → 永不回填空值缓存(短 TTL)/ 布隆过滤器 / 参数校验
击穿某热 key 过期瞬间并发全打库热点 + 过期 + 并发重建互斥重建(只放一个请求查库)/ 热点永不过期+异步刷新
雪崩大批 key 同时失效或缓存整体宕机TTL 集中到期 / 单点TTL 加随机抖动 / 多级缓存 / 集群高可用 / 限流兜底
⚠ 高频陷阱:先删缓存再更新库
错误姿势:写请求先 cache.del 再 db.update,两步之间一个读请求进来 → 后果:读请求把旧值回填进缓存,之后长期读到脏数据(直到 TTL)。正确姿势:先更新库,再删缓存(Cache-Aside 标准序);对一致性要求更高再加延迟双删或订阅 binlog 删缓存。
✓ 记忆口诀
「读:缓存→库→回填;写:改库→删缓存。穿透防空值,击穿防重建,雪崩防齐刷。」缓存不是数据库的替代,是数据库的保镖。

14.4 随堂自测

QUIZ 1
攻击者用随机不存在的商品 ID 疯狂请求接口,数据库被打挂。这是哪类问题、首选对策?
数据本身不存在 → 缓存永远不命中、永远查库,是穿透。空值缓存(存 null 短 TTL)或布隆过滤器(不存在则直接拒绝)都能挡住。TTL 抖动治雪崩、互斥重建治击穿,都对不上症。
QUIZ 2
Cache-Aside 写路径为什么推荐「更新库后删缓存」而不是「更新库后改缓存」?
两个写请求 A(新)、B(旧) 交错时,「改缓存」的到达顺序可能与数据库提交顺序相反,旧值笑到最后。删除是幂等且无值的操作,不存在覆盖问题——这就是「懒加载优于主动推」的原因。
CHAPTER 15 · 分布式与实战

高可用:限流、熔断与降级

一句话总览:高可用不是「不坏」,而是「坏一部分时整体还能用」——冗余消灭单点,超时+重试上限止损,限流保入口、熔断断坏依赖、降级弃车保帅,四件套拦住故障的连锁放大。
⚡
生活化类比
家里的保险丝/空气开关就是熔断器:某个电器短路(下游服务故障),开关立刻跳闸(快速失败),保住整屋电路不被烧毁(调用方线程池不被拖死)。过一会儿你试探性合闸(半开态放一个探测请求):电器修好了就恢复供电(闭合),还短路就再跳(重新打开)。类比边界:保险丝靠物理熔断一次性报废,软件熔断器是状态机,能自动探测自动恢复——下面的演示就是这个过程。

15.1 故障是怎么放大的(雪崩效应)

一个慢依赖拖死整条链:没有超时与熔断的连锁反应
④ 网关排队 用户全站超时 ③ 订单线程池耗尽 每个请求都在傻等 ② 无超时地调用 还叠加无脑重试×3 ① 积分服务变慢 P99: 50ms → 8s 阻断链条:超时 200ms + 重试≤1 次(带退避) + 熔断快速失败 + 积分展示降级为「稍后到账」
为什么慢比挂更可怕:挂了立刻报错释放线程;慢让每个调用都占着线程等资源,耗尽只是时间问题。

15.2 动手演示:熔断器状态机

HANDS-ON DEMO
熔断器三态模拟器(阈值:连续 3 次失败)
场景:订单服务调用积分服务。先连发失败请求看跳闸;打开状态下请求被直接拒绝;点「冷却时间到」进入半开试探,再决定恢复还是重新跳闸。

15.3 四件套各司其职

手段保护谁机制关键点
冗余+故障转移整体服务多副本/多可用区,探活切换副本要真独立(别同机架同电源)
限流自己(入口)令牌桶/滑动窗口,超量拒绝或排队阈值来自压测,不是拍脑袋
熔断自己(出口)失败率超阈值→快速失败→半开探测按依赖粒度熔断,别一刀切全局
降级核心业务关掉/简化非核心功能提前设计好降级文案与兜底数据
舱壁隔离其他业务线程池/连接池按依赖分组积分慢了只耗尽积分池,不拖累支付池
⚠ 高频陷阱:无脑重试放大故障
错误姿势:下游变慢,上游超时后立刻重试 3 次,上游的上游也重试 3 次 → 后果:下游收到 9 倍流量,本来只是慢,直接被重试洪峰彻底打死。正确姿势:重试≤1 次 + 指数退避加抖动 + 只重试幂等操作 + 熔断打开时禁止重试;整条链路只允许一层重试。
✓ 记忆口诀
「入口限流保自己,出口熔断防拖累,降级弃车保元帅,冗余兜底防单点。」大促前演练:拔网线、杀进程、注入 8s 延迟,看四件套是否真的接得住。

15.4 随堂自测

QUIZ 1
熔断器处于「打开」状态时,调用方发请求会发生什么?
打开态的意义就是「快速失败」:不再浪费线程和连接去撞一个已知坏掉的依赖,立刻走降级逻辑。排队会积压资源违背初衷;等冷却期到才放一个探测请求(半开)试探恢复。
QUIZ 2
大促峰值流量超出系统压测容量,「限流」和「降级」的正确配合是?
限流管「进来多少」(入口数量控制),降级管「进来之后服务什么质量」(功能取舍),两者正交互补。扩容有上限与成本,且突发流量秒级到达、扩容分钟级生效,限流仍是最后保险。
CHAPTER 16 · 分布式与实战

架构决策与演进实战

一句话总览:架构能力最终落在三件日常事上——用 ADR 把决策连同理由留档、尊重康威定律让组织与架构对齐、用小步演进(绞杀者模式)替换而不是推倒重来。
🧭
生活化类比
老小区改造:推倒重建(大重写)要全员搬走三年、预算翻倍、交房即过时;逐栋翻新(绞杀者模式)先改水电最烂的一栋,住户边住边改,新栋验收入住一栋,老栋退一栋。ADR 就是改造方案公示牌:为什么这栋先改、当时比较过哪些方案、谁拍的板——三年后接手的人不用靠猜。类比边界:楼翻新期间住户忍一忍就行,系统替换期间新旧两套要并行运行+数据双写对账,工程上更精细。

16.1 ADR:给决策拍照留底

adr-007-order-inventory-consistency.md
# ADR-007: 订单与库存采用 Saga 最终一致,放弃分布式事务
状态: 已接受 | 日期: 2026-11-20 | 决策人: 架构组+订单/库存负责人

## 背景
大促峰值 2000 TPS;2PC 压测仅 300 TPS 且锁等待超时频发。

## 备选方案
A. 2PC/XA     —— 强一致,但吞吐不达标(否决)
B. TCC        —— 吞吐可行,但三接口改造量 6 人月(暂缓)
C. Saga+对账  —— 最终一致,改造 2 人月(✓ 选定)

## 决策与代价
选 C。接受最长 5s 的库存中间态;补偿幂等 + 每 10min 对账兜底;
产品侧配合「库存确认中」文案。若未来出现资金级一致性需求,
在支付子域单独升级 TCC(见 ADR-009 预留)。

## 后果
+ 峰值吞吐 2200 TPS 达标   - 新增对账系统与补偿测试负担
ℹ ADR 的灵魂是「记否决理由」
半年后有人问「为什么不用 2PC?」——没有 ADR,团队会重新吵一遍甚至真去改成 2PC;有 ADR,直接看当时的压测数据和否决理由。决策可以过时,但推理过程永远值钱。状态流转:提议 → 接受 → 废弃/被替代(链接新 ADR)。

16.2 康威定律与演进节奏

原则内容实操
康威定律系统结构复制组织沟通结构想要什么架构,先调团队边界(逆康威操作)
演进式架构架构随需求持续小步调整每次迭代允许偿还一点结构债,别攒到「大重构」
适应度函数把架构目标变成自动化检查CI 里跑:依赖方向检查、P99 压测门禁、契约测试
绞杀者模式新系统逐步包住并替换旧系统网关按路由切流:新接口走新服务,旧接口留旧系统,逐条迁移
绞杀者模式:流量逐步改道,旧系统自然枯死
网关/路由层 按接口逐条切流 新服务(已迁移接口) 订单查询 ✓ 订单创建 ✓ 退款 … 旧单体(剩余接口) 流量越来越少 → 最终下线 迁移期安全网 新旧并行跑 + 结果比对(影子流量) 数据双写 + 对账 每步可一键回切旧路由 反模式:憋两年「全新 2.0」一次性切换 —— 切换日=事故日
为什么小步替换赢大重写:每一步都可验证、可回滚,业务不停摆,需求还在变时不会追不上。
⚠ 高频陷阱:大爆炸式重写(Big Bang Rewrite)
错误姿势:冻结旧系统需求,全团队闭关一年写「2.0」→ 后果:一年后旧系统又多了一年业务逻辑没同步,新系统上线即落后,切换日全网事故,历史上此类项目失败率极高。正确姿势:绞杀者模式——先迁收益最高/风险最小的接口,影子流量比对,随时可回切;重写冲动出现时,先问「能不能局部演进解决?」
✓ 全课收官口诀
「难改的决策慎重做(ADR),边界跟着业务走(DDD/康威),一致性按场景选(CAP/Saga),坏了也要能用(四件套),演进永远小步跑(绞杀者)。」——架构没有终点,只有下一次权衡。

16.3 随堂自测

QUIZ 1
ADR 里最有长期价值的部分是?
结论会过时,但「当时为什么这么选、否掉了什么」能防止后人重复争论或盲目翻案,也帮新人在约束变化时判断决策是否该更新。这正是 ADR 区别于普通会议纪要的价值。
QUIZ 2
公司想要「订单、库存各自独立部署的微服务」,但两个团队一直合坐一个大组、统一排期统一发版。按康威定律最该先做什么?
统一排期统一发版的组织,拆出来的服务仍会被流程绑成「分布式大泥球」。康威定律说系统结构复制沟通结构——想要目标架构,先让组织长成那个形状,这就是逆康威操作。