面对不可逆外部支付回调:基于 TCC 与最大努力通知保证分布式资产终态一致性

面对不可逆外部支付回调:基于 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 风格。

java 复制代码
@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 代码。

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):

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 代码。

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 设,还是动态调整?评论区聊聊。

相关推荐
你三大爷31 分钟前
Seata全局锁泄漏:从上游PR-backport到生产零事故发布实战
架构
Dawson Zhu2 小时前
【分布式训练⑧】通信优化:NCCL、Ring AllReduce与计算通信重叠
人工智能·语言模型·架构·aigc·agi
一条Go3 小时前
Webhook 签名:钉钉、企业微信、飞书的四种算法差异
后端·架构·github
码客-ygluu15 小时前
X3 LUA 异步分布式微服务集群框架
c++·架构·lua
Decay__20 小时前
VMware 安装 SQL Server 双节点 AlwaysOn 可用性组教程 —— WSFC、AG 与侦听器完整部署(系列核心篇)
运维·数据库·sql·mysql·架构
wangruofeng21 小时前
从 GIF 到 AVIF:网页图片格式演进与 2026 年选型指南
前端·架构
Softmaxmap1 天前
从零做一个中文小模型:600 亿 token 数据、mHC + Engram 结构、到强化学习的全流程(开源)
架构
你三大爷1 天前
从 Hessian 迁移到 protostuff:深嵌套模型反序列化耗时与高并发类加载锁的根治实战
后端·架构
一条Go1 天前
接收方合并去重:同一个人为什么只该收到一次通知
后端·架构·github