一、介绍

一说起策略设计模式，相比大家都不陌生，在实际的业务开发中，合理地使用设计模式来编程，可以让代码阅读起来层次感更强，同时扩展性也会得到提升！

最近看同事的代码的时候，学到了一个小技巧，在某些场景下合理地使用策略模式还是非常有用的，在此分享一下给大家。

二、代码实践

在介绍 SpringBoot 在如何实现策略设计模式之前，我们先简单地回顾一下策略模式的设计思路。

以编写一个简单的程序计算器，代码如下！

首先，我们定义一个Operation接口，用于逻辑的计算

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

接着，分别将四个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; }}

然后，创建一个工厂类，用于处理客户端传入的参数

public class OperatorFactory { private static Map operationMap = new HashMap(); static { //初始化实现类 operationMap.put(“add”, new AddOperation()); operationMap.put(“sub”, new SubOperation()); operationMap.put(“multi”, new MultiOperation()); operationMap.put(“p”, new DivOperation()); // more operators } /** * 获取对应的目标实现类 * @param operator * @return */ public static Optional getOperation(String operator){ return Optional.ofNullable(operationMap.get(operator)); }}

最后，在需要的地方引入方法即可！

public class OperatorTestMain { 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); }}

以上就是一个典型的策略模式的实践思路，从代码阅读性、扩展性角度看，还是非常干净利落的。

那么，在SpringBoot项目中，我们应该如何使用呢？

三、SpringBoot 实践应用

3.1、方案一

首先，我们还是定义一个Command接口，用于方法的抽象和统一

public interface Command { /** * 命令类型 * @return */ String operateType(); /** * 执行 * @param a * @param b * @return */ Integer execute(int a, int b);}

接着，编写四套不同的计算处理逻辑

@Componentpublic class AddCommand implements Command { @Override public String operateType() { return “add”; } @Override public Integer execute(int a, int b) { return a + b; }}@Componentpublic class SubCommand implements Command { @Override public String operateType() { return “subtract”; } @Override public Integer execute(int a, int b) { return a – b; }}@Componentpublic class MultiCommand implements Command { @Override public String operateType() { return “multiply”; } @Override public Integer execute(int a, int b) { return a * b; }}@Componentpublic class DivCommand implements Command { @Override public String operateType() { return “pide”; } @Override public Integer execute(int a, int b) { return a / b; }}

然后，编写一个类似于上文的策略处理类

@Componentpublic class CalculatorService implements ApplicationContextAware { private Map commandMap = new ConcurrentHashMap(); /** * 执行计算 * @param operateType * @param a * @param b * @return */ public int calculate(String operateType,int a, int b){ Command targetCommand = Optional.ofNullable(commandMap.get(operateType)) .orElseThrow(() -> new IllegalArgumentException(“Invalid Operator”)); return targetCommand.execute(a,b); } @Override public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { Map tempMap = applicationContext.getBeansOfType(Command.class); tempMap.values().forEach(source -> commandMap.put(source.operateType(), source)); }}

最后，我们只需要在适当的位置应用即可！

@RunWith(SpringRunner.class)@SpringBootTestpublic class CalculatorServiceTest { @Autowired private CalculatorService calculatorService; @Test public void test(){ int result = calculatorService.calculate(“add”, 1,2); System.out.println(“result:” + result); }}

总结：这种方案的实践，和上面介绍的思路基本上一致，不同的地方在于，当 springboot 启动时，会将对象注入到IOC容器。

3.2、方案二（推荐）

翻查Spring的ioc容器，你会发现一个秘密，当一个接口有多个实现类时，Spring会自动将Strategy接口的实现类注入到这个Map中，key为bean id，value值则为对应的策略实现类。

简单的说，我们只需要通过@Autowired注入对象，不需要通过CalculatorService这个类进行单独配置，操作方式如下！

首先，编写一个CommandFactory工厂类，用于逻辑的处理

@Componentpublic class CommandFactory { /** * Spring会自动将Strategy接口的实现类注入到这个Map中，key为bean id，value值则为对应的策略实现类 */ @Autowired private Map commandMap; /** * 执行计算 * @param operateType * @param a * @param b * @return */ public int calculate(String operateType,int a, int b){ Command targetCommand = Optional.ofNullable(commandMap.get(operateType)) .orElseThrow(() -> new IllegalArgumentException(“Invalid Operator”)); return targetCommand.execute(a,b); }}

最后，直接在合适的地方使用CommandFactory即可！

@RunWith(SpringRunner.class)@SpringBootTestpublic class CalculatorServiceTest { @Autowired private CommandFactory commandFactory; @Test public void test(){ int result = commandFactory.calculate(“addCommand”, 1,2); System.out.println(“result:” + result); }}

总结：方案二和方案一的不同点在于，不需要显式的编写CalculatorService策略处理类来初始化对象，Spring在初始化对象的时候，可以帮忙我们实现对象的注入！