← 返回首页 ❓ 面试题库
📑 本篇章节导航 (共10章,点击直达)
一、支付系统架构二、对账系统三、清结算系统四、资金安全五、支付路由六、风控系统七、退款系统八、分布式事务九、面试高频综合题面试速记口诀

Q99 支付系统设计与金融实战

20K Java+AI 岗位高频考点 — 支付系统是金融级系统的代表,面试必考的系统设计题。覆盖支付架构、幂等性、对账、清结算、资金安全、分布式事务等核心场景。

一、支付系统架构

1. 支付系统的整体架构是怎样的?


用户/商户 → API网关 → 支付核心
                       ├── 收银台(下单/支付/退款)
                       ├── 支付路由(智能选择支付渠道)
                       ├── 渠道网关(对接微信/支付宝/银行)
                       ├── 账务系统(记账/余额管理)
                       ├── 清结算系统(商户结算)
                       ├── 对账系统(资金核对)
                       └── 风控系统(反欺诈/限额)

2. 支付核心流程是什么?

支付主流程:

1. 用户下单 → 创建支付单

2. 选择支付方式 → 调用支付渠道(微信/支付宝)

3. 支付渠道回调 → 更新支付状态

4. 记账 → 更新账户余额

5. 通知业务系统 → 订单状态变更

6. 对账 → 与渠道账单核对

7. 清结算 → 商户资金结算

3. 支付单的设计?


CREATE TABLE pay_order (
    id BIGINT PRIMARY KEY,
    pay_no VARCHAR(64) UNIQUE NOT NULL,    -- 支付单号(业务ID)
    out_trade_no VARCHAR(64) NOT NULL,     -- 商户订单号
    merchant_id BIGINT NOT NULL,
    amount DECIMAL(12,2) NOT NULL,         -- 支付金额
    currency VARCHAR(3) DEFAULT 'CNY',
    status TINYINT NOT NULL,               -- INIT/PAID/FAILED/CLOSED
    pay_channel VARCHAR(32),               -- WECHAT/ALIPAY/UNIONPAY
    channel_trade_no VARCHAR(64),          -- 渠道交易号
    expired_at DATETIME,
    created_at DATETIME,
    updated_at DATETIME,
    INDEX idx_out_trade (out_trade_no),
    INDEX idx_merchant (merchant_id, created_at)
) ENGINE=InnoDB;

4. 如何保证支付的幂等性?

场景:网络超时导致重复支付、用户重复点击、渠道重复回调。

幂等方案:

方案一:唯一订单号 + 数据库唯一约束


@Transactional
public PayResult pay(PayRequest request) {
    // 幂等Key = out_trade_no
    PayOrder order = payOrderMapper.findByOutTradeNo(request.getOutTradeNo());
    if (order != null && order.getStatus() == PAID) {
        return PayResult.alreadyPaid(order);  // 已支付,直接返回
    }
    // 创建支付单(唯一约束防止重复创建)
    // ...
}

方案二:Token机制


// 1. 前端先获取Token
String token = tokenService.generate("PAY_" + userId);

// 2. 支付时带Token,服务端校验并删除
if (!tokenService.validateAndDelete(token)) {
    throw new BusinessException("请勿重复支付");
}

方案三:Redis分布式锁


String lockKey = "pay:lock:" + outTradeNo;
if (!redisLock.tryLock(lockKey, 30, TimeUnit.SECONDS)) {
    throw new BusinessException("支付处理中,请勿重复操作");
}
try {
    // 处理支付
} finally {
    redisLock.unlock(lockKey);
}

5. 支付回调(Callback)怎么处理?


@PostMapping("/callback/wechat")
public String wechatCallback(HttpServletRequest request) {
    // 1. 验签(确保是微信发来的)
    String body = StreamUtils.copyToString(request.getInputStream(), StandardCharsets.UTF_8);
    Map<String, String> params = WechatPayUtil.parseXml(body);
    if (!WechatPayUtil.verifySign(params, wechatApiKey)) {
        return "FAIL";  // 验签失败
    }

    // 2. 幂等处理
    String outTradeNo = params.get("out_trade_no");
    PayOrder order = payOrderService.findByOutTradeNo(outTradeNo);
    if (order.getStatus() == PAID) {
        return "SUCCESS";  // 已处理
    }

    // 3. 更新支付状态
    payOrderService.paySuccess(outTradeNo, params.get("transaction_id"));

    // 4. 异步通知业务系统
    eventPublisher.publish(new PaySuccessEvent(outTradeNo));

    return "SUCCESS";
}

