支付中心：统一收银台的设计原理与最佳实践

这是支付中心系列的第8篇，也是最后一篇。我们来聊聊统一收银台——这个直接面向用户、决定支付转化率的关键组件。它就像商场的收银台，是用户完成交易的最后一道门。

一、为什么需要统一收银台

如果你经历过电商早期，可能见过这样的场景：每个业务线自己对接支付渠道，微信支付找微信、支付宝找支付宝、银联找银联……结果就是：

• 重复造轮子：每个业务都要实现一套支付流程
• 体验不一致：A业务的收银台长得像表单，B业务的像抽奖页面
• 维护成本高：支付渠道升级，所有业务线都要改
• 数据分散：想看整体支付数据？不好意思，要去七个系统分别导出

统一收银台就是为了解决这些问题。它的核心价值很简单：把支付这件事，变成一个标准服务，而不是每个业务的私事。

1.1 从架构视角看统一收银台

想象一下，如果每个业务都自己对接支付：

┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│   电商业务   │     │   订单业务   │     │   会员业务   │
└──────┬──────┘     └──────┬──────┘     └──────┬──────┘
       │                   │                   │
       ▼                   ▼                   ▼
   ┌───────────────────────────────────────────────┐
   │              各自对接支付渠道                    │
   │  微信支付 │ 支付宝 │ 银联 │ PayPal │ ...       │
   └───────────────────────────────────────────────┘

这就像每个部门都自己招保洁，而不是找物业公司。表面看似乎灵活，实际上效率低下、成本高昂。

有了统一收银台后：

┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│   电商业务   │     │   订单业务   │     │   会员业务   │
└──────┬──────┘     └──────┬──────┘     └──────┬──────┘
       │                   │                   │
       └───────────────────┼───────────────────┘
                           ▼
              ┌────────────────────────┐
              │      统一收银台         │
              │  (统一接口 + 路由策略)   │
              └───────────┬────────────┘
                          │
       ┌──────────────────┼──────────────────┐
       ▼                  ▼                  ▼
   ┌────────┐        ┌────────┐        ┌────────┐
   │微信支付 │        │ 支付宝  │        │  银联  │
   └────────┘        └────────┘        └────────┘

这种抽象带来的好处是：

1. 业务解耦：业务系统只关心业务逻辑，支付细节全部下沉
2. 统一体验：无论哪个业务线，用户看到的收银台风格一致
3. 灵活扩展：新增支付渠道，业务系统无感知
4. 集中监控：所有支付流量汇聚一处，问题一目了然

1.2 一个真实的故事

我之前接触过一个电商平台，早期每个业务线自己对接支付。有一次支付宝升级接口，要求所有商户在一个月内完成迁移。结果呢？三个业务线，三套代码，三波人马各自折腾。最惨的是会员系统，因为开发资源紧张，拖到最后一周才动工，差点影响线上支付。

后来他们花了两个月搭建统一收银台，再遇到渠道升级，只需要收银台团队改一个地方，所有业务线自动受益。这就是架构的力量——把重复劳动变成基础设施。

1.3 统一收银台的定位

在整体支付架构中，统一收银台处于承上启下的关键位置：

┌─────────────────────────────────────────────────────────────┐
│                        业务系统层                            │
│   电商系统  │  订单系统  │  会员系统  │  营销系统  │  ...    │
└──────────────────────────┬──────────────────────────────────┘
                           │ 统一支付API
                           ▼
┌─────────────────────────────────────────────────────────────┐
│                      统一收银台（核心）                       │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐       │
│  │ 订单管理 │  │ 路由策略 │  │ 风控集成 │  │ 状态管理 │       │
│  └─────────┘  └─────────┘  └─────────┘  └─────────┘       │
└──────────────────────────┬──────────────────────────────────┘
                           │ 渠道适配器
                           ▼
┌─────────────────────────────────────────────────────────────┐
│                        支付渠道层                            │
│  微信支付  │  支付宝  │  银联  │  PayPal  │  数字人民币  │  │
└─────────────────────────────────────────────────────────────┘

• 统一接入：为业务系统提供标准化的支付接口
• 渠道聚合：屏蔽底层渠道差异，实现多渠道统一管理
• 智能路由：根据场景自动选择最优支付渠道
• 状态管理：管理支付订单的完整生命周期
• 风控集成：在支付流程中嵌入风险识别

二、收银台架构设计深度剖析

统一收银台看起来就是一个支付页面，但背后承载的功能远比表面复杂。它就像一个精密的指挥中心，协调着用户、业务系统、支付渠道三方。

2.1 整体架构分层

收银台在架构上分为四层：

┌─────────────────────────────────────────────────────────────┐
│                         展示层                               │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐    │
│  │ App SDK  │  │ H5页面   │  │ 小程序   │  │ PC页面   │    │
│  └────┬─────┘  └────┬─────┘  └────┬─────┘  └────┬─────┘    │
│       │             │             │             │          │
│       └─────────────┴──────┬──────┴─────────────┘          │
│                            ▼                                │
│                    ┌───────────────┐                        │
│                    │   API Gateway  │                       │
│                    │ (鉴权/限流/路由)│                       │
│                    └───────┬───────┘                        │
└────────────────────────────┼────────────────────────────────┘
                             │
┌────────────────────────────┼────────────────────────────────┐
│                            ▼                                │
│                         业务逻辑层                           │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐         │
│  │  订单服务    │  │  路由服务    │  │  风控服务    │         │
│  │  (状态机)    │  │  (策略引擎)  │  │  (规则引擎)  │         │
│  └──────┬──────┘  └──────┬──────┘  └──────┬──────┘         │
│         │                │                │                │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐         │
│  │  用户服务    │  │  优惠服务    │  │  通知服务    │         │
│  └──────┬──────┘  └──────┬──────┘  └──────┬──────┘         │
│         │                │                │                │
│         └────────────────┼────────────────┘                │
│                          ▼                                 │
│                  ┌───────────────┐                         │
│                  │   渠道代理层   │                         │
│                  └───────┬───────┘                         │
└─────────────────────────┼───────────────────────────────────┘
                          │
┌─────────────────────────┼───────────────────────────────────┐
│                         ▼                                   │
│                        渠道适配层                            │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐   │
│  │ 微信适配器│  │ 支付宝适配│  │ 银联适配器│  │ PayPal  │   │
│  └──────────┘  └──────────┘  └──────────┘  └──────────┘   │
└─────────────────────────────────────────────────────────────┘

