如何利用Map与函数式接口来实现去除if else

更新时间：2023年07月12日 09:17:01 作者：HaSaKing_721

这篇文章主要介绍了如何利用Map与函数式接口来实现去除if else问题，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教

前言

我想大家肯定都或多或少的看过各种“策略模式”的讲解、布道等等，这篇文章就是来好好“澄清”一下策略模式，

并尝试回答以下的问题：

策略模式是如何优化业务逻辑代码结构的？
杀鸡焉用宰牛刀？就是几个if else场景我需要用到策略模式？！
有没有什么更好的代码结构来实现策略模式的吗？

策略模式是如何优化业务逻辑代码结构的？

要回答这个问题，我们还得先扒一扒策略模式的定义，从定义着手来理解它

策略模式的教科书定义

它的定义很精简：

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

策略模式优化了什么？

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

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

在这里插入图片描述

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

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

杀鸡焉用宰牛刀？就是几个if else场景我需要用到策略模式？！

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

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

策略类会增多
业务逻辑分散到各个实现类中，而且没有一个地方可以俯视整个业务逻辑

代码Show

针对传统策略模式的缺点，在这分享一个实现思路，这个思路已经帮我们团队解决了多个复杂if else的业务场景，理解上比较容易，代码上需要用到Java8的特性——利用Map与函数式接口来实现。

直接show代码结构：为了简单演示一个思路，代码用String 类型来模拟一个业务BO

其中：

getCheckResult() 为传统的做法
getCheckResultSuper()则事先在Map中定义好了“判断条件”与“业务逻辑”的映射关系,具体讲解请看代码注释

/**
 * 某个业务服务类
 */
