社区编辑申请
注册/登录
实战讲解,原来用 SpringBoot 实现策略模式可以这么简单
开发 前端
本文主要围绕在 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 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));
}

}

最后,在需要的地方引入方法即可!

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 Map<String, Command> 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<String, Command> tempMap = 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 Map<String, Command> 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)
@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 引入策略模式的设计思路和实践方法进行介绍,在实际的业务开发中,合理的使用策略模式,能让代码看起来更佳清爽,业务扩展性也更佳强大,希望能帮助到大家!

责任编辑:武晓燕 来源: Java极客技术
相关推荐

2021-02-01 12:18:55

策略模式Spring

2020-09-25 07:49:36

策略模式Spring

2022-07-05 08:05:00

策略模式接口实现类

2021-03-02 20:42:20

实战策略

2021-06-09 08:53:34

设计模式策略模式工厂模式

2013-11-26 16:09:34

2022-05-09 11:01:18

2009-06-30 09:55:24

Spring运作机制

同话题下的热门内容

如何创建一个无代码的自助客户聊天机器人Java 服务 Docker 容器化优秀实践程序员不得不知道的 API 接口常识如何提高 TypeScript 的代码质量?聊聊 13 种锁的实现方式11个 ES2022(ES13)中惊人的 JavaScript 新特性使用 Vite 和 TypeScript 带你从零打造一个属于自己的 Vue3 组件库Hooks时代,如何写出高质量的react和vue组件?

编辑推荐

太厉害了,终于有人能把TCP/IP协议讲的明明白白了!牛人5次面试腾讯不成功的经验HBase原理–所有Region切分的细节都在这里了Javascript如何监听页面刷新和关闭事件如何搭建一个HTTPS服务端
我收藏的内容
点赞
收藏

51CTO技术栈公众号