《从 0 到 1 构建支付中台：核心业务与技术架构详解》
从 0 到 1 构建支付中台：核心业务与技术架构详解
一、支付中台核心业务流程
1. 开户（用户 / 商户）
- 业务流程
-
实名认证：验证用户 / 商户身份信息（身份证、营业执照等）
-
绑卡验证：验证银行卡信息真实性（四要素验证）
-
账户创建：生成唯一账户 ID，初始化账户余额为 0
-
风险评估：基于反洗钱规则评估风险等级
- 关键接口
// 用户开户接口
public Response createUserAccount(UserInfo userInfo, BankCardInfo bankCard) {
  // 1. 身份验证
  boolean identityVerified = identityVerificationService.verify(userInfo);
  // 2. 绑卡验证
  boolean bankCardVerified = bankCardService.verify(bankCard);
  // 3. 创建账户
  if(identityVerified && bankCardVerified) {
  Account account = accountService.createAccount(userInfo);
  // 4. 风险评估
  RiskLevel riskLevel = riskService.evaluate(account);
  return Response.success(account.getAccountId(), riskLevel);
  }
  return Response.failure("开户失败");
}
2. 支付（核心流程）
- 业务流程
-
订单创建：生成支付订单（金额、商品信息、支付方式）
-
渠道路由：根据支付方式选择最优支付渠道
-
支付处理：调用第三方支付接口，获取支付结果
-
订单结算：支付成功后更新订单状态，记账
- 关键接口
// 支付处理接口
public PaymentResult processPayment(PaymentRequest request) {
  // 1. 创建支付订单
  PaymentOrder order = orderService.createOrder(request);
  // 2. 渠道路由（根据金额、用户等选择渠道）
  PaymentChannel channel = routingService.selectChannel(order);
  // 3. 调用渠道支付
  ChannelResponse channelResponse = channelService.invoke(channel, order);
  // 4. 处理结果
  if(channelResponse.isSuccess()) {
  // 支付成功：更新订单状态
  orderService.updateStatus(order.getOrderId(), OrderStatus.PAID);
  // 记账
  accountingService.recordTransaction(order);
  return PaymentResult.success(order.getOrderId());
  } else {
  // 支付失败：记录失败原因
  orderService.updateStatus(order.getOrderId(), OrderStatus.FAILED);
  return PaymentResult.failure(channelResponse.getErrorCode());
  }
}
3. 分账（多方结算）
- 业务流程
-
分账规则配置：设置分账比例（如平台抽成 10%，商户 80%，供应商 10%）
-
触发分账：支付成功后按规则自动分账或手动触发
-
资金划转：从主账户划转到各分账账户
-
分账记录：记录每笔分账明细
- 关键接口
// 分账处理接口
public SplitResult processSplit(SplitRequest request) {
  // 1. 验证分账规则
  SplitRule rule = ruleService.getRule(request.getOrderId());
  if(!rule.isValid()) {
  return SplitResult.failure("分账规则无效");
  }
  // 2. 计算分账金额
  List\<SplitItem> items = calculateService.calculate(rule, request.getAmount());
  // 3. 执行分账（原子操作）
  boolean success = transactionTemplate.execute(status -> {
  try {
  for(SplitItem item : items) {
  accountService.transfer(
  request.getMainAccountId(), 
  item.getTargetAccountId(), 
  item.getAmount()
  );
  }
  return true;
  } catch(Exception e) {
  status.setRollbackOnly();
  return false;
  }
  });
  // 4. 记录分账结果
  if(success) {
  splitService.record(items);
  return SplitResult.success();
  }
  return SplitResult.failure("分账失败");
}
4. 提现（资金转出）
- 业务流程
-
提现申请：用户提交提现金额和银行卡信息
-
余额校验：验证账户余额是否充足
-
风控审核：检查是否存在洗钱风险
-
银行转账：调用银行接口进行资金转出
-
状态更新：更新提现状态（处理中、成功、失败）
- 关键接口
// 提现处理接口
public WithdrawResult processWithdraw(WithdrawRequest request) {
  // 1. 校验余额
  Account account = accountService.getAccount(request.getAccountId());
  if(account.getBalance() < request.getAmount()) {
  return WithdrawResult.failure("余额不足");
  }
  // 2. 风控审核
  boolean riskPassed = riskService.checkWithdraw(account, request.getAmount());
  if(!riskPassed) {
  return WithdrawResult.failure("提现被风控拦截");
  }
  // 3. 预扣余额
  accountService.lockBalance(request.getAccountId(), request.getAmount());
  // 4. 调用银行转账
  BankResponse bankResponse = bankService.transfer(
  request.getBankCard(), 
  request.getAmount()
  );
  // 5. 更新状态
  if(bankResponse.isSuccess()) {
  accountService.debitBalance(request.getAccountId(), request.getAmount());
  return WithdrawResult.success();
  } else {
  accountService.unlockBalance(request.getAccountId(), request.getAmount());
  return WithdrawResult.failure(bankResponse.getErrorCode());
  }
}
5. 退款（资金退回）
- 业务流程
-
退款申请：用户 / 商户提交退款请求
-
订单校验：验证订单是否可退款（未结算、未过期）
-
退款处理：调用支付渠道退款接口
-
资金退回：退款成功后将资金退回用户账户
-
通知用户：发送退款成功通知
- 关键接口
// 退款处理接口
public RefundResult processRefund(RefundRequest request) {
  // 1. 验证订单
  PaymentOrder order = orderService.getOrder(request.getOrderId());
  if(!order.canRefund()) {
  return RefundResult.failure("订单不可退款");
  }
  // 2. 创建退款订单
  RefundOrder refundOrder = refundService.createRefundOrder(request);
  // 3. 调用渠道退款
  ChannelResponse response = channelService.refund(
  order.getChannelId(), 
  refundOrder.getRefundId(), 
  request.getAmount()
  );
  // 4. 处理结果
  if(response.isSuccess()) {
  // 退款成功：更新状态，退回资金
  refundService.updateStatus(refundOrder.getRefundId(), RefundStatus.SUCCESS);
  accountService.creditBalance(
  order.getPayerAccountId(), 
  request.getAmount()
  );
  notificationService.sendRefundSuccess(order.getPayerId());
  return RefundResult.success();
  } else {
  // 退款失败：记录失败原因
  refundService.updateStatus(refundOrder.getRefundId(), RefundStatus.FAILED);
  return RefundResult.failure(response.getErrorCode());
  }
}
二、技术架构设计
1. 系统分层架构
┌─────────────────────────────────────────────────────────┐
│ 接入层 │
│ (API网关、负载均衡、限流、认证授权、请求路由) │
├─────────────────────────────────────────────────────────┤
│ 应用层 │
│ ┌───────────────┐ ┌───────────────┐ ┌───────────────┐ │
│ │ 支付服务 │ │ 账户服务 │ │ 分账服务 │ │
│ └───────────────┘ └───────────────┘ └───────────────┘ │
│ ┌───────────────┐ ┌───────────────┐ ┌───────────────┐ │
│ │ 退款服务 │ │ 提现服务 │ │ 风控服务 │ │
│ └───────────────┘ └───────────────┘ └───────────────┘ │
├─────────────────────────────────────────────────────────┤
│ 核心层 │
│ (订单管理、账户管理、渠道管理、清算结算、通知中心) │
├─────────────────────────────────────────────────────────┤
│ 数据层 │
│ (数据库、缓存、消息队列、分布式事务) │
└─────────────────────────────────────────────────────────┘
2. 数据模型设计
// 核心数据模型示例
public class Account {
  private String accountId; // 账户ID
  private String userId; // 用户ID
  private BigDecimal balance; // 余额
  private AccountStatus status; // 账户状态
  private Date createTime; // 创建时间
  // getter/setter
}
public class PaymentOrder {
  private String orderId; // 订单ID
  private String merchantId; // 商户ID
  private BigDecimal amount; // 金额
  private String currency; // 币种
  private PaymentMethod method; // 支付方式
  private String channelId; // 支付渠道ID
  private OrderStatus status; // 订单状态
  private Date createTime; // 创建时间
  // getter/setter
}
public class SplitRule {
  private String ruleId; // 规则ID
  private String orderType; // 订单类型
  private List\<SplitItem> items; // 分账项
  private boolean enabled; // 是否启用
  private Date createTime; // 创建时间
  // getter/setter
}
public class RefundOrder {
  private String refundId; // 退款ID
  private String orderId; // 原订单ID
  private BigDecimal amount; // 退款金额
  private RefundReason reason; // 退款原因
  private RefundStatus status; // 退款状态
  private Date createTime; // 创建时间
  // getter/setter
}
3. 支付渠道管理
// 渠道管理核心接口
public interface PaymentChannelService {
  // 获取可用渠道列表
  List\<PaymentChannel> getAvailableChannels(PaymentOrder order);
   
