跳到主要内容

策略模式

策略模式​

策略模式(Strategy Pattern)是一种行为型设计模式,它把一组"完成同一件事的不同方式"分别封装成独立的策略类,让它们之间可以互相替换,客户端在运行时选择合适的策略。核心思想是:把可变的算法抽出去,让主流程稳定。

通俗理解:就像一条 LED 灯带——静态、呼吸、流水、彩虹几种模式都是"发光",但节奏和颜色不同。你切换模式时不需要拆掉灯带,只是把内部的控制策略换掉。

策略模式有 3 个角色:

  1. 抽象策略(Strategy):定义所有具体策略的公共接口。

  2. 具体策略(ConcreteStrategy):实现同一接口的不同算法。

  3. 上下文(Context):持有一个策略引用,把工作委派给它,不关心具体是哪种实现。

一个直观的例子:支付方式​

同一个下单流程可以走微信、支付宝、银行卡等多种支付方式,行为上"发起支付"是一样的,但内部实现不同:

// 1. 抽象策略
interface PaymentStrategy {
void pay(double amount);
}

// 2. 具体策略:微信
class WeChatPay implements PaymentStrategy {
@Override
public void pay(double amount) {
System.out.println("微信支付 ¥" + amount);
}
}

// 具体策略:支付宝
class Alipay implements PaymentStrategy {
@Override
public void pay(double amount) {
System.out.println("支付宝支付 ¥" + amount);
}
}

// 具体策略:银行卡
class CardPay implements PaymentStrategy {
private String cardNo;
public CardPay(String cardNo) { this.cardNo = cardNo; }
@Override
public void pay(double amount) {
System.out.println("银行卡[" + cardNo + "]支付 ¥" + amount);
}
}

// 3. 上下文
class ShoppingCart {
private PaymentStrategy strategy;

public void setStrategy(PaymentStrategy strategy) {
this.strategy = strategy;
}

public void checkout(double total) {
System.out.println("下单,金额 ¥" + total);
strategy.pay(total);
}
}

// 客户端
public class Client {
public static void main(String[] args) {
ShoppingCart cart = new ShoppingCart();

cart.setStrategy(new WeChatPay());
cart.checkout(99.9);

cart.setStrategy(new Alipay());
cart.checkout(199);

cart.setStrategy(new CardPay("6222****1234"));
cart.checkout(1888);
}
}

ShoppingCart 完全不知道具体走的是哪种支付渠道,也不需要写 if (type == "wechat") ... else if (type == "alipay") ... 这样的分支。新增支付方式只需要多写一个策略类,主流程一行不改。

用函数式代替策略类​

在 Java 8+ 里,如果策略接口只有一个抽象方法,完全可以直接用 lambda 甚至方法引用来充当策略,无需为每种算法都写一个类:

Map<String, PaymentStrategy> registry = Map.of(
"wechat", amount -> System.out.println("微信 ¥" + amount),
"alipay", amount -> System.out.println("支付宝 ¥" + amount),
"card", amount -> System.out.println("银行卡 ¥" + amount)
);

cart.setStrategy(registry.get("wechat"));
cart.checkout(99.9);

在 Kotlin、Scala、JavaScript 里这种"函数即策略"更常见。策略模式的骨架不变,只是承载策略的载体从类换成了函数。

策略 vs 状态​

写法上二者非常像——都是"上下文持有一个接口引用、把工作委派过去"。区别在于谁决定切换:

  • 策略:由外部(客户端)决定用哪种算法,策略之间平等且互不感知。
  • 状态:由内部当前状态决定下一个状态是什么,状态之间彼此感知。

同样,策略切换通常是"选一次用一段时间",状态切换则常常伴随业务流程自动流转。

策略 vs if/else​

策略模式常被用来"消除 if/else",但并不是每个 if/else 都值得抽成策略。一个粗略的判断标准:

  • 分支数量少、每个分支代码短、变化频率低 → 保留 if/else 更简单。
  • 分支多、每个分支逻辑较大、经常增删 → 用策略。
  • 分支之间有共同的抽象、可能被别的地方复用 → 用策略。

否则你只是把 if/else 换成了另一个 if/else——把 if (type) 变成了 map.get(type),得不偿失。

使用场景​

  • 算法可插拔:排序、压缩、加密、路由、限流、匹配算法,可以按业务场景切换。
  • 多种付款/配送/优惠方式:电商里最经典的场景。
  • 文件解析器:CSV / JSON / XML 用不同策略解析同一份"数据文件"抽象。
  • AI 与规则引擎:不同的推荐算法、匹配规则、评分模型作为独立策略。
  • 测试友好:把外部依赖包装成策略,测试时替换成假实现。

注意事项​

策略最容易被过度设计。看到几个 if 分支就抽策略,往往会得到一堆"只在一个地方用一次"的策略类。真正的信号是策略需要被复用、需要被独立扩展、或者需要被在运行时动态选择,才值得走这一步。

另一个小坑是策略选择的地方——把"哪种策略"的决定散在客户端很多处,会让新增策略时要改几十个地方。一个常见做法是把"策略选择"集中到一个工厂或注册表里,让客户端只依赖抽象策略接口。