Java策略模式实战：从理论到电商折扣系统应用

1. 策略模式入门：从奶茶店到代码世界

第一次接触策略模式时，我也被那些抽象的定义搞得一头雾水。直到有天在奶茶店点单，才突然开窍——这不就是策略模式的完美案例吗？店员不会因为你要"少糖去冰"就重新培训，他们只是根据不同的选择组合执行对应的制作流程。这种"选择-执行"的分离，正是策略模式的精髓所在。

在Java开发中，策略模式属于行为型设计模式，它定义了一系列算法（策略），并将每个算法封装起来，使它们可以相互替换。最大的特点是算法的变化独立于使用算法的客户。就像奶茶店可以随时新增"零卡糖"选项而不影响其他配方，我们的代码也能灵活扩展新策略而不改动原有逻辑。

提示：策略模式特别适合处理那些业务规则频繁变更的场景，比如电商促销活动、支付方式选择、日志记录策略等。当你的代码中出现大量条件判断语句时，就是考虑策略模式的好时机。

2. 环境准备与基础搭建

2.1 开发环境配置

工欲善其事，必先利其器。虽然策略模式本身不依赖特定工具链，但合理的环境配置能事半功倍。我推荐以下组合：

• JDK 17：长期支持版本，提供了更好的性能和新特性
• IntelliJ IDEA：社区版就足够，它的代码提示和重构工具能极大提升效率
• Maven 3.6+：依赖管理更规范，方便后续集成Spring等框架

验证环境是否就绪：

bash复制java -version  # 应该看到类似"17.0.2"的输出
mvn -v        # 确认Maven版本≥3.6.0

2.2 项目结构设计

清晰的包结构能让策略模式的优势更加凸显。建议采用如下Maven项目结构：

code复制src/
├── main/
│   ├── java/
│   │   └── com/
│   │       └── yourpackage/
│   │           ├── strategy/      # 策略接口和实现
│   │           ├── context/       # 策略上下文
│   │           └── App.java       # 主程序
│   └── resources/                 # 配置文件
└── test/                          # 单元测试

注意：避免把所有策略类堆在一个文件中。每个策略类应该是独立的，这样修改或添加新策略时才不会引发冲突。

3. 策略模式核心实现

3.1 定义策略接口

策略模式的第一步是抽象出可变行为。以电商折扣为例，我们定义一个顶层接口：

java复制public interface DiscountStrategy {
    /**
     * 计算最终价格
     * @param originalPrice 商品原价
     * @return 折后价格
     */
    double applyDiscount(double originalPrice);
    
    /**
     * 策略唯一标识
     * @return 策略名称
     */
    String getStrategyName();
}

接口设计有两个关键点：

1. 方法签名要足够通用，能覆盖所有策略变体
2. 避免在接口中暴露实现细节

3.2 具体策略实现

下面是三种典型折扣策略的实现：

满减策略：

java复制public class FullReductionStrategy implements DiscountStrategy {
    private static final double THRESHOLD = 100.0;
    private static final double REDUCTION = 10.0;

    @Override
    public double applyDiscount(double originalPrice) {
        return originalPrice >= THRESHOLD ? originalPrice - REDUCTION : originalPrice;
    }

    @Override
    public String getStrategyName() {
        return "FULL_REDUCTION";
    }
}

百分比折扣策略：

java复制public class PercentageDiscountStrategy implements DiscountStrategy {
    private final double discountRate;  // 折扣率

    public PercentageDiscountStrategy(double discountRate) {
        if (discountRate <= 0 || discountRate >= 1) {
            throw new IllegalArgumentException("折扣率必须在0到1之间");
        }
        this.discountRate = discountRate;
    }

    @Override
    public double applyDiscount(double originalPrice) {
        return originalPrice * discountRate;
    }

    @Override
    public String getStrategyName() {
        return "PERCENTAGE_" + (int)(discountRate * 100) + "OFF";
    }
}

新用户首单策略：

java复制public class NewUserDiscountStrategy implements DiscountStrategy {
    @Override
    public double applyDiscount(double originalPrice) {
        return originalPrice * 0.8;  // 新用户8折
    }

    @Override
    public String getStrategyName() {
        return "NEW_USER";
    }
}

技巧：策略类应该是无状态的（stateless）。如果需要配置参数，应该通过构造器注入，而不是在方法调用时传入。这使得策略对象可以安全地复用。