  // 调用渠道支付
  ChannelResponse pay(PaymentChannel channel, PaymentOrder order);
   
  // 调用渠道退款
  ChannelResponse refund(PaymentChannel channel, String refundId, BigDecimal amount);
   
  // 查询渠道订单状态
  ChannelResponse queryStatus(PaymentChannel channel, String orderId);
}
// 渠道适配器示例（支付宝）
public class AlipayChannelAdapter implements PaymentChannelAdapter {
  private AlipayClient alipayClient;
   
  @Override
  public ChannelResponse pay(PaymentOrder order) {
  // 构建支付宝请求
  AlipayTradePagePayRequest request = new AlipayTradePagePayRequest();
  request.setReturnUrl(order.getReturnUrl());
  request.setNotifyUrl(order.getNotifyUrl());
  request.setBizContent(buildBizContent(order));
   
  try {
  // 调用支付宝接口
  AlipayTradePagePayResponse response = alipayClient.pageExecute(request);
  if(response.isSuccess()) {
  return ChannelResponse.success(response.getBody());
  } else {
  return ChannelResponse.failure(response.getCode(), response.getMsg());
  }
  } catch (AlipayApiException e) {
  log.error("支付宝支付异常", e);
  return ChannelResponse.failure("9999", "系统异常");
  }
  }
   
