20K Java+AI 岗位高频考点 — 支付系统是金融级系统的代表,面试必考的系统设计题。覆盖支付架构、幂等性、对账、清结算、资金安全、分布式事务等核心场景。
用户/商户 → API网关 → 支付核心
├── 收银台(下单/支付/退款)
├── 支付路由(智能选择支付渠道)
├── 渠道网关(对接微信/支付宝/银行)
├── 账务系统(记账/余额管理)
├── 清结算系统(商户结算)
├── 对账系统(资金核对)
└── 风控系统(反欺诈/限额)
支付主流程:
1. 用户下单 → 创建支付单
2. 选择支付方式 → 调用支付渠道(微信/支付宝)
3. 支付渠道回调 → 更新支付状态
4. 记账 → 更新账户余额
5. 通知业务系统 → 订单状态变更
6. 对账 → 与渠道账单核对
7. 清结算 → 商户资金结算
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;
场景:网络超时导致重复支付、用户重复点击、渠道重复回调。
幂等方案:
方案一:唯一订单号 + 数据库唯一约束
@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);
}
@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";
}
关键点:
对账目的:确保系统记录与支付渠道的实际资金一致。
对账流程:
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);
}
}
自动处理:
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);
}
}
}
}
清算:计算各参与方应该收付多少钱
结算:实际执行资金转移
用户支付100元 → 平台收100元
↓ 清算
商户分到95元(扣除5元手续费)
平台收5元
↓ 结算
T+1日自动打款到商户银行账户
// 分账规则
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;
}
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);
}
}
原则: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()));
}
每笔交易记录两条账目(有借必有贷,借贷必相等):
用户支付100元:
借:应收渠道款 +100元
贷:用户待结算 +100元
商户结算95元:
借:商户待结算 -95元
贷:银行存款 -95元
平台收入5元:
借:商户待结算 -5元
贷:平台收入 +5元
校验:每笔交易的借贷必须平衡,否则告警。
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);
}
支付路由根据多个维度智能选择支付渠道:
@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("无可用支付渠道"));
}
}
路由维度:
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("所有支付渠道不可用");
}
}
}
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("账户受限");
}
}
}
@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);
}
}
场景:支付成功后需要同时更新支付单状态 + 记账 + 通知业务系统
方案一:本地消息表
@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;
}
}
}
核心原则:
DECIMAL(12,2),绝不用FLOAT核心表:
pay_order:支付订单refund_order:退款订单account:账户account_entry:账户流水reconcile_result:对账结果settlement_order:结算订单outbox_message:消息发件箱1. 按商户灰度:先对内部商户上线
2. 按金额灰度:先对小额支付上线
3. 按渠道灰度:先对某个支付渠道上线
4. 特性开关:运行时切换新旧逻辑
5. 实时监控:灰度期间密切监控成功率
1. 需求确认:B2C还是B2B?支持哪些支付渠道?日交易量级?
2. 核心流程:下单→支付→回调→记账→对账→结算
3. 关键设计:
4. 对账结算:T+1对账+自动结算
5. 监控告警:成功率+响应时间+对账差异
支付四核心:幂等防重复、对账保一致、风控防欺诈、审计可追溯
>
资金安全三原则:Decimal存金额、事务保一致、对账做兜底
>
分布式事务:本地消息表最可靠、事务消息最优雅
>
设计回答:需求确认→核心流程→关键设计→对账结算→监控合规