3.3 上下文环境类

Context类是连接客户端和策略的桥梁：

java复制public class DiscountContext {
    private DiscountStrategy strategy;
    
    public void setStrategy(DiscountStrategy strategy) {
        Objects.requireNonNull(strategy, "策略不能为null");
        this.strategy = strategy;
    }
    
    public double executeStrategy(double price) {
        if (strategy == null) {
            throw new IllegalStateException("未设置折扣策略");
        }
        return strategy.applyDiscount(price);
    }
    
    public String getCurrentStrategyName() {
        return strategy != null ? strategy.getStrategyName() : "NONE";
    }
}

关键设计要点：

1. 提供策略的setter方法，允许运行时切换
2. 执行方法中要处理策略未设置的边界情况
3. 可以扩展更多辅助方法，如获取当前策略信息

4. 客户端使用示例

4.1 基础使用方式

java复制public class Client {
    public static void main(String[] args) {
        DiscountContext context = new DiscountContext();
        
        // 满减策略
        context.setStrategy(new FullReductionStrategy());
        System.out.println("满减策略: " + context.executeStrategy(120.0));
        
        // 切换为百分比折扣
        context.setStrategy(new PercentageDiscountStrategy(0.9));
        System.out.println("9折策略: " + context.executeStrategy(120.0));
        
        // 新用户策略
        context.setStrategy(new NewUserDiscountStrategy());
        System.out.println("新用户策略: " + context.executeStrategy(120.0));
    }
}

4.2 结合工厂模式

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

java复制public class DiscountStrategyFactory {
    private static final Map<String, DiscountStrategy> strategies = Map.of(
        "FULL_REDUCTION", new FullReductionStrategy(),
        "PERCENTAGE_90", new PercentageDiscountStrategy(0.9),
        "NEW_USER", new NewUserDiscountStrategy()
    );
    
    public static DiscountStrategy getStrategy(String type) {
        DiscountStrategy strategy = strategies.get(type);
        if (strategy == null) {
            throw new IllegalArgumentException("未知策略类型: " + type);
        }
        return strategy;
    }
    
    public static Set<String> getAvailableStrategies() {
        return strategies.keySet();
    }
}

使用方式：

java复制context.setStrategy(DiscountStrategyFactory.getStrategy("PERCENTAGE_90"));

经验：工厂模式特别适合策略类型较多，或者策略创建过程复杂的情况。如果策略很少且简单，直接new也是可以的。

5. 高级应用技巧

5.1 策略自动注册

在Spring Boot项目中，可以利用依赖注入自动收集所有策略：

java复制@Service
public class DiscountService {
    private final Map<String, DiscountStrategy> strategyMap;
    
    @Autowired
    public DiscountService(List<DiscountStrategy> strategies) {
        this.strategyMap = strategies.stream()
            .collect(Collectors.toMap(
                DiscountStrategy::getStrategyName,
                Function.identity()
            ));
    }
    
    public double applyDiscount(String strategyName, double price) {
        DiscountStrategy strategy = strategyMap.get(strategyName);
        if (strategy == null) {
            throw new IllegalArgumentException("无效策略: " + strategyName);
        }
        return strategy.applyDiscount(price);
    }
}

5.2 策略模式与Lambda

Java 8+中，简单策略可以用Lambda表达式实现：

java复制Map<String, DiscountStrategy> lambdaStrategies = Map.of(
    "VIP", price -> price * 0.85,
    "HOLIDAY", price -> price > 200 ? price - 50 : price
);

适用场景：

• 策略逻辑非常简单（1-2行代码）
• 不需要维护状态
• 策略使用频率低

5.3 策略模式组合

复杂业务可能需要组合多个策略：

java复制public class CombinedDiscountStrategy implements DiscountStrategy {
    private final List<DiscountStrategy> strategies;
    
    public CombinedDiscountStrategy(DiscountStrategy... strategies) {
        this.strategies = List.of(strategies);
    }
    
    @Override
    public double applyDiscount(double originalPrice) {
        double currentPrice = originalPrice;
        for (DiscountStrategy strategy : strategies) {
            currentPrice = strategy.applyDiscount(currentPrice);
        }
        return currentPrice;
    }
    
    // 其他方法实现...
}

使用示例：

java复制DiscountStrategy combined = new CombinedDiscountStrategy(
    new FullReductionStrategy(),
    new PercentageDiscountStrategy(0.9)
);