2.2 支付渠道适配器模式

为了统一管理不同支付渠道的差异，我们采用适配器模式：

// 支付渠道统一接口
public interface PaymentChannel {
    
    /**
     * 获取渠道编码
     */
    String getChannelCode();
    
    /**
     * 获取渠道名称
     */
    String getChannelName();
    
    /**
     * 创建支付单
     * @param order 支付订单
     * @return 支付凭证（用于唤起支付）
     */
    CreatePayResult createPay(PayOrder order);
    
    /**
     * 查询支付状态
     * @param payId 支付单ID
     * @return 支付状态
     */
    QueryPayResult queryPay(String payId);
    
    /**
     * 处理回调通知
     * @param request HTTP请求
     * @return 解析后的回调数据
     */
    CallbackResult handleCallback(HttpServletRequest request);
    
    /**
     * 关闭支付单
     * @param payId 支付单ID
     * @return 关闭结果
     */
    CloseResult closePay(String payId);
    
    /**
     * 申请退款
     * @param refundRequest 退款请求
     * @return 退款结果
     */
    RefundResult refund(RefundRequest refundRequest);
    
    /**
     * 检查渠道是否可用
     */
    boolean isAvailable();
    
    /**
     * 获取渠道费率
     */
    BigDecimal getFeeRate();
}

// 微信支付适配器实现
@Component
public class WechatPayChannel implements PaymentChannel {
    
    @Autowired
    private WechatPayConfig config;
    
    @Autowired
    private WechatPayClient client;
    
    @Override
    public String getChannelCode() {
        return "WECHAT";
    }
    
    @Override
    public CreatePayResult createPay(PayOrder order) {
        try {
            // 1. 构建微信支付请求
            WxPayUnifiedOrderRequest request = WxPayUnifiedOrderRequest.newBuilder()
                .outTradeNo(order.getOrderId())
                .body(order.getSubject())
                .totalFee(order.getAmount().multiply(new BigDecimal("100")).intValue())
                .spbillCreateIp(order.getClientIp())
                .notifyUrl(config.getNotifyUrl())
                .tradeType(TradeType.JSAPI)
                .openid(order.getOpenId())
                .build();
            
            // 2. 调用微信支付API
            WxPayUnifiedOrderResult result = client.createOrder(request);
            
            // 3. 生成前端支付凭证
            String prepayId = result.getPrepayId();
            Map<String, String> payInfo = buildJsapiPayInfo(prepayId);
            
            return CreatePayResult.success(prepayId, payInfo);
            
        } catch (WxPayException e) {
            log.error("微信支付创建失败: orderId={}, error={}", order.getOrderId(), e.getMessage());
            return CreatePayResult.fail(e.getErrCodeDes());
        }
    }
    
    @Override
    public CallbackResult handleCallback(HttpServletRequest request) {
        try {
            // 1. 读取回调数据
            String xmlData = readRequestData(request);
            
            // 2. 验证签名
            if (!client.checkSign(xmlData)) {
                return CallbackResult.fail("签名验证失败");
            }
            
            // 3. 解析回调数据
            WxPayOrderNotifyResult result = client.parseOrderNotifyResult(xmlData);
            
            // 4. 返回统一格式
            return CallbackResult.success()
                .setOrderId(result.getOutTradeNo())
                .setTransactionId(result.getTransactionId())
                .setPayTime(result.getTimeEnd())
                .setAmount(new BigDecimal(result.getTotalFee()).divide(new BigDecimal("100")));
                
        } catch (Exception e) {
            log.error("微信支付回调处理失败", e);
            return CallbackResult.fail(e.getMessage());
        }
    }
    
    // ... 其他方法实现
}

// 支付宝适配器实现
@Component
public class AlipayChannel implements PaymentChannel {
    
    @Autowired
    private AlipayConfig config;
    
    @Autowired
    private AlipayClient client;
    
    @Override
    public String getChannelCode() {
        return "ALIPAY";
    }
    
    @Override
    public CreatePayResult createPay(PayOrder order) {
        try {
            // 1. 构建支付宝请求
            AlipayTradeAppPayRequest request = new AlipayTradeAppPayRequest();
            AlipayTradeAppPayModel model = new AlipayTradeAppPayModel();
            model.setOutTradeNo(order.getOrderId());
            model.setTotalAmount(order.getAmount().toString());
            model.setSubject(order.getSubject());
            model.setProductCode("QUICK_MSECURITY_PAY");
            request.setBizModel(model);
            request.setNotifyUrl(config.getNotifyUrl());
            
            // 2. 调用支付宝API
            AlipayTradeAppPayResponse response = client.sdkExecute(request);
            
            if (response.isSuccess()) {
                return CreatePayResult.success(response.getTradeNo(), 
                    Map.of("orderString", response.getBody()));
            } else {
                return CreatePayResult.fail(response.getSubMsg());
            }
            
        } catch (AlipayApiException e) {
            log.error("支付宝创建失败: orderId={}", order.getOrderId(), e);
            return CreatePayResult.fail(e.getErrMsg());
        }
    }
    
    // ... 其他方法实现
}

• 统一接口：上层业务不需要关心底层渠道差异
• 易于扩展：新增渠道只需实现接口，无需修改现有代码
• 隔离变更：渠道升级只影响对应的适配器

2.3 渠道代理层设计

渠道代理层是收银台的"管家"，负责管理和调度所有支付渠道：

@Service
public class ChannelProxyService {
    
    // 渠道注册表
    private final Map<String, PaymentChannel> channelRegistry = new ConcurrentHashMap<>();
    
    @Autowired
    public ChannelProxyService(List<PaymentChannel> channels) {
        // 自动注册所有渠道
        channels.forEach(channel -> {
            channelRegistry.put(channel.getChannelCode(), channel);
            log.info("注册支付渠道: {} - {}", channel.getChannelCode(), channel.getChannelName());
        });
    }
    
    /**
     * 获取指定渠道
     */
    public PaymentChannel getChannel(String channelCode) {
        PaymentChannel channel = channelRegistry.get(channelCode);
        if (channel == null) {
            throw new ChannelNotFoundException("渠道不存在: " + channelCode);
        }
        return channel;
    }
    
    /**
     * 获取所有可用渠道
     */
    public List<PaymentChannel> getAvailableChannels() {
        return channelRegistry.values().stream()
            .filter(PaymentChannel::isAvailable)
            .collect(Collectors.toList());
    }
    
