今天,我要干掉 if ... else ...

开发 后端
对于目前的现状来说,我如果在原有的基础上来修改,只要稍微注意一下解决需求不是很大的问题,但是说后面可维护性非常差。

[[394207]]

业务背景

近日在公司领到一个小需求,需要对之前已有的试用用户申请规则进行拓展。我们的场景大概如下所示:

  1. if (是否海外用户) { 
  2.  return false
  3. if (刷单用户) { 
  4.   return false
  5. if (未付费用户 && 不再服务时段) { 
  6.   return false
  7. if (转介绍用户 || 付费用户 || 内推用户) { 
  8.   return true
  9. else { 
  10.   return false

按照上述的条件我们可以得出的结论是:

咱们的的主要流程主要是基于 and 或者 or 的关系。

如果有一个不匹配的话,其实咱们后续的流程是不用执行的,就是需要具备一个短路的功能。

对于目前的现状来说,我如果在原有的基础上来修改,只要稍微注意一下解决需求不是很大的问题,但是说后面可维护性非常差。

后面进过权衡过后,我还是决定将这个部分进行重构一下。

规则执行器

针对这个需求,我首先梳理了一下咱们规则执行器大概的设计, 我们首先需要对规则进行抽象, 然后定义规则模板,然后通过规则模板去自己实现具体的规则,最后对于规则中可能会存在共享对象的转换,我们提前在模板方法中定义即可,后期如果需要的话,可以对 DSL 语言或者增加脚本语言解析器,以及反射 class 文件的方式来实现动态拓展。

最后我设计了一个 V1 版本和大家一起分享一下,如果大家也有这样的 case 可以给我分享留言,下面部分主要是设计和实现的流程和 code .

规则执行器的设计

对于我规则的执行器的设计,我收到 <<策略模式>> 和 << 规约模式>> 的启发。 在这个场景咱们首先想到的就是将规则的自然语言转换为程序代码。在 DDD 设计中,我们可以选择 DSL 方式来处理 Rule 的一种方式;对于业务数据处理或者其他的复杂流程,我们可以通过 Rule 模板来进行自定义实现具体的 Rule 策略。

对于规则执行器的处理步骤如下:

  1. 首先需要构造业务数据如用户基本,用户状态,以及一些业务数据;
  2. 然后通过当前的上下文,获取具体规则列表,这里可以从规则工厂中获取;
  3. 然后调用规则执行方法拿到结果。
  4. 在执行的过程,对链接关系的处理,常用的关系有 and or not 等

抽象规则和定义模板

首先需要定义 BaseRule 作为 Rule 的一个抽象,定义 execute 方法为执行方法。然后定义 AbstractRule

作为规则模板,作为一个方法的公共实现,提供拓展点 convert 、executeRule 可以用户转换自定义 RuleDto 数据结构。 AddressRule 和 NationalityRule分别做为两个实现 Rule 的具体策略或者说是具体实现。

  1. // 业务数据 
  2. @Data 
  3. public class RuleDto { 
  4.   private String address; 
  5.   private int age; 
  6.  
  7. // 规则抽象 
  8. public interface BaseRule { 
  9.  
  10.     boolean execute(RuleDto dto); 
  11.  
  12. // 规则模板 
  13. public abstract class AbstractRule implements BaseRule { 
  14.  
  15.     protected <T> T convert(RuleDto dto) { 
  16.         return (T) dto; 
  17.     } 
  18.  
  19.     @Override 
  20.     public boolean execute(RuleDto dto) { 
  21.         return executeRule(convert(dto)); 
  22.     } 
  23.    
  24.     protected <T> boolean executeRule(T t) { 
  25.         return true
  26.     } 
  27.  
  28. // 具体规则- 例子1 
  29. public class AddressRule extends AbstractRule { 
  30.  
  31.     @Override 
  32.     public boolean execute(RuleDto dto) { 
  33.         System.out.println("AddressRule invoke!"); 
  34.         if (dto.getAddress().startsWith(MATCH_ADDRESS_START)) { 
  35.             return true
  36.         } 
  37.         return false
  38.     } 
  39.  
  40. // 具体规则- 例子2 
  41. public class NationalityRule extends AbstractRule { 
  42.  
  43.     @Override 
  44.     protected <T> T convert(RuleDto dto) { 
  45.         NationalityRuleDto nationalityRuleDto = new NationalityRuleDto(); 
  46.         if (dto.getAddress().startsWith(MATCH_ADDRESS_START)) { 
  47.             nationalityRuleDto.setNationality(MATCH_NATIONALITY_START); 
  48.         } 
  49.         return (T) nationalityRuleDto; 
  50.     } 
  51.  
  52.  
  53.     @Override 
  54.     protected <T> boolean executeRule(T t) { 
  55.         System.out.println("NationalityRule invoke!"); 
  56.         NationalityRuleDto nationalityRuleDto = (NationalityRuleDto) t; 
  57.         if (nationalityRuleDto.getNationality().startsWith(MATCH_NATIONALITY_START)) { 
  58.             return true
  59.         } 
  60.         return false
  61.     } 
  62.  
  63. // 常量定义 
  64. public class RuleConstant { 
  65.     public static final String MATCH_ADDRESS_START= "北京"
  66.     public static final String MATCH_NATIONALITY_START= "中国"

规则执行器的核心构建

RuleService 是规则执行和规则管道链接的具体类,在这个类里面我们首先提供了一个构造器方法 create()可以提供默认的初始化过程

  1. // 规则执行器 
  2. public class RuleService { 
  3.  
  4.     private Map<Integer, List<BaseRule>> hashMap = new HashMap<>(); 
  5.     private static final int NOT = 2; 
  6.     private static final int AND = 1; 
  7.     private static final int OR = 0; 
  8.     private RuleDto ruleDto; 
  9.  
  10.     public static RuleService create(RuleDto ruleDto) { 
  11.         RuleService ruleService = new RuleService(); 
  12.         ruleService.ruleDto = ruleDto; 
  13.         return ruleService; 
  14.     } 
  15.  
  16.  
  17.     public RuleService and(List<BaseRule> ruleList) { 
  18.         hashMap.put(AND, ruleList); 
  19.         return this; 
  20.     } 
  21.  
  22.     public RuleService or(List<BaseRule> ruleList) { 
  23.         hashMap.put(OR, ruleList); 
  24.         return this; 
  25.     } 
  26.  
  27.     public RuleService not(List<BaseRule> ruleList) { 
  28.         hashMap.put(NOT, ruleList); 
  29.         return this; 
  30.     } 
  31.  
  32.     public boolean execute() { 
  33.         return this.execute(ruleDto); 
  34.     } 
  35.  
  36.     private boolean execute(RuleDto dto) { 
  37.         for (Map.Entry<Integer, List<BaseRule>> item : hashMap.entrySet()) { 
  38.             List<BaseRule> ruleList = item.getValue(); 
  39.             switch (item.getKey()) { 
  40.                 case AND
  41.                     // 如果是 and 关系,同步执行 
  42.                     System.out.println("execute key = " + 1); 
  43.                     if (!andRule(dto, ruleList)) { 
  44.                         return false
  45.                     } 
  46.                     break; 
  47.                 case OR
  48.                     // 如果是 or 关系,并行执行 
  49.                     System.out.println("execute key = " + 0); 
  50.                     if (!orRule(dto, ruleList)) { 
  51.                         return false
  52.                     } 
  53.                     break; 
  54.                 case NOT
  55.                     // 如果是 not 关系 
  56.                     System.out.println("execute key = " + 2); 
  57.                     if (!notRule(dto, ruleList)) { 
  58.                         return false
  59.                     } 
  60.                 default
  61.                     break; 
  62.             } 
  63.         } 
  64.         return true
  65.     } 
  66.  
  67.     private boolean andRule(RuleDto dto, List<BaseRule> ruleList) { 
  68.         for (BaseRule rule : ruleList) { 
  69.             boolean execute = rule.execute(dto); 
  70.             if (!execute) { 
  71.                 // and 关系匹配失败一次,返回 false 
  72.                 return false
  73.             } 
  74.         } 
  75.         // and 关系全部匹配成功,返回 true 
  76.         return true
  77.     } 
  78.  
  79.     private boolean orRule(RuleDto dto, List<BaseRule> ruleList) { 
  80.         for (BaseRule rule : ruleList) { 
  81.             boolean execute = rule.execute(dto); 
  82.             if (execute) { 
  83.                 // or 关系匹配到一个就返回 true 
  84.                 return true
  85.             } 
  86.         } 
  87.         // or 关系一个都匹配不到就返回 false 
  88.         return false
  89.     } 
  90.  
  91.     private boolean notRule(RuleDto dto, List<BaseRule> ruleList) { 
  92.         // not 规则内部为 and 链接 
  93.         return !andRule(dto, ruleList); 
  94.     } 
  95.  
  96. // 规则工厂类 
  97. public class RuleServices { 
  98.      
  99.     /** 
  100.      * 学生规则教研 
  101.      * 
  102.      * @return 
  103.      */ 
  104.     public static RuleService isValidStudent(RuleDto ruleDto) { 
  105.         AgeRule ageRule = new AgeRule(); 
  106.         NameRule nameRule = new NameRule(); 
  107.         NationalityRule nationalityRule = new NationalityRule(); 
  108.         AddressRule addressRule = new AddressRule(); 
  109.         SubjectRule subjectRule = new SubjectRule(); 
  110.         Flag110Rule flag110Rule = new Flag110Rule(); 
  111.  
  112.         return RuleService 
  113.                 .create(ruleDto) 
  114.                 .and(Arrays.asList(nationalityRule, nameRule, addressRule)) 
  115.                 .or(Arrays.asList(ageRule, subjectRule)) 
  116.                 .not(Collections.singletonList(flag110Rule)); 
  117.     } 

客户端调用代码

客户端调用主要分为三个步骤:

首先是需要构造业务数据,因为规则策略,是基于数据处理的。

然后从规则工厂中,获取规则列表后返回规则定义执行器。

最后执行规则,返回结果。

  1. public class RuleServiceTest { 
  2.  
  3.     @org.junit.Test 
  4.     public void execute() { 
  5.         //规则执行器 
  6.         //优点:比较简单,每个规则可以独立,将规则,数据,执行器拆分出来,调用方比较规整 
  7.         //缺点:数据依赖公共传输对象 dto 
  8.  
  9.         //1. 构造需要的数据 create dto 
  10.         RuleDto dto = new RuleDto(); 
  11.         dto.setAge(5); 
  12.         dto.setName("张三"); 
  13.         dto.setAddress("北京"); 
  14.         dto.setSubject("数学");; 
  15.  
  16.         //2. 定义规则  init rule 
  17.         RuleService ruleService = RuleServices.isValidStudent(dto); 
  18.  
  19.         //3. 规则执行 rule execute 
  20.         boolean ruleResult = ruleService.execute(); 
  21.         System.out.println("this student rule execute result :" + ruleResult); 
  22.     } 

总结

规则执行器的优点和缺点

优点:

  • 比较简单,每个规则可以独立,将规则,数据,执行器拆分出来,调用方比较规整;
  • 我在 Rule 模板类中定义 convert 方法做参数的转换这样可以能够,为特定 rule 需要的场景数据提供拓展。

缺点:上下游 rule 有数据依赖性,如果直接修改 dto 传输对象的值不是特别合理,这种建议采用中间数据存储临时数据。

参考资料

https://www.codenong.com/30430818

 

https://cloud.tencent.com/developer/article/1528935

 

责任编辑:武晓燕 来源: 运维开发故事
相关推荐

2020-04-09 08:29:50

编程语言事件驱动

2021-01-29 07:45:27

if-else代码数据

2020-10-22 09:20:22

SQLNoSQL 数据库

2023-01-19 00:13:28

代码技术计划

2020-07-09 08:59:52

if else模板Service

2019-04-25 14:25:24

Spring Bootif elseJava

2019-03-14 09:18:19

5GWiFi4G

2019-11-26 10:07:10

业务开发逻辑

2022-06-14 10:49:33

代码优化Java

2021-10-27 09:10:50

CSS 技巧else

2019-10-22 09:11:50

策略业务代码

2021-04-27 08:25:52

MVCC数据MySQL

2019-10-22 20:12:22

戴尔

2012-02-22 10:10:16

2022-08-10 19:28:40

Hadoop数据库

2021-06-11 15:22:39

苹果 iOS系统

2019-05-09 10:43:12

微软苹果谷歌

2021-07-12 07:31:22

重构软件行业

2022-01-13 10:45:59

if-else代码Java

2021-01-15 16:05:28

工具VS Code开发
点赞
收藏

51CTO技术栈公众号