6. 性能优化与注意事项

6.1 对象创建开销

频繁创建策略对象可能带来性能问题。解决方案：

1. 对于无状态策略，可以缓存实例：

java复制public enum SingletonStrategies {
    FULL_REDUCTION(new FullReductionStrategy()),
    PERCENTAGE_90(new PercentageDiscountStrategy(0.9));
    
    private final DiscountStrategy strategy;
    
    SingletonStrategies(DiscountStrategy strategy) {
        this.strategy = strategy;
    }
    
    public DiscountStrategy getStrategy() {
        return strategy;
    }
}

2. 使用对象池模式管理有状态的策略实例

6.2 线程安全性

• 无状态策略天然线程安全
• 有状态策略需要同步访问共享数据
• 上下文类通常不是线程安全的（因为持有策略引用）

警告：避免在策略类中使用静态变量，除非你非常清楚并发场景下的行为。

6.3 测试策略

策略模式的一个巨大优势是便于单元测试。测试要点：

1. 为每个策略编写独立的测试用例
2. 测试上下文类的策略切换逻辑
3. 验证边界条件（如空策略、非法输入等）

示例测试：

java复制class FullReductionStrategyTest {
    @Test
    void shouldReduceWhenOverThreshold() {
        DiscountStrategy strategy = new FullReductionStrategy();
        assertEquals(90.0, strategy.applyDiscount(100.0), 0.001);
    }
    
    @Test
    void shouldNotReduceWhenUnderThreshold() {
        DiscountStrategy strategy = new FullReductionStrategy();
        assertEquals(99.0, strategy.applyDiscount(99.0), 0.001);
    }
}

7. 与其他模式的关系

7.1 策略模式 vs 工厂模式

• 工厂模式：关注对象创建，解决"怎么来"的问题
• 策略模式：关注行为抽象，解决"怎么做"的问题

两者经常结合使用，如前面的DiscountStrategyFactory示例。

7.2 策略模式 vs 状态模式

• 策略模式：客户端主动选择算法
• 状态模式：状态转换自动触发行为变化

状态模式可以看作策略模式的变体，其中策略切换由内部状态驱动。

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

• 模板方法：在父类定义算法骨架，子类实现特定步骤
• 策略模式：完全替换整个算法实现

模板方法使用继承，策略模式使用组合。

8. 实际项目经验分享

在电商系统中，我们曾用策略模式重构了复杂的促销引擎。原始代码有3000多行的if-else，维护起来简直是噩梦。重构后：

1. 将每种促销规则抽象为独立策略类
2. 使用策略组合支持"满减+折扣"等复杂促销
3. 通过配置文件动态启用/禁用策略

效果：

• 新增促销类型时间从2天缩短到2小时
• 促销相关bug减少70%
• 系统在"双11"期间稳定支持每秒5000+订单

遇到的坑：

• 最初没有设计策略标识符，导致无法序列化策略配置
• 某些策略有依赖关系，后来引入了优先级机制
• 动态加载策略时，类加载器问题导致ClassNotFoundException

经验：在设计策略接口时，一定要考虑持久化和远程调用的需求。简单的做法是给每个策略设计唯一标识符。

9. 策略模式的最佳实践

1. 保持策略接口精简：接口方法最好不超过5个
2. 策略命名要直观：如FastShippingStrategy、EconomyShippingStrategy
3. 文档化策略行为：每个策略类应该有详细的注释说明适用场景
4. 监控策略使用情况：记录各策略的执行次数和性能指标
5. 提供默认策略：当没有匹配策略时，使用安全的默认行为

反模式警告：

• 避免"上帝策略"（一个策略类处理所有情况）
• 不要为了用模式而用模式，简单if-else可能更合适
• 策略类之间不要有隐式依赖

10. 扩展思考：策略模式的变体

10.1 可配置策略

通过配置文件动态调整策略参数：

yaml复制discount:
  strategies:
    fullReduction:
      threshold: 100.0
      reduction: 10.0
    percentage:
      rate: 0.9

10.2 领域特定语言(DSL)

创建流畅API来组合策略：

java复制DiscountStrategy strategy = DiscountBuilder.create()
    .first(new FullReductionStrategy())
    .then(new PercentageDiscountStrategy(0.9))
    .build();

10.3 策略的热加载