    /**
     * 执行支付（带降级）
     */
    public CreatePayResult executeWithFallback(PayOrder order, String preferredChannel) {
        // 1. 尝试首选渠道
        PaymentChannel channel = channelRegistry.get(preferredChannel);
        if (channel != null && channel.isAvailable()) {
            CreatePayResult result = channel.createPay(order);
            if (result.isSuccess()) {
                return result;
            }
        }
        
        // 2. 降级到其他渠道
        for (PaymentChannel fallbackChannel : getAvailableChannels()) {
            if (!fallbackChannel.getChannelCode().equals(preferredChannel)) {
                CreatePayResult result = fallbackChannel.createPay(order);
                if (result.isSuccess()) {
                    log.warn("支付渠道降级: {} -> {}", preferredChannel, fallbackChannel.getChannelCode());
                    return result;
                }
            }
        }
        
        return CreatePayResult.fail("所有支付渠道均不可用");
    }
}

三、多渠道聚合技术实现

当有多种支付渠道可选时，如何选择最优渠道？这就是多渠道聚合和路由策略要解决的问题。

3.1 多渠道聚合的核心挑战

3.2 路由决策维度

路由决策不是随机的，需要综合考虑多个维度：

┌─────────────────────────────────────────────────────────┐
│                    路由决策模型                          │
└─────────────────────────────────────────────────────────┘
         │
    ┌────┴────┐
    ▼         ▼
┌───────┐ ┌───────┐
│ 硬约束 │ │ 软约束 │
└───┬───┘ └───┬───┘
    │         │
    ▼         ▼
• 限额      • 成本
• 币种      • 成功率
• 业务规则  • 响应时间
• 地区      • 用户偏好
            • 营销策略

3.3 路由策略实现

3.3.1 静态优先级策略

最简单的策略，按预设优先级顺序尝试：

@Component
public class StaticPriorityRouter {
    
    // 渠道优先级配置
    @Value("${pay.router.priority:wechat,alipay,unionpay}")
    private String priorityConfig;
    
    private List<String> channelPriority;
    
    @PostConstruct
    public void init() {
        channelPriority = Arrays.asList(priorityConfig.split(","));
    }
    
    public RouteResult route(PayOrder order) {
        for (String channelCode : channelPriority) {
            PaymentChannel channel = channelProxy.getChannel(channelCode);
            
            // 检查硬约束
            if (!checkConstraints(channel, order)) {
                continue;
            }
            
            // 检查可用性
            if (channel.isAvailable()) {
                return RouteResult.success(channelCode, "静态优先级");
            }
        }
        
        return RouteResult.fail("无可用渠道");
    }
    
    private boolean checkConstraints(PaymentChannel channel, PayOrder order) {
        // 检查限额
        if (order.getAmount().compareTo(channel.getMaxAmount()) > 0) {
            return false;
        }
        
        // 检查币种
        if (!channel.getSupportedCurrencies().contains(order.getCurrency())) {
            return false;
        }
        
        return true;
    }
}

3.3.2 动态权重策略

根据渠道的实时表现动态调整权重：

@Component
public class DynamicWeightRouter {
    
    // 各渠道当前权重（定期更新）
    private final Map<String, Double> channelWeights = new ConcurrentHashMap<>();
    
    // 渠道统计数据
    @Autowired
    private ChannelStatisticsService statisticsService;
    
    /**
     * 路由决策
     */
    public RouteResult route(PayOrder order) {
        // 1. 获取满足硬约束的候选渠道
        List<PaymentChannel> candidates = getCandidateChannels(order);
        
        if (candidates.isEmpty()) {
            return RouteResult.fail("无满足条件的渠道");
        }
        
        // 2. 加权随机选择
        String selectedChannel = weightedRandomSelect(candidates);
        
        return RouteResult.success(selectedChannel, "动态权重路由");
    }
    
    /**
     * 加权随机选择
     */
    private String weightedRandomSelect(List<PaymentChannel> candidates) {
        // 计算总权重
        double totalWeight = candidates.stream()
            .mapToDouble(ch -> channelWeights.getOrDefault(ch.getChannelCode(), 1.0))
            .sum();
        
        // 随机选择
        double random = Math.random() * totalWeight;
        double cumulative = 0;
        
        for (PaymentChannel channel : candidates) {
            cumulative += channelWeights.getOrDefault(channel.getChannelCode(), 1.0);
            if (random < cumulative) {
                return channel.getChannelCode();
            }
        }
        
        // 兜底返回第一个
        return candidates.get(0).getChannelCode();
    }
    
    /**
     * 定时更新权重（每分钟）
     */
    @Scheduled(fixedRate = 60000)
    public void updateWeights() {
        for (String channelCode : channelProxy.getAllChannelCodes()) {
            // 获取最近1小时的统计数据
            ChannelStats stats = statisticsService.getStats(channelCode, Duration.ofHours(1));
            
            if (stats == null || stats.getTotalCount() < 10) {
                // 数据不足，使用默认权重
                channelWeights.put(channelCode, 1.0);
                continue;
            }
            
            // 计算综合权重
            // 权重 = 成功率 * 1000 / (平均延迟 + 100)
            double successRate = stats.getSuccessRate();
            double avgLatency = stats.getAvgLatency();
            double feeRate = channelProxy.getChannel(channelCode).getFeeRate().doubleValue();
            
            // 综合评分：成功率占60%，延迟占20%，费率占20%
            double weight = (successRate * 0.6) 
                         + (1000.0 / (avgLatency + 100) * 0.2)
                         + ((1 - feeRate) * 0.2);
            
            channelWeights.put(channelCode, weight);
            
            log.info("渠道权重更新: {} -> weight={:.4f}, successRate={:.2%}, latency={:.0f}ms",
                channelCode, weight, successRate, avgLatency);
        }
    }
}

3.3.3 规则引擎策略

通过配置规则来决定路由：

