Drools规则文件结构与语法讲解（结合代码讲解语法）

夜夜流光相皎洁_小宁

已于 2024-01-22 11:02:45 修改

阅读量1.2k

点赞数 27

分类专栏： Java技术 # drools 文章标签：规则引擎 Drools java

于 2024-01-22 10:59:59 首次发布

本文链接：https://blog.csdn.net/qq_25409421/article/details/135741991

版权

Java技术同时被 2 个专栏收录

44 篇文章 0 订阅

订阅专栏

drools

5 篇文章 2 订阅

订阅专栏

2.4 LHS(Left Hand Side)

2.5 then

2.6 RHS(Right Hand Side）

5.1.1 contains | not contains语法结构

5.1.2 memberOf | not memberOf语法结构

5.1.3 matches | not matches语法结构

5.2 实例代码

5.2.1 引入maven依赖

5.2.2 工程结构图

5.2.3 创建ComparisonEntity实体

5.2.4 创建comparison.drl规则文件

5.2.5 规则引擎自动配置类

5.2.6 SpringBoot 启动类

5.2.7 SpringBoot 测试启动类

5.2.8 ComparisonTest 测试类

一、规则文件构成

Drools 官网：Drools - Drools - Business Rules Management System (Java™, Open Source)

1.1 文件构成内容

在使用Drools时非常重要的一个工作就是编写规则文件，通常规则文件的后缀为.drl。drl是Drools Rule Language的缩写。在规则文件中编写具体的规则内容。
一套完整的规则文件内容构成如下：

提示：Drools支持的规则文件，除了drl形式，还有Excel文件类型的。

二、规则体语法结构

规则体是规则文件内容中的重要组成部分，是进行业务规则判断、处理业务结果的部分。
规则体语法结构如下：

rule "ruleName"
     attributes
     when
         LHS
     then
         RHS
end

2.1 rule

关键字，表示规则开始，参数为规则的唯一名称。

2.2 attributes

规则属性，是rule与when之间的参数，为可选项。

2.3 when

关键字，后面跟规则的条件部分。

2.4 LHS(Left Hand Side)

是规则的条件部分的通用名称。它由零个或多个条件元素组成。如果LHS为空，则它将被视为始终为true的条件元素。（左手边）

2.5 then

关键字，后面跟规则的结果部分。

2.6 RHS(Right Hand Side）

是规则的后果或行动部分的通用名称。（右手边）

2.7 end

关键字，表示一个规则结束。

三、注释

3.1 注释内容

在drl形式的规则文件中使用注释和Java类中使用注释一致，分为单行注释和多行注释。单行注释用"//"进行标记，多行注释以"/ "开始，以" /"结束。如下示例：

//规则rule1的注释，这是一个单行注释
rule "rule1"
     when
     then
         System.out.println("rule1触发");
end

/*
规则rule2的注释，
这是一个多行注释
*/
rule "rule2"
     when
     then
         System.out.println("rule2触发");
end

四、Pattern模式匹配

前面我们已经知道了Drools中的匹配器可以将Rule Base中的所有规则与Working Memory中的Fact对象进行模式匹配，那么我们就需要在规则体的LHS部分定义规则并进行模式匹配。LHS部分由一个或者多个条件组成，条件又称为pattern。

4.1 pattern的语法结构

pattern的语法结构为：绑定变量名:Object(Field约束)

其中绑定变量名可以省略，通常绑定变量名的命名一般建议以$开始。如果定义了绑定变量名，就可以在规则体的RHS部分使用此绑定变量名来操作相应的Fact对象。Field约束部分是需要返回true或者false的0个或多个表达式。

4.2 举例

4.2.1 例子一

rule "add100"
    no-loop true
    lock-on-active true
    salience 1
    when
       $order : Order(price > 100 && price <= 500)
    then
       $order.setScore(100);
       update($s);
end

4.2.2 例子一说明

通过上面的例子我们可以知道，匹配的条件为：

工作内存中必须存在Order这种类型的Fact对象-----类型约束
Fact对象的price属性值必须大于100------属性约束
Fact对象的price属性值必须小于等于500------属性约束

以上条件必须同时满足当前规则才有可能被激活。

4.2.3 例子二

绑定变量既可以用在对象上，也可以用在对象的属性上。

例如上面的例子可以改为：

rule "add100"
    no-loop true
    lock-on-active true
    salience 1
    when
       $order : Order($price:price > 100 && amopriceut <= 500)
    then
       System.out.println("$price=" + $price);
       $s.setScore(100);
       update($s);
end

4.2.4 例子三

LHS部分还可以定义多个pattern，多个pattern之间可以使用and或者or进行连接，也可以不写，默认连接为and。

rule "add100"
    no-loop true
    lock-on-active true
    salience 1
    when
       $order : Order(price > 100 && price <= 500) and $user : User(level>3)
    then
       System.out.println($order.getUser());
       $order.setScore(100);
       update($order);
end

五、比较操作符

Drools提供的比较操作符，如下表：

前6个比较操作符和Java中的完全相同，下面我们重点学习后6个比较操作符。

5.1 操作符语法说明

5.1.1 contains | not contains语法结构

Object(Field[Collection/Array] contains value)
Object(Field[Collection/Array] not contains value)

5.1.2 memberOf | not memberOf语法结构

Object(field memberOf value[Collection/Array])
Object(field not memberOf value[Collection/Array])

5.1.3 matches | not matches语法结构

Object(field matches "正则表达式")
Object(field not matches "正则表达式")

提示：contain是前面包含后面，memberOf是后面包含前面。

5.2 实例代码

5.2.1 引入maven依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.0</version>
        <relativePath/>
    </parent>

    <groupId>com.ningzhaosheng.drools</groupId>
    <artifactId>drools-test</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.31</version>
        </dependency>

        <dependency>
            <groupId>org.kie</groupId>
            <artifactId>kie-spring</artifactId>
            <version>7.74.1.Final</version>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-tx</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-beans</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-core</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-context</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

    </dependencies>
    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

</project>

5.2.2 工程结构图

5.2.3 创建ComparisonEntity实体

package com.ningzhaosheng.drools.entity;

import lombok.Data;
import lombok.experimental.Accessors;

import java.util.List;

/**
 * @author ningzhaosheng
 * @date 2024/1/17 16:57:27
 * @description
 */
@Data
@Accessors(chain = true)
public class ComparisonEntity {
    /**
     * 名字集合
     */
    private String names;
    /**
     * 字符串集合
     */
    private List<String> list;

}

5.2.4 创建comparison.drl规则文件

package rules
import com.ningzhaosheng.drools.entity.ComparisonEntity
/*
  用于测试Drools提供的比较操作符
*/

//测试比较操作符contains
rule "rule_comparison_contains"
    when
        ComparisonEntity(names contains "张三")
        ComparisonEntity(list contains names)
    then
        System.out.println("规则rule_comparison_contains触发");
end

//测试比较操作符not contains
rule "rule_comparison_notContains"
    when
        ComparisonEntity(names not contains "张三")
        ComparisonEntity(list not contains names)
    then
        System.out.println("规则rule_comparison_notContains触发");
end

//测试比较操作符memberOf
rule "rule_comparison_memberOf"
    when
        ComparisonEntity(names memberOf list)
    then
        System.out.println("规则rule_comparison_memberOf触发");
end


//测试比较操作符not memberOf
rule "rule_comparison_notMemberOf"
    when
        ComparisonEntity(names not memberOf list)
    then
        System.out.println("规则rule_comparison_notMemberOf触发");
end


//测试比较操作符matches
rule "rule_comparison_matches"
    when
        ComparisonEntity(names matches "张.*")
    then
        System.out.println("规则rule_comparison_matches触发");
end


//测试比较操作符not matches
rule "rule_comparison_notMatches"
    when
        ComparisonEntity(names not matches "张.*")
    then
        System.out.println("规则rule_comparison_notMatches触发");
end

5.2.5 规则引擎自动配置类

package com.ningzhaosheng.drools.config;

import org.kie.api.KieBase;
import org.kie.api.KieServices;
import org.kie.api.builder.KieBuilder;
import org.kie.api.builder.KieFileSystem;
import org.kie.api.builder.KieRepository;
import org.kie.api.runtime.KieContainer;
import org.kie.internal.io.ResourceFactory;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;

import java.io.IOException;

/**
 * @author ningzhaosheng
 * @date 2024/1/17 17:40:41
 * @description 规则引擎自动配置类
 */
@Configuration
public class DroolsAutoConfiguration {
    private static final String RULES_PATH = "rules/";

    @Bean
    @ConditionalOnMissingBean(KieServices.class)
    public KieServices getKieServices() {
        return KieServices.Factory.get();
    }

    @Bean
    @ConditionalOnMissingBean(KieFileSystem.class)
    public KieFileSystem kieFileSystem() throws IOException {
        KieFileSystem kieFileSystem = getKieServices().newKieFileSystem();
        for (Resource file : getRuleFiles()) {
            kieFileSystem.write(ResourceFactory.newClassPathResource(RULES_PATH + file.getFilename(), "UTF-8"));
        }
        return kieFileSystem;
    }

    private Resource[] getRuleFiles() throws IOException {
        ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
        return resourcePatternResolver.getResources("classpath*:" + RULES_PATH + "**/*.*");
    }

    @Bean
    @ConditionalOnMissingBean(KieContainer.class)
    public KieContainer kieContainer() throws IOException {
        final KieRepository kieRepository = getKieServices().getRepository();

        kieRepository.addKieModule(() -> kieRepository.getDefaultReleaseId());

        KieBuilder kieBuilder = getKieServices().newKieBuilder(kieFileSystem());
        kieBuilder.buildAll();

        KieContainer kieContainer = getKieServices().newKieContainer(kieRepository.getDefaultReleaseId());

        return kieContainer;
    }

    @Bean
    @ConditionalOnMissingBean(KieBase.class)
    public KieBase kieBase() throws IOException {
        return kieContainer().getKieBase();
    }
}

5.2.6 SpringBoot 启动类

package com.ningzhaosheng.drools;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @author ningzhaosheng
 * @date 2024/1/17 17:42:56
 * @description SpringBoot 启动类
 */
@SpringBootApplication
public class DroolsApplication {
    public static void main(String[] args) {
        SpringApplication.run(DroolsApplication.class, args);
        System.out.println("启动成功");
    }
}

5.2.7 SpringBoot 测试启动类

package com.ningzhaosheng.drools;

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

/**
 * @author ningzhaosheng
 * @date 2024/1/17 17:15:44
 * @description 启动测试
 */
@SpringBootTest
public class DroolsApplicationTests {
    @Test
    void contextLoads() {
    }

}

5.2.8 ComparisonTest 测试类

package com.ningzhaosheng.drools.client;

import com.ningzhaosheng.drools.DroolsApplicationTests;
import com.ningzhaosheng.drools.entity.ComparisonEntity;
import org.junit.jupiter.api.Test;
import org.kie.api.KieBase;
import org.kie.api.runtime.KieSession;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;

/**
 * @author ningzhaosheng
 * @date 2024/1/17 17:06:12
 * @description
 */
public class ComparisonTest extends DroolsApplicationTests {
    @Resource
    public KieBase kieBase;
    @Test
    public void testComparison(){
        KieSession kieSession = kieBase.newKieSession();
        ComparisonEntity comparisonEntity = new ComparisonEntity();
        comparisonEntity.setNames("张三");
        List<String> list = new ArrayList<>();
        list.add("张三");
        list.add("李四");
        comparisonEntity.setList(list);
        kieSession.insert(comparisonEntity);
        kieSession.fireAllRules();
        kieSession.dispose();
    }
}

5.2.9 测试结果

5.3 执行指定规则

通过前面的案例可以看到，我们在调用规则代码时，满足条件的规则都会被执行。那么如果我们只想执行其中的某个规则如何实现呢？

Drools给我们提供的方式是通过规则过滤器来实现执行指定规则。对于规则文件不用做任何修改，只需要修改Java代码即可，如下：

//通过规则过滤器实现只执行指定规则
kieSession.fireAllRules(new kieSession.fireAllRules(new
RuleNameEqualsAgendaFilter("rule_filter_1"));

六、关键字

Drools的关键字分为：硬关键字(Hard keywords)和软关键字(Soft keywords)。

硬关键字是我们在规则文件中定义包名或者规则名时明确不能使用的，否则程序会报错。软关键字虽然可以使用，但是不建议使用。

6.1 硬关键字

硬关键字包括：

true

false

null

6.2 软关键字

软关键字包括：

lock-on-active

date-effective

date-expires

no-loop

auto-focus

activation-group

agenda-group

ruleflow-group

entry-point

duration

package

import

dialect

salience

enabled

attributes

rule

extend
when

then

template

query

declare

function

global

eval

not

and

exists

forall

accumulate

collect

from
action

reverse

result

end

over

init

比如：
rule true //不可以
rule "true" 可以

七、规则文件编码规范

7.1 规范内容

我们在进行drl类型的规则文件编写时尽量遵循如下规范：

所有的规则文件(.drl)应统一放在一个规定的文件夹中，如：/rules文件夹
书写的每个规则应尽量加上注释。注释要清晰明了，言简意赅
同一类型的对象尽量放在一个规则文件中，如所有Student类型的对象尽量放在一个规则文件中
规则结果部分(RHS)尽量不要有条件语句，如if(...)，尽量不要有复杂的逻辑和深层次的嵌套语句
每个规则最好都加上salience属性，明确执行顺序
Drools默认dialect为"Java"，尽量避免使用dialect "mvel"

好了，本次分享就到这里，欢迎大家继续阅读《Drools》专栏内容，如果有帮助到大家，欢迎大家点赞+关注+收藏，有疑问也欢迎大家评论留言！

夜夜流光相皎洁_小宁

关注

27
点赞
踩
27

收藏

觉得还不错? 一键收藏
2
评论
Drools规则文件结构与语法讲解（结合代码讲解语法）

Drools（JBoss Rules ）具有一个易于访问企业策略、易于调整以及易于管理的开源业务规则引擎，符合业内标准，速度快、效率高。业务分析师或审核人员可以利用它轻松查看业务规则，从而检验是否已编码的规则执行了所需的业务规则。释义JBoss Rules 的前身是Codehaus的一个开源项目叫Drools。Drools是一套业务规则管理系统(BRMS)解决方案，今天我们就来讲解下Drools的规则文件结构并结合代码讲解下语法内容。
复制链接

扫一扫