完整架构:秒杀系统的最终架构图

回顾:我们走过了怎样的旅程?🎬

经过前面六章的学习,我们已经掌握了秒杀系统的各个核心模块。现在,让我们把这些拼图组合起来,看看最终的完整架构是什么样子的!🚀


完整架构图 🏗️

架构演进

秒杀系统架构演进

V1.0 - 基础架构

最简单的三层架构,直接访问数据库

用户层

用户请求用户

Web / App / 小程序

应用层

应用服务器服务

处理业务逻辑

数据层

MySQL存储

订单、库存数据


核心流程详解 🔄

架构图是静态的,流程才是动态的。下面把三条主链路拆开讲——它们分别对应架构图里的三个服务层节点:秒杀服务、Redis 集群、Kafka + 订单服务。

1. 秒杀请求处理流程

一个请求从用户手指落到屏幕上,到拿到”锁定名额”的答复,中间经过了 7 段:

① CDN           活动页静态资源(HTML/JS/CSS)直接命中边缘节点,不回源
       ↓
② Nginx LB      4 台,按轮询把流量分给 9 台 API Gateway
       ↓
③ API Gateway   限流检查(Redis 令牌桶)→ 黑名单检查(Redis)→ JWT 鉴权
       ↓        任何一步不通过都在这里返回,请求不进入业务层
④ 反欺诈系统   设备指纹查 Redis → 行为特征实时计算 → 风险评分
       ↓        高风险请求直接判定为「疑似机器」,不进入秒杀服务
⑤ 秒杀服务     库存预检查(Redis GET)→ 库存扣减(Redis Lua 脚本)
       ↓        → 发送消息(Kafka)
⑥ Kafka        3 个 Broker,订单请求在这里排队等待消费
       ↓
⑦ 订单服务     消费消息:幂等校验 → 创建订单(MySQL)→ 扣减 MySQL 库存
       ↓
   返回用户     "您已成功锁定名额,请在 5 分钟内完成支付"

关键点有四个:

  • 第 ③ 步是整条链路的分水岭。库存只有 100 件,50 万个请求里有 49.99 万个注定失败。限流、黑名单、鉴权都在这里做判断,目的就是让这些请求在进入业务层之前就返回。业务层的机器数是按”真正需要处理的请求”来配的。
  • 第 ④ 步是可选的、但不能省。反欺诈系统不是主链路上的同步依赖,它只读 Redis 里的设备指纹和在线计算的轻量特征,单次开销在毫秒级以内。把它做成同步步骤,是为了在”黄牛账号”消耗掉真实用户的资格之前就拦下来。
  • 第 ⑤ 步是全链路唯一有状态的地方。库存判定和扣减都在一次 Redis 脚本里完成,其余步骤都可以横向扩容、无状态。
  • 第 ⑥ 步之后,请求已经和用户解绑了。用户拿到的是”锁定名额”而不是”订单已创建”,真正的订单落库是异步完成的。

各环节的延迟预算(P99):

环节耗时累计
Nginx + 网关(限流/鉴权/黑名单)~5ms5ms
反欺诈评分~3ms8ms
Redis 库存预检查 + Lua 扣减~2ms10ms
Kafka 写入~3ms13ms
网络返回~5ms~18ms

这 18ms 就是用户实际等待的时间。订单真正落库还要再晚几十到几百毫秒,但用户不需要等它——这是第 3 个决策(混合模式)换来的收益。

2. 库存扣减流程

库存扣减是整个系统里唯一不允许出错的操作,它被拆成”一次原子操作 + 两道防线”。

第一步:Redis 原子扣减(第一道防线,事前)

秒杀服务收到请求 { productId: 1001, userId: 8823, quantity: 1 }
      ↓
① 预检查:GET stock:1001
      ├─ key 不存在 → 活动未预热 / 已结束 → 返回"活动不可用"
      └─ 存在 → 继续
      ↓