# 路由规则配置
routing_rules:
  - name: "跨境支付专用"
    id: rule_cross_border
    priority: 100
    condition:
      currency: ["USD", "EUR", "JPY"]
    channels: ["paypal", "stripe", "international_card"]
    
  - name: "大额低费率"
    id: rule_large_amount
    priority: 90
    condition:
      amount_min: 10000
      user_vip_level_min: 3
    channels: ["unionpay", "bank_direct"]
    
  - name: "小额快捷"
    id: rule_small_amount
    priority: 80
    condition:
      amount_max: 100
    channels: ["wechat", "alipay"]
    
  - name: "数字人民币推广"
    id: rule_dcep_promotion
    priority: 85
    condition:
      time_range: "2026-03-01~2026-03-31"
      user_tags: ["dcep_beta"]
    channels: ["dcep"]
    bonus_weight: 50
    
  - name: "默认路由"
    id: rule_default
    priority: 0
    condition: {}
    channels: ["wechat", "alipay", "unionpay"]

规则引擎实现：

@Service
public class RuleEngineRouter {
    
    @Autowired
    private RuleConfigRepository ruleConfigRepository;
    
    private List<RoutingRule> rules;
    
    @PostConstruct
    public void loadRules() {
        rules = ruleConfigRepository.loadAllRules();
        // 按优先级排序
        rules.sort(Comparator.comparingInt(RoutingRule::getPriority).reversed());
    }
    
    public RouteResult route(PayOrder order, UserContext user) {
        // 遍历所有规则，找到第一个匹配的
        for (RoutingRule rule : rules) {
            if (rule.matches(order, user)) {
                List<String> channels = rule.getChannels();
                
                // 从匹配的渠道中选择最优的
                String selectedChannel = selectBestChannel(channels, order);
                
                return RouteResult.success(selectedChannel, 
                    String.format("规则匹配: %s", rule.getName()));
            }
        }
        
        // 兜底：使用默认渠道
        return RouteResult.success("wechat", "默认路由");
    }
    
    private String selectBestChannel(List<String> channelCodes, PayOrder order) {
        // 在候选渠道中，选择可用性最好、成本最低的
        return channelCodes.stream()
            .filter(code -> channelProxy.getChannel(code).isAvailable())
            .min(Comparator.comparing(code -> channelProxy.getChannel(code).getFeeRate()))
            .orElse(channelCodes.get(0));
    }
}

// 规则匹配逻辑
@Data
public class RoutingRule {
    private String id;
    private String name;
    private int priority;
    private RuleCondition condition;
    private List<String> channels;
    private double bonusWeight;
    
    public boolean matches(PayOrder order, UserContext user) {
        return condition.matches(order, user);
    }
}

@Data
public class RuleCondition {
    private List<String> currency;
    private BigDecimal amountMin;
    private BigDecimal amountMax;
    private Integer userVipLevelMin;
    private List<String> userTags;
    private String timeRange;
    
    public boolean matches(PayOrder order, UserContext user) {
        // 币种检查
        if (currency != null && !currency.contains(order.getCurrency())) {
            return false;
        }
        
        // 金额检查
        if (amountMin != null && order.getAmount().compareTo(amountMin) < 0) {
            return false;
        }
        if (amountMax != null && order.getAmount().compareTo(amountMax) > 0) {
            return false;
        }
        
        // VIP等级检查
        if (userVipLevelMin != null && user.getVipLevel() < userVipLevelMin) {
            return false;
        }
        
        // 用户标签检查
        if (userTags != null && !userTags.isEmpty()) {
            boolean hasTag = userTags.stream().anyMatch(tag -> user.getTags().contains(tag));
            if (!hasTag) {
                return false;
            }
        }
        
        // 时间范围检查
        if (timeRange != null) {
            // 解析时间范围并检查
            // ...
        }
        
        return true;
    }
}

3.4 实战中的路由策略组合

实际应用中，往往是多种策略的组合：

@Service
public class CompositeRouter {
    
    @Autowired
    private RuleEngineRouter ruleEngineRouter;
    
    @Autowired
    private DynamicWeightRouter dynamicWeightRouter;
    
    @Autowired
    private UserPreferenceService userPreferenceService;
    
    public RouteResult route(PayOrder order, UserContext user) {
        
        // Step 1: 规则引擎过滤（获取候选渠道）
        List<String> candidates = ruleEngineRouter.getCandidateChannels(order, user);
        
        if (candidates.isEmpty()) {
            return RouteResult.fail("无满足业务规则的渠道");
        }
        
        // Step 2: 渠道可用性检查（剔除不可用渠道）
        candidates = candidates.stream()
            .filter(code -> channelProxy.getChannel(code).isAvailable())
            .collect(Collectors.toList());
        
        if (candidates.isEmpty()) {
            return RouteResult.fail("所有渠道均不可用");
        }
        
        // Step 3: 动态权重排序（按实时表现排序）
        candidates.sort((a, b) -> {
            double weightA = dynamicWeightRouter.getWeight(a);
            double weightB = dynamicWeightRouter.getWeight(b);
            return Double.compare(weightB, weightA); // 降序
        });
        
        // Step 4: 成本优化（同等条件选低费率）
        String bestChannel = candidates.get(0);
        double bestWeight = dynamicWeightRouter.getWeight(bestChannel);
        
        for (String candidate : candidates) {
            double weight = dynamicWeightRouter.getWeight(candidate);
            // 权重差异在5%以内，优先选低费率
            if (Math.abs(weight - bestWeight) / bestWeight < 0.05) {
                BigDecimal feeRate = channelProxy.getChannel(candidate).getFeeRate();
                if (feeRate.compareTo(channelProxy.getChannel(bestChannel).getFeeRate()) < 0) {
                    bestChannel = candidate;
                }
            }
        }
        
        // Step 5: 用户偏好（如果用户有强烈偏好，优先满足）
        String preferredChannel = userPreferenceService.getUserPreferredChannel(user.getUserId());
        if (preferredChannel != null && candidates.contains(preferredChannel)) {
            // 用户偏好渠道在候选列表中，且权重差异不大（20%以内），使用用户偏好
            double preferredWeight = dynamicWeightRouter.getWeight(preferredChannel);
            if (preferredWeight > bestWeight * 0.8) {
                bestChannel = preferredChannel;
            }
        }
        
        return RouteResult.success(bestChannel, "组合路由策略");
    }
}

