Java策略模式实战：优化支付与促销系统设计

1. 策略模式入门：为什么我们需要它？

我刚入行Java开发时，最头疼的就是那些满屏的if-else语句。记得有一次维护一个电商促销模块，光是计算优惠就有20多个条件分支，每次新增活动类型都战战兢兢。直到我学会了策略模式，才真正体会到设计模式的魅力。

策略模式的核心思想其实很简单：把会变化的算法部分抽取出来，封装成独立的策略类，让它们可以相互替换。这种变化独立于使用算法的客户，也就是我们常说的"对修改关闭，对扩展开放"。

举个例子，假设我们要实现一个支付系统：

java复制// 传统写法
public void pay(String paymentType, BigDecimal amount) {
    if ("alipay".equals(paymentType)) {
        // 支付宝支付逻辑
    } else if ("wechat".equals(paymentType)) {
        // 微信支付逻辑
    } else if ("unionpay".equals(paymentType)) {
        // 银联支付逻辑
    }
    // 每新增一种支付方式就要修改这里
}

这种写法至少有三大问题：

1. 违反开闭原则：新增支付方式必须修改原有代码
2. 难以维护：条件分支太多导致代码臃肿
3. 复用性差：相同的支付逻辑无法在其他地方复用

提示：当你在代码中看到超过3个if-else分支处理同一类问题时，就该考虑策略模式了。

2. 策略模式基础实现

2.1 核心组件解析

一个标准的策略模式包含三个关键角色：

1. 策略接口(Strategy Interface)：定义算法的公共接口
2. 具体策略类(Concrete Strategy)：实现策略接口的具体算法
3. 上下文类(Context)：持有一个策略对象的引用，负责调用具体策略

让我们用支付系统的例子来实现：

java复制// 策略接口
public interface PaymentStrategy {
    void pay(BigDecimal amount);
}

// 具体策略类
public class AlipayStrategy implements PaymentStrategy {
    @Override
    public void pay(BigDecimal amount) {
        System.out.println("使用支付宝支付：" + amount);
        // 实际的支付宝支付逻辑
    }
}

public class WechatPayStrategy implements PaymentStrategy {
    @Override
    public void pay(BigDecimal amount) {
        System.out.println("使用微信支付：" + amount);
        // 实际的微信支付逻辑
    }
}

// 上下文类
public class PaymentContext {
    private PaymentStrategy strategy;
    
    public PaymentContext(PaymentStrategy strategy) {
        this.strategy = strategy;
    }
    
    public void executePayment(BigDecimal amount) {
        strategy.pay(amount);
    }
}

2.2 实际使用示例

java复制public class Client {
    public static void main(String[] args) {
        // 使用支付宝支付
        PaymentContext context = new PaymentContext(new AlipayStrategy());
        context.executePayment(new BigDecimal("100.00"));
        
        // 切换为微信支付
        context = new PaymentContext(new WechatPayStrategy());
        context.executePayment(new BigDecimal("200.00"));
    }
}

这样设计的好处显而易见：

1. 新增支付方式只需添加新的策略类，无需修改现有代码
2. 支付逻辑可以复用
3. 单元测试更容易，可以单独测试每个策略

3. 策略模式进阶技巧

3.1 策略工厂模式

当策略较多时，可以使用工厂模式来管理策略对象的创建：

java复制public class StrategyFactory {
    private static final Map<String, PaymentStrategy> strategies = new HashMap<>();
    
    static {
        strategies.put("alipay", new AlipayStrategy());
        strategies.put("wechat", new WechatPayStrategy());
        // 可以继续添加其他策略
    }
    
    public static PaymentStrategy getStrategy(String type) {
        if (type == null || type.isEmpty()) {
            throw new IllegalArgumentException("type should not be empty.");
        }
        return strategies.get(type);
    }
}

// 使用方式
PaymentStrategy strategy = StrategyFactory.getStrategy("alipay");
PaymentContext context = new PaymentContext(strategy);
context.executePayment(amount);

