策略模式--避免冗长的if/else

算是读书笔记吧

极客时间--设计模式之美

---

什么是策略模式

Define a family of algorithms, encapsulate each one, and make them interchangeable. Strategy lets the algorithm vary independently from clients that use it.
定义一族算法类，将每个算法分别封装起来，让它们可以互相替换。策略模式可以使算法的变化独立于使用它们的客户端（这里的客户端代指使用算法的代码）

策略模式对策略的定义、创建、使用三部分进行了解耦

---

策略模式的作用

策略模式解决的问题

策略模式表面上看是为了避免 if-else 分支判断逻辑，但更深层次上，还是为了解耦以及控制代码复杂度

比如在出门旅游时：路线、交通工具的类型、天数、舱位等级、餐饮、住宿等等。
每个节点在执行时，都需要根据预算Type进行不同的操作，从而引起大量的if-else判断。增加一个策略，修改一个策略，都有可能牵一发而动全身。需要对所有状态进行回测。

public void departure () {
  Int money = 100;
  String destination = getDestination(money); //获取目的地
  String vehicles = getVehicles(money); //获取交通工具
  天数、舱位等级、餐饮、住宿等等.....
}

private String getDestination (Int money) {
  if (num < 1000) {
    return "1000块能去得起的地方";
  } else if (num < 5000) {
    return "5000块能去得起的地方";
  } else if (num < 10000) {
    return "10000块能去得起的地方";
  } else if (num < 20000) {
    return "20000块能去得起的地方";
  } else if (num < 40000) {
    return "40000块能去得起的地方";
  } else if (num < 80000) {
    return "80000块能去得起的地方";
  } else  ...
}

private String getVehicles (Int money) {
  if (num < 1000) {
    return "骑车";
  } else if (num < 5000) {
    return "火车";
  } else if (num < 10000) {
    return "火车";
  } else if (num < 20000) {
    return "飞机";
  } else if (num < 40000) {
    return "飞机";
  } else if (num < 80000) {
    return "飞机";
  } else  ...
}

...后面还有一大堆相关的方法需要判断

整个业务如图所示，所有的判断都耦合在业务流程内部，牵一发而动全身

使用策略模式

我们可以将某一条件（Type）下的逻辑，聚合封装到具体的策略类中

public class departureStrategy1000 implements Strategy {  //1000块的旅行策略
  @Override
  public void  getDestination() {
    return "1000块能去得起的地方";
  }
  public void  getVehicles() {
    return "骑车";
  }
  天数、舱位等级、餐饮、住宿等等.....
}

使用策略类后如图所示，每个的情况被封装聚合到单个策略类中，相互隔离

所以策略模式的作用主要体现在：

1. 解耦策略的定义、创建和使用
   控制代码的复杂度，让每个部分都不至于过于复杂、代码量过多。
2. 让复杂框架满足开闭原则
   添加或者修改新策略的时候，最小化、集中化代码改动，减少引入 bug 的风险。

---

策略的定义

策略的定义包含一个策略接口和一组实现这个接口的策略类。
利用基于接口而非实现编程的方式，对具体策略进行解耦。

如下，策略类ConcreteStrategyA、ConcreteStrategyB在策略接口algorithmInterface的使用上，可以随意替换。

public interface Strategy {  //定义策略接口
  void algorithmInterface();
}

public class ConcreteStrategyA implements Strategy {  //实现策略接口的策略类A
  @Override
  public void  algorithmInterface() {
    //具体的算法...
  }
}

public class ConcreteStrategyB implements Strategy { //实现策略接口的策略类B
  @Override
  public void  algorithmInterface() {
    //具体的算法...
  }
}

策略的创建

通常会通过类型（type）来判断创建哪个策略来使用。

这里，有两种创建方式

if-else创建

适用有状态的策略类，每次创建一个新的策略类给业务方使用

public class StrategyFactory {
  public static Strategy getStrategy(String type) {
    if (type == null || type.isEmpty()) {
      throw new IllegalArgumentException("type should not be empty.");
    }

    if (type.equals("A")) {
      return new ConcreteStrategyA();
    } else if (type.equals("B")) {
      return new ConcreteStrategyB();
    }

    return null;
  }
}

通过工厂模式里的Map进行创建

适用于无状态的策略类创建，大家共用一个策略类即可

public class StrategyFactory {
  private static final Map<String, Strategy> strategies = new HashMap<>();

  static {
    strategies.put("A", new ConcreteStrategyA());
    strategies.put("B", new ConcreteStrategyB());
  }

  public static Strategy getStrategy(String type) {
    if (type == null || type.isEmpty()) {
      throw new IllegalArgumentException("type should not be empty.");
    }
    return strategies.get(type);
  }
}

本质上点讲，是借助“查表法”，根据 type 查表替代根据 type 分支判断。

有状态的策略类如何用Map进行创建

可以利用闭包的特性，将创建的逻辑封装进callback中，然后将callback存进Map

---

策略类的使用

如果使用工厂方法创建策略类，其实就和工厂方法相同。
只不过我们从工厂取出来的不再是一个某一个具体类的子类簇。
而是一个实现了策略接口的类簇。

// 运行时动态确定，根据配置文件的配置决定使用哪种策略
public class Application {
  public static void main(String[] args) throws Exception {
    Strategy strategy = null;
    StrategyFactory factory = new StrategyFactory(); 
    strategy = factory.getStrategy("A"); //获取策略类
    strategy.algorithmInterface(); //调用策略接口
    //...
  }
}

---

是不是要抹杀所有的if/else

如果 if-else 分支判断不复杂、代码不多，这并没有任何问题，毕竟 if-else 分支判断几乎是所有编程语言都会提供的语法，存在即有理由。遵循 KISS 原则，怎么简单怎么来，就是最好的设计。非得用策略模式，搞出 n 多类，反倒是一种过度设计