知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 39 - 订单系统核心设计 > 导读:本文用一问一答的方式拆解"设计一个高可用订单系统"这道系统设计题——订单状态机、下单幂等、分库分表、订单号生成。适合准备后端面试、或正在搭建交易链路的工程师阅读。 ## 一、先建立全局认知 ### Q:一个百万级订单系统,难点到底在哪? A:结论:难点可以收敛为四件事——状态流转复杂、下单要幂等、数据量大、订单号要好用。 场景:电商平台日均百万订单,需要设计一个高可用的订单系统。核心挑战: ```text 1. 订单状态流转复杂:待支付 → 已支付 → 已发货 → 已完成 → 已关闭(还有退款、取消等分支) 2. 幂等问题:用户重复点击下单,不能创建多个订单 3. 数据量大:单表千万级,查询变慢 4. 订单号要求:全局唯一、趋势递增、不暴露业务信息 ``` ### Q:这四个挑战分别落在系统的哪一层解决? A:结论:前两个是"业务正确性"问题,在应用层用状态机和幂等控制解决;后两个是"规模"问题,在存储与 ID 生成层用分库分表和订单号编码解决。 - 状态流转复杂 → 订单状态机(定义合法转换 + 乐观锁)。 - 下单幂等 → Token 机制或数据库唯一索引。 - 数据量大 → 分库分表 + 异构索引/ES 支撑跨分片查询。 - 订单号要求 → 时间戳 + 机器 ID + 序列号 + 用户标识的编码方案。 ## 二、理解核心机制 ### Q:订单状态为什么必须用状态机来约束? A:结论:订单状态会被支付、发货、退款等多个模块改写,用状态机把"哪些流转合法"集中定义,并在更新时用 `WHERE status=原状态` 的乐观锁拦住并发跳跃。 术语:订单状态机指用一组"合法的状态 + 允许的流转"约束订单字段,把非法跳转挡在业务层。先看状态定义: ```java public enum OrderStatus { CREATED(0, "待支付"), PAID(1, "已支付"), SHIPPED(2, "已发货"), COMPLETED(3, "已完成"), CANCELLED(4, "已取消"), REFUNDING(5, "退款中"), REFUNDED(6, "已退款"); private final int code; private final String desc; } ``` 状态流转规则(只允许合法的转换):  *图:订单状态之间的合法转换关系* ```text CREATED → PAID(支付成功) CREATED → CANCELLED(超时未支付 / 用户取消) PAID → SHIPPED(商家发货) PAID → REFUNDING(用户申请退款) SHIPPED → COMPLETED(用户确认收货) REFUNDING → REFUNDED(退款成功) REFUNDING → PAID(退款拒绝) ``` ```java public class OrderStateMachine { // 合法的状态转换表 private static final Map<OrderStatus, Set<OrderStatus>> TRANSITIONS = Map.of( OrderStatus.CREATED, Set.of(OrderStatus.PAID, OrderStatus.CANCELLED), OrderStatus.PAID, Set.of(OrderStatus.SHIPPED, OrderStatus.REFUNDING), OrderStatus.SHIPPED, Set.of(OrderStatus.COMPLETED), OrderStatus.REFUNDING, Set.of(OrderStatus.REFUNDED, OrderStatus.PAID) ); public static boolean canTransit(OrderStatus from, OrderStatus to) { Set<OrderStatus> allowed = TRANSITIONS.get(from); return allowed != null && allowed.contains(to); } // 状态变更:校验 + 更新(带乐观锁) public boolean transitStatus(Long orderId, OrderStatus from, OrderStatus to) { if (!canTransit(from, to)) { throw new IllegalStateException("非法状态转换: " + from + " → " + to); } // UPDATE orders SET status=#{to} WHERE order_id=#{orderId} AND status=#{from} int rows = orderMapper.updateStatus(orderId, from.getCode(), to.getCode()); return rows > 0; // rows=0 说明状态已被其他线程改变 } } ``` 关键:`WHERE status=#{from}` 是乐观锁,防止并发状态跳跃。 设计要点: - 校验和更新为什么都要有条件?`canTransit` 在应用层用内存表挡住非法流转;但两个线程可能同时读到相同的 `from`,因此数据库还要用 `WHERE status=#{from}` 兜底——只有一个线程能把行改成 `to`,另一个 `rows=0`。 - 状态机 CAS vs 加锁:这里用"带原状态条件的更新"实现 CAS(Compare-And-Swap,比较并交换),不占锁、吞吐好;冲突频繁时需业务重试。若改用悲观锁(`SELECT ... FOR UPDATE`),能保证顺序但会占用数据库连接与锁资源。 - 代价:状态用整型 code 存储,可读性差,需要保证枚举与 code 的映射一致。  [编辑 Excalidraw 源图](/images/java-interview-copy/system-design/39-design-order-system-design-order-system-state-machine-diagram.excalidraw) ### Q:下单为什么会重复,怎么保证幂等? A:结论:重复来自"用户重复点击 / 网络重试",主流有两条路——Token 机制(一次性令牌)和唯一索引(业务去重键),前者通用,后者靠数据库兜底。 ```java @Service public class OrderService { // 方案一:Token 机制 public String generateToken(Long userId) { String token = UUID.randomUUID().toString(); redis.opsForValue().set("order:token:" + userId, token, 15, TimeUnit.MINUTES); return token; } public Order createOrder(Long userId, String token, OrderDTO dto) { // 1. 校验并删除 Token(原子操作) String script = "if redis.call('GET',KEYS[1]) == ARGV[1] then " + "return redis.call('DEL',KEYS[1]) else return 0 end"; Long result = redis.execute(new DefaultRedisScript<>(script, Long.class), List.of("order:token:" + userId), token); if (result == 0) { throw new BizException("请勿重复提交"); } // 2. 创建订单 Order order = buildOrder(userId, dto); orderMapper.insert(order); return order; } // 方案二:唯一索引(业务去重键) // 表中加唯一索引:UNIQUE KEY uk_biz_key (user_id, product_id, create_date) // 插入时捕获 DuplicateKeyException } ``` 设计要点: - Token 为什么用 Lua 脚本"校验 + 删除"?跟分布式锁同理——判断和删除必须原子,否则两个并发请求可能都读到同一个 token、都通过校验,幂等就失效了。token 是"一次有效"的,用过即焚。 - Token 为什么设 15 分钟过期?给用户一个合理的填写表单时间窗,过期未提交则 token 失效,避免旧 token 长期有效。 - 唯一索引方案的定位:不依赖 Redis,用数据库保证"同一用户 + 同一商品 + 同一天"只落一条订单,插入冲突时捕获 `DuplicateKeyException`。代价是去重维度被索引写死,不如 Token 灵活。 ### Q:单表千万级怎么扛?分片策略怎么定? A:结论:单表超过 2000 万行时考虑分库分表,按 user_id 分片,保证"同一用户的订单落在同一分片",避免跨库查询。 ```text 分片策略:按 user_id 分片(同一用户的订单在同一库/表) 分 4 库 × 8 表 = 32 张表 库路由:user_id % 4 → 决定在哪个库 表路由:user_id / 4 % 8 → 决定在哪张表 ``` ```java // ShardingSphere 分片配置示例 public class OrderShardingAlgorithm implements PreciseShardingAlgorithm<Long> { @Override public String doSharding(Collection<String> availableTargetNames, PreciseShardingValue<Long> shardingValue) { Long userId = shardingValue.getValue(); // 按 user_id 取模路由 String suffix = String.valueOf(userId % availableTargetNames.size()); for (String name : availableTargetNames) { if (name.endsWith(suffix)) { return name; } } throw new IllegalArgumentException("No target found"); } } ``` 分库分表后的查询问题: | 查询场景 | 方案 | |---------|------| | 按 user_id 查(买家查订单) | 直接路由到对应分片,高效 | | 按 order_id 查 | 订单号中嵌入 user_id 信息,或维护映射表 | | 按商家查(卖家查订单) | 异构索引:同步一份按 seller_id 分片的表 | | 后台运营查询 | 同步到 ES,走搜索引擎 | 设计要点: - 为什么按 user_id 而不是 order_id 分片?买家最常用的查询是"我的订单列表",按 user_id 分片能让这类查询精准路由到单个分片。术语:分片键(sharding key)就是决定数据落在哪个库/表的字段。 - 跨分片查询的代价:按卖家、按后台运营维度查询会打散到所有分片,因此要额外维护异构索引(按 seller_id 重新分片的冗余表)或同步到 ES。 - 分片数量怎么定?原文给出 4 库 × 8 表 = 32 张表作为示例;实际数量需结合数据增长速度和单表容量上限评估,属于需要提前预留扩容空间的设计(需结合业务量确认)。 ### Q:订单号怎么设计才能"全局唯一、趋势递增、不暴露业务"? A:结论:用"时间 + 机器 + 序列号 + 用户标识"拼装,天然趋势递增、可反推分片,同时不暴露自增订单量。 ```java /** * 订单号规则:时间 + 机器 + 序列号 + 用户标识 * 格式:yyyyMMddHHmmss(14位)+ 机器ID(2位)+ 序列号(4位)+ userId后2位 * 总共 22 位数字 */ public class OrderIdGenerator { private final AtomicInteger sequence = new AtomicInteger(0); private final int machineId; public OrderIdGenerator(int machineId) { this.machineId = machineId; } public String generate(Long userId) { String time = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMddHHmmss")); int seq = sequence.getAndIncrement() % 10000; String userSuffix = String.format("%02d", userId % 100); return String.format("%s%02d%04d%s", time, machineId, seq, userSuffix); } } ``` 订单号设计要点: - 趋势递增:方便数据库索引,插入性能好。 - 包含时间:方便按时间范围查询和排序。 - 包含用户标识(后几位):分库分表时可以从订单号反推分片。 - 不用自增 ID:避免暴露订单量等业务信息。 补充说明: - 为什么"趋势递增"对数据库友好?自增类主键在 B+ 树索引上是顺序插入,页分裂少、写入快;完全随机的 ID 会导致索引页频繁分裂。 - 局限:序列号依赖单机 `AtomicInteger`,进程重启或同一秒内机器 ID 冲突时可能重号;生产上常改用 Snowflake(雪花算法)一类带机器位与时钟的算法,这里保留原文的编码思路(属常见实践,非原文结论)。 ## 三、放进真实场景 ### Q:分库分表之后,跨库事务怎么办? A:结论:优先通过"按 user_id 分片"把事务收敛到单库,尽量避免跨库事务;确实无法避免时用柔性事务。 尽量避免跨库事务。如果必须,可以用柔性事务: 1)TCC 模式(Try-Confirm-Cancel,两阶段预留/确认/取消); 2)本地消息表 + MQ 最终一致性; 3)Seata AT 模式(自动补偿)。 ### Q:订单超时未支付,怎么自动取消? A:结论:延迟队列 + 定时扫描双保险。 1)延迟队列(RocketMQ 延迟消息 / Redis 过期键通知 / 时间轮); 2)定时任务扫描(兜底方案)。 推荐延迟队列 + 定时扫描双保险。 设计要点: - 为什么要有"兜底扫描"?延迟消息可能因消息丢失、消费失败而漏掉,定时扫描按时间范围扫"超时仍在待支付"的订单,把漏网之鱼捞回来。 - 取消时同样要走状态机:只有 `CREATED → CANCELLED` 是合法的,避免把已支付订单误取消。 ## 四、总结与自测 ### Q:面试里怎么答这道题? A:四点收口: 1. 状态机:定义合法的状态转换表,用 `WHERE status=原状态` 乐观锁防止并发状态跳跃。 2. 幂等:Token 机制(进入页面获取 Token,提交时原子校验删除)或数据库唯一索引去重。 3. 分库分表:按 user_id 分片保证同一用户数据在同一分片;跨分片查询走异构索引或 ES。 4. 订单号:时间戳 + 机器 ID + 序列号 + 用户标识,趋势递增且可反推分片。 ### Q:如果让你把状态机和幂等"合二为一"地讲,怎么串起来? A:结论:两者回答的是同一个问题——"同一次业务动作被重复或并发触发时,如何只生效一次"。 - 幂等针对"同一个请求重复到达":用 Token 或唯一索引让第二次请求直接失败/返回已有结果。 - 状态机针对"同一个订单被并行改写":用 `WHERE status=原状态` 让第二个并发改动落空。 两者叠加,才构成下单链路完整的并发正确性防线。 ## 自测 1. 订单状态机的乐观锁为什么写成 `WHERE status=原状态`,而不是只写 `WHERE order_id=?`? 2. Token 机制和唯一索引两种幂等方案各自的适用场景与代价是什么? 3. 按 user_id 分片后,"卖家查订单"和"后台运营查订单"分别怎么解决?
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入