策略模式详解：原理、实现与应用场景

1. Strategy模式概述

Strategy模式（策略模式）是一种行为型设计模式，它定义了一系列算法，并将每个算法封装起来，使它们可以相互替换。这种模式让算法的变化独立于使用算法的客户端。

在实际开发中，我们经常会遇到需要根据不同条件执行不同算法的情况。比如支付系统需要支持多种支付方式（支付宝、微信、银联等），每种支付方式都有自己独特的处理逻辑。如果直接在业务代码中用if-else或switch-case来处理，会导致代码臃肿且难以维护。

提示：策略模式的核心思想不是消除条件判断，而是将条件判断从业务逻辑中抽离出来，让业务逻辑专注于自身的职责。

2. 策略模式的核心结构

2.1 基本组成元素

策略模式通常包含以下三个核心角色：

1. Context（上下文）：

   • 持有一个Strategy对象的引用
   • 可以定义一个接口让Strategy访问它的数据
   • 通常通过构造函数或setter方法接收具体的策略对象

2. Strategy（策略接口）：

   • 定义所有支持的算法的公共接口
   • Context使用这个接口调用具体的策略实现

3. ConcreteStrategy（具体策略）：

   • 实现Strategy接口的具体算法
   • 每个具体策略类提供一种算法的实现

2.2 UML类图示例

plaintext复制+----------------+       +-----------------+
|   Context      |       |    Strategy     |
|----------------|       |-----------------|
| +strategy:Strategy |<>----| +algorithm():void |
| +contextInterface()|       +-----------------+
+----------------+               ^
                                 |
                 +---------------------+
                 |                     |
       +-----------------+   +-----------------+
       | ConcreteStrategyA|   | ConcreteStrategyB|
       |-----------------|   |-----------------|
       | +algorithm()    |   | +algorithm()    |
       +-----------------+   +-----------------+

3. 策略模式的实现方式

3.1 经典实现示例

下面是一个电商平台折扣策略的Java实现示例：

java复制// 策略接口
public interface DiscountStrategy {
    double applyDiscount(double originalPrice);
}

// 具体策略：无折扣
public class NoDiscount implements DiscountStrategy {
    @Override
    public double applyDiscount(double originalPrice) {
        return originalPrice;
    }
}

// 具体策略：固定折扣
public class FixedDiscount implements DiscountStrategy {
    private double discountAmount;
    
    public FixedDiscount(double discountAmount) {
        this.discountAmount = discountAmount;
    }
    
    @Override
    public double applyDiscount(double originalPrice) {
        return originalPrice - discountAmount;
    }
}

// 具体策略：百分比折扣
public class PercentageDiscount implements DiscountStrategy {
    private double percentage;
    
    public PercentageDiscount(double percentage) {
        this.percentage = percentage;
    }
    
    @Override
    public double applyDiscount(double originalPrice) {
        return originalPrice * (1 - percentage/100);
    }
}

// 上下文类
public class PricingContext {
    private DiscountStrategy strategy;
    
    public PricingContext(DiscountStrategy strategy) {
        this.strategy = strategy;
    }
    
    public double calculatePrice(double originalPrice) {
        return strategy.applyDiscount(originalPrice);
    }
    
    public void setStrategy(DiscountStrategy strategy) {
        this.strategy = strategy;
    }
}

// 客户端使用
public class Client {
    public static void main(String[] args) {
        PricingContext context = new PricingContext(new NoDiscount());
        System.out.println("原价: " + context.calculatePrice(100));
        
        context.setStrategy(new FixedDiscount(20));
        System.out.println("固定折扣: " + context.calculatePrice(100));
        
        context.setStrategy(new PercentageDiscount(10));
        System.out.println("百分比折扣: " + context.calculatePrice(100));
    }
}

3.2 JavaScript实现示例

对于前端开发者，策略模式同样适用。以下是JavaScript实现：

