用Map+函数式接口来实现策略模式
Posted
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了用Map+函数式接口来实现策略模式相关的知识,希望对你有一定的参考价值。
转载自:https://www.cnblogs.com/keeya/p/13187727.html
我想大家肯定都或多或少的看过各种“策略模式”的讲解、布道等等,这篇文章就是来好好“澄清”一下策略模式,并尝试回答以下的问题:
- 策略模式是如何优化业务逻辑代码结构的?
- 杀鸡焉用宰牛刀?就是几个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); } }
鲁迅曾说过,“每解决一个问题,就会引出更多的问题”。我们一起来看看这样的实现有什么好处,会带来什么问题。
好处很直观:
- 在一段代码里直观的看到"判断条件"与业务逻辑的映射关系
- 不需要单独定义接口与实现类,直接使用现有的函数式接口(什么?不知道函数式接口?快去了解),而实现类直接就是业务代码本身。
不好的点:
- 需要团队成员对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与函数式接口来实现的思路。
#yyds干货盘点#还在用策略模式解决 if-else?Map+函数式接口方法才是YYDS!
本文介绍策略模式的具体应用以及Map+函数式接口如何 “更完美” 的解决 if-else的问题。
文章目录
- 需求
- 策略模式
- Map+函数式接口
- 最后捋一捋本文讲了什么
需求
最近写了一个服务:根据优惠券的类型resourceType和编码resourceId来 查询 发放方式grantType和领取规则
实现方式:
- 根据优惠券类型resourceType -> 确定查询哪个数据表
- 根据编码resourceId -> 到对应的数据表里边查询优惠券的派发方式grantType和领取规则
优惠券有多种类型,分别对应了不同的数据库表:
- 红包 —— 红包发放规则表
- 购物券 —— 购物券表
- QQ会员
- 外卖会员
实际的优惠券远不止这些,这个需求是要我们写一个业务分派的逻辑
第一个能想到的思路就是if-else或者switch case:
switch(resourceType)
case "红包":
查询红包的派发方式
break;
case "购物券":
查询购物券的派发方式
break;
case "QQ会员" :
break;
case "外卖会员" :
break;
default : logger.info("查找不到该优惠券类型resourceType以及对应的派发方式");
break;
如果要这么写的话, 一个方法的代码可就太长了,影响了可读性。(别看着上面case里面只有一句话,但实际情况是有很多行的)
而且由于 整个 if-else的代码有很多行,也不方便修改,可维护性低。
策略模式
策略模式是把 if语句里面的逻辑抽出来写成一个类,如果要修改某个逻辑的话,仅修改一个具体的实现类的逻辑即可,可维护性会好不少。
以下是策略模式的具体结构
策略模式在业务逻辑分派的时候还是if-else,只是说比第一种思路的if-else 更好维护一点。
switch(resourceType)
case "红包":
String grantType=new Context(new RedPaper()).ContextInterface();
break;
case "购物券":
String grantType=new Context(new Shopping()).ContextInterface();
break;
default : logger.info("查找不到该优惠券类型resourceType以及对应的派发方式");
break;
但缺点也明显:
- 如果 if-else的判断情况很多,那么对应的具体策略实现类也会很多,上边的具体的策略实现类还只是2个,查询红包发放方式写在类RedPaper里边,购物券写在另一个类Shopping里边;那资源类型多个QQ会员和外卖会员,不就得再多写两个类?有点麻烦了
- 没法俯视整个分派的业务逻辑
Map+函数式接口
用上了Java8的新特性lambda表达式
- 判断条件放在key中
- 对应的业务逻辑放在value中
这样子写的好处是非常直观,能直接看到判断条件对应的业务逻辑
需求:根据优惠券(资源)类型resourceType和编码resourceId查询派发方式grantType
上代码:
public class QueryGrantTypeService
private GrantTypeSerive grantTypeSerive;
private Map<String, Function<String,String>> grantTypeMap=new HashMap<>();
/**
* 初始化业务分派逻辑,代替了if-else部分
* key: 优惠券类型
* value: lambda表达式,最终会获得该优惠券的发放方式
*/
public void dispatcherInit()
grantTypeMap.put("红包",resourceId->grantTypeSerive.redPaper(resourceId));
grantTypeMap.put("购物券",resourceId->grantTypeSerive.shopping(resourceId));
grantTypeMap.put("qq会员",resourceId->grantTypeSerive.QQVip(resourceId));
public String getResult(String resourceType)
//Controller根据 优惠券类型resourceType、编码resourceId 去查询 发放方式grantType
Function<String,String> result=getGrantTypeMap.get(resourceType);
if(result!=null)
//传入resourceId 执行这段表达式获得String型的grantType
return result.apply(resourceId);
return "查询不到该优惠券的发放方式";
如果单个 if 语句块的业务逻辑有很多行的话,我们可以把这些 业务操作抽出来,写成一个单独的Service,即:
//具体的逻辑操作
public class GrantTypeSerive
public String redPaper(String resourceId)
//红包的发放方式
return "每周末9点发放";
public String shopping(String resourceId)
//购物券的发放方式
return "每周三9点发放";
public String QQVip(String resourceId)
//qq会员的发放方式
return "每周一0点开始秒杀";
入参String resourceId是用来查数据库的,这里简化了,传参之后不做处理。
用http调用的结果:
public class GrantTypeController
private QueryGrantTypeService queryGrantTypeService;
("/grantType")
public String test(String resourceName)
return queryGrantTypeService.getResult(resourceName);
用Map+函数式接口也有弊端:
- 你的队友得会lambda表达式才行啊,他不会让他自己百度去
最后捋一捋本文讲了什么
策略模式通过接口、实现类、逻辑分派来完成,把 if语句块的逻辑抽出来写成一个类,更好维护。
Map+函数式接口通过Map.get(key)来代替 if-else的业务分派,能够避免策略模式带来的类增多、难以俯视整个业务逻辑的问题。
以上是关于用Map+函数式接口来实现策略模式的主要内容,如果未能解决你的问题,请参考以下文章
#yyds干货盘点#还在用策略模式解决 if-else?Map+函数式接口方法才是YYDS!
还在用策略模式解决 if-else?Map + 函数式接口就搞定了。。。
#yyds干货盘点#还在用策略模式解决 if-else?Map+函数式接口方法才是YYDS!
还在用策略模式解决 if-else?Map+函数式接口方法才是YYDS!