关键点:


二、对账系统

6. 为什么要对账?怎么对账?

对账目的:确保系统记录与支付渠道的实际资金一致。

对账流程:

1. 每日凌晨获取渠道账单(微信/支付宝提供T+1账单下载)

2. 解析账单数据

3. 与系统支付记录逐笔比对

4. 生成对账差异报告


@Service
public class ReconcileService {
    /**
     * 对账:系统单 vs 渠道单
     */
    public ReconcileResult reconcile(LocalDate date) {
        // 1. 获取系统支付单
        List<PayOrder> systemOrders = payOrderMapper.findByDate(date, PAID);
        // 2. 获取渠道账单
        List<ChannelBill> channelBills = channelBillDownloader.download(date);

        // 3. 以系统单为基准匹配
        Map<String, ChannelBill> channelMap = channelBills.stream()
            .collect(Collectors.toMap(ChannelBill::getOutTradeNo, b -> b));

        List<ReconcileDiff> diffs = new ArrayList<>();
        for (PayOrder order : systemOrders) {
            ChannelBill bill = channelMap.get(order.getOutTradeNo());
            if (bill == null) {
                diffs.add(new ReconcileDiff(order, null, "渠道无记录"));     // 长款(系统有,渠道无)
            } else if (!order.getAmount().equals(bill.getAmount())) {
                diffs.add(new ReconcileDiff(order, bill, "金额不一致"));       // 金额不符
            }
        }
        // 4. 以渠道单为基准匹配(找出短款)
        // ...

        return new ReconcileResult(date, systemOrders.size(), channelBills.size(), diffs);
    }
}

7. 对账差异(长短款)怎么处理?

自动处理:


public void handleDiff(ReconcileDiff diff) {
    switch (diff.getType()) {
        case CHANNEL_MISSING -> {
            // 等待T+2,如果还是长款则人工处理
            scheduleRetry(diff, 2);
        }
        case AMOUNT_MISMATCH -> {
            // 金额差异超过阈值则告警
            if (diff.getAmountDiff().compareTo(threshold) > 0) {
                alertService.send("对账金额差异异常", diff);
            }
        }
    }
}

三、清结算系统

8. 清结算的流程?

清算:计算各参与方应该收付多少钱

结算:实际执行资金转移


用户支付100元 → 平台收100元
              ↓ 清算
商户分到95元(扣除5元手续费)
平台收5元
              ↓ 结算
T+1日自动打款到商户银行账户

9. 如何设计分账/分润系统?


// 分账规则
public class SplitRule {
    private Long merchantId;
    private BigDecimal rate;      // 分账比例
    private BigDecimal minAmount; // 最低分账金额
}

// 分账计算
public List<SplitDetail> calculateSplit(PayOrder order, List<SplitRule> rules) {
    List<SplitDetail> details = new ArrayList<>();
    BigDecimal remaining = order.getAmount();

    for (SplitRule rule : rules) {
        BigDecimal splitAmount = order.getAmount().multiply(rule.getRate())
            .setScale(2, RoundingMode.HALF_UP);
        splitAmount = splitAmount.max(rule.getMinAmount());
        details.add(new SplitDetail(rule.getMerchantId(), splitAmount));
        remaining = remaining.subtract(splitAmount);
    }

    // 剩余归平台
    details.add(new SplitDetail(PLATFORM_ID, remaining));
    return details;
}

10. 结算的T+1/T+0怎么实现?

T+1结算(默认):

T+0结算(实时结算,通常收费更高):


@Scheduled(cron = "0 0 2 * * ?")  // 每天凌晨2点
public void dailySettlement() {
    LocalDate yesterday = LocalDate.now().minusDays(1);

    // 1. 按商户汇总待结算金额
    List<MerchantSettlement> settlements = settlementMapper.sumByMerchant(yesterday);

    // 2. 调用渠道批量代付
    for (MerchantSettlement s : settlements) {
        try {
            transferService.transfer(s.getMerchantId(), s.getAmount());
            s.setStatus(SETTLED);
        } catch (Exception e) {
            s.setStatus(FAILED);
            alertService.send("结算失败", s);
        }
        settlementMapper.update(s);
    }
}

四、资金安全

11. 如何保证资金安全(不出错账)?

原则:never lose money

1. 金额用Decimal:绝不用float/double

2. 数据库事务:记账和状态变更在同一事务