  // 其他方法实现...
}
三、关键技术挑战与解决方案
1. 分布式事务问题
-
方案：TCC（Try-Confirm-Cancel）+ 事务补偿
-
示例（分账场景）：
// TCC分账服务
public class SplitServiceTCC {
  // Try阶段：预占资金
  @Transactional
  public boolean prepareSplit(SplitOrder splitOrder) {
  // 冻结主账户资金
  return accountService.freezeAmount(
  splitOrder.getMainAccountId(), 
  splitOrder.getTotalAmount()
  );
  }
   
  // Confirm阶段：确认分账
  @Transactional
  public boolean confirmSplit(SplitOrder splitOrder) {
  // 执行分账（从冻结金额划转）
  for(SplitItem item : splitOrder.getItems()) {
  accountService.transferFromFrozen(
  splitOrder.getMainAccountId(),
  item.getTargetAccountId(),
  item.getAmount()
  );
  }
  return true;
  }
   
  // Cancel阶段：取消分账
  @Transactional
  public boolean cancelSplit(SplitOrder splitOrder) {
  // 解冻预占资金
  return accountService.unfreezeAmount(
  splitOrder.getMainAccountId(),
  splitOrder.getTotalAmount()
  );
  }
}
2. 高并发处理
- 策略：
-
订单号生成：雪花算法（Snowflake）生成分布式唯一 ID
-
限流熔断：对热点接口限流（如每秒 10 万 QPS），熔断降级
-
异步处理：提现、分账等非实时业务采用 MQ 异步处理
-
读写分离：账户查询走从库，交易操作走主库
- 示例（支付接口限流）：
@Service
public class PaymentServiceImpl implements PaymentService {
  @Autowired
  private RateLimiter rateLimiter; // 限流组件
   
  @Override
  public PaymentResult processPayment(PaymentRequest request) {
  // 尝试获取令牌，超过阈值则拒绝
  if(!rateLimiter.tryAcquire()) {
  return PaymentResult.failure("429", "系统繁忙，请稍后再试");
  }
  // 正常处理支付逻辑
  return doProcessPayment(request);
  }
}
3. 数据一致性保障
- 对账机制：
-
每日定时与支付渠道对账
-
发现差异时生成对账差异表
-
人工干预或自动补偿（如长款退回、短款追缴）
- 幂等设计：
@Service
public class PaymentServiceImpl implements PaymentService {
  @Autowired
  private PaymentOrderRepository orderRepository;
   
  @Override
  @Transactional
  public synchronized PaymentResult processPayment(PaymentRequest request) {
  // 幂等检查：根据业务ID查询是否已处理
  PaymentOrder existingOrder = orderRepository.findByBizId(request.getBizId());
  if(existingOrder != null) {
  return PaymentResult.success(existingOrder.getOrderId());
  }
  // 正常处理支付逻辑
  return doProcessPayment(request);
  }
}
四、部署与运维
1. 微服务拆分
┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
│ 账户服务 │ │ 订单服务 │ │ 支付渠道服务 │
└─────────────────┘ └─────────────────┘ └─────────────────┘
  ▲ ▲ ▲
  │ │ │
┌─────────────────────────────────────────────────┐
│ API网关 │
└─────────────────────────────────────────────────┘
  ▲ ▲ ▲
  │ │ │
┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
│ 商户管理系统 │ │ 运营后台 │ │ 客户端应用 │
└─────────────────┘ └─────────────────┘ └─────────────────┘
2. 弹性伸缩配置
\# 支付服务HPA配置（基于TPS自动伸缩）
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: payment-service-hpa
spec:
  scaleTargetRef:
  apiVersion: apps/v1
  kind: Deployment
  name: payment-service
  minReplicas: 5
  maxReplicas: 50
  metrics:
  \- type: Pods
  pods:
  metric:
  name: payment\_tps
  target:
  type: AverageValue
  averageValue: 2000 # 每个Pod平均处理2000TPS
五、安全与合规
- 数据安全
-
敏感数据加密（银行卡号、身份证号）
-
传输层使用 HTTPS
-
数据库字段加密存储
- 合规要求
-
符合 PCI DSS 支付卡行业数据安全标准
-
满足反洗钱（AML）和 KYC 要求
-
实现交易监控和风险预警
- 权限控制
-
基于 RBAC 的权限模型
-
操作审计日志记录
-
敏感操作二次认证
通过以上设计，可构建一个高可用、高性能、安全合规的支付中台系统，支持开户、支付、分账、提现、退款等核心业务，并具备良好的扩展性和弹性伸缩能力。
（注：文档部分内容可能由 AI 生成）
