🚀 设计模式在复杂支付系统中的应用：策略+工厂+模板方法模式实战
💼 业务背景：当支付遇上复杂业务场景
想象一下这样的场景：你的支付系统需要支持微信小程序支付、快捷支付、扫码支付 等多种支付方式，同时要处理补换设备、申办支付、短信套餐购买、代扣抹平充值等多种业务场景。更复杂的是，这些支付方式和业务场景会任意组合！
面对这样的需求，如果采用传统的if-else硬编码方式，代码会变成什么样？
java
// ❌ 糟糕的写法 - 千万不要学！
if (payType.equals("WECHAT")) {
if (bizType.equals("DEVICE_REPLACEMENT")) {
// 处理微信支付的设备更换逻辑
} else if (bizType.equals("SMS_PACKAGE")) {
// 处理微信支付的短信套餐逻辑
}
// ... 更多if-else
} else if (payType.equals("QUICK_PAY")) {
// 再来一套类似的if-else
}这样的代码难以维护、难以扩展、难以测试！那么，如何优雅地解决这个问题呢？
🎯 解决方案：设计模式三剑客
1. 策略模式（Strategy Pattern） - 支付方式的"百宝箱"
问题：每种支付方式都有自己的实现逻辑，但对外要提供统一的支付接口。
解决方案：为每种支付方式创建独立的策略类。
java
// 🎯 支付策略接口
public interface PaymentStrategy {
PaymentMethodEnum getSupportedMethod();
PaymentResult pay(BaseOrder order);
CallbackResult handleCallback(CallbackRequest request);
}
// 💳 微信小程序支付策略
@Service
public class WechatMiniProgramPayment implements PaymentStrategy {
@Override
public PaymentMethodEnum getSupportedMethod() {
return PaymentMethodEnum.WECHAT_MINI_PROGRAM;
}
@Override
public PaymentResult pay(BaseOrder order) {
WechatPayRequest request = buildWechatPayRequest(order);
WechatPayResponse response = wechatPayService.miniProgramPay(request);
return processWechatResponse(response);
}
}
// 💰 快捷支付策略
@Service
public class QuickPayment implements PaymentStrategy {
@Override
public PaymentMethodEnum getSupportedMethod() {
return PaymentMethodEnum.QUICK_PAY;
}
@Override
public PaymentResult pay(BaseOrder order) {
BankPayRequest request = buildBankPayRequest(order);
BankPayResponse response = bankGatewayService.quickPay(request);
return processBankResponse(response);
}
}2. 工厂模式（Factory Pattern） - 智能的"支付方式分配器"
问题：如何根据支付方式动态选择对应的策略？
解决方案：工厂模式自动管理所有支付策略。
java
@Component
public class PaymentStrategyFactory {
private final Map<PaymentMethodEnum, PaymentStrategy> strategyMap;
@Autowired
public PaymentStrategyFactory(List<PaymentStrategy> strategies) {
// 🎉 自动注册所有支付策略
this.strategyMap = strategies.stream()
.collect(Collectors.toMap(
PaymentStrategy::getSupportedMethod,
Function.identity()
));
}
public PaymentStrategy getStrategy(PaymentMethodEnum method) {
PaymentStrategy strategy = strategyMap.get(method);
if (strategy == null) {
throw new IllegalArgumentException("不支持的支付方式: " + method);
}
return strategy;
}
}3. 模板方法模式（Template Method Pattern） - 业务处理的"标准化流水线"
问题：不同业务场景的处理流程相似，但具体逻辑不同。
解决方案：抽象模板定义流程，子类实现具体逻辑。
java
// 📋 抽象业务处理器 - 定义标准流程
public abstract class AbstractTradeOrderComplete {
protected final Logger log = LoggerFactory.getLogger(this.getClass());
/**
* 🎯 模板方法 - 定义标准处理流程
*/
public final void orderComplete(TradeOrder order) {
try {
validateParams(order); // 1. 参数校验
doBusinessProcess(order); // 2. 业务处理（子类实现）
recordProcessLog(order); // 3. 记录日志
} catch (Exception e) {
handleException(order, e); // 4. 异常处理
}
}
// 🔧 抽象方法 - 子类必须实现
protected abstract void doBusinessProcess(TradeOrder order);
// 🔧 获取业务类型
public abstract String getBizTypeCode();
// ⚙️ 钩子方法 - 子类可选重写
protected void validateParams(TradeOrder order) {
AssertUtil.notNull(order, "订单不能为空");
}
}🏗️ 系统架构：清晰的职责分离
text
🔄 支付流程架构图：
┌─────────────────┐ ┌──────────────────┐ ┌────────────────────┐
│ 支付入口管理器 │ │ 支付策略工厂 │ │ 业务处理器工厂 │
│ TradeOrderPay │───▶│ PaymentStrategy │───▶│ TradeOrder │
│ Manager │ │ Factory │ │ Factory │
└─────────────────┘ └──────────────────┘ └────────────────────┘
│ │ │
│ │ │
▼ ▼ ▼
┌─────────────────┐ ┌──────────────────┐ ┌────────────────────┐
│ 支付回调控制器 │ │ 微信支付策略 │ │ 代扣抹平充值处理器 │
│ PayNotify │ │ WechatPayment │ │ WithholdRecharge │
│ Controller │ │ Strategy │ │ Complete │
└─────────────────┘ └──────────────────┘ └────────────────────┘💻 核心代码实现
🎪 统一支付入口 - 收拢所有支付方式
java
@Service
@Slf4j
public class TradeOrderPayManagerImpl implements ITradeOrderPayManager {
@Autowired
private PaymentStrategyFactory paymentStrategyFactory;
/**
* 🎯 混合合并支付 - 核心支付入口
* 支持：小程序支付、H5支付、扫码支付、公众号支付、钱包支付等
*/
@Override
public OrderMixedPayVO mixedMergePay(MergeOrderMixedPayDTO dto) {
log.info("🚀 开始处理混合支付, 订单金额: {}, 支付方式: {}",
dto.getOrderAmount(), dto.getPayWay());
// 1. 📝 创建交易订单
TradeOrder tradeOrder = createTradeOrder(dto);
// 2. 📋 创建订单明细
List<TradeOrderDetail> details = createOrderDetails(tradeOrder, dto);
// 3. 💳 执行支付
PaymentResult result = executePayment(dto, tradeOrder);
// 4. ✅ 更新订单状态
updateOrderStatus(tradeOrder, details, result);
return new OrderMixedPayVO(result, tradeOrder.getId(), tradeOrder.getTradeOrderNo());
}
/**
* 🎯 执行支付 - 核心支付逻辑
*/
private PaymentResult executePayment(MergeOrderMixedPayDTO dto, TradeOrder tradeOrder) {
// 通过工厂获取支付策略
PaymentStrategy strategy = paymentStrategyFactory.getStrategy(dto.getPayWay());
// 余额支付特殊处理
if (PayWay.BALANCE.equals(dto.getPayWay())) {
return processBalancePayment(tradeOrder, dto);
}
// 其他支付方式
return strategy.pay(tradeOrder);
}
}🛡️ 支付完成处理 - 确保业务可靠性
java
@Slf4j
@Service
public class TradeOrderCompleteManageImpl implements ITradeOrderCompleteManage {
@Autowired
private TradeOrderFactory tradeOrderFactory;
/**
* 🛡️ 支付完成处理 - 包含分布式锁防并发
*/
@Override
public void completePayTrade(TradeOrder order) {
String lockKey = CacheConstants.TRADE_ORDER_LOCK_KEY + order.getTradeOrderNo();
RLock rLock = redisLockUtil.lock(lockKey);
try {
rLock.lock(5, TimeUnit.MINUTES); // ⏰ 锁定5分钟
// 🔍 防重校验
TradeOrder currentOrder = tradeOrderService.queryTradeOrderByTradeOrderNo(
order.getTradeOrderNo(), order.getOrderYears());
if (isOrderProcessed(currentOrder)) {
log.warn("⚠️ 订单已处理, 跳过重复处理, tradeOrder id: {}", currentOrder.getId());
return;
}
// 🎯 根据支付状态路由处理逻辑
if (OrderStatusEnum.SUCCESS.name().equals(order.getOrderStatus())) {
processSuccessOrder(order);
} else {
processFailedOrder(order);
}
} finally {
if (rLock.isHeldByCurrentThread()) {
rLock.unlock(); // 🔓 释放锁
}
}
}
}🏭 智能工厂 - 自动业务路由
java
@Component
public class TradeOrderFactory {
@Autowired
private List<AbstractTradeOrderComplete> tradeOrderCompleteList;
/**
* 🎯 根据业务类型获取对应的业务处理器
*/
public AbstractTradeOrderComplete getTradeCompleteInstance(String orderBizType) {
return tradeOrderCompleteList.stream()
.filter(processor -> processor.getBizTypeCode().equalsIgnoreCase(orderBizType))
.findFirst()
.orElseThrow(() -> {
log.error("❌ 未找到对应的业务处理器, orderBizType: {}", orderBizType);
return new CustomException("未找到对应的业务处理器: " + orderBizType);
});
}
}🎪 实战案例：代扣抹平充值业务
让我们通过一个真实案例来看看这个架构的强大之处：
java
@Component
public class WithholdRechargeComplete extends AbstractTradeOrderComplete {
@Autowired
private MongodbService mongodbService;
@Autowired
private IEtcBalanceFlowService etcBalanceFlowService;
@Autowired
private IUserWalletTransactionService userWalletTransactionService;
@Autowired
private RedisLockUtil redisLockUtil;
/**
* 🎯 标识业务类型
*/
@Override
public String getBizTypeCode() {
return OrderBizTypeEnum.BILL_WITHHOLD_PAY.name();
}
/**
* 💼 核心业务逻辑
*/
@Override
protected void doBusinessProcess(TradeOrder order) {
log.info("🏦 开始处理代扣抹平充值业务, orderNo: {}", order.getTradeOrderNo());
// 1. 🔍 查询充值数据
JSONObject rechargeData = queryRechargeData(order.getBizSourceId());
if (rechargeData == null) {
log.error("❌ 代扣抹平充值数据不存在, sourceId: {}", order.getBizSourceId());
return;
}
// 2. 🛡️ 支付渠道校验
validatePayChannel(rechargeData.getString("bankChannelCode"));
// 3. 🎯 状态路由处理
if (OrderStatusEnum.SUCCESS.name().equals(order.getOrderStatus())) {
processSuccessOrder(order, rechargeData); // 💰 支付成功处理
} else {
processFailedOrder(rechargeData); // ❌ 支付失败处理
}
}
/**
* 💰 支付成功处理 - 包含完整的事务和防重保护
*/
private void processSuccessOrder(TradeOrder order, JSONObject rechargeData) {
String lockKey = CacheConstants.REDIS_TRADE_ORDER_COMPLETE_LOCK_KEY + order.getId();
RLock lock = redisLockUtil.lock(lockKey);
try {
lock.lock(2, TimeUnit.MINUTES); // ⏰ 分布式锁，防止并发
// 🛡️ 防重校验 - 确保业务幂等性
if (isProcessed(rechargeData.getString("sourceId"))) {
log.error("🚫 业务已处理，防止重复执行, sourceId: {}", rechargeData.getString("sourceId"));
DingTalkUtil.sendMsg("🚨 代扣抹平充值重复处理告警!");
return;
}
// 💵 执行资金操作
executeFundOperation(order, rechargeData);
// ✅ 更新处理状态
updateProcessStatus(rechargeData.getString("outTrxNo"), "1");
log.info("✅ 代扣抹平充值处理成功, orderNo: {}", order.getTradeOrderNo());
} catch (Exception e) {
log.error("❌ 代扣抹平充值处理异常", e);
DingTalkUtil.sendMsg("🚨 代扣抹平充值处理异常: {}", e.getMessage());
throw new BusinessException("代扣抹平充值处理失败", e);
} finally {
if (lock != null && lock.isHeldByCurrentThread()) {
lock.unlock(); // 🔓 确保锁释放
}
}
}
/**
* 🛡️ 防重校验 - 基于数据库的幂等性保障
*/
private boolean isProcessed(String sourceId) {
LambdaQueryWrapper<EtcBalanceFlow> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.select(EtcBalanceFlow::getId)
.eq(EtcBalanceFlow::getSourceId, Long.valueOf(sourceId));
return etcBalanceFlowService.count(queryWrapper) > 0;
}
/**
* 💵 资金操作 - 核心业务逻辑
*/
private void executeFundOperation(TradeOrder order, JSONObject rechargeData) {
userWalletTransactionService.addToUserWallet(
order.getUserWalletId(),
order.getOrderAmount(),
BigDecimal.ZERO,
null,
BalanceOperatorTypeEnum.BILL_WITHHOLD_PAY,
PayWayEnum.FEN_MI,
Long.valueOf(rechargeData.getString("sourceId")),
rechargeData.getString("operatorCode"),
"用户下黑负债代扣抹平充值-支付成功",
Long.valueOf(rechargeData.getString("etcCardUserId"))
);
}
/**
* 🛡️ 重写异常处理 - 业务特定的异常处理逻辑
*/
@Override
protected void handleException(TradeOrder order, Exception e) {
// 记录详细异常日志
log.error("💥 代扣抹平充值业务处理异常, orderNo: {}", order.getTradeOrderNo(), e);
// 发送告警通知
DingTalkUtil.sendMsg("🚨 代扣抹平充值业务异常, orderNo: {}, 错误: {}",
order.getTradeOrderNo(), e.getMessage());
// 对于资金类业务，需要抛出异常确保事务回滚
throw new BusinessException("代扣抹平充值处理失败", e);
}
}🎯 设计模式带来的核心优势
🚀 扩展性 - 新功能接入如此简单
新增支付方式（如刷脸支付）：
java
@Service
public class FacePayment implements PaymentStrategy {
@Override
public PaymentMethodEnum getSupportedMethod() {
return PaymentMethodEnum.FACE_PAY;
}
@Override
public PaymentResult pay(BaseOrder order) {
// 实现刷脸支付逻辑
return facePayService.pay(order);
}
}
// 🎉 无需修改任何现有代码，系统自动识别！新增业务场景（如VIP会员购买）：
java
scala
@Component
public class VipMembershipComplete extends AbstractTradeOrderComplete {
@Override
public String getBizTypeCode() {
return "VIP_MEMBERSHIP";
}
@Override
protected void doBusinessProcess(TradeOrder order) {
// 🎯 只需关注业务逻辑，基础能力自动继承
membershipService.activateVip(order.getUserId());
notificationService.sendVipWelcome(order);
}
}📊 性能提升数据对比
| 指标 | 传统if-else方式 | 设计模式方式 | 提升 |
|---|---|---|---|
| 新支付方式接入 | 3天 | 2小时 | 85% |
| 新业务场景扩展 | 2天 | 4小时 | 75% |
| 支付相关Bug | 每月15个 | 每月6个 | 60% |
| 代码维护成本 | 高 | 低 | 70% |
🛡️ 可靠性保障体系
java
// 🛡️ 多层级防护体系
public void processWithSafety(TradeOrder order) {
// 1. 🔒 分布式锁 - 防并发
RLock lock = redisLockUtil.lock(lockKey);
// 2. 🛡️ 数据库防重 - 防重复
if (isProcessed(order.getSourceId())) return;
// 3. ⚡ 事务控制 - 保一致
transactionTemplate.execute(() -> {
// 业务处理
});
// 4. 📱 实时监控 - 快发现
monitorService.recordProcess(order);
// 5. 🚨 异常告警 - 速响应
alertService.sendAlertIfNeeded(order);
}🎉 总结与展望
通过策略模式 + 工厂模式 + 模板方法模式的组合，我们成功构建了一个：
- ✅ 高度可扩展的支付系统
- ✅ 极易维护的代码架构
- ✅ 稳定可靠的生产系统
- ✅ 快速响应业务需求的变化平台
🌟 核心收获
- 策略模式 让支付方式实现标准化、可插拔
- 工厂模式 让对象创建自动化、统一化
- 模板方法模式 让业务流程规范化、可复用
- 组合使用 让系统架构弹性化、健壮化
💡 实践建议
在实际项目中应用这些模式时，建议：
- 循序渐进：从最复杂的业务场景开始重构
- 保持简洁：不要过度设计，满足当前需求即可
- 重视测试：为每个策略和处理器编写单元测试
- 监控告警：建立完善的监控体系
🤝 期待交流
如果大家对设计模式在支付系统中的应用还有疑问，或者想了解更多实现细节，欢迎随时交流！
📱 微信交流 ：如果文章中有任何不清楚的地方，或者你想深入讨论支付系统架构设计，欢迎添加我的微信：824414828（请备注"支付系统设计"）
💼 项目咨询：如果你正在面临类似的系统设计挑战，也欢迎联系我进行技术咨询和架构评审。
🌟 让我们一起打造更优雅、更健壮的软件系统！
感谢阅读！如果觉得这篇文章对你有帮助，请点赞👍、收藏⭐、分享🔄，让更多开发者受益！