┌─────────────────────────────────────────────────────────┐
│                    路由决策流程                          │
└─────────────────────────────────────────────────────────┘
                          │
                          ▼
              ┌───────────────────────┐
              │  1. 规则引擎过滤       │
              │  (业务规则 + 限额校验)  │
              └───────────┬───────────┘
                          │
                          ▼
              ┌───────────────────────┐
              │  2. 渠道可用性检查     │
              │  (剔除维护/故障渠道)   │
              └───────────┬───────────┘
                          │
                          ▼
              ┌───────────────────────┐
              │  3. 动态权重排序       │
              │  (成功率 * 响应时间)   │
              └───────────┬───────────┘
                          │
                          ▼
              ┌───────────────────────┐
              │  4. 成本优化          │
              │  (同等条件选低费率)    │
              └───────────┬───────────┘
                          │
                          ▼
              ┌───────────────────────┐
              │  5. 用户偏好          │
              │  (优先用户常用渠道)    │
              └───────────┬───────────┘
                          │
                          ▼
                   ┌─────────────┐
                   │  选定渠道    │
                   └─────────────┘

四、订单状态机设计

用户在收银台的操作不是原子性的。他可能选了微信支付，扫码后又后悔，切回支付宝。或者支付超时，又重新发起。收银台需要管理这些中间状态，确保：

• 同一笔订单不会重复支付
• 超时订单自动关闭
• 用户放弃后可以重新发起

4.1 订单状态定义

public enum PayOrderStatus {
    
    /**
     * 初始状态 - 订单创建
     */
    INIT("初始", 0),
    
    /**
     * 待支付 - 等待用户操作
     */
    WAIT_PAY("待支付", 10),
    
    /**
     * 支付中 - 用户正在支付
     */
    PAYING("支付中", 20),
    
    /**
     * 支付成功 - 交易完成
     */
    PAY_SUCCESS("支付成功", 30),
    
    /**
     * 支付失败 - 交易失败
     */
    PAY_FAILED("支付失败", 40),
    
    /**
     * 已关闭 - 超时或用户取消
     */
    CLOSED("已关闭", 50),
    
    /**
     * 已退款 - 交易退款
     */
    REFUNDED("已退款", 60),
    
    /**
     * 部分退款 - 部分金额退款
     */
    PARTIAL_REFUNDED("部分退款", 65);
    
    private final String desc;
    private final int code;
    
    PayOrderStatus(String desc, int code) {
        this.desc = desc;
        this.code = code;
    }
    
    // 状态流转规则
    private static final Map<PayOrderStatus, Set<PayOrderStatus>> TRANSITIONS = Map.of(
        INIT, Set.of(WAIT_PAY, CLOSED),
        WAIT_PAY, Set.of(PAYING, CLOSED),
        PAYING, Set.of(PAY_SUCCESS, PAY_FAILED, WAIT_PAY, CLOSED),
        PAY_SUCCESS, Set.of(REFUNDED, PARTIAL_REFUNDED),
        PAY_FAILED, Set.of(WAIT_PAY, CLOSED),
        PARTIAL_REFUNDED, Set.of(REFUNDED)
    );
    
    /**
     * 检查是否可以流转到目标状态
     */
    public boolean canTransitionTo(PayOrderStatus target) {
        return TRANSITIONS.getOrDefault(this, Set.of()).contains(target);
    }
}

4.2 状态流转图

                    ┌──────────────────┐
                    │     重试         │
                    │                  │
                    ▼                  │
┌────────┐    ┌────────┐    ┌────────┐ │    ┌────────┐
│  初始   │───▶│ 待支付  │───▶│ 支付中  │─┘───▶│ 支付成功 │
└────────┘    └────────┘    └────────┘      └────────┘
                   │              │               │
                   │              │               │
                   ▼              ▼               ▼
              ┌────────┐    ┌────────┐     ┌────────┐
              │ 已关闭  │    │ 支付失败 │     │ 已退款  │
              └────────┘    └────────┘     └────────┘

4.3 状态机实现

@Service
public class PayOrderStateMachine {
    
    @Autowired
    private PayOrderRepository orderRepository;
    
    @Autowired
    private PayOrderLogRepository logRepository;
    
    /**
     * 状态流转（带事务保证）
     */
    @Transactional
    public boolean transition(String orderId, PayOrderStatus targetStatus, String operator) {
        // 1. 查询订单
        PayOrder order = orderRepository.selectById(orderId);
        if (order == null) {
            throw new OrderNotFoundException("订单不存在: " + orderId);
        }
        
        PayOrderStatus currentStatus = order.getStatus();
        
        // 2. 校验状态流转合法性
        if (!currentStatus.canTransitionTo(targetStatus)) {
            log.warn("非法状态流转: {} -> {}, orderId={}", currentStatus, targetStatus, orderId);
            return false;
        }
        
        // 3. 乐观锁更新
        int updated = orderRepository.updateStatus(
            orderId, 
            currentStatus.getCode(), 
            targetStatus.getCode()
        );
        
        if (updated == 0) {
            log.warn("状态流转冲突: orderId={}, expected={}", orderId, currentStatus);
            return false;
        }
        
        // 4. 记录状态变更日志
        PayOrderLog orderLog = PayOrderLog.builder()
            .orderId(orderId)
            .fromStatus(currentStatus.getCode())
            .toStatus(targetStatus.getCode())
            .operator(operator)
            .operateTime(LocalDateTime.now())
            .build();
        logRepository.insert(orderLog);
        
        log.info("订单状态流转成功: {} -> {}, orderId={}", currentStatus, targetStatus, orderId);
        return true;
    }
    
    /**
     * 支付成功处理
     */
    @Transactional
    public void handlePaySuccess(String orderId, PayCallbackData callbackData) {
        // 1. 状态流转
        boolean success = transition(orderId, PayOrderStatus.PAY_SUCCESS, "SYSTEM");
        
        if (!success) {
            // 可能是重复回调，幂等处理
            log.warn("支付成功处理失败，可能是重复回调: orderId={}", orderId);
            return;
        }
        
        // 2. 更新支付渠道信息
        PayOrder order = orderRepository.selectById(orderId);
        order.setTransactionId(callbackData.getTransactionId());
        order.setPayTime(callbackData.getPayTime());
        order.setChannelCode(callbackData.getChannelCode());
        orderRepository.updateById(order);
        
        // 3. 异步通知业务系统
        notifyBusinessSystem(order);
    }
}

4.4 超时订单处理

@Component
public class OrderTimeoutHandler {
    
    @Autowired
    private PayOrderRepository orderRepository;
    
    @Autowired
    private PayOrderStateMachine stateMachine;
    
