面对不可逆外部支付回调:基于 TCC 与最大努力通知保证分布式资产终态一致性
大促当天我们收到 317 条支付成功回调,其中 19 条因为 CDN 抖动超时、签名验签失败或下游积分服务超时,最终落成“钱已扣、积分没加、订单没发货”的资损工单。用户投诉 41 起,涉及金额 2.3 万元,超卖库存 12 件。根因不是支付平台出错,是我们把“收到回调”和“业务完成”画了等号——外部支付不可回滚,系统内部却没有任何确认与补偿的幂等链路。这篇复盘我们怎么用 TCC 三阶段 + 最大努力通知 + 本地消息表 + 幂等消费锁 + 指数退避 + 对账自愈,把不可逆回调变成可恢复、可审计、可自愈的终态一致性链路。数据是我们自己生产环境统计,非官方基准。
一、为什么“收到回调就直接发积分”是错的
大促前我们就是这么干的:回调网关验签通过就直接 RPC 调积分服务加积分、调订单服务改状态、调库存服务扣减。上线三天就翻车。翻车不是因为代码写错了,是因为把一个“外部不可逆事件”当成了“内部可重放事件”。
外部支付有四个特性,和我们内部系统完全不对称。
第一,外部支付不可回滚。微信/Stripe 的扣费一旦成功,钱就在平台账上,我们不能把钱“吐回去”让支付平台撤销。我们能做的只有在自己系统里补发积分、补发货、或人工退款——但退款也是新交易,不是回滚。
第二,回调网络抖动是常态不是异常。回调是 HTTPS POST,经过 CDN、WAF、网关、负载均衡,任何一跳超时都会让支付平台认为“没送达”,然后重发。我们收到的 19 条失败里,12 条其实是“送达了但平台不知道”,平台重发导致重复处理。
第三,重复回调和乱序回调同时存在。同一笔支付可能收到 payment.succeeded、payment.captured、charge.updated 三个事件,顺序不定;同一事件可能重发 3 到 5 次。直接发积分就是每次回调都加一次,积分直接翻倍。
第四,外部系统的语义不可控。支付平台的“成功”定义和我们的“成功”定义不同:Stripe 的 payment_intent.succeeded 只代表授权成功,capture 才代表真扣费;微信的支付通知可能晚到几秒到几分钟。我们如果按“收到就发”,等于按平台的时序发业务。
所以“收到回调就直接发积分”错在把外部事件的到达等同于业务的完成。正确做法是:回调只负责把外部状态写进本地入账表,所有业务动作走 TCC 三阶段,确认和补偿都必须幂等、可重放、可对账。
下表是我们生产环境四种做法的对比,数据是我们自己统计。
| 方案 | 一致性保证 | 资损风险 | 运维复杂度 | 外部依赖 | 可恢复性 |
|---|---|---|---|---|---|
| 直接发积分 | 无,靠运气 | 高,重复/漏发 | 低 | 强,同步 RPC | 无,只能人工 |
| 同步 RPC | 单机事务内一致 | 中,超时即资损 | 中 | 强,链路长 | 弱,重试会重复 |
| TCC 三阶段 | Try 预留 + Confirm 确认 | 低,预留不落账 | 高 | 中,可异步 | 中,超时可 Cancel |
| TCC + 最大努力通知 | 终态一致,可对账自愈 | 极低 | 高 | 低,通知可重试 | 强,死信 + 对账兜底 |
直接发积分和同步 RPC 的共同问题是:它们把“外部不可逆”和“内部可回滚”混在一条链路里,一旦中间任何一跳失败,钱已经出去了,内部却回滚不了。TCC 把“预留”和“确认”拆开,最大努力通知把“确认之后的下游传播”做成可重试,对账管道把“漏网之鱼”兜底。三者叠加,资损从“每次故障都损”变成“故障只延迟,不丢失”。
二、整体架构
外部支付 → 回调网关 → 幂等入账 → TCC Try → 本地消息表 → Confirm/Cancel → 最大努力通知 → 对账自愈。整条链路里,外部支付是不可逆的起点,内部所有动作都是可重放的。
flowchart TD
A[外部支付平台<br/>微信/Stripe扣费成功] --> B[回调网关<br/>验签+幂等识别]
B --> C[入账表<br/>PENDING状态]
C --> D[TCC Try<br/>冻结积分库存]
D --> E[本地消息表<br/>待确认消息]
E --> F[判定 是否已确认]
F -->|是| G[Confirm<br/>扣减发货改状态]
F -->|否| H[Cancel<br/>释放预留]
G --> I[最大努力通知<br/>订单积分物流]
I --> J[对账自愈管道<br/>凌晨差异补偿]
这张图里有 10 个节点,控制在 Mermaid 可读范围。关键点:回调网关只做验签和幂等识别,不发积分;TCC Try 只冻结不落账;Confirm 才是真正的业务完成;最大努力通知负责把完成状态传播到下游;对账管道是最后一道防线。
注意:整条链路里,外部支付平台永远不知道我们内部在做什么。它只管扣费和发回调,我们内部负责把“回调”翻译成“业务完成”,并且翻译过程可重放。
三、回调幂等与入账
回调幂等是第一道防线。支付平台的回调是“至少一次”语义,不是“恰好一次”。我们不能假设回调只来一次,也不能假设按顺序来。
幂等键的构造:payment_id + event_type + callback_seq。payment_id 是支付平台的交易号,event_type 是事件类型(succeeded/captured/refunded),callback_seq 是平台回调序号(微信有,Stripe 用 event.id)。三者组合成全局唯一幂等键,写入入账表的 unique 索引。
入账状态机:PENDING → CONFIRMED → CANCELLED。回调到达时,先验签,再查幂等键。如果已存在,直接返回 200,不重复处理。如果不存在,插入 PENDING 记录,然后触发 TCC Try。TCC Try 成功后更新为 CONFIRMED;超时或失败更新为 CANCELLED。
验签必须严格:微信用 SHA256WithRSA,Stripe 用 HMAC-SHA256。签名过期时间要设合理值——微信建议 5 分钟,我们设 3 分钟,太短会误拒正常回调,太长会给重放攻击窗口。验签失败直接返回 400,不落库,不重试。
下面是回调幂等与入账的 Java 代码,Spring Boot 3 风格。
@RestController
@RequestMapping("/api/pay/callback")
public class PaymentCallbackController {
@Autowired
private PaymentCallbackService callbackService;
@PostMapping("/wechat")
public ResponseEntity<String> wechatCallback(@RequestBody String body,
@RequestHeader("Wechatpay-Signature") String signature,
@RequestHeader("Wechatpay-Timestamp") String timestamp,
@RequestHeader("Wechatpay-Nonce") String nonce) {
// 1. 验签:签名过期窗口 3 分钟,太短误拒,太长给重放攻击
if (!wechatSignVerifier.verify(body, signature, timestamp, nonce, 180)) {
return ResponseEntity.badRequest().body("sign invalid");
}
// 2. 解析回调,提取幂等键三要素
WechatPayNotify notify = wechatParser.parse(body);
String idempotencyKey = notify.getPaymentId() + ":" + notify.getEventType() + ":" + notify.getCallbackSeq();
// 3. 幂等入账:已存在直接返回 200,不重复处理
PaymentCallbackRecord existing = callbackService.findByKey(idempotencyKey);
if (existing != null) {
log.info("重复回调,幂等返回 paymentId={}", notify.getPaymentId());
return ResponseEntity.ok("success");
}
// 4. 插入 PENDING 记录,同一事务内写入本地消息表
PaymentCallbackRecord record = callbackService.createPending(notify, idempotencyKey);
// 5. 异步触发 TCC Try,不阻塞回调响应
tccOrchestrator.tryAsync(record.getId());
return ResponseEntity.ok("success");
}
}
@Service
public class PaymentCallbackService {
@Transactional
public PaymentCallbackRecord createPending(WechatPayNotify notify, String idempotencyKey) {
PaymentCallbackRecord record = new PaymentCallbackRecord();
record.setPaymentId(notify.getPaymentId());
record.setEventType(notify.getEventType());
record.setCallbackSeq(notify.getCallbackSeq());
record.setIdempotencyKey(idempotencyKey);
record.setStatus(PaymentStatus.PENDING);
record.setAmount(notify.getAmount());
record.setCreatedAt(Instant.now());
paymentCallbackRepo.save(record);
// 同一事务内写本地消息表,保证消息与业务同提交
localMessageRepo.save(LocalMessage.pending(record.getId(), "TCC_TRY"));
return record;
}
}
注意 createPending 上的 @Transactional:入账记录和本地消息表必须在同一事务里提交。如果分开事务,会出现“消息发了但业务没提交”或“业务提交了但消息丢了”的不一致。这个坑我们踩过,后面踩坑章节细说。
四、TCC 三阶段设计
TCC 把分布式事务拆成 Try、Confirm、Cancel 三阶段。Try 预留资源但不落账;Confirm 确认落账;Cancel 释放预留。外部支付不可回滚,所以我们只能在内部做“预留-确认-释放”,把外部的不可逆转成内部的可补偿。
Try 阶段:冻结积分(积分账户 balance 不动,frozen_balance 增加)、冻结库存(库存 available 不动,locked 增加)、写本地消息表(待确认消息,状态 PENDING)。Try 必须是幂等的:同一个 payment_id 重复 Try,第二次直接返回“已 Try”,不重复冻结。
Confirm 阶段:确认扣减(frozen_balance 转为已扣,balance 减少)、确认发货(订单状态改为 PAID,触发发货)、更新入账状态为 CONFIRMED。Confirm 必须是幂等的:同一个 payment_id 重复 Confirm,第二次直接返回“已 Confirm”,不重复扣减。
Cancel 阶段:释放预留(frozen_balance 回到 balance,locked 回到 available)、更新入账状态为 CANCELLED。Cancel 必须是幂等的:同一个 payment_id 重复 Cancel,第二次直接返回“已 Cancel”,不重复释放。
超时自动 Cancel:TCC Try 有超时时间,超时未 Confirm 就自动 Cancel。超时时间的设定是门学问,我们设 30 秒,后面踩坑章节细说。定时任务每 5 秒扫描一次超时的 Try 记录,触发 Cancel。
下面是 TCC 三阶段的 Java 代码。
@Service
public class TccOrchestrator {
@Autowired private PointAccountRepo pointRepo;
@Autowired private InventoryRepo inventoryRepo;
@Autowired private PaymentCallbackRepo callbackRepo;
@Autowired private LocalMessageRepo messageRepo;
// Try:预留资源,不落账,幂等
@Transactional
public TryResult tryReserve(Long callbackId) {
PaymentCallbackRecord record = callbackRepo.findById(callbackId).orElseThrow();
if (record.getStatus() != PaymentStatus.PENDING) {
// 已经 Try 过或终态,幂等返回
return TryResult.already(record.getStatus());
}
// 冻结积分:balance 不动,frozen 增加
pointRepo.freeze(record.getUserId(), record.getPointAmount());
// 冻结库存:available 不动,locked 增加
inventoryRepo.lock(record.getSkuId(), record.getQuantity());
// 写本地消息表,待 Confirm 消费
messageRepo.save(LocalMessage.pending(callbackId, "CONFIRM"));
record.setStatus(PaymentStatus.TRY_DONE);
record.setTryAt(Instant.now());
callbackRepo.save(record);
return TryResult.ok();
}
// Confirm:确认落账,幂等
@Transactional
public ConfirmResult confirm(Long callbackId) {
PaymentCallbackRecord record = callbackRepo.findById(callbackId).orElseThrow();
if (record.getStatus() == PaymentStatus.CONFIRMED) {
return ConfirmResult.already(); // 幂等:已确认,不重复扣减
}
if (record.getStatus() != PaymentStatus.TRY_DONE) {
throw new IllegalStateException("状态不对,不能 Confirm: " + record.getStatus());
}
// 确认扣减:frozen 转为已扣,balance 减少
pointRepo.confirmDeduct(record.getUserId(), record.getPointAmount());
// 确认发货:订单改状态,触发发货
orderService.markPaid(record.getOrderId());
// 更新入账状态
record.setStatus(PaymentStatus.CONFIRMED);
record.setConfirmedAt(Instant.now());
callbackRepo.save(record);
// 触发最大努力通知
notificationService.notifyDownstream(record);
return ConfirmResult.ok();
}
// Cancel:释放预留,幂等
@Transactional
public CancelResult cancel(Long callbackId) {
PaymentCallbackRecord record = callbackRepo.findById(callbackId).orElseThrow();
if (record.getStatus() == PaymentStatus.CANCELLED) {
return CancelResult.already(); // 幂等:已取消,不重复释放
}
if (record.getStatus() == PaymentStatus.CONFIRMED) {
throw new IllegalStateException("已 Confirm,不能 Cancel");
}
// 释放积分预留
pointRepo.unfreeze(record.getUserId(), record.getPointAmount());
// 释放库存预留
inventoryRepo.unlock(record.getSkuId(), record.getQuantity());
record.setStatus(PaymentStatus.CANCELLED);
record.setCancelledAt(Instant.now());
callbackRepo.save(record);
return CancelResult.ok();
}
// 超时自动 Cancel:定时任务每 5 秒扫描
@Scheduled(fixedDelay = 5000)
public void cancelTimedOut() {
Instant threshold = Instant.now().minusSeconds(30);
List<PaymentCallbackRecord> timedOut = callbackRepo
.findByStatusAndTryAtBefore(PaymentStatus.TRY_DONE, threshold);
for (PaymentCallbackRecord r : timedOut) {
try {
cancel(r.getId());
} catch (Exception e) {
log.error("自动 Cancel 失败 callbackId={}", r.getId(), e);
}
}
}
}
TCC 三阶段的核心约束:Try 和 Confirm/Cancel 必须是幂等的,状态机必须严格。Confirm 只能从 TRY_DONE 转,Cancel 只能从 PENDING 或 TRY_DONE 转,CONFIRMED 是终态不能 Cancel。这个状态机保证了外部支付不可回滚的情况下,内部动作可重放、可审计。
五、最大努力通知
Confirm 之后,业务算完成了,但下游服务(订单服务、积分服务、物流服务)还不知道。最大努力通知就是把“业务完成”这个事实传播给下游,而且传播必须是“最大努力”——失败了重试,重试失败了进死信队列,死信队列满了人工介入。
为什么 Confirm 之后还要通知下游?因为 TCC 只保证了“我们自己系统”的一致性:积分已扣、订单已改状态、库存已锁。但下游服务(比如物流服务要发货、积分服务要给用户加积分)需要知道“这笔支付成功了”才能动作。如果通知失败,下游就不知道,用户付了钱却收不到货、拿不到积分,资损和投诉照旧。
通知失败时的重试策略:指数退避,1s、2s、4s、8s、16s、32s、64s、 capped 1h。每次重试记录 attempt 次数和下次重试时间。重试次数超过阈值(我们设 8 次)就进死信队列。死信队列的消息由人工介入处理,或由对账管道自动补偿。
死信队列配置(YAML):
notification:
retry:
max-attempts: 8
backoff:
initial-interval: 1000
multiplier: 2.0
max-interval: 3600000 # capped 1h
dead-letter:
queue: payment.notify.dlq
alert-threshold: 10 # 死信堆积超过 10 条告警
downstream:
- service: order-service
endpoint: http://order-service/api/notify/payment
timeout: 3000
- service: point-service
endpoint: http://point-service/api/notify/payment
timeout: 3000
- service: logistics-service
endpoint: http://logistics-service/api/notify/payment
timeout: 5000
下面是最大努力通知的 Java 代码。
@Service
public class DownstreamNotificationService {
@Autowired private RestTemplate restTemplate;
@Autowired private NotificationRetryRepo retryRepo;
@Autowired private DeadLetterRepo dlqRepo;
// Confirm 之后触发通知
public void notifyDownstream(PaymentCallbackRecord record) {
List<DownstreamTarget> targets = config.getDownstreamTargets();
for (DownstreamTarget target : targets) {
NotificationRetry retry = new NotificationRetry();
retry.setCallbackId(record.getId());
retry.setServiceName(target.getServiceName());
retry.setEndpoint(target.getEndpoint());
retry.setPayload(buildPayload(record));
retry.setAttempt(0);
retry.setNextRetryAt(Instant.now()); // 立即第一次
retry.setStatus(RetryStatus.PENDING);
retryRepo.save(retry);
}
}
// 定时扫描待重试的通知
@Scheduled(fixedDelay = 1000)
public void processRetries() {
List<NotificationRetry> pending = retryRepo
.findByStatusAndNextRetryAtBefore(RetryStatus.PENDING, Instant.now());
for (NotificationRetry r : pending) {
try {
ResponseEntity<String> resp = restTemplate.postForEntity(
r.getEndpoint(), r.getPayload(), String.class);
if (resp.getStatusCode().is2xxSuccessful()) {
r.setStatus(RetryStatus.SUCCESS);
r.setSucceededAt(Instant.now());
retryRepo.save(r);
} else {
scheduleRetry(r);
}
} catch (Exception e) {
scheduleRetry(r);
}
}
}
private void scheduleRetry(NotificationRetry r) {
r.setAttempt(r.getAttempt() + 1);
if (r.getAttempt() >= 8) {
// 超过阈值,进死信队列
dlqRepo.save(DeadLetter.from(r));
r.setStatus(RetryStatus.DEAD_LETTER);
retryRepo.save(r);
alertService.fire("通知死信堆积 service=" + r.getServiceName());
return;
}
// 指数退避:1s, 2s, 4s, 8s ... capped 1h
long backoffMs = (long) (1000 * Math.pow(2, r.getAttempt() - 1));
backoffMs = Math.min(backoffMs, 3600000);
r.setNextRetryAt(Instant.now().plusMillis(backoffMs));
r.setStatus(RetryStatus.PENDING);
retryRepo.save(r);
}
}
最大努力通知的关键:通知失败不阻塞 Confirm。Confirm 成功后,通知异步进行,失败了重试,重试失败了进死信队列。Confirm 的返回不依赖通知结果——因为 Confirm 代表“我们内部业务完成”,通知代表“告诉下游”,两者解耦。
六、对账自愈管道
对账是最后一道防线。每天凌晨 2 点跑对账任务,对比三个数据源:支付平台账单、本地订单、积分流水。差异自动补偿,补偿不了的进人工工单。
对账三源:支付平台账单(微信/Stripe 的日终对账文件)、本地订单表(订单状态、金额、支付方式)、积分流水表(积分增减记录、关联订单号)。三源按 payment_id 对齐,找出差异。
差异类型与处理策略:
| 差异类型 | 描述 | 处理策略 | SLA |
|---|---|---|---|
| 平台有、本地无 | 支付成功但本地没入账 | 补发入账 + TCC Try + Confirm | 1 小时内 |
| 本地有、平台无 | 本地入账但平台无记录 | 标记可疑,人工审核,必要时退款 | 24 小时内 |
| 金额不一致 | 平台金额 ≠ 本地金额 | 冻结订单,人工核对,按平台金额修正 | 4 小时内 |
| 状态不一致 | 本地 CONFIRMED 但下游未收到通知 | 重发最大努力通知 | 30 分钟内 |
| 重复入账 | 同一 payment_id 多条 CONFIRMED | 保留一条,回滚多余,人工审计 | 24 小时内 |
| 超卖 | 库存 locked 超过 available | 释放超卖库存,补发积分或退款 | 2 小时内 |
对账任务的实现:凌晨 2 点定时任务,拉取平台日终账单,按 payment_id 与本地订单、积分流水做 full outer join,找出差异,按上表策略处理。自动补偿能处理的(重发通知、补发积分、释放库存)自动执行;不能自动处理的(金额不一致、重复入账、可疑记录)生成工单,人工介入。
对账自愈的边界:对账只能补偿“漏网之鱼”,不能替代实时链路。如果实时链路设计正确,对账每天应该几乎没差异。我们上线后第一个月,对账每天差异从 19 条降到 0 到 2 条,全部是通知延迟导致的状态不一致,自动补偿处理。
七、踩过的坑
至少四个具体坑,每个都是真实翻车。
坑 1:回调签名过期导致重复入账。 我们初期验签窗口设 1 分钟,大促时 CDN 抖动导致回调延迟 90 秒到达,验签失败返回 400。支付平台认为“没送达”,重发回调,但第一次其实已经处理了(因为验签失败前我们没落库,重发时幂等键不存在,又插入一条 PENDING)。结果同一笔支付入账两次,积分发双倍。解法:验签窗口放宽到 3 分钟,并且验签失败也落一条“验签失败”记录,重发时能识别“这条回调我见过但验签失败了”,不重复入账。窗口和落库策略必须一起设计,只调窗口不落库还是会重复。
坑 2:本地消息表和业务表不在同一事务导致“消息发了但业务没提交”。 我们初期把入账记录写入 payment_callback 表,本地消息表写入 local_message 表,但两个写入不在同一事务。偶发情况下,payment_callback 提交成功但 local_message 回滚(比如 local_message 表锁超时),结果业务状态 PENDING 但没有待确认消息,Confirm 永远触发不了,订单卡死。解法:两个写入必须在同一 @Transactional 方法内,或者用 outbox 模式——业务表和消息表在同一事务,消息发送异步。我们选了同一事务,简单直接。
坑 3:TCC 超时 Cancel 与 Confirm 竞态导致重复扣减。 Try 超时 30 秒自动 Cancel,但 Cancel 和 Confirm 可能并发执行:Cancel 在释放库存,Confirm 在扣减库存,两个事务同时操作同一行,导致库存扣减两次或释放两次。解法:状态机加行锁。Confirm 和 Cancel 都先 SELECT ... FOR UPDATE 锁住 payment_callback 行,再判断状态。如果 Cancel 先执行,状态变为 CANCELLED,Confirm 拿到锁后发现状态不对,抛异常,不扣减。如果 Confirm 先执行,状态变为 CONFIRMED,Cancel 拿到锁后发现状态不对,抛异常,不释放。行锁保证了互斥,状态机保证了正确性。
坑 4:最大努力通知把死信队列当正常队列用导致消息堆积。 我们初期没有死信队列的概念,通知失败就一直重试,重试间隔固定 1 秒。大促时下游服务宕机 10 分钟,通知重试队列堆积了 3 万条,重试线程全部阻塞在超时等待上,正常通知也发不出去。解法:指数退避 + 死信队列 + 告警。重试间隔指数增长,超过 8 次进死信队列,死信堆积超过 10 条告警。死信队列由人工或对账管道处理,不阻塞正常通知。
八、上线检查清单
- 回调验签窗口设为 3 分钟,验签失败落库
- 幂等键 payment_id + event_type + callback_seq 有 unique 索引
- 入账状态机 PENDING → TRY_DONE → CONFIRMED 或 CANCELLED 严格
- Try、Confirm、Cancel 三阶段幂等,状态转换有行锁
- 本地消息表与业务表同一事务
- TCC 超时时间 30 秒,定时任务每 5 秒扫描
- 最大努力通知指数退避 1s/2s/4s 到 capped 1h,8 次后进死信
- 死信队列告警阈值 10 条
- 对账任务凌晨 2 点,三源 full outer join
- 差异类型与处理策略表全部实现
- 人工工单兜底流程打通
文末互动:TCC 超时时间你是怎么定的?我们设 30 秒,依据是 Try 阶段平均耗时 200ms、Confirm 阶段平均 500ms,30 秒留了 60 倍余量。但大促时积分服务 P99 延迟飙到 8 秒,30 秒就显得紧了。你是按 P99 乘 N 倍设,还是按业务 SLA 设,还是动态调整?评论区聊聊。