3. 对账兜底:每日对账发现差异

4. 操作审计:所有资金操作记录日志

5. 权限控制:资金操作需要审批

6. 熔断:异常时停止处理,人工介入


// 资金操作 - 事务保证
@Transactional
public void transfer(TransferRequest request) {
    // 1. 扣减转出账户
    Account from = accountMapper.selectForUpdate(request.getFromAccountId());
    if (from.getBalance().compareTo(request.getAmount()) < 0) {
        throw new BusinessException("余额不足");
    }
    from.setBalance(from.getBalance().subtract(request.getAmount()));
    accountMapper.update(from);

    // 2. 增加转入账户
    Account to = accountMapper.selectForUpdate(request.getToAccountId());
    to.setBalance(to.getBalance().add(request.getAmount()));
    accountMapper.update(to);

    // 3. 记录流水
    accountLogMapper.insert(new AccountLog(from.getId(), TRANSFER_OUT, request.getAmount()));
    accountLogMapper.insert(new AccountLog(to.getId(), TRANSFER_IN, request.getAmount()));
}

12. 账户系统的双记账法?

每笔交易记录两条账目(有借必有贷,借贷必相等):


用户支付100元:
  借:应收渠道款  +100元
  贷:用户待结算  +100元

商户结算95元:
  借:商户待结算  -95元
  贷:银行存款    -95元

平台收入5元:
  借:商户待结算  -5元
  贷:平台收入    +5元

校验:每笔交易的借贷必须平衡,否则告警。

13. 如何防止重复支付?

1. 前端防重:按钮置灰 + Token

2. 后端幂等:唯一订单号 + 状态检查

3. 渠道去重:调用渠道时传递唯一请求号

4. 异步校验:对账时发现重复则调退款


// 渠道调用前先查询
public PayResult pay(PayOrder order) {
    // 1. 先查询渠道是否已支付
    ChannelQueryResult query = channelService.query(order.getOutTradeNo());
    if (query.isSuccess()) {
        // 已支付,更新状态(不重复调渠道)
        payOrderService.paySuccess(order.getOutTradeNo(), query.getTransactionId());
        return PayResult.success(query.getTransactionId());
    }

    // 2. 未支付,调用渠道
    return channelService.pay(order);
}

五、支付路由

14. 支付路由的设计?

支付路由根据多个维度智能选择支付渠道:


@Component
public class PayRouter {
    List<PayChannel> channels;

    public PayChannel route(PayRequest request) {
        return channels.stream()
            .filter(ch -> ch.supports(request))            // 支持该支付方式
            .filter(ch -> ch.isAvailable())                // 渠道可用
            .filter(ch -> ch.getFeeRate() <= maxFeeRate)   // 费率可接受
            .min(Comparator.comparing(PayChannel::getFeeRate))  // 选最便宜的
            .orElseThrow(() -> new BusinessException("无可用支付渠道"));
    }
}

路由维度:

15. 支付渠道的降级策略?


public class PayChannelFacade {
    @Autowired List<PayChannel> channels;

    public PayResult pay(PayRequest request) {
        PayChannel primary = channels.get(0);
        try {
            return primary.pay(request);
        } catch (ChannelException e) {
            log.warn("主渠道失败,切换备用渠道", e);
            // 降级到备用渠道
            for (int i = 1; i < channels.size(); i++) {
                try {
                    return channels.get(i).pay(request);
                } catch (ChannelException ex) {
                    log.error("渠道{}也失败了", i, ex);
                }
            }
            throw new BusinessException("所有支付渠道不可用");
        }
    }
}

六、风控系统

16. 支付风控的核心规则?

1. 限额控制:单笔限额、单日限额、单月限额

2. 频率控制:同一用户/商户的支付频率

3. 黑名单:高风险用户/商户/IP

4. 设备指纹:识别同一设备的多次支付

5. 异常行为:短时间大量小额支付(洗钱特征)

6. 地域异常:非常用地区支付


@Service
public class PayRiskControl {
    public void check(PayRequest request) {
        // 1. 限额检查
        if (request.getAmount().compareTo(singleLimit) > 0) {
            throw new RiskException("超出单笔限额");
        }

        // 2. 日限额检查
        BigDecimal todayTotal = payOrderMapper.sumTodayByUser(request.getUserId());
        if (todayTotal.add(request.getAmount()).compareTo(dailyLimit) > 0) {
            throw new RiskException("超出日限额");
        }

        // 3. 频率检查
        long recentCount = payOrderMapper.countRecent(request.getUserId(), 10, TimeUnit.MINUTES);
        if (recentCount >= 10) {
            throw new RiskException("支付频率过高");
        }

        // 4. 黑名单检查
        if (blacklistService.isBlack(request.getUserId())) {
            throw new RiskException("账户受限");
        }
    }
}