    /**
     * 每分钟扫描超时订单
     */
    @Scheduled(cron = "0 * * * * ?")
    public void handleTimeoutOrders() {
        // 查询超时未支付的订单（超过30分钟）
        LocalDateTime timeoutThreshold = LocalDateTime.now().minusMinutes(30);
        List<PayOrder> timeoutOrders = orderRepository.selectList(
            new QueryWrapper<PayOrder>()
                .eq("status", PayOrderStatus.WAIT_PAY.getCode())
                .lt("create_time", timeoutThreshold)
        );
        
        for (PayOrder order : timeoutOrders) {
            try {
                // 关闭订单
                stateMachine.transition(order.getOrderId(), PayOrderStatus.CLOSED, "TIMEOUT_JOB");
                
                // 如果已经创建了渠道支付单，需要关闭
                if (StringUtils.isNotBlank(order.getChannelPayId())) {
                    closeChannelPay(order);
                }
                
                log.info("订单超时关闭成功: orderId={}", order.getOrderId());
                
            } catch (Exception e) {
                log.error("订单超时关闭失败: orderId={}", order.getOrderId(), e);
            }
        }
    }
}

五、支付流程优化

5.1 完整支付流程

┌──────────────────────────────────────────────────────────────┐
│                        支付完整流程                           │
└──────────────────────────────────────────────────────────────┘

用户端                收银台                    渠道层
  │                    │                        │
  │  1.发起支付        │                        │
  ├───────────────────▶│                        │
  │                    │                        │
  │                    │  2.创建订单            │
  │                    ├───────────────────────▶│
  │                    │                        │
  │                    │  3.返回订单ID          │
  │                    │◀───────────────────────┤
  │                    │                        │
  │  4.返回支付凭证    │                        │
  │◀───────────────────┤                        │
  │                    │                        │
  │  5.用户支付        │                        │
  ├───────────────────────────────────────────▶│
  │                    │                        │
  │                    │  6.支付回调            │
  │                    │◀───────────────────────┤
  │                    │                        │
  │                    │  7.更新订单状态        │
  │                    ├───────────────────────▶│
  │                    │                        │
  │  8.支付结果        │                        │
  │◀───────────────────┤                        │
  │                    │                        │

5.2 异步回调处理

@RestController
@RequestMapping("/callback")
public class PayCallbackController {
    
    @Autowired
    private PayCallbackService callbackService;
    
    /**
     * 微信支付回调
     */
    @PostMapping("/wechat")
    public String wechatCallback(HttpServletRequest request) {
        try {
            // 1. 读取回调数据
            String xmlData = readRequestBody(request);
            
            // 2. 处理回调
            CallbackResult result = callbackService.handleCallback("WECHAT", xmlData);
            
            if (result.isSuccess()) {
                // 3. 返回成功响应
                return "<xml><return_code><![CDATA[SUCCESS]]></return_code></xml>";
            } else {
                log.error("微信回调处理失败: {}", result.getErrorMsg());
                return "<xml><return_code><![CDATA[FAIL]]></return_code></xml>";
            }
            
        } catch (Exception e) {
            log.error("微信回调异常", e);
            return "<xml><return_code><![CDATA[FAIL]]></return_code></xml>";
        }
    }
}

@Service
public class PayCallbackService {
    
    @Autowired
    private ChannelProxyService channelProxy;
    
    @Autowired
    private PayOrderStateMachine stateMachine;
    
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    
    /**
     * 处理支付回调（幂等）
     */
    public CallbackResult handleCallback(String channelCode, String callbackData) {
        // 1. 解析回调数据
        PaymentChannel channel = channelProxy.getChannel(channelCode);
        CallbackResult result = channel.parseCallback(callbackData);
        
        if (!result.isSuccess()) {
            return result;
        }
        
        String orderId = result.getOrderId();
        
        // 2. 幂等性校验（使用Redis分布式锁）
        String lockKey = "callback_lock:" + orderId;
        Boolean locked = redisTemplate.opsForValue().setIfAbsent(
            lockKey, "1", Duration.ofMinutes(5)
        );
        
        if (!locked) {
            // 正在处理中或已处理，直接返回成功
            log.info("回调正在处理中，跳过: orderId={}", orderId);
            return CallbackResult.success();
        }
        
        try {
            // 3. 检查订单状态（避免重复处理）
            PayOrder order = orderRepository.selectById(orderId);
            if (order.getStatus() == PayOrderStatus.PAY_SUCCESS) {
                log.info("订单已支付成功，跳过: orderId={}", orderId);
                return CallbackResult.success();
            }
            
            // 4. 更新订单状态
            stateMachine.handlePaySuccess(orderId, result);
            
            // 5. 异步通知业务系统
            CompletableFuture.runAsync(() -> {
                notifyBusinessSystem(order);
            });
            
            return CallbackResult.success();
            
        } finally {
            // 释放锁
            redisTemplate.delete(lockKey);
        }
    }
}

5.3 主动查询补偿

@Component
public class PayStatusCompensator {
    
    @Autowired
    private PayOrderRepository orderRepository;
    
    @Autowired
    private ChannelProxyService channelProxy;
    
    @Autowired
    private PayOrderStateMachine stateMachine;
    
    /**
     * 每分钟检查支付中的订单
     */
    @Scheduled(cron = "0 * * * * ?")
    public void checkPayingOrders() {
        // 查询支付中超过5分钟的订单
        LocalDateTime threshold = LocalDateTime.now().minusMinutes(5);
        List<PayOrder> payingOrders = orderRepository.selectList(
            new QueryWrapper<PayOrder>()
                .eq("status", PayOrderStatus.PAYING.getCode())
                .lt("update_time", threshold)
                .isNotNull("channel_pay_id")
        );
        
        for (PayOrder order : payingOrders) {
            try {
                // 主动查询渠道状态
                QueryPayResult result = channelProxy.getChannel(order.getChannelCode())
                    .queryPay(order.getChannelPayId());
                
                if (result.isSuccess()) {
                    // 更新订单状态
                    if ("SUCCESS".equals(result.getPayStatus())) {
                        stateMachine.handlePaySuccess(order.getOrderId(), result);
                    } else if ("CLOSED".equals(result.getPayStatus())) {
                        stateMachine.transition(order.getOrderId(), PayOrderStatus.CLOSED, "COMPENSATOR");
                    }
                }
                
            } catch (Exception e) {
                log.error("订单状态查询失败: orderId={}", order.getOrderId(), e);
            }
        }
    }
}

六、安全与风控集成

收银台直接涉及资金流转，安全是重中之重。

6.1 安全措施清单

6.2 请求签名实现

