【设计模式】策略模式：我是一个有谋略的类

什么是策略模式？

策略模式是指有一定行动内容的相对稳定的策略名称。策略模式在古代中又称“计策”，简称“计”，如《汉书·高帝纪上》：“汉王从其计”。这里的“计”指的就是计谋、策略。策略模式具有相对稳定的形式，如“避实就虚”、“出奇制胜”等。一定的策略模式，既可应用于战略决策，也可应用于战术决策；既可实施于大系统的全局性行动，也可实施于大系统的局部性行动（百度百科）。

策略上模式：定义一族算法类，将每个算法分别封装起来，让它们可以互相替换。策略模式可以使算法的变化独立于使用它们的客户端（这里的客户端代指使用算法的代码）。

其实策略模式也是为了实现解耦的，不过它和工厂不同的是它是对策略的定义、创建、使用这三部分进行解耦，下面我们一起来看看如何使用这美妙的策略模式把。

讲了这么多到底什么是策略模式呢？概念理解起来比较抽象，这个时候就需要引入一个生活中的栗子，小明很喜欢旅游，只要一有时间就会到世界各地游玩，但是有一个问题一直在困扰着他，那就是出行工具问题，是选择飞机呢？高铁呢？还是火车，每次都会考虑很久，直到有一天，它得到了一个狗头军师，每次出行都是这个狗头军师为它安排出行的方式，小明只需要把目的地告诉狗头军师，狗头军师为它选择最合适的出行工具，这就是现实生活中的策略，狗头军师就相当于程序中的策略接口，飞机、高铁、火车则是真正的策略类（用于解决问题）。

策略的实现

设计原则中一直推荐我们使用面向接口编程而非实现，策略模式也是如此，它需要先定义一个策略接口，然后在定义一组策略类来实现策略接口，这个时候我们只需要关注的是接口，而并非是那一组的策略类。

/**
/**
 * 策略接口
 */
public interface IStrategy {
​
    String strategyTravel();
}
/**
 * 飞机
 */
@Service
public class AircraftStrategyImpl  implements IStrategy{
    @Override
    public String strategyTravel() {
​
        return null;
    }
}
​
​
​
/**
 * 高铁
 */
@Service
public class SHRStrategyImpl implements IStrategy{
    @Override
    public String strategyTravel() {
        return null;
    }
}​
​
​
/**
 * 火车
 */
@Service
public class TrainStrategyImpl implements IStrategy {
    @Override
    public String strategyTravel() {
        return null;
    }
}

上面的代码就是一个简单的策略模式，我们定义了一个策略接口：IStrategy，同时定义了一组策略类：AircraftStrategyImpl、SHRStrategyImpl、TrainStrategyImpl，对于小明来说，它需要对接的是策略接口，告诉策略接口自己要去的地方离自己有多远，策略模式经过自己的谋略就会计算出最佳的出行工具了。

哈哈，策略模式的实现是不是特别简单，细心的朋友一眼就发现了，这不就是多态的​特性吗？怎么就成策略模式了呢？策略是模式 多态是技术 策略侧重应用场景 多态侧重代码实现，所以大家不要把多态和策略模式想成是一个东西，虽然策略是运用了多态的技术。

策略模式的结构我们是熟悉了，但是策略接口和策略类怎么创建​呢？或者说怎么​绑定他们之间的关系？大家可以先​思考一下，然后接着往下看。

​如何创建策略？

我们的策略类有很多个，一般情况下我们需要通过一个type来区分使用哪个策略，小明出行的这个例子，也是通过类型来区分，比如：国外游选择飞机；国内省外选择高铁；国内省内选择火车，那具体怎么创建呢？不知道大家对工厂​模式还熟悉吗？

没错，我们就可以通过工厂来创建策略类，我们叫他策略工厂，熟悉工厂模式的同学应该知道工厂模式有两个经典的实现方式​：饿汉式、懒汉式，我们的策略工厂也可以根据具体的需求来创建策略，我们先来看看饿汉式​。

/**
 * 策略工厂
 */
@Component
public class StrategyFactory {
​
    /**
     * 用于存储策略类，为什么使用HashMap而不用ConcurrentHashMap呢？
     * 那是因为它没有并发问题，所以不需要使用ConcurrentHashMap
     */
    private static final Map<Integer,IStrategy> strategy = new HashMap<Integer, IStrategy>();
    static{
        //国外   选择飞机
        strategy.put(1,new AircraftStrategyImpl());
        //国内--省外   选择高铁
        strategy.put(1,new SHRStrategyImpl());
        //国内--省内   选择火车
        strategy.put(1,new TrainStrategyImpl());
    }
​
​
    public static IStrategy  getStrategy(Integer type){
        if(type == null ){
            throw new IllegalArgumentException("请选择类型");
        }
        return strategy.get(type);
    }
}

