规则执行器的设计实现
Posted dingwen_blog
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了规则执行器的设计实现相关的知识，希望对你有一定的参考价值。
规则执行器的设计实现
[!NOTE]
此规则执行器的设计旨在替代大量的
if、else if、else嵌套，对代码进行优化。其他规则以及实体，使用案例中使用的规则类参考完整代码。地址：https://gitee.com/dingwen-gitee/java8-study.git
1.使用场景
if (条件一){
}
if (条件二){
}
if (条件三){
}
...
if (){
}else if (){
}else {
}
if (条件1 && 条件2 ｜｜ 条件3){
}
...
switch(条件){
case: 条件1:
break;
...
}
2.规则dto
package rule;
import java.util.List;
import java.util.Map;
/**
* <p>
* 规则Dto
* 业务数据
* </P>
*
* @author dingwen
* @date 2021.09.09 09:52
*/
public class RuleDto<T> {
/**
* 规则Dto值
*/
private T value;
public T getValue() {
return value;
}
public void setValue(T value) {
this.value = value;
}
}
3.规则的抽象接口
- 多条件返回
Boolean类型 - 多条件返回任意类型
- 多条件无返回值（按照指定规则执行）
package rule;
/**
* <p>
* 规则的抽象接口
* </P>
*
* @author dingwen
* @date 2021.09.09 09:57
*/
public abstract class AbstractBaseRule<R, T> {
/**
* 执行
*
* @param ruleDto 规则dto
* @return {@link Boolean}
*/
Boolean executeBoolean(RuleDto<T> ruleDto) {
return false;
}
/**
* 执行
*
* @param ruleDto 规则dto
* @return {@link R}
*/
R executeObject(RuleDto<T> ruleDto) {
return null;
}
/**
* 执行
* 没有返回值
*
* @param ruleDto 规则dto
*/
void executeVoid(RuleDto<T> ruleDto){
}
}
4.规则执行器
package rule;
import org.omg.CORBA.ORB;
import java.util.*;
import java.util.stream.Collectors;
/**
* <p>
* 执行器构建规则服务
* </P>
*
* @author dingwen
* @date 2021.09.09 10:39
*/
public class RuleService<R, T> {
/**
* 规则对象集合
*/
private final Map<Integer, List<AbstractBaseRule<R, T>>> ruleMap = new HashMap<>();
/**
* AND 规则列表
*/
private final List<AbstractBaseRule<R, T>> ruleAndList = new ArrayList<>();
/**
* or 规则列表
*/
private final List<AbstractBaseRule<R, T>> ruleOrList = new ArrayList<>();
/**
* 类型:
* 1: AND
* 0: OR
*/
private int type = 1;
/**
* 和
*/
private static final int AND = 1;
/**
* 或
*/
private static final int OR = 0;
private RuleService() {
}
public static <R, T> RuleService<R, T> getInstance() {
return new RuleService<>();
}
/**
* 和
*
* @return {@link RuleService<>}
*/
public final RuleService<R, T> and() {
type = AND;
return this;
}
/**
* 或
*
* @return {@link RuleService<>}
*/
public final RuleService<R, T> or() {
type = OR;
return this;
}
/**
* 构建器
*
* @param rule 规则
* @return {@link RuleService<>}
*/
public RuleService<R, T> builder(AbstractBaseRule<R, T> rule) {
if (type == AND) {
ruleAndList.add(rule);
} else {
ruleOrList.add(rule);
}
return this;
}
/**
* 构建
*
* @return {@link RuleService<>}
*/
public RuleService<R, T> build() {
if (type == AND) {
ruleMap.put(AND, ruleAndList);
} else {
ruleMap.put(OR, ruleOrList);
}
return this;
}
/**
* 和
*
* @param ruleDto 规则dto
* @param ruleList 规则列表
* @return {@link Boolean}
*/
private Boolean and(RuleDto<T> ruleDto, List<AbstractBaseRule<R, T>> ruleList) {
return ruleList.stream().parallel().allMatch(rtAbstractBaseRule -> rtAbstractBaseRule.executeBoolean(ruleDto));
}
/**
* 或
*
* @param ruleDto 规则dto
* @param ruleList 规则列表
* @return {@link Boolean}
*/
private Boolean or(RuleDto<T> ruleDto, List<AbstractBaseRule<R, T>> ruleList) {
return ruleList.stream().parallel().anyMatch(rtAbstractBaseRule -> rtAbstractBaseRule.executeBoolean(ruleDto));
}
/**
* 执行
*
* @param ruleDto 规则dto
* @return {@link Boolean}
*/
public Boolean execute(RuleDto<T> ruleDto) {
boolean result = false;
if (ruleMap.containsKey(AND) && !ruleMap.containsKey(OR)) {
result = and(ruleDto, ruleMap.get(AND));
} else if (!ruleMap.containsKey(AND) && ruleMap.containsKey(OR)) {
result = or(ruleDto, ruleMap.get(OR));
} else if (ruleMap.containsKey(AND) && ruleMap.containsKey(OR)) {
if (type == AND) {
result = and(ruleDto, ruleMap.get(AND)) && or(ruleDto, ruleMap.get(AND));
} else {
result = and(ruleDto, ruleMap.get(OR)) || or(ruleDto, ruleMap.get(OR));
}
} else {
return false;
}
ruleMap.clear();
return result;
}
/**
* 执行
*
* @param ruleDto 规则dto
* @param rule 规则
* @return {@link R}
*/
public R execute(RuleDto<T> ruleDto, AbstractBaseRule<R, T> rule) {
return rule.executeObject(ruleDto);
}
/**
* 执行
* 没有返回值
*
* @param ruleDto 规则dto
* @param rule 规则
*/
public void executeVoid(RuleDto<T> ruleDto, AbstractBaseRule<R, T> rule) {
rule.executeVoid(ruleDto);
}
}
5.使用
package rule;
import entity.Student;
import java.util.HashMap;
import java.util.Map;
/**
* <p>
* 测试
* </P>
*
* @author dingwen
* @date 2021.09.09 12:01
*/
public class Test {
public static void main(String[] args) {
// 多值多判断情况
RuleDto<Map<String, String>> usernameRuleDto = new RuleDto<>();
HashMap<String, String> valueMap = new HashMap<>(2);
valueMap.put(UserNameRule.class.getSimpleName(), "dingwen");
valueMap.put(PasswordRule.class.getSimpleName(), "123456");
usernameRuleDto.setValue(valueMap);
RuleService<Boolean, Map<String, String>> ruleService = RuleService.getInstance();
// Boolean r1 = ruleService.and()
// .builder(new UserNameRule("dingwen"))
// .builder(new PasswordRule())
// .build()
// .execute(usernameRuleDto);
//
// System.out.println("r1 = " + r1);
//
// Boolean r2 = ruleService.or()
// .builder(new UserNameRule("dingwen"))
// .builder(new PasswordRule())
// .build()
// .and()
// .builder(new UserNameRule("dingwen"))
// .builder(new PasswordRule())
// .build()
// .execute(usernameRuleDto);
// System.out.println("r2 = " + r2);
// Boolean r3 = ruleService.or()
// .builder(new UserNameRule("din1gwen"))
// .builder(new PasswordRule())
// .build()
// .or()
// .builder(new UserNameRule("dingwen"))
// .builder(new PasswordRule())
// .build()
// .execute(usernameRuleDto);
// System.out.println("r3 = " + r3);
// Boolean r4 = ruleService.and()
// .builder(new UserNameRule("dingwen"))
// .builder(new PasswordRule())
// .build()
// .and()
// .builder(new UserNameRule("dingwen"))
// .builder(new PasswordRule())
// .build()
// .execute(usernameRuleDto);
// System.out.println("r4 = " + r4);
Boolean r6 = ruleService.and()
.builder(new UserNameRule("dingwen"))
.builder(new PasswordRule())
.build()
.or()
.builder(new UserNameRule("dingwen"))
.builder(new PasswordRule())
.build()
.execute(usernameRuleDto);
System.out.println("r6 = " + r6);
// // 指定规则指定返回类型
// RuleDto<Student> studentRuleDto = new RuleDto<>();
// Student student = new Student();
// student.setName("dingwen");
// studentRuleDto.setValue(student);
// Double sore = RuleService.<Double, Student>getInstance().execute(studentRuleDto, new StudentRule());
// System.out.println("sore = " + sore);
//
// // 指定规则没有返回值
//
// RuleDto<String> stringRuleDto = new RuleDto<>();
// stringRuleDto.setValue("y");
//
// RuleService.<Object,String>getInstance().executeVoid(stringRuleDto,new PrintRule());
//
//
// // 一个条件对应不同返回值
// RuleDto<String> ruleDto = new RuleDto<>();
// ruleDto.setValue("张三");
// RuleService<Student, String> ruleService1 = RuleService.getInstance();
// Student student1 = ruleService1.execute(ruleDto, new Student2Rule());
// System.out.println("student1 = " + student1);
}
}
以上是关于规则执行器的设计实现的主要内容，如果未能解决你的问题，请参考以下文章