@Component
public class RequestSigner {
    
    private static final String SIGN_ALGORITHM = "HmacSHA256";
    
    /**
     * 生成签名
     */
    public String sign(Map<String, String> params, String secretKey) {
        // 1. 参数排序
        List<String> sortedKeys = params.keySet().stream()
            .sorted()
            .collect(Collectors.toList());
        
        // 2. 拼接待签名字符串
        StringBuilder sb = new StringBuilder();
        for (String key : sortedKeys) {
            String value = params.get(key);
            if (StringUtils.isNotBlank(value)) {
                sb.append(key).append("=").append(value).append("&");
            }
        }
        sb.append("key=").append(secretKey);
        
        // 3. HMAC-SHA256签名
        try {
            Mac mac = Mac.getInstance(SIGN_ALGORITHM);
            SecretKeySpec keySpec = new SecretKeySpec(secretKey.getBytes(StandardCharsets.UTF_8), SIGN_ALGORITHM);
            mac.init(keySpec);
            byte[] hash = mac.doFinal(sb.toString().getBytes(StandardCharsets.UTF_8));
            return Hex.encodeHexString(hash).toUpperCase();
        } catch (Exception e) {
            throw new RuntimeException("签名失败", e);
        }
    }
    
    /**
     * 验证签名
     */
    public boolean verify(Map<String, String> params, String expectedSign, String secretKey) {
        String actualSign = sign(params, secretKey);
        return actualSign.equals(expectedSign);
    }
}

6.3 风控系统集成

@Service
public class RiskControlService {
    
    @Autowired
    private List<RiskRule> riskRules;
    
    /**
     * 支付前风控检查
     */
    public RiskResult checkRisk(PayOrder order, UserContext user, DeviceInfo device) {
        int totalScore = 0;
        List<String> riskReasons = new ArrayList<>();
        
        for (RiskRule rule : riskRules) {
            RiskCheckResult result = rule.check(order, user, device);
            
            if (result.isBlocked()) {
                // 直接拦截
                return RiskResult.block(result.getReason());
            }
            
            totalScore += result.getScore();
            if (result.getScore() > 0) {
                riskReasons.add(result.getReason());
            }
        }
        
        // 综合评分
        if (totalScore >= 100) {
            return RiskResult.block("综合风险评分过高");
        } else if (totalScore >= 50) {
            return RiskResult.review("需人工审核", riskReasons);
        } else {
            return RiskResult.pass();
        }
    }
}

// 风控规则示例：金额风险规则
@Component
public class AmountRiskRule implements RiskRule {
    
    @Override
    public RiskCheckResult check(PayOrder order, UserContext user, DeviceInfo device) {
        BigDecimal amount = order.getAmount();
        
        // 大额支付风险检查
        if (amount.compareTo(new BigDecimal("10000")) > 0) {
            // 检查用户历史消费
            BigDecimal avgAmount = getUserAvgAmount(user.getUserId());
            if (amount.compareTo(avgAmount.multiply(new BigDecimal("5"))) > 0) {
                return RiskCheckResult.block("金额异常：超过历史平均消费5倍");
            }
        }
        
        // 超大额需要人工审核
        if (amount.compareTo(new BigDecimal("50000")) > 0) {
            return RiskCheckResult.review(30, "超大额支付需审核");
        }
        
        return RiskCheckResult.pass();
    }
}

// 频率风险规则
@Component
public class FrequencyRiskRule implements RiskRule {
    
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    
    @Override
    public RiskCheckResult check(PayOrder order, UserContext user, DeviceInfo device) {
        String userId = user.getUserId();
        
        // 检查1小时内支付次数
        String key = "pay_frequency:" + userId;
        Long count = redisTemplate.opsForValue().increment(key);
        
        if (count == 1) {
            redisTemplate.expire(key, 1, TimeUnit.HOURS);
        }
        
        if (count > 50) {
            return RiskCheckResult.block("支付频率过高，疑似异常");
        } else if (count > 20) {
            return RiskCheckResult.review(20, "支付频率较高");
        }
        
        return RiskCheckResult.pass();
    }
}

七、用户体验优化

收银台是支付转化的最后一公里，体验好坏直接影响成交率。根据数据统计，优化收银台体验能提升3-8%的支付转化率。

7.1 智能默认支付方式

根据用户历史偏好自动选中：

@Service
public class UserPreferenceService {
    
    @Autowired
    private UserPayHistoryRepository historyRepository;
    
    /**
     * 获取用户首选支付方式
     */
    public String getUserPreferredChannel(String userId) {
        // 查询用户最近30天的支付记录
        List<UserPayHistory> histories = historyRepository.findRecentByUserId(userId, 30);
        
        if (histories.isEmpty()) {
            return null; // 新用户，无偏好
        }
        
        // 统计各渠道使用频率
        Map<String, Long> channelCount = histories.stream()
            .collect(Collectors.groupingBy(
                UserPayHistory::getChannelCode, 
                Collectors.counting()
            ));
        
        // 返回使用最多的渠道
        return channelCount.entrySet().stream()
            .max(Map.Entry.comparingByValue())
            .map(Map.Entry::getKey)
            .orElse(null);
    }
}

7.2 清晰的金额明细展示

┌─────────────────────────────────────┐
│           订单金额明细               │
├─────────────────────────────────────┤
│ 商品金额                ¥ 299.00    │
│ 优惠券                 -¥ 50.00    │
│ 运费                    ¥ 10.00    │
├─────────────────────────────────────┤
│ 实付金额                ¥ 259.00    │
│                                     │
│ 支付后预计2小时内发货                │
└─────────────────────────────────────┘

7.3 友好的失败处理

支付失败时，给出明确的失败原因和解决建议：

┌─────────────────────────────────────┐
│         ❌ 支付失败                  │
│                                     │
│ 失败原因：银行卡余额不足             │
│                                     │
│ 建议您尝试：                         │
│ • 更换其他银行卡支付                 │
│ • 使用余额支付                       │
│ • 选择信用支付（花呗/白条）          │
│                                     │
│ ┌─────────┐  ┌─────────┐           │
│ │ 换卡支付 │  │ 余额支付 │           │
│ └─────────┘  └─────────┘           │
└─────────────────────────────────────┘

7.4 跨端状态同步

用户在PC端扫码支付，需要实时更新PC端状态：

// 前端轮询支付状态
class PayStatusPoller {
    constructor(orderId) {
        this.orderId = orderId;
        this.stopped = false;
    }
    