@Service
public class BizService {
    /**
     * 传统的 if else 解决方法
     * 当每个业务逻辑有 3 4 行时，用传统的策略模式不值得，直接的if else又显得不易读
     */
    public String getCheckResult(String order) {
        if ("校验1".equals(order)) {
            return "执行业务逻辑1";
        } else if ("校验2".equals(order)) {
            return "执行业务逻辑2";
        }else if ("校验3".equals(order)) {
            return "执行业务逻辑3";
        }else if ("校验4".equals(order)) {
            return "执行业务逻辑4";
        }else if ("校验5".equals(order)) {
            return "执行业务逻辑5";
        }else if ("校验6".equals(order)) {
            return "执行业务逻辑6";
        }else if ("校验7".equals(order)) {
            return "执行业务逻辑7";
        }else if ("校验8".equals(order)) {
            return "执行业务逻辑8";
        }else if ("校验9".equals(order)) {
            return "执行业务逻辑9";
        }
        return "不在处理的逻辑中返回业务错误";
    }
    /**
     * 业务逻辑分派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("校验1", order -> String.format("对%s执行业务逻辑1", order));
        checkResultDispatcher.put("校验2", order -> String.format("对%s执行业务逻辑2", order));
        checkResultDispatcher.put("校验3", order -> String.format("对%s执行业务逻辑3", order));
        checkResultDispatcher.put("校验4", order -> String.format("对%s执行业务逻辑4", order));
        checkResultDispatcher.put("校验5", order -> String.format("对%s执行业务逻辑5", order));
        checkResultDispatcher.put("校验6", order -> String.format("对%s执行业务逻辑6", order));
        checkResultDispatcher.put("校验7", order -> String.format("对%s执行业务逻辑7", order));
        checkResultDispatcher.put("校验8", order -> String.format("对%s执行业务逻辑8", order));
        checkResultDispatcher.put("校验9", order -> String.format("对%s执行业务逻辑9", order));
    }
    public String getCheckResultSuper(String order) {
        //从逻辑分派Dispatcher中获得业务逻辑代码，result变量是一段lambda表达式
        Function<String, String> result = checkResultDispatcher.get(order);
        if (result != null) {
            //执行这段表达式获得String类型的结果
            return result.apply(order);
        }
        return "不在处理的逻辑中返回业务错误";
    }
}

通过http调用一下看看效果：

/**
 * 模拟一次http调用
 */
@RestController
public class BizController {
    @Autowired
    private BizService bizService;
    @PostMapping("/v1/biz/testSuper")
    public String test2(String order) {
        return bizService.getCheckResultSuper(order);
    }
}

在这里插入图片描述

这是个简单的demo演示，之后会举一些复杂的场景案例。

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

好处很直观：

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

不好的点：

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

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

在真实业务场景问题的解决思路

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

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

/**
 * 某个业务服务类
 */
@Service
public class BizService {
    private Map<String, Function<String, String>> checkResultDispatcherMuti = new HashMap<>();
    /**
     * 初始化 业务逻辑分派Map 其中value 存放的是 lambda表达式
     */
    @PostConstruct
    public void checkResultDispatcherMuitInit() {
        checkResultDispatcherMuti.put("key_订单1", order -> String.format("对%s执行业务逻辑1", order));
        checkResultDispatcherMuti.put("key_订单1_订单2", order -> String.format("对%s执行业务逻辑2", order));
        checkResultDispatcherMuti.put("key_订单1_订单2_订单3", order -> String.format("对%s执行业务逻辑3", order));
    }
    public String getCheckResultMuti(String order, int level) {
        //写一段生成key的逻辑：
        String ley = getDispatcherKey(order, level);
        Function<String, String> result = checkResultDispatcherMuti.get(ley);
        if (result != null) {
            //执行这段表达式获得String类型的结果
            return result.apply(order);
        }
        return "不在处理的逻辑中返回业务错误";
    }
    /**
     * 判断条件方法
     */
    private String getDispatcherKey(String order, int level) {
        StringBuilder key = new StringBuilder("key");
        for (int i = 1; i <= level; i++) {
            key.append("_" + order + i);
        }
        return key.toString();
    }
}

用http模拟一下：

/**
 * 模拟一次http调用
 */
@RestController
public class BizController {
    @Autowired
    private BizService bizService;
    @PostMapping("/v1/biz/testMuti")
    public String test1(String order, Integer level) {
        return bizService.getCheckResultMuti(order, level);
    }
}

在这里插入图片描述

只要设计好你的key的生成规则就好。

还有小伙伴会问：我的业务逻辑有很多很多行，在checkResultDispatcherMuitInit()方法的Map中直接写不会很长吗？

直接写当然长了，我们可以抽象出一个service服务专门放业务逻辑，然后在定义中调用它就好了：

提供一个业务逻辑单元：

/**
 * 提供业务逻辑单元
 */
@Service
public class BizUnitService {
    public String bizOne(String order) {
        return order + "各种花式操作1";
    }
    public String bizTwo(String order) {
        return order + "各种花式操作2";
    }
    public String bizThree(String order) {
        return order + "各种花式操作3";
    }
}

/**
 * 某个业务服务类
 */
@Service
public class BizService {
    @Autowired
    private BizUnitService bizUnitService;
    private Map<String, Function<String, String>> checkResultDispatcherComX = new HashMap<>();
    /**
     * 初始化 业务逻辑分派Map 其中value 存放的是 lambda表达式
     */
    @PostConstruct
    public void checkResultDispatcherComXInit() {
        checkResultDispatcherComX.put("key_订单1", order -> bizUnitService.bizOne(order));
        checkResultDispatcherComX.put("key_订单1_订单2", order -> bizUnitService.bizTwo(order));
        checkResultDispatcherComX.put("key_订单1_订单2_订单3", order -> bizUnitService.bizThree(order));
    }
    public String getCheckResultComX(String order, int level) {
        //写一段生成key的逻辑：
        String ley = getDispatcherComXKey(order, level);
        Function<String, String> result = checkResultDispatcherComX.get(ley);
        if (result != null) {
            //执行这段表达式获得String类型的结果
            return result.apply(order);
        }
        return "不在处理的逻辑中返回业务错误";
    }
    /**
     * 判断条件方法
     */
    private String getDispatcherComXKey(String order, int level) {
        StringBuilder key = new StringBuilder("key");
        for (int i = 1; i <= level; i++) {
            key.append("_" + order + i);
        }
        return key.toString();
    }
}

在这里插入图片描述

总结

最后，我们一起尝试回答以下几个问题：

1.策略模式是如何优化业务逻辑代码结构的？

抽象了出了接口，将业务逻辑封装成一个一个的实现类，任意地替换。在复杂场景（业务逻辑较多）时比直接 if else 来的好维护些。

2.杀鸡焉用宰牛刀？就是几个if else场景我需要用到策略模式？！

我们所不满的其实就是传统接口实现的缺点：

策略类会很多。
业务逻辑分散到各个实现类中，而且没有一个地方可以俯览整个业务逻辑

3.有没有什么更好的代码结构来实现策略模式的吗？

针对传统策略模式的缺点，分享了利用Map与函数式接口来实现的思路。

以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。

您可能感兴趣的文章:

SpringBoot实现单文件上传
这篇文章主要为大家详细介绍了SpringBoot实现单文件上传，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2019-11-11
利用logback filter过滤某个类屏蔽某个类
这篇文章主要介绍了利用logback filter过滤某个类屏蔽某个类的操作，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2021-07-07
Java中的Enum枚举使用方法解析
这篇文章主要介绍了Java中的Enum枚举使用方法解析,枚举是一种数据类型,和int、double、string等类型相似,枚举用于声明一组命名的常数,当一个变量有几种可能的取值时,可以将它定义为枚举类型,需要的朋友可以参考下
2023-11-11
Java中二叉树的建立和各种遍历实例代码
这篇文章主要介绍了Java中二叉树的建立和各种遍历实例代码，涉及树节点的定义，后序遍历，层序遍历，深度优先和广度优先等相关内容，具有一定借鉴价值,需要的朋友可以参考下
2018-01-01
Java对日期Date类进行加减运算、年份加减月份加减、时间差等等
这篇文章主要介绍了Java对日期Date类进行加减运算、年份加减月份加减、时间差等等，在网上查阅资料，加上自己总结的一些关于Date类的工具类
2017-01-01
2020年IntelliJ IDEA最新最详细配置图文教程详解
这篇文章主要介绍了2020年IntelliJ IDEA最新最详细配置图文教程详解,本文通过图文并茂的形式给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
2021-02-02
Spring Boot 入门指南
Spring Boot 简化了Spring 应用的初始搭建、开发过程，开发人员可使用Spring提供的特定的方式来进行配置，不再需要重复自定义样板化的配置。本文就将带你入门Spring Boot
2021-05-05
SpringBoot 如何优雅的实现跨服务器上传文件的示例
这篇文章主要介绍了SpringBoot 如何优雅的实现跨服务器上传文件的示例，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2006-11-11
Spring MVC中JSON数据处理方式实战案例
Spring MVC是个灵活的框架,返回JSON数据的也有很多五花八门的方式,下面这篇文章主要给大家介绍了关于Spring MVC中JSON数据处理方式的相关资料,需要的朋友可以参考下
2024-01-01
java实现ftp文件上传下载功能
这篇文章主要为大家详细介绍了java实现ftp文件上传下载功能的相关资料，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2017-04-04