② 原子扣减:EVALSHA deduct.lua stock:1001 {1001} 1
      ↓   脚本内部(单线程,不可被打断):
      │   stock = GET stock:1001
      │   if not stock then return -1 end
      │   if stock < 1 then return 0 end        -- 售罄
      │   DECRBY stock:1001 1
      │   SET deduct:flow:{orderId} ... EX 3600  -- 扣减流水
      │   return stock - 1
      │
      ├─ 返回 0  → 已售罄 → 返回用户"手慢了,已售罄"
      ├─ 返回 -1 → 异常 → 返回"活动异常,请稍后再试"
      └─ 返回 >0 → 扣减成功,进入第二步

第 ② 步里的 deduct:flow:{orderId} 是扣减流水——它记录了”这次扣减属于哪个订单”,是后续异步落库和对账的依据。把它写在同一个脚本里,是因为”扣减”和”记账”必须同时成功或同时不存在。

第二步:异步落库(第二道防线,事中)

Kafka 消息 { orderId, productId, userId, quantity }
      ↓
消费端幂等校验:订单号是否已存在?
      ↓
事务内:
  UPDATE product SET stock = stock - 1 WHERE id = ? AND stock >= 1
  INSERT INTO orders (order_id, ...) VALUES (...)   -- 唯一索引,重复则回滚
COMMIT
      ↓
影响行数为 0 → 说明 Redis 与 MySQL 的库存已经不一致
             → 订单不成立 → 触发补偿,把多扣的库存还回去(见 6.2 节)

WHERE stock >= 1 这一行不能省。 Redis 扣减和 MySQL 扣减之间隔着消息队列,只要有一次消息丢失、一次消费失败,两边就会对不上。MySQL 侧的条件更新是独立成立的第二道防线——即使 Redis 侧出了问题,货也发不出去。

第三步:对账收敛(第三道防线,事后)

定时任务比对 Redis 预扣总量与 MySQL 实际销量,发现差异就修复并告警(见 6.2 节)。前两道防线是”事前”和”事中”,这一道是”事后”兜底——三者缺一不可。

3. 异步订单创建流程

订单创建被整体搬到了 Kafka 消费者侧,主链路只负责”锁定资格”。

① 消费消息
   ↓
② 幂等校验
   查 orders 表:order_id 是否已存在?
   ├─ 存在 → 已处理过 → 直接 ACK 消息,跳过(幂等)
   └─ 不存在 → 继续
   ↓
③ 事务内写库
   BEGIN
     UPDATE product SET stock = stock - 1 WHERE id = ? AND stock >= 1
     INSERT INTO orders (order_id, user_id, product_id, quantity, status)
     VALUES (?, ?, ?, 1, 'PENDING')
   COMMIT
   ↓
   ├─ 插入冲突(唯一索引)→ 事务回滚 → 视为重复消息,直接 ACK
   └─ 影响行数为 0 → 库存不足 → 走补偿流程
   ↓
④ 发送通知
   消息推送:短信/APP Push,告知"订单已创建,请尽快完成支付"
   ↓
⑤ 支付与超时释放
   支付成功 → 订单状态 PENDING → PAID
   超过 5 分钟未支付 → 订单关闭 → 库存回补(回补同样要幂等)

这条流程里有三个必须做到位的点:

  • 幂等靠订单号唯一索引。消费者可能因为网络抖动或重启重复消费同一条消息,靠 order_id 的唯一索引让第二次插入直接失败并回滚,库存不会被扣第二次。
  • 失败路径和成功路径一样重要。消费失败不 ACK,让消息重回队列并退避重试;重试次数用完就进死信队列并告警,而不是静默丢弃。
  • 订单状态要有明确的终态。PENDING → PAID / CLOSED 是必备的状态机,超时释放和支付回调都可能并发到达,状态判断必须原子化。

这条链路上还有一个容易被忽略的消费者:Kafka 消费积压。如果消费速度跟不上生产速度,订单创建会整体延迟,用户收到”已锁定名额”的提示,却迟迟看不到订单。监控上必须盯住消费延迟(lag),它比 CPU、内存更早暴露问题。