3.2 结合Spring框架使用

在实际项目中，我们通常会结合Spring框架使用策略模式：

java复制// 定义策略接口
public interface FileParser {
    String parse(File file);
}

// 具体策略实现
@Service("csvParser")
public class CsvParser implements FileParser {
    @Override
    public String parse(File file) {
        // CSV解析逻辑
    }
}

@Service("excelParser")
public class ExcelParser implements FileParser {
    @Override
    public String parse(File file) {
        // Excel解析逻辑
    }
}

// 使用Map自动注入所有实现
@RestController
public class FileController {
    @Autowired
    private Map<String, FileParser> parsers;
    
    @PostMapping("/parse")
    public String parseFile(@RequestParam String type, @RequestParam MultipartFile file) {
        FileParser parser = parsers.get(type + "Parser");
        if (parser == null) {
            throw new IllegalArgumentException("Unsupported file type");
        }
        return parser.parse(convert(file));
    }
}

这种方式的优势：

1. Spring会自动管理所有策略实现类的生命周期
2. 新增策略只需添加新的@Service实现类
3. 通过Map可以方便地获取所有策略

4. 策略模式最佳实践

4.1 策略对象的创建

策略对象通常应该是无状态的，这样可以安全地在多个上下文中共享同一个策略实例。如果策略需要维护状态，应该考虑：

1. 每次使用时创建新实例
2. 通过方法参数传递状态

java复制// 无状态策略 - 可以共享实例
public class DiscountStrategy {
    public BigDecimal apply(BigDecimal amount) {
        return amount.multiply(BigDecimal.valueOf(0.9));
    }
}

// 有状态策略 - 需要每次创建新实例
public class PersonalizedDiscountStrategy {
    private final User user;
    
    public PersonalizedDiscountStrategy(User user) {
        this.user = user;
    }
    
    public BigDecimal apply(BigDecimal amount) {
        // 根据用户属性计算折扣
    }
}

4.2 策略选择逻辑

策略选择可以基于：

1. 客户端显式指定
2. 根据运行时条件自动判断
3. 配置文件或数据库配置

java复制// 基于条件的自动选择
public class AutoSelectionContext {
    private List<ConditionalStrategy> strategies;
    
    public AutoSelectionContext(List<ConditionalStrategy> strategies) {
        this.strategies = strategies;
    }
    
    public void execute(ContextData data) {
        for (ConditionalStrategy strategy : strategies) {
            if (strategy.canApply(data)) {
                strategy.execute(data);
                return;
            }
        }
        throw new IllegalStateException("No applicable strategy found");
    }
}

public interface ConditionalStrategy {
    boolean canApply(ContextData data);
    void execute(ContextData data);
}

5. 策略模式常见问题与解决方案

5.1 策略类爆炸问题

当策略很多时，可能会导致类数量急剧增加。解决方案：

1. 使用匿名类或lambda表达式（适用于简单策略）
2. 将相关策略组合成层次结构
3. 使用组合模式构建复杂策略

java复制// 使用lambda表达式
public class LambdaStrategy {
    private final Map<StrategyType, Function<String, String>> strategies;
    
    public LambdaStrategy() {
        strategies = new HashMap<>();
        strategies.put(StrategyType.A, s -> s.toUpperCase());
        strategies.put(StrategyType.B, s -> s.toLowerCase());
        // 可以继续添加其他策略
    }
    
    public String apply(StrategyType type, String input) {
        return strategies.get(type).apply(input);
    }
}

5.2 策略之间共享数据

有时策略需要共享一些公共数据，可以通过：

1. 将共享数据作为参数传递给策略方法
2. 使用上下文对象封装共享数据
3. 对于线程安全的共享数据，可以使用单例

java复制public class SharedDataContext {
    private final Strategy strategy;
    private final SharedData sharedData;
    
    public SharedDataContext(Strategy strategy, SharedData sharedData) {
        this.strategy = strategy;
        this.sharedData = sharedData;
    }
    
    public void execute() {
        strategy.execute(sharedData);
    }
}