17. 如何设计反洗钱(AML)系统?


七、退款系统

18. 退款的设计和实现?


@Service
public class RefundService {
    @Transactional
    public RefundResult refund(RefundRequest request) {
        // 1. 校验
        PayOrder order = payOrderMapper.findByOutTradeNo(request.getOutTradeNo());
        if (order.getStatus() != PAID) {
            throw new BusinessException("订单状态不允许退款");
        }
        BigDecimal refunded = refundMapper.sumByOrder(order.getId());
        if (refunded.add(request.getAmount()).compareTo(order.getAmount()) > 0) {
            throw new BusinessException("退款金额超出支付金额");
        }

        // 2. 创建退款单
        RefundOrder refund = new RefundOrder(order, request.getAmount());
        refundMapper.insert(refund);

        // 3. 调用渠道退款
        ChannelRefundResult result = channelService.refund(refund);

        // 4. 更新状态
        if (result.isSuccess()) {
            refund.setStatus(REFUND_SUCCESS);
            // 冲正记账
            accountService.reverse(order, request.getAmount());
        } else {
            refund.setStatus(REFUND_FAILED);
        }
        refundMapper.update(refund);
        return RefundResult.of(refund);
    }
}

19. 部分退款怎么处理?


八、分布式事务

20. 支付中的分布式事务怎么处理?

场景:支付成功后需要同时更新支付单状态 + 记账 + 通知业务系统

方案一:本地消息表


@Transactional
public void paySuccess(String outTradeNo, String channelTradeNo) {
    // 1. 更新支付单
    payOrderMapper.updateStatus(outTradeNo, PAID, channelTradeNo);
    // 2. 记账
    accountService.record(new AccountEntry(...));
    // 3. 写消息表
    messageMapper.insert(new OutboxMessage("PAY_SUCCESS", outTradeNo));
}

// 异步发送消息
@Scheduled(fixedRate = 5000)
public void sendMessages() {
    List<OutboxMessage> messages = messageMapper.findPending();
    for (OutboxMessage msg : messages) {
        kafkaTemplate.send("pay-events", msg.getKey(), msg.getBody());
        messageMapper.updateStatus(msg.getId(), SENT);
    }
}

方案二:RocketMQ事务消息


@Transactional
public void pay(PayRequest request) {
    // 1. 创建支付单
    PayOrder order = new PayOrder(request);
    payOrderMapper.insert(order);
    // 2. 发送事务消息
    rocketMQTemplate.sendMessageInTransaction("pay-topic",
        MessageBuilder.withPayload(order).build(), order);
}

// 事务回查
@RocketMQTransactionListener
class PayTransactionListener implements RocketMQLocalTransactionListener {
    @Override
    public RocketMQLocalTransactionState executeLocalTransaction(Message msg, Object arg) {
        try {
            channelService.pay((PayOrder) arg);
            return COMMIT;
        } catch (Exception e) {
            return ROLLBACK;
        }
    }
}

九、面试高频综合题

21. 如何设计一个支付系统的数据库?

核心原则:

核心表:

22. 支付系统的SLA怎么设计?

23. 支付系统如何做灰度发布?

1. 按商户灰度:先对内部商户上线

2. 按金额灰度:先对小额支付上线

3. 按渠道灰度:先对某个支付渠道上线

4. 特性开关:运行时切换新旧逻辑

5. 实时监控:灰度期间密切监控成功率

24. 如何回答"设计一个支付系统"?

1. 需求确认:B2C还是B2B?支持哪些支付渠道?日交易量级?

2. 核心流程:下单→支付→回调→记账→对账→结算

3. 关键设计:

4. 对账结算:T+1对账+自动结算

5. 监控告警:成功率+响应时间+对账差异

25. 支付系统的合规要求?


面试速记口诀

支付四核心:幂等防重复、对账保一致、风控防欺诈、审计可追溯

>

资金安全三原则:Decimal存金额、事务保一致、对账做兜底

>

分布式事务:本地消息表最可靠、事务消息最优雅

>

设计回答:需求确认→核心流程→关键设计→对账结算→监控合规