Java设计模式之策略模式再温习

java中的策略模式在实际业务场景中，合理的引用，可以让代码阅读起来层次感更强，同时扩展性也会更好，下面对策略模式回顾一下，再次温习理解。
实例1
应用策略模式实现简单的算术计算，包括＋、-、×、÷
1、定义计算接口

public interface Operation {

    /**
     * 执行计算
     * @param a
     * @param b
     * @return
     */
    int execute(int a, int b);
}

2、将＋、-、×、÷ 四个if判断逻辑独立成一个模块，单独处理

public class AddOperation implements Operation {

    @Override
    public int execute(int a, int b) {
        return a + b;
    }
}
public class SubOperation implements Operation {

    @Override
    public int execute(int a, int b) {
        return a - b;
    }
}
public class MultiOperation implements Operation {

    @Override
    public int execute(int a, int b) {
        return a * b;
    }
}
public class DivOperation implements Operation {

    @Override
    public int execute(int a, int b) {
        return a / b;
    }
}

3、工厂类，用于处理调用者传入的参数

public class OperatorFactory {

    private static Map<String, Operation> operationMap = new HashMap<>();

    static {
        //初始化实现类
        operationMap.put("add", new AddOperation());
        operationMap.put("sub", new SubOperation());
        operationMap.put("multi", new MultiOperation());
        operationMap.put("div", new DivOperation());
        // more operators
    }

    /**
     * 获取对应的目标实现类
     * @param operator
     * @return
     */
    public static Optional<Operation> getOperation(String operator){
        return Optional.ofNullable(operationMap.get(operator));
    }

}

4、测试

	public static void main(String[] args) {
        //获取计算的目标实现类
        Operation targetOperation = OperatorFactory.getOperation("add").orElseThrow(() -> new IllegalArgumentException("Invalid Operator"));
        int result = targetOperation.execute(1, 2);
        System.out.println("result:" +  result);
    }

实例2
在springboot中应用策略模式
1、定义接口及不同的策略实现类
2、定义上下文的策略处理类

@Component
public class OperationStrategy implements ApplicationContextAware {

    private Map<String, Operation> operationMap = new ConcurrentHashMap<>();

    /**
     * 执行计算
     * @param operateType
     * @param a
     * @param b
     * @return
     */
    public int calculate(String operateType,int a, int b){
        Operation targetOperation = Optional.ofNullable(operationMap.get(operateType))
                .orElseThrow(() -> new IllegalArgumentException("Invalid Operator"));
        return targetOperation.execute(a,b);
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        Map<String, Operation> map = applicationContext.getBeansOfType(Operation.class);
        map.values().forEach(source -> operationMap.put(source.operateType(), source));
    }

}

或
定义策略工厂类
在spring中，会自动将Strategy接口的实现类注入到这个Map中，key为bean id，value值则为对应的策略实现类。

@Component
public class OperationFactory {

    /**
     * Spring会自动将Strategy接口的实现类注入到这个Map中，key为bean id，value值则为对应的策略实现类
     */
    @Autowired
    private Map<String, Operation> operationMap;

    /**
     * 执行计算
     * @param operateType
     * @param a
     * @param b
     * @return
     */
    public int calculate(String operateType,int a, int b){
        Operation targetOperation = Optional.ofNullable(operationMap.get(operateType))
                .orElseThrow(() -> new IllegalArgumentException("Invalid Operator"));
        return targetOperation.execute(a,b);
    }
}

通过下面的方式不需要现实的编写上下文的策略处理类来初始化对象，Spring在初始化对象的时候，可以帮忙我们实现对象的注入！
3、测试

	@Autowired
    private OperationFactory operationFactory;

    @Test
    void test3(){
        int result = operationFactory.calculate("addOperation", 1,2);
        System.out.println("result:" +  result);
    }

是实际的业务开发中，思考其应用的场景和方式，提升代码的层次性和扩展性。