使用Java的Instrumentation API或Spring Cloud的RefreshScope实现运行时策略更新。

11. 常见问题解答

Q1：什么时候不该用策略模式？
A：当算法很少变化、或者条件逻辑非常简单时。比如只有2-3个固定分支的if-else，引入策略模式反而会增加复杂度。

Q2：策略类需要设计成单例吗？
A：如果策略是无状态的，单例可以节省内存；有状态策略则需要根据场景决定。Spring中通常用@Scope("prototype")管理有状态bean。

Q3：如何处理策略执行失败的情况？
A：可以在策略接口中定义统一的异常类型，或者返回包含详细结果的策略执行结果对象。

Q4：策略模式会导致类爆炸吗？
A：确实有这个风险。对于简单策略，可以使用Lambda或方法引用；也可以将相关策略组织在同一个类中，通过内部类实现。

Q5：如何选择策略？
A：常见方式包括：配置文件、数据库配置、运行时决策算法等。复杂的策略选择可以单独抽象为"策略选择器"。

12. 代码重构实战

让我们看一个重构前的代码片段：

java复制public double calculatePrice(User user, Product product) {
    if (user.isVip()) {
        if (product.getCategory().equals("ELECTRONICS")) {
            return product.getPrice() * 0.85;
        } else {
            return product.getPrice() * 0.9;
        }
    } else if (user.isNewUser()) {
        return product.getPrice() * 0.95;
    } else if (product.isOnSale()) {
        return product.getPrice() - 10;
    }
    return product.getPrice();
}

重构步骤：

1. 识别变化点：VIP折扣、新用户折扣、促销折扣
2. 定义策略接口：

java复制public interface PriceCalculationStrategy {
    boolean supports(User user, Product product);
    double calculate(User user, Product product);
}

3. 实现具体策略：

java复制public class VipElectronicsStrategy implements PriceCalculationStrategy {
    @Override
    public boolean supports(User user, Product product) {
        return user.isVip() && product.getCategory().equals("ELECTRONICS");
    }
    
    @Override
    public double calculate(User user, Product product) {
        return product.getPrice() * 0.85;
    }
}
// 其他策略类似...

4. 创建策略上下文：

java复制public class PriceCalculator {
    private final List<PriceCalculationStrategy> strategies;
    
    public PriceCalculator(List<PriceCalculationStrategy> strategies) {
        this.strategies = strategies;
    }
    
    public double calculate(User user, Product product) {
        return strategies.stream()
            .filter(s -> s.supports(user, product))
            .findFirst()
            .map(s -> s.calculate(user, product))
            .orElse(product.getPrice());
    }
}

重构后的优势：

• 新增折扣类型只需添加新策略类
• 每种折扣逻辑独立测试
• 支持策略优先级等复杂逻辑

13. 单元测试指南

良好的策略模式实现应该具备高可测试性。测试要点：

1. 策略接口测试：验证接口契约

java复制public interface DiscountStrategyTest<T extends DiscountStrategy> {
    T createStrategy();
    
    @Test
    default void shouldReturnSameOrLowerPrice() {
        T strategy = createStrategy();
        double original = 100.0;
        double discounted = strategy.applyDiscount(original);
        assertTrue(discounted <= original, 
            "折扣后价格不应高于原价");
    }
}

2. 具体策略测试：

java复制class FullReductionStrategyTest implements DiscountStrategyTest<FullReductionStrategy> {
    @Override
    public FullReductionStrategy createStrategy() {
        return new FullReductionStrategy();
    }
    
    @Test
    void shouldApplyReductionWhenOverThreshold() {
        FullReductionStrategy strategy = createStrategy();
        assertEquals(90.0, strategy.applyDiscount(100.0));
    }
}

3. 上下文测试：

java复制class DiscountContextTest {
    @Test
    void shouldUseCurrentStrategy() {
        DiscountContext context = new DiscountContext();
        context.setStrategy(new FullReductionStrategy());
        assertEquals(90.0, context.executeStrategy(100.0));
    }
    
    @Test
    void shouldThrowWhenStrategyNotSet() {
        DiscountContext context = new DiscountContext();
        assertThrows(IllegalStateException.class, 
            () -> context.executeStrategy(100.0));
    }
}

4. 集成测试：

java复制@SpringBootTest
class DiscountServiceIntegrationTest {
    @Autowired
    private DiscountService discountService;
    
