新来的同事用策略模式把if-else给优化了技术总监说能不能想好了再改

4次阅读

共计 7266 个字符，预计需要花费 19 分钟才能阅读完成。

本文来自作者投稿，原作者：上帝爱吃苹果

目前在魔都，贝壳找房是我的雇主，平时关注一些 java 领域相关的技术，希望你们能在这篇文章中找到些有用的东西。个人水平有限，如果文章有错误还请指出，在留言区一起交流。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

<pre>/**

某个业务服务类

*/
@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&lt;String, String&gt; 的含义是接收一个 Stirng 类型的变量，返回一个 String 类型的结果
 */
private Map&lt;String, Function&lt;String, String&gt;&gt; checkResultDispatcher = new HashMap&lt;&gt;();

/**
 * 初始化 业务逻辑分派 Map 其中 value 存放的是 lambda 表达式
 */
@PostConstruct
public void checkResultDispatcherInit() {checkResultDispatcher.put("校验 1", order -&gt; String.format("对 %s 执行业务逻辑 1", order));
    checkResultDispatcher.put("校验 2", order -&gt; String.format("对 %s 执行业务逻辑 2", order));
    checkResultDispatcher.put("校验 3", order -&gt; String.format("对 %s 执行业务逻辑 3", order));
    checkResultDispatcher.put("校验 4", order -&gt; String.format("对 %s 执行业务逻辑 4", order));
    checkResultDispatcher.put("校验 5", order -&gt; String.format("对 %s 执行业务逻辑 5", order));
    checkResultDispatcher.put("校验 6", order -&gt; String.format("对 %s 执行业务逻辑 6", order));
    checkResultDispatcher.put("校验 7", order -&gt; String.format("对 %s 执行业务逻辑 7", order));
    checkResultDispatcher.put("校验 8", order -&gt; String.format("对 %s 执行业务逻辑 8", order));
    checkResultDispatcher.put("校验 9", order -&gt; String.format("对 %s 执行业务逻辑 9", order));
}

public String getCheckResultSuper(String order) {
    // 从逻辑分派 Dispatcher 中获得业务逻辑代码，result 变量是一段 lambda 表达式
    Function&lt;String, String&gt; result = checkResultDispatcher.get(order);
    if (result != null) {
        // 执行这段表达式获得 String 类型的结果
        return result.apply(order);
    }
    return "不在处理的逻辑中返回业务错误";
}

}
</pre>

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

/**
 * 模拟一次 http 调用
 */
@RestController
public class BizController {

    @Autowired
    private BizService bizService;

    @PostMapping("/v1/biz/testSuper")
    public String test2(String order) {return bizService.getCheckResultSuper(order);
    }
}

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

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

好处很直观：

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

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

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

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

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

<pre>/**

某个业务服务类

*/
@Service
public class BizService {

private Map&lt;String, Function&lt;String, String&gt;&gt; checkResultDispatcherMuti = new HashMap&lt;&gt;();

/**
 * 初始化 业务逻辑分派 Map 其中 value 存放的是 lambda 表达式
 */
@PostConstruct
public void checkResultDispatcherMuitInit() {checkResultDispatcherMuti.put("key_订单 1", order -&gt; String.format("对 %s 执行业务逻辑 1", order));
    checkResultDispatcherMuti.put("key_订单 1_订单 2", order -&gt; String.format("对 %s 执行业务逻辑 2", order));
    checkResultDispatcherMuti.put("key_订单 1_订单 2_订单 3", order -&gt; String.format("对 %s 执行业务逻辑 3", order));
}

public String getCheckResultMuti(String order, int level) {
    // 写一段生成 key 的逻辑：String ley = getDispatcherKey(order, level);

    Function&lt;String, String&gt; 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 &lt;= level; i++) {key.append("_" + order + i);
    }
    return key.toString();}

}
</pre>

用 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 服务专门放业务逻辑，然后在定义中调用它就好了：

提供一个业务逻辑单元：

<pre>/**

提供业务逻辑单元

*/
@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";}

}
</pre>

<pre>/**

某个业务服务类

*/
@Service
public class BizService {

@Autowired
private BizUnitService bizUnitService;

private Map&lt;String, Function&lt;String, String&gt;&gt; checkResultDispatcherComX = new HashMap&lt;&gt;();

/**
 * 初始化 业务逻辑分派 Map 其中 value 存放的是 lambda 表达式
 */
@PostConstruct
public void checkResultDispatcherComXInit() {checkResultDispatcherComX.put("key_订单 1", order -&gt; bizUnitService.bizOne(order));
    checkResultDispatcherComX.put("key_订单 1_订单 2", order -&gt; bizUnitService.bizTwo(order));
    checkResultDispatcherComX.put("key_订单 1_订单 2_订单 3", order -&gt; bizUnitService.bizThree(order));
}

public String getCheckResultComX(String order, int level) {
    // 写一段生成 key 的逻辑：String ley = getDispatcherComXKey(order, level);

    Function&lt;String, String&gt; 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 &lt;= level; i++) {key.append("_" + order + i);
    }
    return key.toString();}

}
</pre>

调用结果：

最后，我们一起尝试回答以下几个问题：1. 策略模式是如何优化业务逻辑代码结构的？

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

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

我们所不满的其实就是传统接口实现的缺点：1、策略类会很多。2、业务逻辑分散到各个实现类中，而且没有一个地方可以俯览整个业务逻辑

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

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

正文完

java

发表至： java

2020-06-24

0

关于java:你见过最垃圾的代码长什么样来长长见识

关于java:关于我在面试时答不上的HashMap问题

JAVA多线程使用场景和注意事项

自己实现-aop-和-spring-aop

技术干货丨卷积神经网络之LeNet5迁移实践案例

新来的同事用策略模式把if-else给优化了技术总监说能不能想好了再改

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

策略模式的教科书定义

策略模式优化了什么？

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

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

总结

站内搜索