数据流向图 📊

用户请求
   │
   ▼
┌──────────────────────────────────────────┐
│  CDN (静态资源直接返回)                   │
└──────────────────────────────────────────┘
   │
   ▼
┌──────────────────────────────────────────┐
│  Nginx (负载均衡)                         │
└──────────────────────────────────────────┘
   │
   ▼
┌──────────────────────────────────────────┐
│  API Gateway                             │
│  ├─ 限流检查 → Redis                     │
│  ├─ 黑名单检查 → Redis                   │
│  └─ 鉴权 → JWT                           │
└──────────────────────────────────────────┘
   │
   ▼
┌──────────────────────────────────────────┐
│  反欺诈系统                               │
│  ├─ 设备指纹 → Redis                     │
│  ├─ 行为分析 → 实时计算                   │
│  └─ 风险评分                             │
└──────────────────────────────────────────┘
   │
   ▼
┌──────────────────────────────────────────┐
│  秒杀服务                                 │
│  ├─ 库存预检查 → Redis                   │
│  ├─ 库存扣减 → Redis (Lua 脚本)          │
│  └─ 发送消息 → Kafka                     │
└──────────────────────────────────────────┘
   │
   ▼
┌──────────────────────────────────────────┐
│  Kafka (消息队列)                        │
└──────────────────────────────────────────┘
   │
   ▼
┌──────────────────────────────────────────┐
│  订单服务 (Consumer)                      │
│  ├─ 创建订单 → MySQL                     │
│  ├─ 扣减库存 → MySQL (乐观锁)            │
│  └─ 发送通知 → 消息推送                   │
└──────────────────────────────────────────┘
   │
   ▼
用户收到结果

系统容量规划 📈

服务器配置

组件数量配置用途
Nginx4 台8C16G负载均衡
API Gateway9 台8C16G网关服务
秒杀服务10 台16C32G核心业务逻辑
商品服务5 台8C16G商品查询
用户服务5 台8C16G用户信息
Redis Master3 台16C64G主节点
Redis Slave3 台16C64G从节点
MySQL Master3 台32C128G主库
MySQL Slave3 台32C128G从库
Kafka Broker3 台16C64G消息队列

性能指标

指标目标值说明
QPS100,000+峰值处理能力
P99 延迟< 100ms99% 请求在 100ms 内返回
可用性99.99%年停机时间 < 53 分钟
库存准确率100%零超卖
反欺诈准确率> 95%黄牛识别率

关键技术栈 🛠️

配置要点

  • 配置表达的是环境差异和运行参数,不是业务规则本身。
  • 队列、缓存、存储和服务参数决定系统在高峰期的缓冲能力。

想一想

问题 1:如果 Redis 集群宕机,系统还能工作吗?

点击查看答案

降级策略:

  1. 本地缓存兜底(Guava Cache / Caffeine)
  2. 直接查数据库(性能下降,但可用)
  3. 限流更严格(保护数据库)
  4. 页面提示”系统繁忙,请稍后再试”

核心原则:保证可用性 > 保证性能

问题 2:如何保证 Redis 和 MySQL 的库存一致性?

点击查看答案

最终一致性方案:

  1. Redis 先扣减(快速响应用户)
  2. 异步消息同步到 MySQL
  3. 定时对账任务检查差异
  4. 发现不一致时,以 MySQL 为准回滚

关键点:允许短暂不一致,但最终必须一致

问题 3:如果秒杀流量超过预期 10 倍,怎么办?

点击查看答案

应急方案:

  1. 立即启动更严格的限流(降级到 1 万 QPS)
  2. 静态页面直接返回”已售罄”(如果库存已完)
  3. 关闭非核心功能(评论、推荐等)
  4. 扩容(如果有预留资源)
  5. 启用备用集群(如果有灾备)

预防方案:

  1. 提前压力测试,了解系统上限
  2. 预留 50% 以上的资源余量
  3. 制定详细的应急预案

发现内容有问题?

告诉我们哪里需要改进。