    @Test
    void shouldApplyConfiguredStrategies() {
        double price = discountService.applyDiscount("FULL_REDUCTION", 100.0);
        assertEquals(90.0, price);
    }
}

14. 性能考量

虽然策略模式提供了良好的设计，但也需要考虑性能影响：

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

   • 解决方案：重用无状态策略实例

2. 方法调用开销：多一层间接调用

   • 热点路径可以考虑内联优化

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

   • 监控类加载情况

基准测试示例（JMH）：

java复制@BenchmarkMode(Mode.Throughput)
@State(Scope.Benchmark)
public class StrategyPerformanceBenchmark {
    private DiscountStrategy strategy;
    private DiscountContext context;
    
    @Setup
    public void setup() {
        strategy = new FullReductionStrategy();
        context = new DiscountContext();
        context.setStrategy(strategy);
    }
    
    @Benchmark
    public double directCall() {
        return strategy.applyDiscount(100.0);
    }
    
    @Benchmark
    public double throughContext() {
        return context.executeStrategy(100.0);
    }
}

典型结果：

• 直接调用 vs 通过上下文：约2-3倍的性能差异
• 在大多数业务场景中，这种开销可以忽略
• 对性能极度敏感的代码段可能需要特殊处理

15. 设计陷阱与规避

1. 策略泄露：上下文暴露了策略内部细节

   • 错误示例：context.getStrategy().internalMethod()
   • 正确做法：通过上下文提供完整接口

2. 过度抽象：为不太可能变化的逻辑创建策略

   • 判断标准：该逻辑在未来6个月内会变化吗？

3. 策略膨胀：一个策略类变得过于复杂

   • 解决方案：拆分为多个子策略

4. 循环依赖：策略之间相互调用

   • 应该通过上下文协调策略交互

5. 忽略null策略：没有处理策略未设置的情况

   • 始终验证策略引用不为null

16. 与其他技术的结合

16.1 Spring集成

利用Spring的依赖注入管理策略：

java复制@Configuration
public class StrategyConfig {
    @Bean
    @ConditionalOnProperty(name = "discount.strategy.full-reduction.enabled", havingValue = "true")
    public DiscountStrategy fullReductionStrategy() {
        return new FullReductionStrategy();
    }
    
    // 其他策略bean...
}

16.2 动态代理

为策略添加横切关注点：

java复制public class LoggingStrategyProxy implements InvocationHandler {
    private final DiscountStrategy target;
    
    public static DiscountStrategy create(DiscountStrategy target) {
        return (DiscountStrategy) Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            new LoggingStrategyProxy(target)
        );
    }
    
    private LoggingStrategyProxy(DiscountStrategy target) {
        this.target = target;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        long start = System.currentTimeMillis();
        Object result = method.invoke(target, args);
        long duration = System.currentTimeMillis() - start;
        System.out.printf("策略%s执行耗时%dms%n", 
            target.getStrategyName(), duration);
        return result;
    }
}

16.3 函数式编程

Java 8+中可以用函数表示简单策略：

java复制public class FunctionalDiscountContext {
    private Function<Double, Double> strategy;
    
    public void setStrategy(Function<Double, Double> strategy) {
        this.strategy = strategy;
    }
    
    public double execute(double price) {
        return strategy.apply(price);
    }
}

使用方式：

java复制context.setStrategy(price -> price > 100 ? price - 10 : price);

17. 架构层面的应用

在大型系统中，策略模式可以应用于：

1. 插件架构：每个策略作为独立插件
2. 业务规则引擎：规则即策略
3. 算法服务：如推荐算法、定价算法的动态切换
4. 适配不同供应商：各供应商对接作为独立策略

微服务中的策略模式示例：

java复制@FeignClient(name = "payment-service")
public interface PaymentStrategy {
    @PostMapping("/pay")
    PaymentResult pay(@RequestBody PaymentRequest request);
}

// 具体策略
@Service
@RequiredArgsConstructor
public class AlipayStrategy implements PaymentStrategy {
    private final AlipayClient alipayClient;
    
    @Override
    public PaymentResult pay(PaymentRequest request) {
        // 支付宝具体实现
    }
}

// 上下文服务
@Service
public class PaymentService {
    private final Map<String, PaymentStrategy> strategies;
    
