目前在魔都, 贝壳找房是我的雇主, 平时关注一些 java 领域相关的技术, 希望你们能在这篇文章中找到些有用的东西. 个人水平有限, 如果文章有错误还请指出, 在留言区一起交流.
本文已投稿至公众号 Hollis 原文链接: https://mp.weixin.qq.com/s/hkypvNBkRjPM6HM51_jW9g
我想大家肯定都或多或少的看过各种 "策略模式" 的讲解, 布道等等, 这篇文章就是来好好 "澄清" 一下策略模式, 并尝试回答以下的问题:
策略模式是如何优化业务逻辑代码结构的?
杀鸡焉用宰牛刀? 就是几个 if else 场景我需要用到策略模式?!
有没有什么更好的代码结构来实现策略模式的吗?
策略模式是如何优化业务逻辑代码结构的?
要回答这个问题, 我们还得先扒一扒策略模式的定义, 从定义着手来理解它:
策略模式的教科书定义
它的定义很精简: 一个类的行为或其算法可以在运行时更改. 我们把它降维到代码层面, 用人话翻译一下就是, 运行时我给你这个类的方法传不同的 "key", 你这个方法会执行不同的业务逻辑. 细品一下, 这不就是 if else 干的事吗?
策略模式优化了什么?
其实策略模式的核心思想和 if else 如出一辙, 根据不同的 key 动态的找到不同的业务逻辑, 那它就只是如此吗?
实际上, 我们口中的策略模式其实就是在代码结构上调整, 用接口 + 实现类 + 分派逻辑来使代码结构可维护性好点.
一般教科书上讲解到接口与实现类就结束了, 其他博客上会带上提及分派逻辑. 这里就不啰嗦了.
小结一下, 即使用了策略模式, 你该写的业务逻辑照常写, 到逻辑分派的时候, 还是变相的 if else. 而它的优化点是抽象了出了接口, 将业务逻辑封装成一个一个的实现类, 任意地替换. 在复杂场景 (业务逻辑较多) 时比直接 if else 来的好维护些.
杀鸡焉用宰牛刀? 就是几个 if else 场景我需要用到策略模式?!
我想小伙伴们经常有这样的不满, 我的业务逻辑就 3 4 行, 你给我整一大堆类定义? 有必要这么麻烦吗? 我看具体的业务逻辑还需要去不同的类中, 简单点行不行.
其实我们所不满的就是策略模式带来的缺点: 1, 策略类会增多 2, 业务逻辑分散到各个实现类中, 而且没有一个地方可以俯视整个业务逻辑
针对传统策略模式的缺点, 在这分享一个实现思路, 这个思路已经帮我们团队解决了多个复杂 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();
- }
- }
调用结果:
总结
最后, 我们一起尝试回答以下几个问题:
策略模式是如何优化业务逻辑代码结构的?
-- 抽象了出了接口, 将业务逻辑封装成一个一个的实现类, 任意地替换. 在复杂场景 (业务逻辑较多) 时比直接 if else 来的好维护些.
杀鸡焉用宰牛刀? 就是几个 if else 场景我需要用到策略模式?!-- 我们所不满的其实就是传统接口实现的缺点: 1, 策略类会很多. 2, 业务逻辑分散到各个实现类中, 而且没有一个地方可以俯览整个业务逻辑
有没有什么更好的代码结构来实现策略模式的吗?-- 针对传统策略模式的缺点, 分享了利用 Map 与函数式接口来实现的思路.
来源: https://www.cnblogs.com/keeya/p/13187727.html