行为型 策略模式（上）（策略入门）（文末有项目连接）

1：什么是策略模式？

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

注意：
策略是分有状态和无状态的（后面会提及）

注意：
工厂模式主要逻辑在于 创建
策略模式主要逻辑在于 使用

2：策略的定义

策略类的定义比较简单，包含一个策略接口和一组实现这个接口的策略类。
因为所有的策略类都实现相同的接口，所以，客户端代码基于接口而非实现编程，可以灵活地替换不同的策略。

public interface Strategy {

    void algorithmInterface();
}

public class ConcreteStrategyA implements Strategy {

    @Override
    public void algorithmInterface() {
        //具体逻辑
        System.out.println("我是ConcreteStrategyA 的算法逻辑");
    }
}
public class ConcreteStrategyB implements Strategy {

    @Override
    public void algorithmInterface() {
        //具体逻辑
        System.out.println("我是ConcreteStrategyB 的算法逻辑");
    }
}

3：策略的创建

因为策略模式会包含一组策略，在使用它们的时候，一般会通过类型（type）来判断创建哪个策略来使用。
为了封装创建逻辑，我们需要对客户端代码屏蔽创建细节。
我们可以把根据 type 创建策略的逻辑抽离出来，放到工厂类中。

如果策略类是无状态的，不包含成员变量，只是纯粹的算法实现，
这样的策略对象是可以被共享使用的，
不需要在每次调用 getStrategy() 的时候，都创建一个新的策略对象。

如果策略类是有状态的，根据业务场景的需要，
我们希望每次从工厂方法中，获得的都是新创建的策略对象，
而不是缓存好可共享的策略对象，那我们就需要每次都重新创建一个对象

//无状态  可以缓存对象
public class StrategyFactoryStateless {

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

    static {
        strategies.put("ConcreteStrategyA", new ConcreteStrategyA());
        strategies.put("ConcreteStrategyB", 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);
    }
}

//有状态  需要创建对象
public class StrategyFactoryState {
    
    public static Strategy getStrategy(String type) {
        if (type == null || type.isEmpty()) {
            throw new IllegalArgumentException("type should not be empty.");
        }

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

4:策略的使用

策略模式包含一组可选策略，客户端代码一般如何确定使用哪个策略呢？

运行时动态确定使用哪种策略：  在程序运行期间，根据配置、用户输入、计算结果等这些不确定因素，动态决定使用哪种策略策略模式；
非运行时动态指定使用哪种策略：并不能发挥策略模式的优势，退化成了“面向对象的多态特性”或“基于接口而非实现编程原则”

  private static void strategyOne() throws IOException {
        //运行时动态 根据配置文件的配置决定使用哪种策略
        Properties props = new Properties();
        props.load(new FileInputStream("./config.properties"));
        String strategyType = props.getProperty("eviction_type");

        StrategyFactoryStateless strategyFactoryStateless = new StrategyFactoryStateless();
        Strategy strategy = strategyFactoryStateless.getStrategy(strategyType);
        strategy.algorithmInterface();
    }

    private static void strategyTwo() {
        //非运行时动态  在代码中指定使用哪种策略
        StrategyFactoryStateless strategyFactoryStateless = new StrategyFactoryStateless();
        Strategy strategy = strategyFactoryStateless.getStrategy("ConcreteStrategyB");
        strategy.algorithmInterface();
    }

项目连接

请配合项目代码食用效果更佳：
项目地址：
https://github.com/hesuijin/hesujin-design-pattern
Git下载地址：
https://github.com.cnpmjs.org/hesuijin/hesujin-design-pattern.git

demo-study模块  下 behavior_design_pattern  strategy包