    public PaymentService(List<PaymentStrategy> strategyList) {
        this.strategies = strategyList.stream()
            .collect(Collectors.toMap(
                s -> s.getClass().getSimpleName(),
                Function.identity()
            ));
    }
    
    public PaymentResult processPayment(String provider, PaymentRequest request) {
        PaymentStrategy strategy = strategies.get(provider + "Strategy");
        if (strategy == null) {
            throw new IllegalArgumentException("不支持的支付提供商");
        }
        return strategy.pay(request);
    }
}

18. 调试与问题排查

当策略模式出现问题时，可以检查：

1. 策略未生效：

   • 确认正确设置了策略
   • 检查策略的supports/conditions逻辑
   • 验证策略是否被Spring正确加载

2. 性能问题：

   • 使用Profiler分析策略创建开销
   • 检查是否有不必要的策略实例化

3. 内存泄漏：

   • 确认策略实例被正确释放
   • 检查缓存策略的Map是否无限增长

调试技巧：

• 在上下文类中添加日志记录策略切换
• 为策略接口添加toString()方法方便调试
• 使用条件断点调试特定策略

19. 代码生成与自动化

对于高度规范的策略模式实现，可以考虑：

1. 注解处理器自动生成策略类：

java复制@Strategy(pattern = ".*Discount")
public class PercentageDiscountStrategyImpl implements DiscountStrategy {
    // 自动生成代码
}

2. IDE模板快速创建策略类：

• IntelliJ的File Template
• Eclipse的Code Template

3. 元编程工具如Lombok简化代码：

java复制@RequiredArgsConstructor
public abstract class AbstractDiscountStrategy implements DiscountStrategy {
    private final String strategyName;
    
    @Override
    public String getStrategyName() {
        return strategyName;
    }
}

20. 持续演进与重构

随着业务发展，策略模式实现可能需要调整：

1. 策略版本化：支持多版本策略共存

java复制public interface DiscountStrategy {
    String getVersion();
    // 其他方法...
}

2. 策略元数据：添加更多描述信息

java复制public class StrategyDescriptor {
    private String name;
    private String description;
    private String author;
    private LocalDate createdDate;
    // getters/setters...
}

3. 策略生命周期管理：

java复制public interface ManageableStrategy extends DiscountStrategy {
    void init();
    void destroy();
    boolean isEnabled();
}

重构路径建议：

1. 从简单if-else开始
2. 提取为策略模式
3. 引入策略工厂
4. 添加自动发现机制
5. 支持动态加载

21. 跨语言视角

策略模式在其他语言中的实现特点：

Python：

• 利用一等函数简化策略实现
• 鸭子类型减少接口定义

python复制def full_reduction_strategy(price):
    return price - 10 if price >= 100 else price

context.strategy = full_reduction_strategy

JavaScript：

• 对象字面量作为策略集合

javascript复制const strategies = {
    fullReduction: price => price >= 100 ? price - 10 : price,
    percentage: price => price * 0.9
};

context.execute = function(strategyName, price) {
    return strategies[strategyName](price);
};

Go：

• 接口+结构体实现
• 通常结合选项模式(Option Pattern)

go复制type DiscountStrategy interface {
    Apply(float64) float64
}

type fullReduction struct{}

func (s fullReduction) Apply(price float64) float64 {
    if price >= 100 {
        return price - 10
    }
    return price
}

22. 领域驱动设计中的应用

在DDD中，策略模式常用于：

1. 领域服务：将可变业务规则实现为策略
2. 规约模式：组合业务规则
3. 支付/配送等可变领域行为

示例：运费计算策略

java复制public interface ShippingCostStrategy {
    Money calculate(Order order);
}

public class StandardShipping implements ShippingCostStrategy {
    public Money calculate(Order order) {
        // 标准计算逻辑
    }
}

public class ExpeditedShipping implements ShippingCostStrategy {
    public Money calculate(Order order) {
        // 加急计算逻辑
    }
}

23. 设计原则验证

策略模式体现了以下SOLID原则：

1. 单一职责原则(SRP)：每个策略只负责一个算法
2. 开闭原则(OCP)：新增策略无需修改现有代码
3. 依赖倒置原则(DIP)：高层模块依赖抽象接口
4. 接口隔离原则(ISP)：策略接口保持精简
5. 组合优于继承：通过组合策略对象改变行为

24. 反模式警示

1. 策略膨胀：创建过多细粒度策略

   • 解决方案：合并相关策略

