JAVA规则引擎 - 调研分析设计搭建全过程＜三＞

规则引擎搭建

怎么设计层级

为什么要设计思想

 为了代码简洁
代码解耦
关联代码强校验，防止类型不匹配，以及参数，从编译代码层面校验你的代码质量
可扩展
层次分明，便于查看
逻辑清晰，便于拆分合并
方便统一管理
...........等等

但是不是为了设计模式，而一定要添加设计模式和设计原则，也不要硬套某一种设计模式，有些业务不一定符合某一种模式。一定是站在业务的基础上，从业务出发，整体考虑。适合什么样的模式和原则。从而添加什么样的设计模式和设计原则。代码是为了业务服务。方便业务的。如果使用了设计模式。加大了业务复杂度。那么就不能使用设计模式了。使用的原则，就是为了扩展业务。方便开发。便于后期维护。减少出bug的几率。

模型，分组，规则，条件表达式，从业务考虑，不一定考虑的全面哈........：

处理器（抽繁化简）：根据不同业务设计不同处理器，都集成同一个公共处理器
业务处理器（站在业务出发）：自定义业务逻辑处理方法
业务执行链（执行者）：实现具体业务处理类，通过重写方法，实现自己的可扩展业务
业务管理器（管理者）：可管理某一业务，也可管理所有处理器，站在全局
调到者（消费者）：唤起管理器，开始执行
架构设计思想:    整体思想分为    base基础部分----core核心模块----work工作流----manager启动  

有那些基本属性

一个规则引擎都需要什么：
1.需要定义场景
2.需要定义规则组
3.需要规则
4.计算条件

设计图

基本构建应该可以满足，代码样例部分
核心简易模型

@Service
@Slf4j
public /*abstract*/ class ModelProcessorManager<Process extends ModelProcessor,Event extends Model> {

    List<Process> processList;
    public ModelProcessorManager(List<Process> processList) {
        this.processList = processList;
        this.processList.sort(Comparator.comparingInt(Process::priority));
        log.info("Init ModelService processors: {}", StringUtils.join(
                processList.stream().map(p -> p.getClass().getSimpleName()).collect(Collectors.toList()), ",")
        );
    }

    /**
     * 通用模型模型处理器
     * 定制化，特殊化模型特殊处理
     * @param event
     * @return
     */
    public <T> T execModel(Event event,String modelProcessorChain){
        /*for (Process process:processList){
            if (process.isMatch(event.getModelCode())){
                // 此方法可做在做抽取，考虑模型业务未来不一定有什么特殊需求，故不做集成
                return process.exec(event);
            }
        }*/
        if (StringUtils.isBlank(modelProcessorChain)){
            modelProcessorChain = ConstantUtils.model_match_simple;
        }
        for (Process process:processList){
            if (process.isMatch(modelProcessorChain)){
                return process.exec(event);
            }
        }
        return null;
    }


    /**
     * 支付模型Test
     * @param event
     * @return
     */
    public <T> T execOrderModel(OrderModel event){
        return execModel((Event) event,null);
    }

    /**
     * 登录模型Test
     * @param event
     * @return
     */
    public <T> T execUserModel(UserModel event){
        return execModel((Event) event,null);
    }

}

核心规则模型

@Service
@Slf4j
public class RuleProcessorManager<Process extends RuleProcessor> {

    List<Process> processList;
    public RuleProcessorManager(List<Process> processList) {
        this.processList = processList;
        this.processList.sort(Comparator.comparingInt(Process::priority));
        log.info("Init ModelService processors: {}", StringUtils.join(
                processList.stream().map(p -> p.getClass().getSimpleName()).collect(Collectors.toList()), ",")
        );
    }

    /**
     * 规则处理器
     * 规则处理器：可扩展多个规则，（根据业务，感觉应该只有一个规则处理器，不过支持扩展）
     * @param ruleProcessorChain 规则执行链
     * @param env 入参
     * @return
     */
    public List<Integer> execRuleManager(String ruleProcessorChain, Map<String, Object> env){
        if (StringUtils.isBlank(ruleProcessorChain)){
            ruleProcessorChain = ConstantUtils.rule_match_simple;
        }
        for (Process process:processList){
            if (process.isMatch(ruleProcessorChain)){
                return process.execRule(env);
            }
        }
        return null;
    }
}

核心执行条件模型

@Service
@Slf4j
public class ConditionProcessorManager<Process extends ConditionProcessor,Event extends ConditionEvent>{

    List<Process> processList;
    public ConditionProcessorManager(List<Process> processList) {
        this.processList = processList;
        this.processList.sort(Comparator.comparingInt(ConditionProcessor::priority));
        log.info("Init ModelService processors: {}", StringUtils.join(
                processList.stream().map(p -> p.getClass().getSimpleName()).collect(Collectors.toList()), ",")
        );
    }

    /**
     * 条件处理器：执行条件链路
     * @param event
     * @return
     */
    public Boolean execCondition(Event event){
        for (Process process:processList){
            if (process.isMatch(event.getMatch())){
                return process.exec(event);
            }
        }
        return Boolean.FALSE;
    }
}

后面下一篇继续