实战讲解，原来用 SpringBoot 实现策略模式可以这么简单

一、实战讲解介绍

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

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

二、可简代码实践

在介绍 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 MapoperationMap = 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 OptionalgetOperation(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);

}

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

@Component

public class AddCommand implements Command {

@Override

public String operateType() {

return "add";

}

@Override

public Integer execute(int a, int b) {

return a + b;

}

}@Component

public class SubCommand implements Command {

@Override

public String operateType() {

return "subtract";

}

@Override

public Integer execute(int a, int b) {

return a - b;

}

}@Component

public class MultiCommand implements Command {

@Override

public String operateType() {

return "multiply";

}

@Override

public Integer execute(int a, int b) {

return a * b;

}

}@Component

public class DivCommand implements Command {

@Override

public String operateType() {

return "divide";

}

@Override

public Integer execute(int a, int b) {

return a / b;

}

}

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

@Component

public class CalculatorService implements ApplicationContextAware {

private MapcommandMap = 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 {

MaptempMap = applicationContext.getBeansOfType(Command.class);

tempMap.values().forEach(source -> commandMap.put(source.operateType(), source));

}

}

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

@RunWith(SpringRunner.class)

@SpringBootTest

public 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工厂类，用于逻辑的处理；

@Component

public class CommandFactory {

/

**

* Spring会自动将Strategy接口的实现类注入到这个Map中，key为bean id，value值则为对应的策略实现类

*/

@Autowired

private MapcommandMap;

/

**

* 执行计算

* @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)

@SpringBootTest

public class CalculatorServiceTest {

@Autowired

private CommandFactory commandFactory;

@Test

public void test(){

int result = commandFactory.calculate("addCommand", 1,2);

System.out.println("result:" + result);

}

}

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

四、小结

本文主要围绕在 SpringBoot 引入策略模式的设计思路和实践方法进行介绍，在实际的业务开发中，合理的使用策略模式，能让代码看起来更佳清爽，业务扩展性也更佳强大，希望能帮助到大家！

很赞哦!（53388）