架构与系统设计 / 系统课时

退款订单创建

退款订单创建

退款订单创建不是简单插入一条记录,而是一次带幂等、额度校验和并发保护的业务事务。本课将实现一个可运行的最小示例,并说明生产环境中如何用事务与唯一约束防止重复退款和超额退款。

学习目标

  • 设计退款请求的校验顺序
  • 生成可追踪的退款订单
  • 使用幂等键防止重复创建

创建流程

退款接口收到请求后,应先按商户号与请求号查询历史退款单;命中后校验关键参数是否一致,一致则直接返回原结果。未命中时再校验支付订单、可退金额和退款期限,最后创建退款单并占用额度。

退款订单创建时序图

推荐校验顺序是“幂等检查在前,业务校验在后”。这样重复请求即使发生在订单已过退款期限之后,也能稳定返回第一次创建的退款单,而不会因当前规则变化产生不同结果。

可运行的创建示例

下面使用 Java 17 编写一个内存版示例,覆盖支付状态校验、可退金额计算、退款单号生成和重复请求返回。生产环境应把内存仓库替换为数据库事务。

java
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;

public class RefundOrderDemo {

    enum PaymentStatus { SUCCESS, FAILED }
    enum RefundStatus { CREATED, PROCESSING, SUCCESS, FAILED }

    record PaymentOrder(String paymentNo, String merchantNo,
                        BigDecimal amount, PaymentStatus status) {}

    record RefundOrder(String refundNo, String paymentNo, String merchantNo,
                       String requestId, BigDecimal amount, RefundStatus status) {}

    static final class RefundService {
        private final Map<String, PaymentOrder> payments = new ConcurrentHashMap<>();
        private final Map<String, RefundOrder> refundsByRequest = new ConcurrentHashMap<>();
        private final List<RefundOrder> refunds = new ArrayList<>();
        private final AtomicLong sequence = new AtomicLong();

        void savePayment(PaymentOrder paymentOrder) {
            payments.put(paymentOrder.paymentNo(), paymentOrder);
        }

        synchronized RefundOrder create(String merchantNo, String paymentNo,
                                        String requestId, BigDecimal amount) {
            String idempotencyKey = merchantNo + ":" + requestId;
            RefundOrder existing = refundsByRequest.get(idempotencyKey);

            // 相同请求号重复提交时返回原退款单,参数不同则拒绝。
            if (existing != null) {
                if (!existing.paymentNo().equals(paymentNo)
                        || existing.amount().compareTo(amount) != 0) {
                    throw new IllegalArgumentException("幂等请求参数冲突");
                }
                return existing;
            }

            // 只允许当前商户对已成功的支付订单发起退款。
            PaymentOrder payment = payments.get(paymentNo);
            if (payment == null || !payment.merchantNo().equals(merchantNo)) {
                throw new IllegalArgumentException("支付订单不存在");
            }
            if (payment.status() != PaymentStatus.SUCCESS) {
                throw new IllegalStateException("支付订单未成功");
            }
            if (amount.compareTo(BigDecimal.ZERO) <= 0) {
                throw new IllegalArgumentException("退款金额必须大于零");
            }

            // 成功和处理中退款都会占用可退额度。
            BigDecimal occupied = refunds.stream()
                    .filter(r -> r.paymentNo().equals(paymentNo))
                    .filter(r -> r.status() == RefundStatus.SUCCESS
                            || r.status() == RefundStatus.PROCESSING
                            || r.status() == RefundStatus.CREATED)
                    .map(RefundOrder::amount)
                    .reduce(BigDecimal.ZERO, BigDecimal::add);

            BigDecimal refundable = payment.amount().subtract(occupied);
            if (amount.compareTo(refundable) > 0) {
                throw new IllegalArgumentException("退款金额超过可退金额");
            }

            // 通过平台退款单号串联后续渠道提交与结果查询。
            String refundNo = "RF%06d".formatted(sequence.incrementAndGet());
            RefundOrder created = new RefundOrder(
                    refundNo, paymentNo, merchantNo, requestId,
                    amount, RefundStatus.CREATED);

            refunds.add(created);
            refundsByRequest.put(idempotencyKey, created);
            return created;
        }
    }

    public static void main(String[] args) {
        RefundService service = new RefundService();
        service.savePayment(new PaymentOrder(
                "PAY1001", "M1001", new BigDecimal("100.00"),
                PaymentStatus.SUCCESS));

        RefundOrder first = service.create(
                "M1001", "PAY1001", "REQ-001", new BigDecimal("30.00"));
        RefundOrder repeated = service.create(
                "M1001", "PAY1001", "REQ-001", new BigDecimal("30.00"));

        System.out.println("第一次创建:" + first.refundNo()
                + ",状态=" + first.status());
        System.out.println("重复请求:" + repeated.refundNo()
                + ",状态=" + repeated.status());
        System.out.println("两次是否同一退款单:"
                + first.refundNo().equals(repeated.refundNo()));
    }
}

预期输出

text
第一次创建:RF000001,状态=CREATED
重复请求:RF000001,状态=CREATED
两次是否同一退款单:true

示例中的 synchronized 只适用于单进程演示。多实例部署时,它不能阻止其他节点同时创建退款单,因此不能替代数据库锁、条件更新或分布式一致性方案。

持久化与并发约束

生产环境建议在退款表上建立两个唯一约束:退款单号唯一,以及“商户号 + 请求号”唯一。即使两个节点同时通过了首次查询,数据库也只允许一个请求成功插入,另一个请求捕获唯一键冲突后再查询并返回原退款单。

可退额度校验与退款单插入必须位于同一事务。常见做法是锁定支付订单行,汇总成功和处理中退款金额,再创建退款单;也可以维护独立的已占用退款金额,并通过带条件的原子更新完成扣减。

创建成功只代表平台已经受理,并不代表渠道退款成功。退款单初始状态可设为 CREATED,提交渠道后变为 PROCESSING,最终根据同步响应、异步通知或主动查询更新为 SUCCESS 或 FAILED。

运行与验收

将代码保存为 RefundOrderDemo.java,使用 JDK 17 编译运行。实际路径可能不同,可将 <PATH> 替换为源码所在目录。

bash
cd <PATH>
javac RefundOrderDemo.java
java RefundOrderDemo

预期输出

text
第一次创建:RF000001,状态=CREATED
重复请求:RF000001,状态=CREATED
两次是否同一退款单:true

两次提交相同请求号只产生一个退款单号。验收时还应补充测试:金额为零、支付订单失败、超出可退金额,以及相同请求号但金额不同的冲突场景。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

退款订单创建

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通