行为型设计模式-策略模式(Strategy Pattern)

简介: 行为型设计模式-策略模式(Strategy Pattern)

策略模式

策略模式:百度百科中引述为:指对象有某个行为,但是在不同的场景中,该行为有不同的实现算法。

  1. 策略模式是对算法的包装,是把使用算法的责任和算法本身分割开来,委派给不同的对象管理。
  2. 策略模式通常把一个系列的算法包装到一系列的策略类里面,作为一个抽象策略类的子类。用一句话来说,就是:“准备一组算法,并将每一个算法封装起来,使得它们可以互换”。【此处的算法,可以理解为解决业务需求的方法。】

 换一种说法就是:一个类的行为或其算法可以在运行时更改。我们把它降维到代码层面, 用人话翻译一下就是 ,运行时我给你这个类的方法传不同的“key”,你这个方法会执行不同的业务逻辑。细品一下,这不就是 if else 干的事吗?

 举个实际的例子:审核流程,请假和调休都是提交审核>审批,这个审批的时候要干的事就不同了。如果你传的Type是请假,诶!那就要扣你工资了,起码全勤是没了。如果type是调休的话那就没事了,工资照常发。那正常的代码结构一般就是下面这样了

if(请假){
    //todo 扣你工资xxx
} else if(调休){
    //todo 工资照发
}

其实策略模式的核心思想和 if else如出一辙,根据不同的key动态的找到不同的业务逻辑,那它就只是如此吗?

实际上,我们口中的策略模式其实就是在代码结构上调整,用接口+实现类+分派逻辑来使代码结构可维护性好点。

一般教科书上讲解到接口与实现类就结束了,其他博客上会带上提及分派逻辑。这里就不啰嗦了。

小结一下,即使用了策略模式,你该写的业务逻辑照常写,到逻辑分派的时候,还是变相的if else。而它的优化点是抽象了出了接口,将业务逻辑封装成一个一个的实现类,任意地替换。在复杂场景(业务逻辑较多)时比直接 if else 来的好维护些。

就是几个if else场景我需要用到策略模式?

 我想小伙伴们经常有这样的不满,我的业务逻辑就3 4 行,你给我整一大堆类定义?有必要这么麻烦吗?我看具体的业务逻辑还需要去不同的类中,简单点行不行。

其实我们所不满的就是策略模式带来的缺点:

1、策略类会增多

2、业务逻辑分散到各个实现类中,而且没有一个地方可以俯视整个业务逻辑

 针对传统策略模式的缺点,在这分享一个实现思路,这个思路已经帮我们团队解决了多个复杂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;
@Service
public class TestService {
    /**
     * 业务逻辑分派Map
     * Function为函数式接口,下面代码中 Function<String, String> 的含义是接收一个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);
    }
}

使用接口测试工具得到如下结果:

鲁迅曾说过,“每解决一个问题,就会引出更多的问题”。我们一起来看看这样的实现有什么好处,会带来什么问题。


好处很直观:

  1. 在一段代码里直观的看到"判断条件"与业务逻辑的映射关系
  2. 不需要单独定义接口与实现类,直接使用现有的函数式接口(什么?不知道函数式接口?快去了解),而实现类直接就是业务代码本身。

不好的点:

  1. 需要团队成员对lambda表达式有所了解(什么?Java17都出来了还有没用上Java8新特性的小伙伴?)

接下来我举几个在业务中经常遇到的if else场景,并用Map+函数式接口的方式来解决它

有的小伙伴会说,我的判断条件有多个啊,而且很复杂,你之前举个例子只有单个判断逻辑,而我有多个判断逻辑该怎么办呢?

很好解决:写一个判断逻辑的方法,Map的key由方法计算出

@Service
public class TestService {
    /**
     * 业务逻辑分派Map
     * Function为函数式接口,下面代码中 Function<String, String> 的含义是接收一个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;
    }
}

测试 controller修改如下:

@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<String, String> 的含义是接收一个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;
    }
}

测试结果如下所示:

道不行,乘桴浮于海.    --《论语·公冶长》

相关文章
|
24天前
|
设计模式 算法 Kotlin
Kotlin - 改良设计模式 - 策略模式
Kotlin - 改良设计模式 - 策略模式
45 4
|
15天前
|
设计模式 算法 Kotlin
Kotlin教程笔记(53) - 改良设计模式 - 策略模式
Kotlin教程笔记(53) - 改良设计模式 - 策略模式
35 1
|
19天前
|
设计模式 前端开发 JavaScript
JavaScript设计模式及其在实战中的应用,涵盖单例、工厂、观察者、装饰器和策略模式
本文深入探讨了JavaScript设计模式及其在实战中的应用,涵盖单例、工厂、观察者、装饰器和策略模式,结合电商网站案例,展示了设计模式如何提升代码的可维护性、扩展性和可读性,强调了其在前端开发中的重要性。
24 2
|
1月前
|
设计模式 算法 Kotlin
Kotlin教程笔记(53) - 改良设计模式 - 策略模式
Kotlin教程笔记(53) - 改良设计模式 - 策略模式
43 2
|
2月前
|
设计模式 算法 Kotlin
Kotlin教程笔记(53) - 改良设计模式 - 策略模式
本教程详细讲解Kotlin语法,适合深入学习。快速入门可参考“简洁”系列教程。本文通过游泳运动员的案例,介绍策略模式及其在Kotlin中的改良应用,利用高阶函数简化代码结构,提高灵活性。
35 3
|
2月前
|
设计模式 算法 Kotlin
Kotlin教程笔记(53) - 改良设计模式 - 策略模式
本教程详细讲解Kotlin语法,适合深入学习。快速入门可参考“简洁”系列教程。本文介绍策略模式在Kotlin中的应用,通过游泳运动员的例子,展示如何使用接口和高阶函数实现策略模式,使代码更简洁、灵活。
31 2
|
2月前
|
设计模式 算法 Kotlin
Kotlin教程笔记(53) - 改良设计模式 - 策略模式
Kotlin教程笔记(53) - 改良设计模式 - 策略模式
64 3
|
2月前
|
设计模式 算法 Kotlin
Kotlin - 改良设计模式 - 策略模式
Kotlin - 改良设计模式 - 策略模式
|
2月前
|
设计模式 算法 PHP
PHP中的设计模式:策略模式的深入解析与实践
【10月更文挑战第12天】 在软件开发的世界中,设计模式是解决常见问题的最佳实践。它们不是具体的代码,而是一种编码和设计经验的总结。在PHP开发中,合理运用设计模式可以极大地提高代码的可维护性、扩展性和复用性。本文将深入探讨策略模式(Strategy Pattern)的原理、实现方式及其在PHP中的应用。通过具体示例,我们将展示如何利用策略模式来解耦算法与对象,从而让代码更加灵活和易于管理。
19 0
|
2月前
|
设计模式 存储 算法
PHP中的设计模式:策略模式的深入解析与实践
【10月更文挑战第9天】 在PHP开发领域,设计模式是提升代码可维护性、扩展性和重用性的关键技术之一。本文聚焦于策略模式这一行为型设计模式,通过理论阐述与实例分析,揭示其在PHP应用程序中优化算法切换和业务逻辑解耦方面的强大效用。不同于常规摘要,本文不直接概述研究方法或结果,而是基于实际开发场景,探讨策略模式的应用价值和实现方式,旨在为PHP开发者提供一种高效应对复杂业务需求变化和技术债务累积问题的策略思维。