SpringBoot가 쉬운 규칙 규칙 엔진을 통합하는 프로세스는 무엇입니까?

1. 개요

구성 파일에 비즈니스 규칙을 구성하면 코드를 간소화하고 유지할 수 있습니다. 규칙을 수정하면 구성 파일만 수정하면 됩니다. easy-rules는 Spring의 SPEL 표현식은 물론 Apache JEXL 표현식 및 MVL 표현식도 지원하는 컴팩트 규칙 엔진입니다.

2. 프로젝트에 종속성을 추가합니다

프로젝트의 gradle에 종속성을 추가합니다.

build.gradle:

plugins {
id 'org.springframework.boot' 버전 '3.0.5'
id 'io.spring.dependent-management' 버전 '1.1.0'
id 'java'
}

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

configurations {
  compileOnly {
                           extendsFrom testAnnotationProcessor
}
}

저장소 {
mavenCentral()

}

종속성 {
구현 "org.springframework.boot:spring-boot-starter-json"

구현 'org.springframework.boot:spring-boot-starter-validation'

구현 'org. 4.1.0'
구현 'org.jeasy:easy-rules-spel:4.1.0'
구현 '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'
}

dependentManagement {
imports {

mavenBom "org.springframework.cloud:spring-cloud-dependentities:2022.0.1"

}
}

test {
tPlatform( )

}

3. 구성 파일

샘플 프로그램은 비즈니스 규칙을 구성 파일인 비즈니스 규칙 구성 파일(demo-rule.yml)에 넣습니다. 코드:

name: "age rule"

description: ""

priority: 1

condition : "#person.getAdult() == false"
actions:
- "T(java.lang.System).out.println("가게: 죄송합니다. 술을 구입할 수 없습니다." )"
- "# person.setAdult(true)"
- "#person.setAge(18)"
---
name: "alcohol rule"
description: ""
priority: 1
condition: "#person .getAdult() == true"
actions:
- "T(java.lang.System).out.println("Shop: 이제 술을 구입할 수 있습니다.")"


구성 파일의 규칙은 구성을 통과합니다. 규칙이 충족되면 작업에 구성된 작업이 호출됩니다.

예제 프로젝트에서는 규칙 구성을 위해 Spring의 SPEL 표현식을 사용합니다. 구성 파일에는 두 가지 규칙이 구성되어 있습니다. 첫 번째 규칙은 Spring Bean person에서 getAdult()를 통해 규칙이 충족되는지 여부를 결정합니다. 규칙이 충족되면 메서드가 호출됩니다.

spring-boot 자체 구성 파일의 application.yml에서 규칙 파일을 구성합니다.

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")"

rule:🎜 Skip-on-first-failed-rule: true🎜 Skip-on-first-applied-rule: false🎜 Skip- on-first-non-triggered-rule: true🎜 rule:🎜 - rule-id: "demo"🎜 rule-file-location: "classpath:demo-rule.yml"🎜🎜🎜 넷째, 규칙 엔진을 수행합니다. 코드 Configuration🎜🎜스프링 구성 클래스 RuleEngineConfig를 통해 규칙 엔진을 구성합니다. 🎜rrreee🎜스프링 빈 ruleEngineTemplate이 구성 파일에 구성되고 규칙 엔진은 ruleEngineTemplate을 통해 트리거됩니다. 🎜🎜5. 규칙 엔진 실행 🎜🎜ruleEngineTemplate이 구성된 후 비즈니스 코드에서 규칙 엔진을 실행하고 구성 파일에 구성된 비즈니스 규칙을 처리할 수 있습니다. 🎜🎜데모로, 규칙 엔진을 사용하겠습니다. 실행 코드는 Application의 run 메소드에 있습니다. 규칙 엔진은 프로그램이 시작된 후 즉시 실행됩니다. 🎜rrreee🎜프로그램이 실행된 후 Shop: Sorry, 당신은 술을 구입할 수 없습니다가 콘솔에 인쇄됩니다. 이 내용은 "T(java.lang.System).out.println("Shop: Sorry, you are not allowed to"에 해당합니다. buy drink")" code>는 규칙이 성공적으로 실행되었음을 나타냅니다. 🎜

위 내용은 SpringBoot가 쉬운 규칙 규칙 엔진을 통합하는 프로세스는 무엇입니까?의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!