设计模式-策略模式详解
策略模式：百度百科中引述为：指对象有某个行为，但是在不同的场景中，该行为有不同的实现算法。
- 策略模式是对算法的包装，是把使用算法的责任和算法本身分割开来，委派给不同的对象管理。
- 策略模式通常把一个系列的算法包装到一系列的策略类里面，作为一个抽象策略类的子类。用一句话来说，就是：“准备一组算法，并将每一个算法封装起来，使得它们可以互换”。
【此处的算法，可以理解为解决业务需求的方法。】
换一种说法就是：一个类的行为或其算法可以在运行时更改。我们把它降维到代码层面，用人话翻译一下就是，运行时我给你这个类的方法传不同的“key”，你这个方法会执行不同的业务逻辑。细品一下，这不就是 if else 干的事吗？
举个实际的例子：审核流程，请假和调休都是提交审核>审批，这个审批的时候要干的事就不同了。如果你传的Type是请假，诶！那就要扣你工资了，起码全勤是没了。如果type是调休的话那就没事了，工资照常发。那正常的代码结构一般就是下面这样了
if(请假){
//todo 扣你工资xxx
} else if(调休){
//todo 工资照发
}
其实策略模式的核心思想和 if else如出一辙，根据不同的key动态的找到不同的业务逻辑，那它就只是如此吗？
实际上，我们口中的策略模式其实就是在代码结构上调整，用接口+实现类+分派逻辑来使代码结构可维护性好点。
一般教科书上讲解到接口与实现类就结束了，其他博客上会带上提及分派逻辑。这里就不啰嗦了。
小结一下，即使用了策略模式，你该写的业务逻辑照常写，到逻辑分派的时候，还是变相的if else。而它的优化点是抽象了出了接口，将业务逻辑封装成一个一个的实现类，任意地替换。在复杂场景（业务逻辑较多）时比直接 if else 来的好维护些。
使用MAP方式实现
就是几个if else场景我需要用到策略模式？！
我想小伙伴们经常有这样的不满，我的业务逻辑就3 4 行，你给我整一大堆类定义？有必要这么麻烦吗？我看具体的业务逻辑还需要去不同的类中，简单点行不行。
其实我们所不满的就是策略模式带来的缺点：
- 策略类会增多
- 业务逻辑分散到各个实现类中，而且没有一个地方可以俯视整个业务逻辑
针对传统策略模式的缺点，在这分享一个实现思路，这个思路已经帮我们团队解决了多个复杂if else的业务场景，理解上比较容易，代码上需要用到Java8的特性——利用Map与函数式接口来实现。
直接show代码结构：为了简单演示一个思路，代码用String 类型来模拟一个业务BO
import org.springframework.stereotype.Service;
import javax.annotation.PostConstruct;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;
/**
* @author: tanghaizhi
* @CreateTime: 2022/6/10 16:26
* @Description:
*/
@Service
public class TestService {
/**
* 业务逻辑分派Map
* Function为函数式接口，下面代码中 Function 的含义是接收一个Stirng类型的变量，返回一个String类型的结果
*/
private Map<String, Function<String, String>> checkResultDispatcher = new HashMap<>();
/**
* 初始化 业务逻辑分派Map 其中value 存放的是 lambda表达式
*/
@PostConstruct
public void checkResultDispatcherInit() {
checkResultDispatcher.put("请假", type -> String.format("%s扣你工资", type));
checkResultDispatcher.put("调休", type -> String.format("%s不扣你工资", type));
}
public String getCheckResultSuper(String type) {
//从逻辑分派Dispatcher中获得业务逻辑代码，result变量是一段lambda表达式
Function<String, String> result = checkResultDispatcher.get(type);
if (result != null) {
//执行这段表达式获得String类型的结果
return result.apply(type);
}
return "不正确的业务类型";
}
}
测试
@RestController
public class TestCtrl {
@Autowired
TestService testService;
@PostMapping("/v1/demo/test")
public String test2(String type) {
return testService.getCheckResultSuper(type);
}
}
鲁迅曾说过，“每解决一个问题，就会引出更多的问题”。我们一起来看看这样的实现有什么好处，会带来什么问题。
好处很直观：
- 在一段代码里直观的看到"判断条件"与业务逻辑的映射关系
- 不需要单独定义接口与实现类，直接使用现有的函数式接口（什么？不知道函数式接口？快去了解），而实现类直接就是业务代码本身。
不好的点：
- 需要团队成员对lambda表达式有所了解(什么？Java17都出来了还有没用上Java8新特性的小伙伴？)
接下来我举几个在业务中经常遇到的if else场景，并用Map+函数式接口的方式来解决它
有的小伙伴会说，我的判断条件有多个啊，而且很复杂，你之前举个例子只有单个判断逻辑，而我有多个判断逻辑该怎么办呢？
很好解决：写一个判断逻辑的方法，Map的key由方法计算出
@Service
public class TestService {
/**
* 业务逻辑分派Map
* Function为函数式接口，下面代码中 Function 的含义是接收一个Stirng类型的变量，返回一个String类型的结果
*/
private Map<String, Function<String, String>> checkResultDispatcher = new HashMap<>();
private static String QJ_PASS = "请假_通过";
private static String QJ_REJECT = "请假_驳回";
private static String TX_PASS = "调休_通过";
private static String TX_REJECT = "调休_驳回";
/**
* 初始化 业务逻辑分派Map 其中value 存放的是 lambda表达式
*/
@PostConstruct
public void checkResultDispatcherInit() {
checkResultDispatcher.put(QJ_PASS, type -> String.format("%s成功,扣你工资", type));
checkResultDispatcher.put(QJ_REJECT, type -> String.format("%s失败，老实上班", type));
checkResultDispatcher.put(TX_PASS, type -> String.format("%s成功，不扣你工资，放心去浪", type));
checkResultDispatcher.put(TX_REJECT, type -> String.format("%s失败，老实上班", type));
}
public String getCheckResultSuper(String type, String state) {
//从逻辑分派Dispatcher中获得业务逻辑代码，result变量是一段lambda表达式
String key = getDispatcherKey(type,state);
Function<String, String> result = checkResultDispatcher.get(key);
if (result != null) {
//执行这段表达式获得String类型的结果
return result.apply(type);
}
return "不正确的业务类型";
}
/**
* 判断条件方法
*/
private String getDispatcherKey(String type, String state) {
return type + "_" + state;
}
}
测试 ctrl修改如下
@PostMapping("/v1/demo/test")
public String test2(String type, String state) {
return testService.getCheckResultSuper(type,state);
}
测试结果如下所示
可以看出，只要设计好key的生成规则，多判断逻辑的需求是完全可以满足的。
既然鲁迅说过，“每解决一个问题，就会引出更多的问题”。那么我们接下来看看还有什么问题
如果我的业务逻辑有很多很多行，在checkResultDispatcherMuitInit()方法的Map中直接写不会很长吗？
直接写当然长了，我们可以抽象出一个service服务专门放业务逻辑，然后在定义中调用它就好了：
@Service
public class BizUnitService {
public String qjPass(String type) {
return type + "通过+各种花式操作";
}
public String qjReject(String type) {
return type + "失败+各种花式操作";
}
public String txPass(String type) {
return type + "成功+各种花式操作";
}
public String txReject(String type) {
return type + "失败+各种花式操作";
}
}
@Service
public class TestService {
@Autowired
BizUnitService bizUnitService;
/**
* 业务逻辑分派Map
* Function为函数式接口，下面代码中 Function 的含义是接收一个Stirng类型的变量，返回一个String类型的结果
*/
private Map<String, Function<String, String>> checkResultDispatcher = new HashMap<>();
private static String QJ_PASS = "请假_通过";
private static String QJ_REJECT = "请假_驳回";
private static String TX_PASS = "调休_通过";
private static String TX_REJECT = "调休_驳回";
/**
* 初始化 业务逻辑分派Map 其中value 存放的是 lambda表达式
*/
@PostConstruct
public void checkResultDispatcherInit() {
checkResultDispatcher.put(QJ_PASS, type -> bizUnitService.qjPass(type));
checkResultDispatcher.put(QJ_REJECT, type -> bizUnitService.qjReject(type));
checkResultDispatcher.put(TX_PASS, type -> bizUnitService.txPass(type));
checkResultDispatcher.put(TX_REJECT, type -> bizUnitService.txReject(type));
}
public String getCheckResultSuper(String type, String state) {
//从逻辑分派Dispatcher中获得业务逻辑代码，result变量是一段lambda表达式
String key = getDispatcherKey(type,state);
Function<String, String> result = checkResultDispatcher.get(key);
if (result != null) {
//执行这段表达式获得String类型的结果
return result.apply(type);
}
return "不正确的业务类型";
}
/**
* 判断条件方法
*/
private String getDispatcherKey(String type, String state) {
return type + "_" + state;
}
}
测试结果如下所示
使用接口方式实现
先定义一个接口
public interface WebSocketService {
void msgConsume(ReceiveMsgModel receiveMsgModel);
}
可以在不同的类中实现接口方法，做不同的事
可以用@Component(“msgConsumeType1”)注解的方式重命名bean的name
因为使用@Component(“msgConsumeType1”)注解的方式重命名bean的name，因此我们可以根据bean的name拿到具体实现类，以执行不同的业务代码。
@Override
public void onMessage(String msg) {
log.debug("[websocket {}] 收到消息：{}",wsName,msg);
try{
if(StringUtils.isNotBlank(msg)){
ReceiveMsgModel receiveMsg = JSON.parseObject(msg,ReceiveMsgModel.class);
receiveMsg.setWsName(wsName);
String beanName= "msgConsumeType" + receiveMsg.getType();
WebSocketService service = SpringApplicationContextUtil.getBean(beanName,WebSocketService.class);
if(service != null){
service.msgConsume(receiveMsg);
}else {
log.info("[websocket {}] 未知的消息类型：{}",wsName,msg);
}
}
} catch (Exception e){
e.printStackTrace();
log.info("[websocket {}] 消息处理失败：{}",wsName,msg);
}
}
SpringApplicationContextUtil spring获取bean的工具类
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
/**
* @author: tanghaizhi
* @CreateTime: 2022/10/19 15:09
* @Description:
*/
@Component
public class SpringApplicationContextUtil implements ApplicationContextAware {
private static ApplicationContext applicationContext;
public ApplicationContext getApplicationContext() {
return SpringApplicationContextUtil.applicationContext;
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
SpringApplicationContextUtil.applicationContext = applicationContext;
}
/**
* 通过工厂类获取对应的服务
* @param actionName 服务类名
* @return 服务类
*/
public static Object getBean(String name){
Object object=null;
try{
object = SpringApplicationContextUtil.applicationContext.getBean(name);
}catch(Exception e){
e.printStackTrace();
}
return object;
}
/**
* 通过工厂类获取对应的服务
* @param clazz 对应的class
* @return 服务类
*/
public static <T> T getBean(Class<T> clazz){
T object=null;
try{
object = SpringApplicationContextUtil.applicationContext.getBean(clazz);
}catch(Exception e){
}
return object;
}
/**
* 获取指定class类型的服务类
* @param name 名称
* @param requiredType class对象
* @return 服务类
*/
public static <T> T getBean(String name,Class<T> requiredType){
T object=null;
try{
object=SpringApplicationContextUtil.applicationContext.getBean(name,requiredType);
}catch(NoSuchBeanDefinitionException e){
}catch(Exception e){
}
return object;
}
/**
* 是否存在执行名称的服务类
* @param name 名称
* @return true 存在 flase 不存在
*/
public static boolean containsBean(String name){
return SpringApplicationContextUtil.applicationContext.containsBean(name);
}
/**
* 获取注册class类型
* @param name
* @return
*/
public static String[] getAliases(String name){
String[] s=null;
try{
s=SpringApplicationContextUtil.applicationContext.getAliases(name);
}catch(NoSuchBeanDefinitionException e){
}catch(Exception e){
}
return s;
}
}