javascript复制// 策略对象
const strategies = {
    "regular": (amount) => amount,
    "fixed": (amount) => amount - 10,
    "percentage": (amount) => amount * 0.9
};

// 上下文
class ShoppingCart {
    constructor(discountStrategy = 'regular') {
        this.discountStrategy = discountStrategy;
        this.items = [];
    }
    
    addItem(item) {
        this.items.push(item);
    }
    
    calculateTotal() {
        const subtotal = this.items.reduce((sum, item) => sum + item.price, 0);
        return strategies[this.discountStrategy](subtotal);
    }
    
    setDiscountStrategy(strategy) {
        this.discountStrategy = strategy;
    }
}

// 使用示例
const cart = new ShoppingCart();
cart.addItem({ name: 'Book', price: 50 });
cart.addItem({ name: 'Pen', price: 10 });

console.log('Regular price:', cart.calculateTotal()); // 60

cart.setDiscountStrategy('fixed');
console.log('Fixed discount:', cart.calculateTotal()); // 50

cart.setDiscountStrategy('percentage');
console.log('Percentage discount:', cart.calculateTotal()); // 54

4. 策略模式的适用场景

4.1 典型应用场景

1. 支付系统：不同支付方式（支付宝、微信、银联等）有不同的处理逻辑
2. 表单验证：不同字段需要不同的验证规则
3. 排序算法：根据数据特点选择最优排序算法（快速排序、归并排序等）
4. 导航系统：根据交通状况选择不同路线策略（最快、最短、最少收费等）
5. 游戏AI：不同敌人有不同的攻击策略

4.2 实际案例：电商促销活动

假设我们正在开发一个电商平台，需要支持多种促销活动：

typescript复制interface PromotionStrategy {
    applyPromotion(originalPrice: number): number;
}

class FullReduction implements PromotionStrategy {
    private threshold: number;
    private reduction: number;
    
    constructor(threshold: number, reduction: number) {
        this.threshold = threshold;
        this.reduction = reduction;
    }
    
    applyPromotion(originalPrice: number): number {
        return originalPrice >= this.threshold ? 
            originalPrice - this.reduction : 
            originalPrice;
    }
}

class Discount implements PromotionStrategy {
    private discountRate: number;
    
    constructor(discountRate: number) {
        this.discountRate = discountRate;
    }
    
    applyPromotion(originalPrice: number): number {
        return originalPrice * this.discountRate;
    }
}

class PromotionContext {
    private strategy: PromotionStrategy;
    
    setStrategy(strategy: PromotionStrategy) {
        this.strategy = strategy;
    }
    
    executePromotion(price: number): number {
        return this.strategy.applyPromotion(price);
    }
}

// 使用示例
const context = new PromotionContext();

// 满减活动
context.setStrategy(new FullReduction(100, 20));
console.log(context.executePromotion(150)); // 130

// 折扣活动
context.setStrategy(new Discount(0.8));
console.log(context.executePromotion(150)); // 120

5. 策略模式的优缺点

5.1 主要优点

1. 开闭原则：无需修改上下文即可引入新策略
2. 消除条件语句：避免大量的if-else或switch-case语句
3. 提高可复用性：策略可以在不同上下文中复用
4. 便于测试：每个策略可以独立测试
5. 运行时切换：可以在运行时动态切换算法

5.2 潜在缺点

1. 客户端必须了解策略差异：客户端需要知道不同策略的区别以选择合适的策略
2. 增加对象数量：每个策略都是一个类，可能增加系统复杂度
3. 通信开销：策略和上下文之间可能需要交换数据，增加通信开销

6. 策略模式的最佳实践

6.1 与工厂模式结合

策略模式常与工厂模式结合使用，将策略的创建逻辑封装起来：

