Wie läuft bei SpringBoot die Integration der Easy-Rules-Regel-Engine ab?

1. Übersicht: Durch die Konfiguration von Geschäftsregeln in der Konfigurationsdatei kann der Code optimiert und verwaltet werden. Wenn die Regeln geändert werden, muss nur die Konfigurationsdatei geändert werden. easy-rules ist eine kompakte Regel-Engine, die die SPEL-Ausdrücke von Spring sowie Apache JEXL-Ausdrücke und MVL-Ausdrücke unterstützt.

2. Abhängigkeiten zum Projekt hinzufügen

Abhängigkeiten im Gradle des Projekts hinzufügen.

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 testAnnotationProcessor
}
}

repositories {
mavenCentral()
}

Abhängigkeiten {

Implementierung 'org.springframework.boot:spring-boot-starter-json'
Implementierung 'org.springframework.boot:spring-boot-starter-validation'
Implementierung 'org jeasy:easy-rules-core: 4.1.0'

Implementierung 'org.jeasy:easy-rules-spel:4.1.0'

Implementierung '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 {
tPlatform( )
}

3. Konfigurationsdatei

Das Beispielprogramm fügt die Geschäftsregeln in die Konfigurationsdatei (demo-rule.yml) ein, Code:

Name: „Altersregel“

Beschreibung: „“

Priorität: 1

Bedingung : "#person.getAdult() == false"

actions:

- "T(java.lang.System).out.println("Shop: Entschuldigung, Sie dürfen keinen Alkohol kaufen")"
- "# person.setAdult(true)“
– „#person.setAge(18)“
---
Name: „Alkoholregel“
Beschreibung: „“
Priorität: 1
Bedingung: „#person .getAdult() == true"
actions:
- "T(java.lang.System).out.println("Shop: Sie dürfen jetzt Alkohol kaufen")"


Die Regeln in der Konfigurationsdatei bestehen die Bedingung Konfigurieren, und wenn die Wenn die Regeln erfüllt sind, werden die in Aktionen konfigurierten Aktionen aufgerufen.

Das Beispielprojekt verwendet den SPEL-Ausdruck von Spring für die Konfigurationsdatei. Die erste Regel bestimmt, ob die Regel durch getAdult() in der Spring-Bean person erfüllt wird werden aufgerufen, wenn die Regeln erfüllt sind.

Konfigurieren Sie die Regeldatei in application.yml in der Konfigurationsdatei von Spring-Boot selbst:

rule: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)
@Configuration
public 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 方法中，程序启动后立即执行规则引擎：

@SpringBootApplication
public 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")"skip-on-first-failed-rule: true

skip-on-first-applied-rule: false🎜 Skip-On-First-Non-Triggered-Rule: True🎜 Regeln:🎜 - Regel-ID: „demo“🎜 Regeldateispeicherort: „classpath:demo-rule.yml“🎜🎜🎜 Viertens: Führen Sie die Regel-Engine aus im Code Konfiguration🎜🎜Konfigurieren Sie die Regel-Engine über die Spring-Konfigurationsklasse RuleEngineConfig: 🎜rrreee🎜Die Spring-Bean ruleEngineTemplate wird in der Konfigurationsdatei konfiguriert und die Ausführung erfolgt Die Regel-Engine wird durch RuleEngineTemplate ausgelöst. 🎜🎜5. Ausführung der Regel-Engine 🎜🎜Nachdem ruleEngineTemplate konfiguriert wurde, können wir die Regel-Engine im Geschäftscode ausführen und die in der Konfigurationsdatei konfigurierten Geschäftsregeln verarbeiten: 🎜🎜Zur Demonstration: Wir werden die Regel-Engine verwenden. Der Ausführungscode wird in der Ausführungsmethode von Application platziert. Die Regel-Engine wird sofort nach dem Start des Programms ausgeführt: 🎜rrreee🎜Nachdem das Programm ausgeführt wurde, können Sie Folgendes sehen: Shop: Sorry, Sie dürfen keinen Alkohol kaufen steht auf der Konsole, dieser Inhalt entspricht dem "T(java.lang.System).out.println("Shop: Leider ist es Ihnen nicht gestattet Alkohol kaufen")" code>, was anzeigt, dass die Regel erfolgreich ausgeführt wurde. 🎜

Das obige ist der detaillierte Inhalt vonWie läuft bei SpringBoot die Integration der Easy-Rules-Regel-Engine ab?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!