2. 上下文过载：上下文承担太多职责

   • 应该保持上下文精简

3. 策略耦合：策略之间直接调用

   • 应该通过上下文协调

4. 过度设计：为简单变化引入策略模式

   • 评估变化频率和复杂度

25. 工具与库支持

1. Spring的@Conditional：条件化策略bean
2. Guava的Strategy模式工具：如AbstractExecutionStrategy
3. Apache Commons Chain：策略链实现
4. 规则引擎：Drools, EasyRules等

Spring示例：

java复制@Configuration
public class StrategyConfiguration {
    @Bean
    @ConditionalOnExpression("#{'${discount.strategy.type}' == 'percentage'}")
    public DiscountStrategy percentageStrategy() {
        return new PercentageDiscountStrategy(0.9);
    }
}

26. 文档化策略

良好的文档能极大提升策略模式的可维护性：

1. 策略接口文档：说明契约和预期行为
2. 具体策略文档：记录算法细节和适用场景
3. 上下文文档：说明策略生命周期管理
4. 示例代码：展示典型用法

JavaDoc示例：

java复制/**
 * 折扣策略接口，用于计算商品折扣后价格。
 * 
 * <p>实现类应该：
 * <ul>
 *   <li>保证幂等性：相同输入产生相同输出</li>
 *   <li>线程安全：无状态或妥善管理状态</li>
 *   <li>提供有意义的策略名称</li>
 * </ul>
 * 
 * @see FullReductionStrategy 满减策略实现
 * @see PercentageDiscountStrategy 百分比折扣策略
 */
public interface DiscountStrategy {
    // ...
}

27. 监控与运维

生产环境中策略模式的监控要点：

1. 策略执行指标：次数、成功率、耗时
2. 策略切换记录：跟踪运行时变化
3. 异常监控：策略特定错误
4. 性能指标：内存占用、GC影响

Spring Boot Actuator示例：

java复制@RestController
public class StrategyMetricsController {
    private final MeterRegistry meterRegistry;
    private final DiscountService discountService;
    
    @GetMapping("/metrics/strategies")
    public Map<String, Object> getStrategyMetrics() {
        Map<String, Object> metrics = new HashMap<>();
        metrics.put("activeStrategies", discountService.getStrategyCount());
        metrics.put("executionCount", 
            meterRegistry.counter("strategy.executions").count());
        return metrics;
    }
}

28. 安全考量

策略模式的安全注意事项：

1. 策略注入：防止恶意策略实现

   • 使用ClassLoader限制策略来源
   • 验证策略签名

2. 敏感操作：策略可能执行特权操作

   • 实施适当的权限检查

3. 配置安全：保护策略配置数据

   • 加密敏感配置

4. 审计日志：记录关键策略操作

29. 团队协作建议

多人协作开发策略模式时：

1. 明确接口契约：定义清晰的策略接口
2. 代码所有权：分配策略维护责任
3. 测试规范：统一的测试标准
4. 文档标准：一致的文档格式
5. 变更流程：策略修改的评审机制

30. 个人实践心得

在实际项目中应用策略模式多年，我有几点深刻体会：

1. 适度抽象：不是所有if-else都需要策略模式，但遇到频繁变更的业务规则时，策略模式能显著提升可维护性。

2. 命名至关重要：策略类和方法的命名要能直观反映其目的，如ExpressShippingStrategy比StrategyImplA要好得多。

3. 测试友好性：策略模式让单元测试变得简单，每个策略可以独立测试，这是提高代码质量的重要保障。

4. 性能平衡：虽然策略模式引入了一定间接性，但在大多数业务场景中，这种开销远小于其带来的架构收益。

5. 组合威力：策略模式与其他模式（如工厂、装饰器）组合使用时，能解决更复杂的业务问题。

最成功的案例是在一个金融项目中，我们使用策略模式管理不同的手续费计算规则。当监管要求变化时，我们能快速添加新策略而不影响现有逻辑，这在频繁变化的金融领域尤为重要。

最大的教训是在早期项目中忽略了策略的生命周期管理，导致内存泄漏。现在我会特别注意：

• 无状态策略尽量用单例
• 有状态策略明确清理责任
• 使用WeakReference管理策略缓存

策略模式就像瑞士军刀中的不同工具，关键在于识别何时该用哪个"工具"。随着经验积累，你会越来越擅长做出这种判断。