java复制public class StrategyFactory {
    public static DiscountStrategy createStrategy(String strategyType) {
        switch(strategyType) {
            case "FIXED":
                return new FixedDiscount(10);
            case "PERCENTAGE":
                return new PercentageDiscount(15);
            case "SEASONAL":
                return new SeasonalDiscount();
            default:
                return new NoDiscount();
        }
    }
}

// 使用方式
DiscountStrategy strategy = StrategyFactory.createStrategy("FIXED");
PricingContext context = new PricingContext(strategy);

6.2 使用枚举简化策略管理

对于简单的策略，可以使用枚举来实现：

java复制public enum DiscountType {
    NONE {
        public double apply(double price) { return price; }
    },
    FIXED_10 {
        public double apply(double price) { return price - 10; }
    },
    PERCENT_20 {
        public double apply(double price) { return price * 0.8; }
    };
    
    public abstract double apply(double price);
}

// 使用方式
double finalPrice = DiscountType.PERCENT_20.apply(originalPrice);

6.3 在Spring框架中的应用

在Spring应用中，可以利用依赖注入来管理策略：

java复制@Service
public class PaymentService {
    private Map<String, PaymentStrategy> strategies;
    
    @Autowired
    public PaymentService(List<PaymentStrategy> strategyList) {
        strategies = strategyList.stream()
            .collect(Collectors.toMap(
                PaymentStrategy::getType,
                Function.identity()
            ));
    }
    
    public void processPayment(String type, BigDecimal amount) {
        PaymentStrategy strategy = strategies.get(type);
        if (strategy == null) {
            throw new IllegalArgumentException("Unsupported payment type");
        }
        strategy.process(amount);
    }
}

public interface PaymentStrategy {
    String getType();
    void process(BigDecimal amount);
}

@Service
public class AlipayStrategy implements PaymentStrategy {
    @Override
    public String getType() {
        return "ALIPAY";
    }
    
    @Override
    public void process(BigDecimal amount) {
        // 支付宝支付逻辑
    }
}

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

7.1 策略选择问题

问题：如何让客户端选择合适的策略？

解决方案：

1. 使用工厂模式封装策略创建逻辑
2. 提供策略的元数据描述，让客户端基于描述选择
3. 实现策略的自动选择机制（如基于输入参数的特征）

7.2 策略共享数据问题

问题：策略需要访问上下文的数据怎么办？

解决方案：

1. 将需要的数据作为参数传递给策略方法
2. 让策略持有上下文的引用（但会增加耦合）
3. 使用上下文对象封装共享数据

7.3 策略组合问题

问题：如何支持多个策略的组合使用？

解决方案：

1. 实现组合策略类，内部维护一个策略列表
2. 定义策略的组合规则（如顺序执行、条件执行等）
3. 使用责任链模式来链式执行多个策略

java复制public class CompositeStrategy implements DiscountStrategy {
    private List<DiscountStrategy> strategies;
    
    public CompositeStrategy(List<DiscountStrategy> strategies) {
        this.strategies = strategies;
    }
    
    @Override
    public double applyDiscount(double originalPrice) {
        double result = originalPrice;
        for (DiscountStrategy strategy : strategies) {
            result = strategy.applyDiscount(result);
        }
        return result;
    }
}

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

8.1 与状态模式的区别

策略模式和状态模式在结构上相似，但意图不同：

• 策略模式：客户端主动选择策略，策略之间通常互不了解
• 状态模式：状态转换由上下文或状态类控制，状态之间知道彼此的存在

8.2 与命令模式的区别

• 策略模式：关注算法的不同实现
• 命令模式：关注请求的封装和参数化

8.3 与模板方法模式的区别

• 策略模式：通过组合实现算法变化
• 模板方法模式：通过继承实现算法部分步骤的变化

在实际项目中，我经常发现策略模式被过度使用的情况。对于简单的、不太可能变化的算法差异，有时直接使用条件语句反而更清晰。策略模式真正的价值在于处理那些可能频繁变化、需要灵活组合的复杂算法场景。