public interface Strategy {
    void execute(SharedData sharedData);
}

6. 策略模式与其他模式的关系

6.1 策略模式 vs 工厂模式

工厂模式关注对象创建，策略模式关注行为封装。它们经常一起使用：

• 工厂负责创建合适的策略对象
• 上下文使用策略对象执行算法

6.2 策略模式 vs 模板方法模式

两者都用于封装算法，但：

• 模板方法使用继承，在父类中定义算法骨架
• 策略模式使用组合，完全委托给策略对象

6.3 策略模式 vs 状态模式

结构相似但意图不同：

• 状态模式中，状态改变导致行为改变，状态知道其他状态
• 策略模式中，策略之间相互独立，客户端选择策略

7. 实际项目中的应用经验

在我参与的一个电商平台项目中，我们使用策略模式重构了价格计算系统。原来的系统有大量if-else判断各种促销活动，维护困难。重构后：

1. 定义了PriceCalculationStrategy接口
2. 实现了各种计算策略：
   • RegularPriceStrategy（常规价格）
   • DiscountStrategy（折扣）
   • CouponStrategy（优惠券）
   • BundleStrategy（套装优惠）
3. 使用策略链组合多个优惠

重构后的优势：

1. 新增促销类型只需添加新策略，不影响现有代码
2. 每种策略可以单独测试
3. 可以动态组合不同的促销策略
4. 性能提升，因为减少了条件判断

经验分享：策略模式特别适合处理业务规则经常变化的场景。我们在双11前新增了5种促销策略，都通过新增策略类实现，没有修改任何现有代码。

8. 性能考量与优化

虽然策略模式很灵活，但也需要注意性能问题：

1. 对象创建开销：频繁创建策略对象会影响性能

   • 解决方案：对无状态策略使用单例
   • 使用对象池管理有状态策略

2. 方法调用开销：策略模式会增加一层间接调用

   • 对于性能关键路径，考虑内联策略
   • 使用JIT编译器友好的实现

3. 内存占用：大量策略类会增加内存使用

   • 对于简单策略，可以使用lambda表达式
   • 及时清理不再使用的策略实例

java复制// 使用枚举实现单例策略
public enum SingletonStrategy implements Strategy {
    INSTANCE;
    
    @Override
    public void execute() {
        // 实现逻辑
    }
}

// 使用对象池
public class StrategyPool {
    private final ObjectPool<ExpensiveStrategy> pool;
    
    public StrategyPool() {
        pool = new GenericObjectPool<>(new ExpensiveStrategyFactory());
    }
    
    public void executeWithStrategy() {
        ExpensiveStrategy strategy = pool.borrowObject();
        try {
            strategy.execute();
        } finally {
            pool.returnObject(strategy);
        }
    }
}

9. 测试策略模式

策略模式的一个主要优势就是便于测试。测试时要注意：

1. 为每个策略类编写单元测试
2. 测试上下文类与策略的交互
3. 测试策略选择逻辑

java复制public class DiscountStrategyTest {
    @Test
    public void testRegularDiscount() {
        DiscountStrategy strategy = new RegularDiscountStrategy();
        assertEquals(100, strategy.apply(100), 0.001);
    }
    
    @Test
    public void testVIPDiscount() {
        DiscountStrategy strategy = new VIPDiscountStrategy();
        assertEquals(90, strategy.apply(100), 0.001);
    }
    
    @Test
    public void testContextWithStrategy() {
        DiscountContext context = new DiscountContext(new VIPDiscountStrategy());
        assertEquals(90, context.execute(100), 0.001);
    }
}

10. 何时不使用策略模式

虽然策略模式很强大，但并不是所有情况都适用：

1. 算法很简单且不太可能变化：过度设计会增加复杂性
2. 策略之间需要大量共享数据：可能导致紧耦合
3. 客户端需要知道策略的具体细节：破坏封装性

在这些情况下，简单的条件语句可能更合适。记住：设计模式是工具，不是目标。