1 定义

策略模式(Strategy Pattern)：定义一族算法，将每个算法都封装起来，并且使它们之间可以互换。
策略模式使用的是面向对象的集成和多态机制，易于掌握和理解。
策略模式的通用类图：

策略模式的通用类图

1. Context封装角色
   叫做上下文角色，起到承上启下的封装作用，屏蔽高层模块对策略、算法的直接访问，封装可能存在的变化。
2. Strategy抽象策略角色
   策略/算法家族的抽象，通常为接口，定义每个策略/算法必须具有的方法和属性。
3. ConcreteStrategy具体策略角色
   实现抽象策略中的操作，该类中有具体的算法规则实现。

2 策略模式代码实现

1. 抽象的策略角色
   抽象的策略角色，可以是一个普通的接口，可以定义一个或者多个具体的算法规则。

public interface Strategy {
    /**
     * 策略模式的运算法则
     */
    public void operate();
}

2. 具体的策略角色
   具体策略也是非常普通的实现类，只要实现了接口中的方法就可以。

• 具体策略角色ConcreteStrategyA

@Slf4j
public class ConcreteStrategyA implements Strategy {
    @Override
    public void operate() {
        log.info("具体的策略运算法则：{}", this.getClass().getName());
    }
}

• 具体策略角色ConcreteStrategyB

@Slf4j
public class ConcreteStrategyB implements Strategy {
    @Override
    public void operate() {
        log.info("具体的策略运算法则：{}", this.getClass().getName());
    }
}

3. 封装角色
   策略模式的重点是封装角色，借用了代理模式的思路。策略模式和代理模式的区别在于：代理模式的封装角色和被封装的具体策略角色实现同一个接口，而策略模式的封装角色和被封装的策略类不是同一个接口。

@Slf4j
public class Context {
    /**
     * 抽象策略
     */
    private Strategy strategy = null;

    /**
     * 构造函数设置具体策略
     */
    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    /**
     * 封装后的策略方法
     */
    public void doSomething() {
        log.info("我是封装的策略方法:{}", this.getClass().getName());
        this.strategy.operate();
    }
}

4. 高层客户端模块
   客户端模块的调用非常简单，只要知道要用那个策略，产生出对象，然后放到封装角色中就可以完成任务了。

@Slf4j
public class Client {
    public static void main(String[] args) {
        //声明一个具体的策略
        Strategy strategy = new ConcreteStrategyA();
        //声明一个上下文对象
        Context context = new Context(strategy);
        //执行封装后的方法
        context.doSomething();
    }
}

3 策略模式的优缺点

1. 优点

• 算法可以自由切换
  策略模式本身定义要求，只要实现抽象策略，就能成为策略家族的成员，通过封装角色对其进行封装，保证对外提供“可以自由切换”的策略。
• 避免使用多重条件判断
  如果没有策略模式，如果一个策略家族有多个策略算法，若不确定使用哪个，就需要使用多重条件进行判断，不易维护，容易出错。如果使用策略模式，就可以由其他高层模块决定采用何种策略，策略家族对外提供的访问借口就是封装类，简化了操作，同时避免了条件语句判断。
• 扩展性好
  在现有策略中增加一个策略很容易，只要增加一个接口实现就可以了，其他任何东西都不用修改，类似于一个可以反复拆卸的插件，符合“开闭原则”。

2. 缺点

• 策略类数量增多
  每一个策略都是一个类，复用的可能性很小，类数量真多。
• 所有的策略类都需要对外暴露
  上层模块需要知道有哪些策略，然后才能知道使用哪个策略，与迪米特法则相违背。但是可以使用其他模式来弥补这个缺陷，如工厂方法模式、代理模式或享元模式。

4 策略模式的使用场景

• 多个类只有在算法或行为上稍有不同的场景。
• 算法需要自由切换的场景
  算法的选择由使用者决定。
• 需要屏蔽算法规则的场景
  不需要知道具体的算法细节。

注意
如果系统中一个算法家族的具体策略数量超过4个，需要考虑使用混合模式，解决策略类膨胀和对外暴露的问题。否则，后期系统的可维护性会大大降低。

5 策略角色的扩展——枚举策略

枚举策略是一个优秀和方便的模式，但是受到枚举类型的显示，每个枚举项都是public static final的，扩展性受到了约束。在系统开发中，枚举策略一般担当不经常发生变化的角色。

• 策略枚举类Calculator

@Getter
public enum Calculator {
    ADD("+") {
        @Override
        public int exec(int a, int b) {
            return a + b;
        }
    },
    SUB("-") {
        @Override
        public int exec(int a, int b) {
            return a - b;
        }
    };

    private String value;

    Calculator(String value) {
        this.value = value;
    }

    /**
     * 抽象方法exec
     *
     * @param a 第一个算子
     * @param b 第二个算子
     * @return 两个算子的计算结果
     */
    public abstract int exec(int a, int b);
}

• 应用场景类

@Slf4j
public class Client {
    public static void main(String[] args) {
        if (log.isInfoEnabled()) {
            log.info("输入参数为：args={}", Arrays.toString(args));
        }
        //输入两个参数
        int a = Integer.parseInt(args[0]);
        int b = Integer.parseInt(args[1]);
        int result = Calculator.ADD.exec(a, b);
        log.info("计算结果为:result={}", result);
    }
}

6 策略模式的最佳实践

策略模式实现简单，但是由于致命缺点——所有策略都要暴露，在实际项目中很少单独使用，一般是通过工厂方法来实现策略类的声明，结合使用。

参考

1. 设计模式之禅