策略模式结合模板方法模式

之前学习了策略模式加模板方法模式
策略模式单独详解
模板方法模式单独详解

这里回忆起完全可以进行策略和模板方法模式的组合。

import java.util.HashMap;
import java.util.Map;

// 上下文对象（解决参数传递问题）
class OrderContext {
    private final Map<String, Object> data = new HashMap<>();
    
    public OrderContext put(String key, Object value) {
        data.put(key, value);
        return this;
    }
    
    public <T> T get(String key) {
        return (T) data.get(key);
    }
}

// 策略接口
interface OrderProcessingStrategy {
    boolean validate(OrderContext context);
    boolean processPayment(OrderContext context);
    void beforePayment(OrderContext context);
    void deductInventory(OrderContext context);
    void sendNotification(OrderContext context);
    boolean needSpecialNotification(OrderContext context);
}

// 抽象模板类（现在只包含算法骨架，不包含具体实现）
abstract class OrderProcessor {
    
    protected OrderProcessingStrategy strategy;
    
    public OrderProcessor(OrderProcessingStrategy strategy) {
        this.strategy = strategy;
    }
    
    // 模板方法（final防止子类覆盖）
    public final void processOrder(OrderContext context) {
        if (!strategy.validate(context)) {
            rollback(context);
            return;
        }
        
        strategy.beforePayment(context);
        boolean paymentResult = strategy.processPayment(context);
        
        if (paymentResult) {
            strategy.deductInventory(context);
            if (strategy.needSpecialNotification(context)) {
                strategy.sendNotification(context); // 这里可以假设sendNotification已经根据needSpecialNotification处理过
            } else {
                // 可选：提供一个默认的通知方式，或者不做任何操作
                System.out.println("发送默认通知给用户");
            }
            afterSuccess(context);
        } else {
            handlePaymentFailure(context);
        }
    }
    
    // 公共方法（这些方法现在与策略无关，但仍然是订单处理流程的一部分）
    protected void rollback(OrderContext context) {
        System.out.println("执行订单回滚操作");
    }
    
    protected void handlePaymentFailure(OrderContext context) {
        System.out.println("处理支付失败流程");
    }
    
    protected void afterSuccess(OrderContext context) {
        System.out.println("订单后续处理");
    }
}

// 具体策略实现：团购订单处理
class GroupBuyOrderProcessingStrategy implements OrderProcessingStrategy {
    @Override
    public boolean validate(OrderContext context) {
        Integer groupSize = context.get("groupSize");
        System.out.println("验证团购人数：" + groupSize);
        return groupSize != null && groupSize >= 5;
    }

    @Override
    public boolean processPayment(OrderContext context) {
        System.out.println("执行团购优惠价支付");
        return true;
    }

    @Override
    public void beforePayment(OrderContext context) {
        // 团购一般没有特别的前置支付操作，但可以保留此方法以备扩展
    }

    @Override
    public void deductInventory(OrderContext context) {
        System.out.println("按团购规则扣减库存");
    }

    @Override
    public void sendNotification(OrderContext context) {
        System.out.println("发送团购专属通知");
    }

    @Override
    public boolean needSpecialNotification(OrderContext context) {
        return true;
    }
}

// 具体策略实现：秒杀订单处理
class FlashSaleOrderProcessingStrategy implements OrderProcessingStrategy {
    @Override
    public boolean validate(OrderContext context) {
        System.out.println("验证秒杀资格和库存");
        return true; // 假设秒杀资格和库存验证总是通过，实际情况需要具体实现
    }

    @Override
    public boolean processPayment(OrderContext context) {
        System.out.println("执行秒杀价支付（10秒内完成）");
        return true;
    }

    @Override
    public void beforePayment(OrderContext context) {
        System.out.println("锁定秒杀库存30秒");
    }

    @Override
    public void deductInventory(OrderContext context) {
        System.out.println("按秒杀规则扣减库存");
    }

    @Override
    public void sendNotification(OrderContext context) {
        // 秒杀可以发送特别通知，也可以不发送，或者发送默认通知
        // 这里我们假设发送默认通知（或者在实际应用中根据业务逻辑决定）
        System.out.println("发送默认秒杀通知给用户");
    }

    @Override
    public boolean needSpecialNotification(OrderContext context) {
        return false; // 假设秒杀不需要特别通知，实际情况需要具体实现
    }
}

// 使用示例
public class TemplateMethodPatternWithStrategyExample {
    public static void main(String[] args) {
        // 处理团购订单
        OrderContext groupBuyContext = new OrderContext()
            .put("groupSize", 8)
            .put("productId", 1001);
        
        OrderProcessor groupBuyProcessor = new OrderProcessor(new GroupBuyOrderProcessingStrategy());
        groupBuyProcessor.processOrder(groupBuyContext);

        System.out.println("\n===============\n");
        
        // 处理秒杀订单
        OrderContext flashSaleContext = new OrderContext()
            .put("userId", "u123456")
            .put("flashSaleId", "fs2023");
        
        OrderProcessor flashSaleProcessor = new OrderProcessor(new FlashSaleOrderProcessingStrategy());
        flashSaleProcessor.processOrder(flashSaleContext);
    }
}

总结

上面的模板方法由依赖具体策略变成依赖抽象策略接口interface OrderProcessingStrategy，这里就比较好的结合了两个设计模式。