知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 接口幂等性设计 > 导读:用一个"支付按钮被点了两次"的场景,讲清接口幂等性是什么、为什么一定会遇到、五种落地方案各适合什么场景,以及支付链路里怎么分层兜底。适合正在准备后端面试、或正在设计下单/支付/消息消费类接口的同学阅读。 ## 一、先建立全局认知 ### Q:什么是幂等性?哪些操作天生幂等,哪些不是? A:**幂等性指同一个操作执行多次,结果和执行一次相同。** 判断一个接口要不要做防重,第一步就是看它是否天生幂等。 - 天然幂等的操作: GET 查询:多次查询结果相同 DELETE 删除:删除后再删除,结果还是不存在 PUT 更新(覆盖):多次设置同一个值,结果相同 - 非幂等的操作: POST 创建:多次创建会产生多条记录 扣款/转账:多次执行会多次扣款 发送消息:多次发送会收到多条消息 > 一句话记法:**查询、删除、整体覆盖天然幂等;创建、累加/扣减、发消息都不幂等**,必须额外设计。 ### Q:为什么支付、下单这类接口一定要做幂等?不做会怎样? A:因为"同一个请求到达两次"在分布式系统里是常态,而不是异常。常见来源有四类: - **客户端重试**:网络超时后前端或网关自动重试,用户点一次按钮,服务端收到两次。 - **用户重复点击**:接口响应慢,用户手动连点。 - **消息重复投递**:MQ 为了不丢消息,通常采用"至少一次"投递语义,消费端就可能收到重复消息。 - **上游重试**:调用方(网关、定时任务、其他服务)调用失败后重试。 不做幂等保护的直接后果就是重复扣款、重复下单、重复发券。**面试里最典型的问法就是:用户点击支付按钮,网络超时后重试,如何防止重复扣款?** 下面几个方案都是围绕这个问题展开的。 ## 二、理解核心机制 ### Q:方案一:数据库唯一键——什么样的场景最适合它?怎么落地? A:**结论:只要业务本身有天然的唯一键(如订单号、流水号),数据库唯一键就是成本最低、最可靠的方案,应当优先考虑。** 做法是加唯一索引,插入时捕获唯一键冲突,并把冲突当作"已成功"处理。 ```java // 订单表加唯一索引 CREATE TABLE orders ( id BIGINT PRIMARY KEY, order_no VARCHAR(64) UNIQUE, -- 业务唯一键 user_id BIGINT, amount DECIMAL(10,2), status TINYINT ); // 插入时捕获唯一键冲突 public boolean createOrder(Order order) { try { orderMapper.insert(order); return true; } catch (DuplicateKeyException e) { // 唯一键冲突,说明是重复请求,直接返回成功 log.info("重复请求,订单已存在: {}", order.getOrderNo()); return true; } } ``` **关键点**:冲突时返回"成功"而不是"失败",因为对调用方来说目标状态(订单已存在)已经达成,这本身符合幂等语义。 **适用场景**:创建类操作,且有天然的业务唯一键(如订单号)。 **代价**:唯一键规则要由业务保证;它只能覆盖"插入"这一种重复形态,非插入类的重复请求要靠别的方案。 ### Q:方案二:Token 机制——完整流程是什么?为什么校验必须用 Lua? A:**结论:Token 机制把"防重判断"提前到业务执行之前,适合前端表单提交、下单按钮这类可配合前端的场景。** ```text 流程: 1. 前端请求接口前,先调用"获取 Token"接口 2. 服务端生成唯一 Token,存入 Redis(设置过期时间) 3. 前端将 Token 放在请求头中 4. 服务端处理请求时,先验证并删除 Token(原子操作) 5. Token 不存在 → 重复请求,拒绝 6. Token 存在 → 首次请求,处理并删除 Token ``` ```mermaid sequenceDiagram autonumber participant C as 前端客户端 participant S as 业务服务 participant R as Redis participant B as 业务逻辑 C->>S: 请求获取 Token S->>R: SET idempotent:token:{token}(TTL 5 分钟) R-->>S: 写入成功 S-->>C: 返回唯一 Token C->>S: 提交请求(请求头携带 Token) S->>R: Lua:原子校验并删除 Token alt Token 存在 R-->>S: 返回 1(首次请求) S->>B: 执行业务逻辑 B-->>S: 处理完成 S-->>C: 返回成功结果 else Token 不存在或已过期 R-->>S: 返回 0(重复请求) S-->>C: 拒绝请求或返回重复提交提示 end ``` ```java // 获取 Token public String getToken(String userId) { String token = UUID.randomUUID().toString(); redis.set("idempotent:token:" + token, userId, 300); // 5 分钟有效 return token; } // 处理请求(Lua 脚本保证原子性) public boolean processRequest(String token, Runnable business) { String luaScript = """ if redis.call('exists', KEYS[1]) == 1 then redis.call('del', KEYS[1]) return 1 else return 0 end """; Long result = redis.eval(luaScript, 1, "idempotent:token:" + token); if (result == 0) { throw new RuntimeException("重复请求,Token 已失效"); } business.run(); // 执行业务逻辑 return true; } ``` **为什么用 Lua 脚本?** `exists` 和 `del` 两步操作必须是原子的,否则并发时两个请求都能通过 `exists` 检查,然后都执行业务逻辑。Redis 会把整段 Lua 脚本当作一次原子调用执行,因此"判断存在 + 删除"才真正等价于一次 CAS。 **注意**:Token 机制只能拦住"带着同一个 Token"的重复请求。如果调用方每次都重新申请 Token,防重就会被绕过——所以它更适合配合前端表单使用,而不是作为唯一的正确性保障。 ### Q:方案三:Redis SETNX 状态机——怎么做?为什么处理完不能删 Key? A:**结论:用 SETNX 给每笔业务打一个"处理中"标记,只有抢到标记的请求才真正执行,其余请求改为查询已有结果返回。** ```java public boolean processPayment(String orderId, BigDecimal amount) { String lockKey = "payment:processing:" + orderId; // SETNX:不存在才设置,设置成功说明是首次处理 boolean isFirst = redis.setnx(lockKey, "processing", 300); // 5 分钟过期 if (!isFirst) { // 已经在处理中或已处理完,查询结果返回 String status = getPaymentStatus(orderId); return "success".equals(status); } try { // 执行支付逻辑 boolean success = doPayment(orderId, amount); // 更新状态 redis.set("payment:status:" + orderId, success ? "success" : "failed", 86400); return success; } finally { // 注意:不要删除 lockKey,让它自然过期 // 删除后重试请求会再次进入,可能重复处理 } } ``` **关键点**:`finally` 里刻意**不删除** Key。因为 Key 一旦删掉,后续的重试请求会再次抢到标记并重复执行;保留 Key 让它自然过期,就能在 TTL 窗口内持续拦住重复请求。这也是它和"分布式锁"的区别——锁要尽快释放,幂等标记要尽量保留。 **取舍**:TTL 要在"拦得住重试"和"不要长期占用 Key"之间平衡,一般按业务最大处理时长再加一定余量设置。 ### Q:如果并发量很大,瞬时订单很多,Redis 能撑得住吗?撑不住怎么处理? A:**Redis 可以承接很高的并发,但不能把它当作支付幂等的唯一正确性保障。** 这里每笔请求主要是一次 `SET NX EX` 与少量状态查询/写入,都是常数时间操作;真正能承载多少 QPS 取决于 CPU、网络、Value 大小、持久化策略、命令延迟和热点分布,必须以压测结果决定容量。 对大量**不同订单**,`payment:processing:{orderId}` 的 Key 会自然分散;应使用 Redis Cluster 按 Key 分片并水平扩容,避免把所有请求压到单一实例。Key 和 Value 保持小,TTL 应与支付处理的最大时长匹配,并监控 QPS、P99 延迟、CPU、内存、连接数、慢查询和主从复制延迟。 对同一个订单的瞬时重复点击,优先在入口做限流/请求合并;`SETNX` 失败后不要让所有请求立刻高频轮询 Redis,可短暂返回"处理中"并让客户端轮询结果,或通过消息/回调通知结果。这样避免单个热点订单把 Redis 打成热点 Key。 当 Redis 接近或超过容量时,采用分层保护: 1. **网关限流与熔断**:超过系统可承受阈值时快速返回"系统繁忙",避免请求继续涌入。 2. **MQ 削峰**:允许异步受理的支付/订单流程写入消息队列,由消费者按下游能力处理;同步扣款仍需保留明确超时与失败反馈。 3. **Redis Cluster 扩容与副本高可用**:通过分片增加写吞吐,用副本、Sentinel 或集群故障转移提高可用性;注意写请求只能由主节点处理,副本不会线性提升写能力。 4. **降级到持久层幂等**:Redis 不可用时,使用支付流水的 `order_id` 唯一索引、订单 `UNPAID → PAYING → PAID` 条件更新(CAS),并保持支付网关 `out_trade_no` 不变。这样即使 Redis 防重失效,也不能重复扣款。 因此 Redis 更适合作为**高性能第一道去重层**;数据库唯一约束/状态机和支付网关幂等才是最终兜底。支付场景还应为"处理中"设定可查询状态与超时补偿,不能仅依赖 5 分钟 TTL 自然过期。 ### Q:方案四:更新类操作用乐观锁怎么做? A:**结论:给数据行加一个 version 字段,更新时带上前一次读到的 version,用"影响行数是否为 0"判断是否发生了并发冲突。** ```java // 表结构加 version 字段 UPDATE orders SET status = 'paid', version = version + 1 WHERE id = #{orderId} AND status = 'pending' -- 只有待支付状态才能支付 AND version = #{version} -- 版本号匹配 // Java 代码 public boolean pay(Long orderId, int version) { int rows = orderMapper.updateStatus(orderId, "paid", version); if (rows == 0) { // 更新失败:要么已支付,要么版本号不匹配(并发冲突) Order order = orderMapper.findById(orderId); if ("paid".equals(order.getStatus())) { return true; // 已支付,幂等返回成功 } throw new RuntimeException("支付失败,请重试"); } return true; } ``` **关键点**:`rows == 0` 时不能一律报错,要先回查一次当前状态——如果已经是 `paid`,说明这是重复请求,应当幂等返回成功;只有状态仍不正确才算真正的并发冲突。 **适用场景**:更新类操作、并发不高的场景。它的本质和订单场景里的状态机 CAS 是同一招,区别只在于用 version 字段比较,还是直接比较 status 字段。 ### Q:方案五:消息队列消费怎么做幂等? A:**结论:给每条消息一个全局唯一的 msgId,消费前先用 `SETNX` 抢占"已处理"标记,抢不到就跳过。** ```java // 消费者处理消息时,记录已处理的消息 ID @RabbitListener(queues = "payment.queue") public void handlePayment(PaymentMessage msg) { String msgId = msg.getMsgId(); // 检查是否已处理(Redis 或数据库) if (redis.setnx("msg:processed:" + msgId, "1", 86400)) { // 首次处理 processPayment(msg); } else { // 重复消息,跳过 log.info("重复消息,跳过: {}", msgId); } } ``` **关键点**:这和方案三是同一个思路,只是去重键从"订单号"换成了"消息 ID"。 **适用场景**:所有消费端可能收到重复投递的场景,是"至少一次投递 + 消费端幂等"组合拳的关键一环。 ## 三、放进真实场景 ### Q:这五种方案到底怎么选? A:先看操作类型有没有唯一键、要不要依赖 Redis,再决定用哪一种: | 方案 | 实现复杂度 | 性能 | 适用场景 | |------|-----------|------|---------| | 数据库唯一键 | 低 | 中 | 创建类操作,有业务唯一键 | | Token 机制 | 中 | 高 | 前端表单提交防重 | | Redis SETNX | 中 | 高 | 支付、转账等关键操作 | | 乐观锁 | 低 | 中 | 更新类操作,并发不高 | | 消息队列幂等 | 低 | 高 | 消息消费去重 |  [编辑 Excalidraw 源图](/images/java-interview-copy/business-scenario/10-idempotency-idempotency-strategy-diagram.excalidraw) **选型口诀**:能靠数据库唯一约束解决的,就不要引入 Redis;关键操作把 Redis 当第一道闸门,把数据库当最后一道兜底。 ### Q:真实支付链路里,这些方案是只用一种,还是组合使用? A:**结论:生产上的支付链路一定是分层组合的,不会只靠一种。** 一个常见的分层是: 1. **入口层**:前端 Token 或按钮置灰,挡掉大部分用户重复点击(方案二)。 2. **去重层**:Redis `SETNX` 按订单号拦截瞬时重复请求,追求高性能(方案三)。 3. **正确性层**:数据库唯一索引 + 订单状态机(`UNPAID → PAYING → PAID`)条件更新,即使 Redis 失效也不能重复扣款(方案一、方案四)。 4. **外部依赖层**:调用支付网关时保持 `out_trade_no` 不变,由支付网关自身的幂等保证同一笔外部交易不会被重复扣款。 **为什么这样设计**:越靠前的层性能越高但可靠性越弱,越靠后的层越可靠但成本越高;用"高性能层拦截 + 高可靠层兜底"的组合,既扛得住并发,又不会因为缓存故障产生资金风险。 **代价**是链路变长、排障更复杂,所以每一层都要记录自己的判定结果,便于事后对账。 ### Q:如果 Redis 宕机,Token 方案的幂等就完全失效了吗?怎么办? A:**不会完全失效,前提是提前准备了降级预案。** 降级方向有两个: - **临时关闭幂等校验**(允许重复请求):可用性优先,但要依赖下游的数据库唯一键或状态机兜住正确性。 - **把 Token 落到数据库**:可靠性优先,性能会明显下降,但功能不受影响。 **关键要有降级预案并演练过**,而不是等 Redis 真的挂了再临时决定——支付链路里"降级到哪一层"必须在设计阶段就写清楚。 ## 四、总结与自测 ### Q:面试里怎么答这道题? A:可以按"是什么 → 为什么 → 怎么做 → 兜底"四步作答: 1. **先给定义**:幂等性指同一操作执行多次结果与执行一次相同;GET/DELETE/PUT 天然幂等,POST 创建、扣款、发消息不幂等。 2. **再说触发来源**:客户端重试、用户重复点击、MQ 重复投递、上游重试,所以幂等是必需而非可选。 3. **分场景给方案**:有业务唯一键就用数据库唯一键;前端表单防重用 Token + Lua 原子校验;关键操作用 Redis `SETNX` 状态机;更新类用乐观锁;消息消费按 msgId 去重。 4. **最后强调兜底**:Redis 只是高性能第一道去重层,数据库唯一约束/状态机 + 支付网关幂等才是最终保障,并且要有 Redis 不可用时的降级预案。 ### Q:幂等性和事务有什么关系? A:**幂等性和事务是不同维度的概念。** 事务保证操作的原子性(要么全成功要么全失败),幂等性保证重复操作的结果一致。两者可以结合使用:在事务中执行业务逻辑,同时用幂等机制防止重复执行。 --- ## 自测 1. 说出三种天然幂等的操作,并解释为什么 POST 创建不幂等。 2. Token 机制里,为什么校验和删除 Token 必须放在同一段 Lua 脚本里执行?把两步拆开会出什么问题? 3. 如果只允许你在支付链路里保留一层幂等保护,你会保留 Redis 还是数据库唯一约束?说明理由。
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入