    start() {
        this.poll();
    }
    
    stop() {
        this.stopped = true;
    }
    
    async poll() {
        while (!this.stopped) {
            try {
                const response = await fetch(`/api/pay/status?orderId=${this.orderId}`);
                const data = await response.json();
                
                if (data.status === 'SUCCESS') {
                    this.onSuccess(data);
                    this.stop();
                    break;
                } else if (data.status === 'FAILED' || data.status === 'CLOSED') {
                    this.onFailed(data);
                    this.stop();
                    break;
                }
                
                // 等待2秒后继续轮询
                await this.sleep(2000);
                
            } catch (error) {
                console.error('轮询支付状态失败', error);
                await this.sleep(3000);
            }
        }
    }
    
    sleep(ms) {
        return new Promise(resolve => setTimeout(resolve, ms));
    }
    
    onSuccess(data) {
        // 显示支付成功页面
        window.location.href = `/pay/success?orderId=${this.orderId}`;
    }
    
    onFailed(data) {
        // 显示支付失败页面
        showError(data.reason || '支付失败，请重试');
    }
}

八、高可用与性能优化

支付系统对可用性要求极高，通常要求达到99.99%（全年不可用时间不超过53分钟）。

8.1 高可用架构

                    ┌─────────────────┐
                    │    DNS/CDN      │
                    └────────┬────────┘
                             │
                    ┌────────┴────────┐
                    │   负载均衡       │
                    │  (Nginx/F5)     │
                    └────────┬────────┘
                             │
        ┌────────────────────┼────────────────────┐
        │                    │                    │
        ▼                    ▼                    ▼
   ┌─────────┐         ┌─────────┐         ┌─────────┐
   │ 机房 A  │         │ 机房 B  │         │ 机房 C  │
   │ (北京)  │         │ (上海)  │         │ (广州)  │
   └────┬────┘         └────┬────┘         └────┬────┘
        │                   │                   │
        └───────────────────┼───────────────────┘
                            │
                    ┌───────┴───────┐
                    │   数据库集群   │
                    │ (主从 + 分片)  │
                    └───────────────┘

8.2 熔断降级（理论篇）

当支付渠道出现故障（响应超时、错误率飙升）时，继续调用只会浪费时间。熔断器会"跳闸"，后续请求自动切换到备用渠道或返回失败。

// 理论代码示例：使用Resilience4j实现熔断
@Configuration
public class CircuitBreakerConfig {
    
    @Bean
    public CircuitBreaker wechatPayCircuitBreaker() {
        CircuitBreakerConfig config = CircuitBreakerConfig.custom()
            .failureRateThreshold(50)              // 失败率50%触发熔断
            .waitDurationInOpenState(Duration.ofSeconds(30))  // 熔断30秒
            .permittedNumberOfCallsInHalfOpenState(5)  // 半开状态试5次
            .slidingWindowSize(20)                 // 滑动窗口20次
            .slidingWindowType(SlidingWindowType.COUNT_BASED)
            .build();

        return CircuitBreaker.of("wechat-pay", config);
    }
}

• 网关层的限流保护
• 多支付渠道的冗余配置
• 手动切换渠道的能力

随着业务增长，未来会引入更精细的熔断策略。 } catch (CallNotPermittedException e) { // 熔断器打开，返回降级结果 log.warn("微信支付熔断中，返回降级结果"); return CreatePayResult.fallback("微信支付暂时不可用，请尝试其他支付方式"); } } }

### 8.3 限流保护

@Component public class RateLimiterInterceptor implements HandlerInterceptor {

private final RateLimiter globalLimiter = RateLimiter.create(10000); // 全局1万QPS private final Map userLimiters = new ConcurrentHashMap<>();

@Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { // 全局限流 if (!globalLimiter.tryAcquire()) { response.setStatus(429); response.getWriter().write("{\"code\":\"RATE_LIMIT\",\"msg\":\"系统繁忙，请稍后重试\"}"); return false; }

// 用户级限流（每用户每秒5次） String userId = getCurrentUserId(); RateLimiter userLimiter = userLimiters.computeIfAbsent(userId, k -> RateLimiter.create(5));

if (!userLimiter.tryAcquire()) { response.setStatus(429); response.getWriter().write("{\"code\":\"RATE_LIMIT\",\"msg\":\"操作过于频繁\"}"); return false; }

return true; } }

### 8.4 可观测性

**全链路追踪示例**：

TraceID: trace_20260301_abc123 ├── [10:30:00.000] API Gateway - 接收请求 ├── [10:30:00.005] Auth Service - 鉴权通过 ├── [10:30:00.015] Order Service - 创建订单 ├── [10:30:00.020] Risk Service - 风控通过 ├── [10:30:00.022] Router Service - 选择渠道: wechat ├── [10:30:00.180] Channel Service - 调用微信支付 ├── [10:30:00.190] Order Service - 更新订单状态 └── [10:30:00.195] API Gateway - 返回结果 ```

九、实战案例分析

9.1 某电商平台收银台改造

• 日订单量50万，支付成功率仅85%
• 各业务线支付体验差异大
• 年手续费支出约300万

1. 统一收银台服务：所有业务线接入统一API
2. 智能路由系统：根据场景选择最优渠道
3. 用户体验优化：智能默认、失败引导

• 支付成功率：85% → 93%（+8%）
• 年节省手续费：约280万
• 用户投诉下降：60%

9.2 双十一高并发应对

1. 预热扩容：提前2小时完成服务器扩容
2. 削峰填谷：引入消息队列，平滑处理请求
3. 多级降级：制定多级降级策略

十、总结与展望

10.1 核心设计原则回顾

统一收银台的设计，本质上是在解决三个问题：

1. 业务解耦：把支付变成基础设施，让业务系统专注业务
2. 渠道聚合：屏蔽渠道差异，提供统一的服务能力
3. 体验优化：减少用户操作，提升支付转化率

10.2 技术选型建议

10.3 未来趋势

支付中心系列写到这里就结束了。从账户体系到交易流水，从渠道对接到对账系统，从风控设计到统一收银台，我们试图把支付中心的完整面貌呈现出来。

当然，每个环节展开都是一门学问，这里只能讲原理、谈思路。具体的实现细节，需要在实践中摸索。就像学游泳，看再多教程也不如下水试一试。

希望这个系列对正在搭建或优化支付系统的朋友有所帮助。