饿汉式就是在程序启动的时候将所有的策略类创建完成，需要使用的时候直接调用即可，​那什么时候使用这种方式呢？对象的创建很复杂的时候，比如策略类的创建需要通过计算、引用各种类，创建策略类的时候会花费大量的时间，按照 fail-fast 的设计原则（有问题及早暴露），推荐使用饿汉式​；如果策略类中没有共享变量，无状态，仅仅只是用于谋略（计算），这个时候我们也可以使用​饿汉式。

那懒汉式呢？我们先来看看懒汉式的实现

/**
 * 策略工厂
 */
@Component
public class StrategyFactory {
    
    public static IStrategy  getStrategy(Integer type){
        if(type == null ){
            throw new IllegalArgumentException("请选择类型");
        }
        if(type == 1){
            //国外   选择飞机
            return new AircraftStrategyImpl();
        }else if(type == 2){
            //国内--省外   选择高铁
            return new SHRStrategyImpl();
        }else if(type == 3){
            //国内--省内   选择火车
            return new TrainStrategyImpl();
        }
        return null;
    }
}

懒汉式则是在调用的时候创建，根据调用的类型实时创建对应的策略，这种模式是用于存在共享变量的策略类，因为存在共享就会存在并发安全问题，所以懒汉式是一个不错的选择，至于选择哪种，相信大家已经有了​自己的答案了。​​

策略模式的使用

策略模式的结构、创建都已经讲清楚了，​那我们如何使用策略模式呢？就算我们之前写的代码再漂亮，如果不能使用，那将毫无意义，接下来我们一起来看看如何使用策略模式吧​。

话不多说，直接上代码，新建Context策略行为类：

/**
 * Context 改变策略 Strategy 行为变化。
 */
public class Context {
​
    private  IStrategy strategy;
    public Context(IStrategy strategy){
        this.strategy = strategy;
    }
​
    public String strategyTravel(){
        return this.strategy.strategyTravel();
    }
}

对之前的策略类做了小小的改动

/**
 * 飞机
 */
@Service
public class AircraftStrategyImpl  implements IStrategy{
    @Override
    public String strategyTravel() {
        return "国外，当然是选择飞机出行了！";
    }
}
/**
 * 高铁
 */
@Service
public class SHRStrategyImpl implements IStrategy{
    @Override
    public String strategyTravel() {
        return "省外，当然是高铁啊，速度杠杠的！";
    }
}
​
​
/**
 * 火车
 */
@Service
public class TrainStrategyImpl implements IStrategy {
    @Override
    public String strategyTravel() {
        return "既然是省内，那就是选择火车出行吧！";
    }
}

测试代码如下

public class StrategyTest {
​
    public static void main(String[] args) {
        //国外
        IStrategy strategy1 = StrategyFactory.getStrategy(1);
        Context context1 = new Context(strategy1);
        String tool1 = context1.strategyTravel();
        System.out.println( tool1);
        //国内--省外
        IStrategy strategy2 = StrategyFactory.getStrategy(2);
        Context context2 = new Context(strategy2);
        String tool2 = context2.strategyTravel();
        System.out.println(tool2);
        //国内--省内
        IStrategy strategy3 = StrategyFactory.getStrategy(3);
        Context context3 = new Context(strategy3);
        String tool3 = context3.strategyTravel();
        System.out.println(tool3);
    }
}

这样，完整的策略模式代码就完成了，我们看看运行结果​：
这次的出行工具为：国外，当然是选择飞机出行了！
这次的出行工具为：省外，当然是高铁啊，速度杠杠的！
这次的出行工具为：既然是省内，那就是选择火车出行吧！
​
​
Process finished with exit code 0

完美，大家知道为什么需要引入一个Context​吗？文章的最开始讲到这么一句话，不知道大家还记得吗​？
策略上模式：定义一组算法类，将每个算法分别封装起来，让它们可以互相替换​。
这个Context就是为这句话而生的，好了，策略模式的基本使用已经讲的差不多了。

为什么要使用策略模式？

策略模式虽然讲完了，但是大家都知道了什么时候该使用策略模式吗？我来举几个例子：

1.会员等级的折扣，很多时候会员等级的不同买东西享受的折扣也是不一样的，比如：一级的时候只能享受九五折；二级可以享受八五折，三级之后享受七折同时支持买三送一，这个时候推荐使用策略模式，有意想不到的惊喜。
2.文件的读取，我们知道文件类型有很多，像java开发的人应该对yml和properties很熟悉，他们的数据格式是完全不相同的，所以对它们的操作也可以使用策略模式。
3.日志的处理，为什么日志的处理也可以使用策略模式呢？​日志中肯定会出现很多的报错信息，比如：​数据库的错误信息、前端传递的参数错误信息、业务的逻辑错误信息等等，我们需要对这些错误信息进行不同的补救方式，所以策略是一个好选择。

其实说到底策略模式适用于许多相关类但是行为不同，都可以使用策略模式。

总结

设计模式不能滥用，不能为了使用设计模式而使用设计模式，我们要在合适的地方使用合适的方式，并不一定使用设计模式就是最好的，所以一定要结合实际场景。