SpringBoot集成easy-rules规则引擎的流程是什么

这篇文章主要讲解了“SpringBoot集成easy-rules规则引擎的流程是什么”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“springBoot集成easy-rules规则引擎的流程是什么”吧！

一、概述

通过将业务规则配置的配置文件中，可以精简代码，同时已于维护，当规则修改时，只需要修改配置文件即可。easy-rules是一个小巧的规则引擎，支持spring的SPEL表达式，同时还支持 Apache JEXL 表达式和 MVL 表达式。

二、项目中加入依赖

在项目的gradle中增加依赖关系。

build.gradle:

plugins {
    id 'org.springframework.boot' version '3.0.5'
    id 'io.spring.dependency-management' version '1.1.0'
    id 'java'
}

group = 'cn.sprinGCamp'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '17'

configurations {
    compileOnly {
        extendsFrom annotationProcessor
    }
    testCompileOnly {
        extendsFrom testAnnotationProcessor
    }
}

repositories {
    MavenCentral()
}

dependencies {
    implementation "org.springframework.boot:spring-boot-starter-JSON"
    implementation 'org.springframework.boot:spring-boot-starter-validation'
    implementation 'org.jeasy:easy-rules-core:4.1.0'
    implementation 'org.jeasy:easy-rules-spel:4.1.0'
    implementation 'org.jeasy:easy-rules-support:4.1.0'
    annotationProcessor 'org.projectlombok:lombok'
    testAnnotationProcessor 'org.projectlombok:lombok'
    testImplementation "org.springframework.boot:spring-boot-starter-test"
    testImplementation 'org.junit.vintage:junit-vintage-engine'
    testImplementation 'org.junit.vintage:junit-vintage-engine'
}

dependencyManagement {
    imports {
        mavenBom "org.springframework.cloud:spring-cloud-dependencies:2022.0.1"
    }
}

test {
    useJUnitPlatfORM()
}

三、配置文件

示例程序将业务规则放到配置文件中，业务规则配置文件(demo-rule.yml)代码:

name: "age rule"
description: ""
priority: 1
condition: "#person.getAdult() == false"
actions:
  - "T(java.lang.System).out.println(\"Shop: Sorry, you are not allowed to buy alcohol\")"
  - "#person.setAdult(true)"
  - "#person.setAge(18)"
---
name: "alcohol rule"
description: ""
priority: 1
condition: "#person.getAdult() == true"
actions:
  - "T(java.lang.System).out.println(\"Shop: you are now allowed to buy alcohol\")"

配置文件中的规则通过 condition 进行配置，当满足规则时，会调用 actions 中配置的动作。

示例项目使用了spring的SPEL表达式进行规则配置，配置文件中配置了2个规则，第一个规则通过 person这个spring bean中的getAdult()判断是否满足规则，满足规则时调用三个方法。

在spring-boot本身的配置文件中 application.yml 配置规则文件：

rule:
  skip-on-first-failed-rule: true
  skip-on-first-applied-rule: false
  skip-on-first-non-triggered-rule: true
  rules:
    - rule-id: "demo"
      rule-file-location: "classpath:demo-rule.yml"

四、代码中对规则引擎进行配置

通过 RuleEngineConfig这个spring的配置类对规则引擎进行配置：

@Slf4j@EnableConfigurationProperties(RuleEngineConfigProperties.class)@Configurationpublic class RuleEngineConfig implements BeanFactoryAware {    @Autowired(required = false)    private List<RuleListener> ruleListeners;    @Autowired(required = false)    private List<RulesEngineListener> rulesEngineListeners;    private BeanFactory beanFactory;    @Bean    public RulesEngineParameters rulesEngineParameters(RuleEngineConfigProperties properties) {        RulesEngineParameters parameters = new RulesEngineParameters();        parameters.setSkipOnFirstAppliedRule(properties.isSkipOnFirstAppliedRule());        parameters.setSkipOnFirstFailedRule(properties.isSkipOnFirstFailedRule());        parameters.setSkipOnFirstNonTriggeredRule(properties.isSkipOnFirstNonTriggeredRule());        return parameters;    }    @Bean    public RulesEngine rulesEngine(RulesEngineParameters rulesEngineParameters) {        DefaultRulesEngine rulesEngine = new DefaultRulesEngine(rulesEngineParameters);        if (!CollectionUtils.isEmpty(ruleListeners)) {            rulesEngine.reGISterRuleListeners(ruleListeners);        }        if (!CollectionUtils.isEmpty(rulesEngineListeners)) {            rulesEngine.registerRulesEngineListeners(rulesEngineListeners);        }        return rulesEngine;    }    @Bean    public BeanResolver beanResolver() {        return new BeanFactoryResolver(beanFactory);    }    @Bean    public RuleEngineTemplate ruleEngineTemplate(RuleEngineConfigProperties properties, RulesEngine rulesEngine) {        RuleEngineTemplate ruleEngineTemplate = new RuleEngineTemplate();        ruleEngineTemplate.setBeanResolver(beanResolver());        ruleEngineTemplate.setProperties(properties);        ruleEngineTemplate.setRulesEngine(rulesEngine);        return ruleEngineTemplate;    }    @Bean    public RuleListener defaultRuleListener() {        return new RuleListener() {            @Override            public boolean beforeEvaluate(Rule rule, Facts facts) {                return true;            }            @Override            public void afterEvaluate(Rule rule, Facts facts, boolean b) {                log.info("-----------------afterEvaluate-----------------");                log.info(rule.getName() + rule.getDescription() + facts.toString());            }            @Override            public void beforeExecute(Rule rule, Facts facts) {                log.info("-----------------beforeExecute-----------------");                log.info(rule.getName() + rule.getDescription() + facts.toString());            }            @Override            public void onSuccess(Rule rule, Facts facts) {                log.info("-----------------onSuccess-----------------");                log.info(rule.getName() + rule.getDescription() + facts.toString());            }            @Override            public void onFailure(Rule rule, Facts facts, Exception e) {                log.info("-----------------onFailure-----------------");                log.info(rule.getName() + "----------" + rule.getDescription() + facts.toString() + e.toString());            }        };    }    @Override    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {        this.beanFactory = beanFactory;    }}

配置文件中配置了 ruleEngineTemplate这个spring bean，通过ruleEngineTemplate触发规则引擎的执行。

五、执行规则引擎

ruleEngineTemplate配置好后，我们可以在业务代码中执行规则引擎，处理配置文件中配置的业务规则：

最为演示，我们将规则引擎的执行代码放到了 Application 的 run 方法中，程序启动后立即执行规则引擎：

@SpringBootApplicationpublic class Application implements CommandLineRunner {    @Autowired    RuleEngineTemplate ruleEngineTemplate;    public static void main(String[] args) {        SpringApplication.run(Application.class, args);    }    @Override    public void run(String... args) {        Person person = new Person();        Facts facts = new Facts();        facts.put("person", person);        ruleEngineTemplate.fire("demo", facts);    }}

程序执行后可以看到控制台里打印了 Shop: Sorry, you are not allowed to buy alcohol，这个内容对应的是我们在规则文件中的actions中配置的 "T(java.lang.System).out.println(\"Shop: Sorry, you are not allowed to buy alcohol\")"，说明规则成功执行了。

感谢各位的阅读，以上就是“SpringBoot集成easy-rules规则引擎的流程是什么”的内容了，经过本文的学习后，相信大家对SpringBoot集成easy-rules规则引擎的流程是什么这一问题有了更深刻的体会，具体使用情况还需要大家实践验证。这里是编程网，小编将为大家推送更多相关知识点的文章，欢迎关注！