1. 策略模式：从概念到实战的完整指南
在软件开发中，我们经常会遇到这样的情况：同一个功能，在不同场景下需要采用不同的算法或行为。比如电商平台的折扣计算（新用户折扣、会员折扣、促销折扣），或者游戏中的角色移动策略（步行、跑步、飞行）。如果把这些算法硬编码在业务逻辑中，代码很快就会变得臃肿且难以维护。这就是策略模式要解决的问题。
策略模式（Strategy Pattern）是一种行为型设计模式，它定义了一系列算法，并将每个算法封装起来，使它们可以相互替换。这种模式让算法的变化独立于使用算法的客户，让程序更灵活、更易于扩展。我第一次真正理解策略模式的价值，是在重构一个老旧的支付系统时——当时系统里有十几种支付方式，全部用if-else堆砌，每次新增支付方式都要修改核心逻辑，测试起来简直是噩梦。
2. 策略模式的核心结构与实现
2.1 UML类图解析
策略模式的经典结构包含三个核心角色：
-
Context（上下文）：持有一个策略对象的引用，负责与客户端交互。它提供了一个设置策略的方法，通常还包含一个执行策略的方法。
-
Strategy（策略接口）：定义所有支持的算法或行为的公共接口。Context通过这个接口调用具体策略。
-
ConcreteStrategy（具体策略）：实现了Strategy接口的具体算法类。
mermaid复制classDiagram
class Context {
-strategy: Strategy
+setStrategy(Strategy)
+executeStrategy()
}
class Strategy {
<<interface>>
+execute()
}
class ConcreteStrategyA {
+execute()
}
class ConcreteStrategyB {
+execute()
}
Context --> Strategy
Strategy <|-- ConcreteStrategyA
Strategy <|-- ConcreteStrategyB
2.2 代码实现示例
让我们用一个实际的电商折扣计算案例来演示策略模式的实现。假设我们有三种折扣策略：无折扣、固定折扣和百分比折扣。
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 final double discountAmount;
public FixedDiscount(double discountAmount) {
this.discountAmount = discountAmount;
}
@Override
public double applyDiscount(double originalPrice) {
return Math.max(0, originalPrice - discountAmount);
}
}
// 具体策略：百分比折扣
public class PercentageDiscount implements DiscountStrategy {
private final double discountPercentage;
public PercentageDiscount(double discountPercentage) {
this.discountPercentage = discountPercentage;
}
@Override
public double applyDiscount(double originalPrice) {
return originalPrice * (1 - discountPercentage / 100);
}
}
// 上下文类
public class DiscountContext {
private DiscountStrategy strategy;
public void setStrategy(DiscountStrategy strategy) {
this.strategy = strategy;
}
public double applyDiscount(double originalPrice) {
if (strategy == null) {
throw new IllegalStateException("Discount strategy not set");
}
return strategy.applyDiscount(originalPrice);
}
}
// 客户端使用
public class Client {
public static void main(String[] args) {
DiscountContext context = new DiscountContext();
// 使用无折扣策略
context.setStrategy(new NoDiscount());
System.out.println("Price after no discount: " + context.applyDiscount(100));
// 使用固定折扣策略
context.setStrategy(new FixedDiscount(20));
System.out.println("Price after $20 discount: " + context.applyDiscount(100));
// 使用百分比折扣策略
context.setStrategy(new PercentageDiscount(15));
System.out.println("Price after 15% discount: " + context.applyDiscount(100));
}
}
提示：在实际项目中，策略对象通常是无状态的，可以被多个上下文共享。如果策略需要维护状态，应该确保状态是线程安全的，或者为每个上下文创建独立的策略实例。
3. 策略模式的应用场景与优势
3.1 何时使用策略模式
策略模式特别适合以下场景：
-
一个系统需要在多种算法中选择一种：比如排序算法（快速排序、归并排序、冒泡排序）根据不同数据规模选择最优算法。
-
需要动态切换算法：如游戏中的AI行为根据难度级别切换不同策略。
-
避免使用多重条件判断：当系统中存在大量条件语句（if-else或switch-case）来选择不同行为时。
-
隐藏算法实现细节：当不希望暴露复杂的算法细节给客户端时。
3.2 策略模式的优势
-
开闭原则：可以在不修改现有代码的情况下引入新策略。
-
消除条件语句：避免了大量的条件判断，代码更清晰。
-
提高可测试性：每个策略可以独立测试，上下文也可以单独测试。
-
运行时灵活性：可以在运行时切换策略。
-
代码复用：不同上下文可以共享相同的策略实例。
我在一个物流系统中应用策略模式时，发现它特别适合处理运费计算这种业务规则经常变化的场景。当业务部门提出新的运费规则时，我们只需要新增一个策略类，完全不需要修改现有代码，大大降低了回归测试的成本。
4. 策略模式的进阶应用与注意事项
4.1 策略枚举（Enum Strategy）
在Java中，可以使用枚举来实现简单的策略模式，这在策略数量固定且简单时特别有用：
java复制public enum Calculator {
ADD {
@Override
public int execute(int a, int b) {
return a + b;
}
},
SUBTRACT {
@Override
public int execute(int a, int b) {
return a - b;
}
};
public abstract int execute(int a, int b);
}
// 使用方式
int result = Calculator.ADD.execute(5, 3);
4.2 策略模式与工厂模式结合
在实际项目中，我们经常将策略模式与工厂模式结合使用，由工厂负责创建和管理策略实例：
java复制public class DiscountStrategyFactory {
private static final Map<String, DiscountStrategy> strategies = new HashMap<>();
static {
strategies.put("NO_DISCOUNT", new NoDiscount());
strategies.put("FIXED_20", new FixedDiscount(20));
strategies.put("PERCENT_15", new PercentageDiscount(15));
}
public static DiscountStrategy getStrategy(String strategyKey) {
DiscountStrategy strategy = strategies.get(strategyKey);
if (strategy == null) {
throw new IllegalArgumentException("Unknown strategy: " + strategyKey);
}
return strategy;
}
}
// 客户端使用
DiscountStrategy strategy = DiscountStrategyFactory.getStrategy("PERCENT_15");
context.setStrategy(strategy);
4.3 常见问题与解决方案
-
策略选择逻辑放在哪里？
- 如果选择逻辑很简单，可以直接放在客户端。
- 如果选择逻辑复杂，可以创建一个专门的策略选择器类。
-
策略对象的创建开销
- 如果策略创建成本高，可以考虑使用对象池或缓存策略实例。
- 无状态策略可以设计为单例。
-
策略间的数据共享
- 避免策略之间直接耦合，可以通过上下文共享必要数据。
-
策略过多导致类爆炸
- 如果策略数量过多，可以考虑使用组合模式来组织策略。
- 对于简单策略，可以使用lambda表达式（Java 8+）或函数式接口。
我在实际项目中遇到过一个典型问题：策略类之间需要共享一些公共数据。最初的做法是通过构造函数传递，但这导致策略接口变得复杂。后来改为通过上下文对象提供这些数据，策略在需要时从上下文中获取，这样保持了策略接口的简洁性。
5. 策略模式在不同语言中的实现差异
5.1 Java中的实现
Java作为典型的面向对象语言，策略模式通常通过接口和实现类来完成，如前面的示例所示。Java 8引入的函数式接口和lambda表达式让策略模式的实现更加简洁：
java复制// 使用函数式接口定义策略
@FunctionalInterface
public interface DiscountStrategy {
double applyDiscount(double originalPrice);
}
// 直接使用lambda表达式作为策略
context.setStrategy(price -> price * 0.9); // 10%折扣
context.setStrategy(price -> price > 100 ? price - 20 : price); // 满100减20
5.2 Python中的实现
Python作为动态类型语言，策略模式的实现更加灵活。可以使用普通函数作为策略，无需定义接口：
python复制class DiscountContext:
def __init__(self, strategy=None):
self._strategy = strategy or (lambda x: x) # 默认无折扣
def set_strategy(self, strategy):
self._strategy = strategy
def apply_discount(self, price):
return self._strategy(price)
# 使用函数作为策略
def fixed_discount(amount):
return lambda price: max(0, price - amount)
def percentage_discount(percent):
return lambda price: price * (1 - percent / 100)
# 客户端代码
context = DiscountContext()
context.set_strategy(fixed_discount(20))
print(context.apply_discount(100)) # 输出80
context.set_strategy(percentage_discount(15))
print(context.apply_discount(100)) # 输出85
5.3 JavaScript中的实现
JavaScript中函数是一等公民，策略模式的实现与Python类似：
javascript复制class DiscountContext {
constructor(strategy = price => price) {
this.strategy = strategy;
}
setStrategy(strategy) {
this.strategy = strategy;
}
applyDiscount(price) {
return this.strategy(price);
}
}
// 策略函数
const fixedDiscount = amount => price => Math.max(0, price - amount);
const percentageDiscount = percent => price => price * (1 - percent / 100);
// 使用
const context = new DiscountContext();
context.setStrategy(fixedDiscount(20));
console.log(context.applyDiscount(100)); // 80
context.setStrategy(percentageDiscount(15));
console.log(context.applyDiscount(100)); // 85
注意：在动态类型语言中使用策略模式时，由于缺乏接口约束，需要特别注意确保所有策略都符合预期的调用约定。良好的文档和单元测试尤为重要。
6. 策略模式在真实项目中的实践案例
6.1 电商平台中的价格计算
在一个大型电商平台中，商品价格计算涉及多种因素：会员等级、促销活动、优惠券、满减规则等。使用策略模式可以优雅地处理这种复杂的价格计算逻辑。
java复制// 价格计算策略接口
public interface PricingStrategy {
BigDecimal calculatePrice(OrderItem item, User user);
}
// 会员折扣策略
public class MemberPricingStrategy implements PricingStrategy {
@Override
public BigDecimal calculatePrice(OrderItem item, User user) {
BigDecimal price = item.getBasePrice();
switch (user.getMemberLevel()) {
case GOLD:
return price.multiply(BigDecimal.valueOf(0.85));
case SILVER:
return price.multiply(BigDecimal.valueOf(0.9));
default:
return price;
}
}
}
// 促销策略
public class PromotionPricingStrategy implements PricingStrategy {
@Override
public BigDecimal calculatePrice(OrderItem item, User user) {
if (item.getPromotions().contains(Promotion.SPECIAL_OFFER)) {
return item.getBasePrice().multiply(BigDecimal.valueOf(0.8));
}
return item.getBasePrice();
}
}
// 价格计算上下文
public class PriceCalculator {
private final List<PricingStrategy> strategies;
public PriceCalculator(List<PricingStrategy> strategies) {
this.strategies = strategies;
}
public BigDecimal calculateFinalPrice(OrderItem item, User user) {
BigDecimal price = item.getBasePrice();
for (PricingStrategy strategy : strategies) {
price = strategy.calculatePrice(item.withPrice(price), user);
}
return price;
}
}
这种设计允许我们灵活组合不同的价格计算策略，比如先应用会员折扣，再应用促销折扣。当需要新增一种折扣类型时，只需添加新的策略类，不会影响现有代码。
6.2 游戏中的AI行为控制
在游戏开发中，策略模式常用于控制NPC的行为。同一个NPC在不同情境下可以表现出不同的行为模式：
csharp复制// 行为策略接口
public interface IAIBehavior {
void Update(AIEntity entity);
}
// 巡逻行为
public class PatrolBehavior : IAIBehavior {
public void Update(AIEntity entity) {
// 实现巡逻逻辑
if (entity.ReachedWaypoint()) {
entity.SetNextWaypoint();
}
entity.MoveTowards(entity.CurrentWaypoint);
}
}
// 追击行为
public class ChaseBehavior : IAIBehavior {
public void Update(AIEntity entity) {
// 实现追击玩家逻辑
if (entity.CanSeePlayer()) {
entity.MoveTowards(entity.PlayerPosition);
} else {
entity.SetBehavior(new PatrolBehavior());
}
}
}
// 逃跑行为
public class FleeBehavior : IAIBehavior {
public void Update(AIEntity entity) {
// 实现逃跑逻辑
if (entity.Health > 0.2f) {
entity.MoveAwayFrom(entity.PlayerPosition);
} else {
entity.SetBehavior(new ChaseBehavior());
}
}
}
// AI实体类
public class AIEntity {
private IAIBehavior _behavior;
public void SetBehavior(IAIBehavior newBehavior) {
_behavior = newBehavior;
}
public void Update() {
_behavior?.Update(this);
}
}
这种设计使得游戏AI的行为可以动态变化，比如当NPC发现玩家时从巡逻切换到追击，当生命值过低时切换到逃跑。每种行为逻辑都封装在独立的策略类中，维护和扩展都非常方便。
6.3 文件解析器设计
在处理不同格式的文件（CSV、JSON、XML等）时，策略模式也非常有用：
python复制from abc import ABC, abstractmethod
class FileParser(ABC):
@abstractmethod
def parse(self, file_path):
pass
class CsvParser(FileParser):
def parse(self, file_path):
import csv
with open(file_path) as f:
return list(csv.DictReader(f))
class JsonParser(FileParser):
def parse(self, file_path):
import json
with open(file_path) as f:
return json.load(f)
class XmlParser(FileParser):
def parse(self, file_path):
import xml.etree.ElementTree as ET
tree = ET.parse(file_path)
root = tree.getroot()
return self._parse_element(root)
def _parse_element(self, element):
# 将XML元素转换为字典
return {child.tag: self._parse_element(child) for child in element}
class FileProcessor:
def __init__(self):
self._parsers = {
'.csv': CsvParser(),
'.json': JsonParser(),
'.xml': XmlParser()
}
def process_file(self, file_path):
import os
ext = os.path.splitext(file_path)[1].lower()
parser = self._parsers.get(ext)
if not parser:
raise ValueError(f"Unsupported file format: {ext}")
return parser.parse(file_path)
# 使用示例
processor = FileProcessor()
data = processor.process_file('data.csv')
这种设计使得添加对新文件格式的支持变得非常简单——只需创建一个新的解析器类并在FileProcessor中注册即可。我在一个数据迁移项目中采用这种设计，当客户突然要求增加对Excel文件的支持时，我们只花了不到一小时就完成了扩展，而核心处理逻辑完全不需要修改。
7. 策略模式与其他设计模式的关系
7.1 策略模式 vs 工厂模式
策略模式和工厂模式经常被混淆，但它们解决的是不同的问题：
| 特性 | 策略模式 | 工厂模式 |
|---|---|---|
| 目的 | 封装算法，使它们可以互换 | 创建对象，隐藏创建逻辑 |
| 关注点 | 行为 | 对象创建 |
| 方法签名 | 通常相同 | 可以不同 |
| 运行时 | 可以动态切换 | 通常在创建时确定 |
在实践中，两种模式经常一起使用：工厂负责创建策略对象，策略模式负责执行不同的算法。
7.2 策略模式 vs 状态模式
策略模式和状态模式在结构上非常相似，但它们的意图不同：
| 特性 | 策略模式 | 状态模式 |
|---|---|---|
| 目的 | 封装可互换的算法 | 封装与状态相关的行为 |
| 变化触发 | 由客户端显式选择 | 由状态转换自动触发 |
| 知晓性 | 策略通常不知道其他策略 | 状态通常知道其他状态 |
| 生命周期 | 策略通常长期存在 | 状态经常随着状态转换而改变 |
简单来说，策略模式是"你做这件事有不同的方法"，而状态模式是"你在不同状态下做不同的事"。
7.3 策略模式 vs 模板方法模式
模板方法模式也涉及算法的变化，但它使用继承而不是组合：
| 特性 | 策略模式 | 模板方法模式 |
|---|---|---|
| 实现方式 | 组合 | 继承 |
| 扩展性 | 运行时灵活 | 编译时确定 |
| 代码复用 | 通过共享策略实例 | 通过父类代码 |
| 修改影响 | 只需修改策略类 | 可能需要修改所有子类 |
策略模式通常更灵活，因为它允许在运行时改变行为，而且不需要继承层次结构。
8. 策略模式的局限性及替代方案
8.1 策略模式的缺点
-
客户端必须了解不同策略：客户端代码需要知道有哪些策略以及何时使用哪种策略。
-
增加了对象数量：每个策略都是一个单独的类，可能导致类数量膨胀。
-
策略间的通信：策略之间通常不能直接通信，必须通过上下文对象。
-
性能开销：在性能敏感的场景中，策略对象的创建和方法调用的开销可能成为问题。
8.2 何时不考虑使用策略模式
-
算法非常简单且不太可能变化：如果只有一两种简单的算法，直接实现可能更简单。
-
算法需要在运行时频繁修改：如果算法需要频繁访问和修改其内部状态，策略模式可能不太适合。
-
性能至上的场景：虚拟方法调用和对象创建的开销在极端性能要求的场景中可能不可接受。
8.3 替代方案
-
函数指针/lambda表达式：在支持函数式编程的语言中，可以使用函数代替策略类。
-
服务定位器模式：当策略需要从全局访问时，可以使用服务定位器来获取策略实例。
-
依赖注入：通过依赖注入框架来管理和注入策略对象。
-
条件语句：对于简单且稳定的算法选择，简单的条件语句可能更直接。
在实际项目中，我见过一个过度使用策略模式的案例：系统中有30多个策略类，但其中20多个只有细微差别。后来我们通过将部分策略参数化，合并成了5个更通用的策略类，大大简化了系统。
9. 策略模式的最佳实践与性能考量
9.1 设计策略接口的最佳实践
-
保持策略接口精简：策略接口应该只包含必要的方法。如果接口太大，考虑是否应该拆分成多个策略。
-
无状态策略：尽可能设计无状态的策略，这样它们可以被共享和重用。
-
明确的契约：清晰地定义策略接口的契约，包括前置条件、后置条件和异常情况。
-
文档化策略选择标准：为每种策略提供文档，说明何时应该使用它。
9.2 性能优化技巧
-
策略对象复用：如果策略是无状态的，可以将其实现为单例或享元。
-
避免频繁切换策略：策略切换可能带来开销，特别是在高性能场景中。
-
考虑策略缓存：如果策略创建成本高，可以缓存策略实例。
-
使用轻量级策略：对于简单策略，考虑使用lambda表达式或方法引用。
-
内联简单策略：在性能关键路径上，有时内联简单策略的逻辑可能更高效。
9.3 测试策略模式
-
单元测试每个策略：每个具体策略都应该有独立的测试用例。
-
测试上下文与策略的交互：确保上下文正确使用策略对象。
-
测试策略切换：验证在运行时切换策略的正确性。
-
性能测试：对于性能敏感的应用，测量策略模式引入的开销。
我在一个高频交易系统中使用策略模式时，最初遇到了性能问题。通过将策略对象缓存并重用，以及将一些简单策略内联，最终将性能开销降低了70%。关键是要在灵活性和性能之间找到平衡点。
10. 现代编程语言中的策略模式演变
10.1 函数式编程中的策略模式
在支持函数式编程的语言中，策略模式变得更加简洁，因为函数本身就是一等公民：
javascript复制// 策略作为函数
const strategies = {
add: (a, b) => a + b,
subtract: (a, b) => a - b,
multiply: (a, b) => a * b
};
// 上下文
function calculate(strategy, a, b) {
return strategy(a, b);
}
// 使用
console.log(calculate(strategies.add, 5, 3)); // 8
console.log(calculate(strategies.multiply, 5, 3)); // 15
10.2 Java中的函数式策略
Java 8引入的lambda表达式和函数式接口让策略模式实现更简洁：
java复制import java.util.function.DoubleUnaryOperator;
public class DiscountContext {
private DoubleUnaryOperator strategy;
public void setStrategy(DoubleUnaryOperator strategy) {
this.strategy = strategy;
}
public double applyDiscount(double originalPrice) {
return strategy.applyAsDouble(originalPrice);
}
}
// 使用
DiscountContext context = new DiscountContext();
context.setStrategy(price -> price * 0.9); // 10%折扣
double finalPrice = context.applyDiscount(100);
10.3 Python中的策略模式变体
Python的鸭子类型和一等函数特性提供了多种实现策略模式的方式：
python复制# 使用类实现
class Strategy:
def execute(self, a, b):
raise NotImplementedError
class AddStrategy(Strategy):
def execute(self, a, b):
return a + b
# 使用函数实现
def add_strategy(a, b):
return a + b
def subtract_strategy(a, b):
return a - b
# 使用字典分发
strategies = {
'add': add_strategy,
'subtract': subtract_strategy
}
def calculate(strategy_name, a, b):
return strategies[strategy_name](a, b)
10.4 C#中的委托策略
C#的委托和lambda表达式为策略模式提供了优雅的实现方式：
csharp复制public class DiscountContext {
private Func<double, double> _discountStrategy;
public DiscountContext(Func<double, double> discountStrategy) {
_discountStrategy = discountStrategy;
}
public double ApplyDiscount(double originalPrice) {
return _discountStrategy(originalPrice);
}
}
// 使用
var context = new DiscountContext(price => price * 0.9);
double finalPrice = context.ApplyDiscount(100);
这些现代语言特性并没有使策略模式过时，而是让它变得更加简洁和灵活。关键在于理解模式的本质——封装变化的行为，而不是特定的实现方式。