Drools从入门到精通

最新推荐文章于 2025-03-12 16:58:55 发布

李大爷的博客

最新推荐文章于 2025-03-12 16:58:55 发布

阅读量3k

点赞数 9

分类专栏：第三方技术文章标签： spring boot spring java

本文链接：https://blog.csdn.net/m0_49261516/article/details/128661030

版权

第三方技术专栏收录该内容

1 篇文章

订阅专栏

1、什么是规则引擎？

规则引擎，全称为业务规则管理系统，英文名为BRMS（即Business Rule Management System）。

规则引擎的主要思想是将应用程序中的业务决策部分分离出来，并使用预定义的语义模板编写业务决策（业务规则），由用户或开发者在需要时进行配置、管理。

需要注意的的规则引擎并不是一个具体的技术框架，而是指的一类系统，即业务规则管理系统。~~目前市面上具体的规则引擎产品有：drools、VisualRules、iLog~~等。

规则引擎实现了将业务决策从应用程序代码中分离出来，接收数据输入，解释业务规则，并根据业务规则做出业务决策。规则引擎其实就是一个输入输出平台。

2、Drools介绍

drools是一款由JBoss组织提供的基于java语言开发的开源规则引擎，可以将复杂且多变的业务规则从硬编码中解放出来，以规则脚本的形式存放在文件或特定的存储介质中（如存放在数据库中），使得业务规则的变更不需要修改项目代码、重启服务器就可以在线上环境立即生效。

drools官网：https://www.drools.org/

drools中文网：Drools中文网 | 基于java的功能强大的开源规则引擎

drools源码下载地址：https://github.com/kiegroup/drools

在项目中使用drools时，既可以单独使用也可以整合spring使用。如果单独使用只需导入如下maven坐标即可：

<dependency>
  <groupId>org.drools</groupId>
  <artifactId>drools-compiler</artifactId>
  <version>7.6.0.Final</version>
</dependency>

3、Drools入门案例

1、业务场景说明

业务场景：消费者在图书商城购买图书，下单后需要在支付页面显示订单优惠后的价格。具体优惠规则如下：

现在需要根据上面的规则计算优惠后的价格。

2、开发实现

第一步：创建maven工程并导入drools相关maven坐标

<!-- drools规则引擎 -->
<dependency>
  <groupId>org.drools</groupId>
  <artifactId>drools-compiler</artifactId>
  <version>7.6.0.Final</version>
</dependency>

<!-- junit单元测试 -->
<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.12</version>
</dependency>

第二部：根据drools要求创建resources/META-INF/kmodule.xml

<?xml version="1.0" encoding="UTF-8"?>
<kmodule xmlns="http://jboss.org/kie/6.0.0/kmodule">

  <!--
  name:指定kbase的名称，可以任意，但是需要唯一
  packages:指定规则文件的目录，需要根据实际情况填写，否则无法加载到规则文件
  default:指定当前kbase是否为默认
  -->
  <kbase name="myKbase1" packages="rules" default="true">
    <!--
    name:指定ksession的名称，可以任意，但需要唯一
    default:指定当前session是否为默认
    -->
    <ksession name="ksession-rule" default="true"/>
  </kbase>
</kmodule>

注意：上面配置文件的名字和位置都是固定写法，不能更改。

第三步：创建实体类Order

@Data
    public class Order {
        private Double originalPrice;
        // 订单原始价格，即优惠前的价格
        private Double realPrice;
        // 订单真实价格，即优惠后的价格
    }

第四步：创建规则文件resources/rules/bookDiscount.drl

// 图书优惠规则
package book.discount
import com.drools.entity.Order

    // 规则一：所购图书总价在100元以下的没有优惠
    rule "book_discount_1"
    when
        $order: Order(originalPrice < 100) // 匹配模式，到规则引擎中（工作内存）查找Order对象，命名为$order
        then
        $order.setRealPrice($order.getOriginalPrice());
System.out.println("成功匹配到规则一，所购图书总价在100元以下无优惠");
end

    // 规则二：所购图书总价在100~200的优惠20元
    rule "book_discount_2"
    when
    $order: Order(originalPrice >= 100 && originalPrice < 200)
    then
    $order.setRealPrice($order.getOriginalPrice() - 20);
System.out.println("成功匹配到规则二，所购图书总价在100~200元之间");
end

    // 规则三：所购图书总价在200~300元的优惠50元
    rule "book_discount_3"
    when
    $order: Order(originalPrice >= 200 && originalPrice < 300)
    then
    $order.setRealPrice($order.getOriginalPrice() - 50);
System.out.println("成功匹配到规则三，所购图书总价在200~300元之间");
end

    // 规则四：所购图书总价在300元及以上的优惠100元
    rule "book_discount_4"
    when
    $order: Order(originalPrice >= 300)
    then
    $order.setRealPrice($order.getOriginalPrice() - 100);
System.out.println("成功匹配到规则四，所购图书总价在300元及以上");
end

第五步：编写单元测试

@Test
    public void DroolsDemoTest01() {
        // 获取KieServices服务
        KieServices kieServices = KieServices.Factory.get();
        // 获取Kie容器对象（默认容器对象
        KieContainer kieContainer = kieServices.newKieClasspathContainer();
        // 从Kie容器对象中获取会话对象（默认session对象
        KieSession kieSession = kieContainer.newKieSession();

        Order order = new Order();
        order.setOriginalPrice(160d);

        // 将order对象插入工作内存
        kieSession.insert(order);

        System.out.println("匹配规则前优惠后价格：" + order.getRealPrice());

        // 匹配对象
        // 激活规则，由drools框架自动进行规则匹配。若匹配成功，则执行
        kieSession.fireAllRules();

        // 关闭会话
        kieSession.dispose();

        System.out.println("优惠前价格：" + order.getOriginalPrice() + "\n优惠后价格：" + order.getRealPrice());

    }

控制台输出如下：

可以发现，使用drools引擎规则主要工作就是编写规则文件，在规则文件中定义和业务相关的业务规则，例如本案例定义的就是图书的优惠规则。

规则定义好后就需要调用drools提供的api将数据提供给规则引擎进行规则模式匹配，规则引擎会执行匹配成功的规则，并将计算的结果返回。

可能大家会有疑问，虽然没有在代码中编写规则的判断逻辑，但是还是在规则文件中编写了业务规则，这跟在代码中编写规则有什么本质的区别？

前面已经提到，使用规则引擎时，规则可以做到动态管理。业务人员可以像管理数据一样对业务规则进行管理，比如查询、添加、更新、统计、提交业务规则等。这样就可以做到在不重启服务的情况下调整业务规则。

4、小结

1、规则引擎构成

drools规则引擎由以下三部分构成：

Working Memory（工作内存）

Rule Base（规则库）

Inference Engine（推理引擎）

其中Inference Engine（推理引擎）又包括：

Pattern Matcher（匹配器）

Agenda（议程）

Execution Engine（执行引擎）

如下图所示：

2、相关概念说明

:::tips

Working Memory：工作内存，drools规则引擎会从Working Memory中获取数据并和规则文件中定义的规则进行模式匹配，所以我们开发的应用程序只需要将我们的数据插入到Working Memory中即可，例如本案例中我们调用kieSession.insert(order);就是将order对象插入到工作内存中。

Fact：事实，是指在drools规则应用当中，将一个普通的javaBean插入到Working Memory后的对象就是Fact对象，例如本案例中的Order对象就属于Fact对象。Fact对象是我们的应用和规则引擎进行交互的桥梁或通道。

Rule Base：规则库，我们在规则文件中定义的规则都会被加载到规则库中。

:::

:::tips

Pattern Matcher：匹配器，将Rule Base中的所有规则与Working Memory中的Fact对象进行模式匹配，匹配成功则被激活并放入Agenda中。

Agenda：议程，用于存放通过匹配器进行模式匹配后被激活的规则。

Execution Engine：执行引擎，执行Agenda中被激活的规则。

:::

3、KIE介绍

我们在操作Drools时经常使用的API以及他们之间的关系如下图：

通过上面的API可以发现，大部分类都是以Kie开头。Kie全称为Knowledge is Everything，即“知识就是一切”的缩写，是Jboss一系列项目的总称。如下图所示，Kie的主要模块有OptaPlanner、Drools、UberFire、jBPM。

通过上图可以看到，Drools是整个KIE项目中的一个组件，Drools中还包括一个Drools-WB的模块，他是一个可视化的规则编辑器。

5、Drools基础语法

1、规则文件构成

在使用Drools时非常重要的一个工作就是编写规则文件，通常规则文件的后缀为.drl。

drl是Drools Rule Language的缩写。在规则文件中编写具体的规则内容。

一套完整的规则文件内容构成如下：

关键字	描述
package	包名，只限于逻辑上的管理，同一个包名下的查询或者函数可以直接调用
import	用于导入类或静态方法
global	全景变量
function	自定义函数
query	查询
rule...end	规则体

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

2、规则体语法结构

规则体是规则文件中的重要组成部分，是进行业务规则判断、处理业务结果的部分。

规则语法结构如下：

rule "ruleName"
    attributes
    when
        LHS
    then
        RHS
end

rule：关键字，表示规则开始，参数为规则的唯一名称。
attribute：规则属性，是rule与when之间的参数，为可选项。
when：关键字，后面跟规则的条件部分。
LHS（Left Hand Side）：是规则的条件部分的通用名称。它由零个或多个条件元素组成。如果LHS为空，则它将被视为始终为true的条件元素。
then：关键字，后面跟规则的结果部分。
RHS（Right Hand Side）：是规则的后果或行动部分的通用名称。
end：关键字，表示一个规则的结束。

3、注释

在drl形式的规则文件中使用注释和Java类中使用注释一致，分为单行注释和多行注释。

单行注释用”//"进行标记，多行注释以"/"开始，以"/"结束。

4、Pattern匹配规则

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

pattern的语法结构为：

绑定变量名:Object(Field约束)

其中绑定变量名可以省略，通常绑定变量名的命名一般建议以$开始。如果定义了绑定变量名，就可以在规则体的RHS部分使用此绑定变量名来操作相应的Fact对象。

Field约束部分是需要返回true或者false的0个或多个表达式。

例如我们的入门案例中：

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

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

工作内存中必须存在Order这种类型的Fact对象---类型约束
Fact对象的originalPrice属性值必须小于200----属性约束
Fact对象的originalPrice属性值必须大于等于1-0----属性约束

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

绑定变量既可以用在对象上,也可以用在对象的属性上。例如上面的例子可以改为：

// 规则二：所购图书总价在100~200的优惠20元
rule "book_discount_2"
    when
        $order: Order($op:originalPrice >= 100 && originalPrice < 200)
    then
        System.out.println("$op=" + $op);
        $order.setRealPrice($order.getOriginalPrice() - 20);
        System.out.println("成功匹配到规则二，所购图书总价在100~200元之间");
    end

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

5、比较操作符

符号	说明
>	大于
<	小于
>=	大于等于
<=	小于等于
==	等于
!=	不等于
contains	检查一个Fact对象的某个属性值是否包含一个指定的对象值
not contains	检查一个Fact对象的某个属性值是否不包含一个指定的对象值
memberOf	判断一个Fact对象的某个属性是否在一个或多个集合中
not memberOf	判断一个Fact对象的某个属性是否不在一个或多个集合中
matches	判断一个Fact对象的属性是否与提供的标准的Java正则表达式进行匹配
not matches	判断一个Fact对象的属性是否不与提供的标准的Java正则表达式进行匹配

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

1、语法

●contains | not contains语法结构    // 包含与不包含，是模糊匹配，类似于sql的like
    Object(Field[Collection/Array] contains value)
    Object(Field[Collection/Array] npt contains value)

        ●memberOf | not memberOf语法结构
        Object(field memberOf value[Collection/Array])
Object(field not memberOf value[Collection/Array1)

    ●matches | not matches语法结构
    Object(field matches "正则表达式")
    Object(field not matches "正则表达式")

2、操作步骤

第一步：创建实体类，用于测试比较运算符

@Data
public class ComparisonOperatorEntity {
    private String names;
    private List<String> list;
}

第二步：创建规则文件resources/rules/comparisonOperator.drl

package comparisonOperator
 
import com.ws.soon.entity.ComparisonOperatorEntity
 
/**
 * 当前规则用于测试drools提供的操作运算符
 */
 
// 测试比较操作符contains
rule "rule_comparison_contains"
    when
        ComparisonOperatorEntity(names contains "王小白") or
        ComparisonOperatorEntity(list contains names)
    then
        System.out.println("规则：rule_comparison_contains触发了...");
end
 
// 测试比较操作符contains
rule "rule_comparison_not_contains"
    when
        ComparisonOperatorEntity(names not contains "王小白") and
        ComparisonOperatorEntity(list not contains names)
    then
        System.out.println("规则：rule_comparison_not_contains触发了...");
end
 
// 测试比较操作符memberOf
rule "rule_comparison_memberOf"
    when
        ComparisonOperatorEntity(names memberOf list)
    then
        System.out.println("规则：rule_comparison_memberOf触发了...");
end
 
// 测试比较操作符not memberOf
rule "rule_comparison_not_memberOf"
    when
        ComparisonOperatorEntity(names not memberOf list)
    then
        System.out.println("规则：rule_comparison_not_memberOf触发了...");
end
 
// 测试比较操作符matches
rule "rule_comparison_matches"
    when
        ComparisonOperatorEntity(names matches "王.*") // 正则表达式
    then
        System.out.println("规则：rule_comparison_matches触发了...");
end
 
// 测试比较操作符not matches
rule "rule_comparison_not_matches"
    when
        ComparisonOperatorEntity(names not matches "王.*") // 正则表达式
    then
        System.out.println("规则：rule_comparison_not_matches触发了...");
end

第三步：编写单元测试

public class ComparisonOperatorEntityTest {
 
    @Test
    public void test() {
        KieServices kieServices = KieServices.Factory.get();
        // 获取Kie容器对象（默认容器对象
        KieContainer kieContainer = kieServices.newKieClasspathContainer();
        // 从Kie容器对象中获取会话对象（默认session对象
        KieSession kieSession = kieContainer.newKieSession();
 
        ComparisonOperatorEntity fact = new ComparisonOperatorEntity();
        String names = "1王小白";
        fact.setNames(names);
 
        List<String> list = new ArrayList<String>();
        list.add("小黑");
        list.add("小白");
//        list.add(names);
        fact.setList(list);
        // 将order对象插入工作内存
        kieSession.insert(fact);
 
        // 匹配对象
        // 激活规则，由drools框架自动进行规则匹配。若匹配成功，则执行
        kieSession.fireAllRules();
 
        // 关闭会话
        kieSession.dispose();
 
    }
}

执行指定规则

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

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

//测试执行指定规则
@Test
public void test3(){
    KieServices kieServices = KieServices.Factory.get();
	KieContainer kieClasspathContainer = kieServices.getKieClasspathContainer();
	KieSession kieSession = kieClasspathContainer.newKieSession();
	
	ComparisonOperatorEntity comparisonOperatorEntity = new ComparisonOperatorEntity();
	comparisonOperatorEntity.setNames("张三");
	List<String> list = new ArrayList<String>();
	list.add("张三");
	list.add("李四");
	comparisonOperatorEntity.setList(list);
	kieSession.insert(comparisonOperatorEntity);
	
	//激活规则，由Drools框架自动进行规则匹配，如果规则匹配成功，则执行当前规则
    //使用框架提供的规则过滤器执行指定规则
    //kieSession.fireAllRules(new RuleNameEqualsAgendaFilter("rule_comparison_memberOf"));
    kieSession.fireAllRules(new RuleNameStartsWithAgendaFilter("rule_"));
	kieSession.dispose();
}

关键字

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

:::info

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

:::

硬关键字硬关键字包括：true false null

:::info

软关键字虽然可以使用，但是不建议使用。

:::

软关键字软关键字包括：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 in or and exists forall accumulate collect from action reverse result end over init

Drools内置方法

规则文件的RHS部分的主要作用是通过插入，删除或修改工作内存中的Fact数据，来达到控制规则引擎执行的目的

Drools提供了一些方法可以用来操作工作内存中的数据，操作完成后规则引擎会重新进行相关规则的匹配，原来没有匹配成功的规则在我们修改数据完成后有可能就会匹配成功了

创建如下实体类

@Data
public class Student {

    private int id;
    private String name;
    private int age;
}

update方法

:::info

update方法的作用是更新工作内存中的数据，并让相关的规则重新匹配。

:::

第一步：编写规则文件/resources/rules/student.drl，文件内容如下

/*
 当前规则文件用于测试Drools提供的内置方法
*/
package student
import cn.com.javakf.drools.entity.Student

//当前规则用于测试update内置方法
rule "rule_student_age小于10岁"
    when
        $s:Student(age < 10)
    then
        $s.setAge(15);
        update($s);//更新数据，导致相关的规则会重新匹配
        System.out.println("规则rule_student_age小于10岁触发");
end

//当前规则用于测试update内置方法
rule "rule_student_age等于10岁时删除数据"
    /*
    salience：设置当前规则的执行优先级，数值越大越优先执行，默认值为0.
    因为当前规则的匹配条件和下面规则的匹配条件相同，为了保证先执行当前规则，需要设置优先级
    */
    salience 100
    when
        $s:Student(age == 10)
    then
        retract($s);//retract方法的作用是删除工作内存中的数据，并让相关的规则重新匹配。
        System.out.println("规则rule_student_age等于10岁时删除数据触发");
end

//当前规则用于测试update内置方法
rule "rule_student_age大于20岁"
    when
        $s:Student(age > 20)
    then
        System.out.println("规则rule_student_age大于20岁触发");
end

第二步：编写单元测试

//测试Drools内置方法---update
@Test
public void test4() {
	KieServices kieServices = KieServices.Factory.get();
	//获得Kie容器对象
	KieContainer kieContainer = kieServices.newKieClasspathContainer();
	//从Kie容器对象中获取会话对象
	KieSession kieSession = kieContainer.newKieSession();

	Student student = new Student();
	student.setAge(5);

	kieSession.insert(student);

	//激活规则，由Drools框架自动进行规则匹配，如果规则匹配成功，则执行当前规则
	kieSession.fireAllRules();

	//关闭会话
	kieSession.dispose();
}

通过控制台的输出可以看到规则文件中定义的三个规则都触发了。

在更新数据时需要注意防止发生死循环。

insert方法

insert方法的作用是向工作内存中插入数据，并让相关的规则重新匹配。

第一步：修改student.drl文件内容如下

/*
 当前规则文件用于测试Drools提供的内置方法
*/
package student
import cn.com.javakf.drools.entity.Student

//当前规则用于测试insert内置方法
rule "rule_student_age等于10岁"
    when
        $s:Student(age == 10)
    then
        Student student = new Student();
        student.setAge(5);
        insert(student);//插入数据，导致相关的规则会重新匹配
        System.out.println("规则rule_student_age等于10岁触发");
end

//当前规则用于测试update内置方法
rule "rule_student_age小于10岁"
    when
        $s:Student(age < 10)
    then
        $s.setAge(15);
        update($s);//更新数据，导致相关的规则会重新匹配
        System.out.println("规则rule_student_age小于10岁触发");
end

//当前规则用于测试update内置方法
rule "rule_student_age等于10岁时删除数据"
    /*
    salience：设置当前规则的执行优先级，数值越大越优先执行，默认值为0.
    因为当前规则的匹配条件和下面规则的匹配条件相同，为了保证先执行当前规则，需要设置优先级
    */
    salience 100
    when
        $s:Student(age == 10)
    then
        retract($s);//retract方法的作用是删除工作内存中的数据，并让相关的规则重新匹配。
        System.out.println("规则rule_student_age等于10岁时删除数据触发");
end

//当前规则用于测试update内置方法
rule "rule_student_age大于20岁"
    when
        $s:Student(age > 20)
    then
        System.out.println("规则rule_student_age大于20岁触发");
end

第二步：编写单元测试

//测试Drools内置方法---insert、retract
@Test
public void test5() {
	KieServices kieServices = KieServices.Factory.get();
	//获得Kie容器对象
	KieContainer kieContainer = kieServices.newKieClasspathContainer();
	//从Kie容器对象中获取会话对象
	KieSession kieSession = kieContainer.newKieSession();

	Student student = new Student();
	student.setAge(10);

	kieSession.insert(student);

	//激活规则，由Drools框架自动进行规则匹配，如果规则匹配成功，则执行当前规则
	kieSession.fireAllRules();

	//关闭会话
	kieSession.dispose();
}

通过控制台输出可以发现，四个规则都触发了，这是因为首先进行规则匹配时只有第一个规则可以匹配成功，但是在第一个规则中向工作内存中插入了一个数据导致重新进行规则匹配，此时第二个规则可以匹配成功。在第二个规则中进行了数据修改导致第三个规则也可以匹配成功，以此类推最终四个规则都匹配成功并执行了。

retract方法

retract方法的作用是删除工作内存中的数据，并让相关的规则重新匹配。

第一步：修改student.drl文件内容如下

/*
 当前规则文件用于测试Drools提供的内置方法
*/
package student
import cn.com.javakf.drools.entity.Student

//当前规则用于测试retract内置方法
rule "要求Student的age等于10岁用于删除"
    salience 10
    dialect "java"//指定规则使用的语言
    enabled true//enabled属性用于指定当前规则是否启用，取值为true或者false，默认值true
    when
        $student:Student(age == 10)
    then
        retract($student);//retract方法作用是删除工作内存中的Fact对象，会导致相关规则重新匹配
        System.out.println("规则：要求Student的age等于10岁用于删除触发了...");
end

//当前规则用于测试insert内置方法
rule "rule_student_age等于10岁"
    when
        $s:Student(age == 10)
    then
        Student student = new Student();
        student.setAge(5);
        insert(student);//插入数据，导致相关的规则会重新匹配
        System.out.println("规则rule_student_age等于10岁触发");
end

//当前规则用于测试update内置方法
rule "rule_student_age小于10岁"
    when
        $s:Student(age < 10)
    then
        $s.setAge(15);
        update($s);//更新数据，导致相关的规则会重新匹配
        System.out.println("规则rule_student_age小于10岁触发");
end

//当前规则用于测试update内置方法
rule "rule_student_age等于10岁时删除数据"
    /*
    salience：设置当前规则的执行优先级，数值越大越优先执行，默认值为0.
    因为当前规则的匹配条件和下面规则的匹配条件相同，为了保证先执行当前规则，需要设置优先级
    */
    salience 100
    when
        $s:Student(age == 10)
    then
        retract($s);//retract方法的作用是删除工作内存中的数据，并让相关的规则重新匹配。
        System.out.println("规则rule_student_age等于10岁时删除数据触发");
end

//当前规则用于测试update内置方法
rule "rule_student_age大于20岁"
    when
        $s:Student(age > 20)
    then
        System.out.println("规则rule_student_age大于20岁触发");
end

第二步：编写单元测试

//测试Drools内置方法---insert、retract
@Test
public void test5() {
	KieServices kieServices = KieServices.Factory.get();
	//获得Kie容器对象
	KieContainer kieContainer = kieServices.newKieClasspathContainer();
	//从Kie容器对象中获取会话对象
	KieSession kieSession = kieContainer.newKieSession();

	Student student = new Student();
	student.setAge(10);

	kieSession.insert(student);

	//激活规则，由Drools框架自动进行规则匹配，如果规则匹配成功，则执行当前规则
	kieSession.fireAllRules();

	//关闭会话
	kieSession.dispose();
}

通过控制台输出可以发现，只有第一个规则触发了，因为在第一个规则中将工作内存中的数据删除了导致第二个规则并没有匹配成功。

Drools规则属性

Drools中提供的属性如下表(部分属性)：

属性名	说明
salience	指定规则执行优先级
dialect	指定规则使用的语言类型，取值为java和mvel
enabled	指定规则是否启用
date-effective	指定规则生效时间
date-expires	指定规则失效时间
activation-group	激活分组，具有相同分组名称的规则只能有一个规则触发
agenda-group	议程分组，只有获取焦点的组中的规则才有可能触发
timer	定时器，指定规则触发的时间
auto-focus	自动获取焦点，一般结合agenda-group一起使用
no-loop	防止死循环

1.enabled属性

enabled属性对应的取值为true和false，默认值为true。

用于指定当前规则是否启用，如果设置的值为false则当前规则无论是否匹配成功都不会触发。

rule "rule_student_age等于10岁用于删除"
enabled false
salience 10  //权重，保重该规则先执行
    when
        $s:Student(age == 10)
    then
        retract($s);//删除内存中的对象
        System.out.println("规则rule_student_age等于10岁触发用于删除");
end

说明：

内存中的对象没有被删除，所以其他的规则被触发了。

2.dialect属性

dialect属性用于指定当前规则使用的语言类型，取值为java和mvel，默认值为mvel。

:::info

注：mvel是一种基于java语法的表达式语言。

mvel像正则表达式一样，有直接支持集合、数组和字符串匹配的操作符。

mvel还提供了用来配置和构造字符串的模板语言。

mvel表达式内容包括属性表达式，布尔表达式，方法调用，变量赋值，函数定义等。

:::

3.salience属性

salience属性用于指定规则的执行优先级，取值类型为Integer。数值越大越优先执行。每个规则都有一个默认的执行顺序，如果不设置salience属性，规则体的执行顺序为由上到下。

可以通过创建规则文件/resource/rules/salience.drl来测试salience属性，内容如下：

package rules;
dialect  "mvel"

rule "rule_1"
    when
        eval(true)
    then
        System.out.println("规则rule_1触发");
end

rule "rule_2"
    when
        eval(true)
    then
        System.out.println("规则rule_2触发");
end

rule "rule_3"
    when
        eval(true)
    then
        System.out.println("规则rule_3触发");
end

测试代码：

@Test
    public void test5(){
        KieServices kieServices = KieServices.Factory.get();
        KieContainer kieClasspathContainer = kieServices.getKieClasspathContainer();
        KieSession kieSession = kieClasspathContainer.newKieSession();
        int count = kieSession.fireAllRules();
        System.out.println("条数："+count);
    }

通过控制台可以看到，由于以上三个规则没有设置salience属性，所以执行的顺序是按照规则文件中规则的顺序由上到下执行的。接下来我们修改一下文件内容：

package rules;
dialect  "mvel"

rule "rule_1"
salience 15
    when
        eval(true)
    then
        System.out.println("规则rule_1触发");
end

rule "rule_2"
salience 20
    when
        eval(true)
    then
        System.out.println("规则rule_2触发");
end

rule "rule_3"
salience 10
    when
        eval(true)
    then
        System.out.println("规则rule_3触发");
end

可以看到，规则文件执行的顺序是按照我们设置的salience值由大到小顺序执行的。

建议在编写规则时使用salience属性明确指定执行优先级。

4.no-loop属性

no-loop属性用于防止死循环，当规则通过update之类的函数修改了Fact对象时，可能使当前规则再次被激活从而导致死循环。取值类型为Boolean，默认值为false。测试步骤如下：

第一步：编写规则文件/resource/rules/noloop.drl

package rules;
dialect  "mvel"
import drools.entity.Student

rule "noloop"
    no-loop true
    when
        $student:Student(age == 25)
    then
        update($student);//注意此处执行update会导致当前规则重新被激活
        System.out.println("规则rule_noloop触发");
end

第二步：编写单元测试

@Test
    public void test6(){
        KieServices kieServices = KieServices.Factory.get();
        KieContainer kieClasspathContainer = kieServices.getKieClasspathContainer();
        KieSession kieSession = kieClasspathContainer.newKieSession();
        Student fact=new Student();
        fact.setAge(25);
        fact.setName("张三");
        System.out.println(fact);
        kieSession.insert(fact);
        int count = kieSession.fireAllRules(new RuleNameEqualsAgendaFilter("noloop"));
        System.out.println("条数："+count);
        System.out.println(fact);
    }

由于没有设置no-loop属性的值，所以发生了死循环。接下来设置no-loop的值为true再次测试则不会发生死循环。

5.activation-group属性

activation-group属性是指激活分组，取值为String类型。具有相同分组名称的规则只能有一个规则被触发。

第一步：编写规则文件/resources/rules/activationgroup.drl

package rules;
dialect  "mvel"
/*
    此规则文件用于测试activation-group属性
*/
rule "rule_activationgroup_1"
    activation-group "mygroup"
    when
    then
        System.out.println("规则rule_activationgroup_1触发");
end
rule "rule_activationgroup_2"
    activation-group "mygroup"
    when
    then
        System.out.println("规则rule_activationgroup_2触发");
end

第二步：编写单元测试

@Test
    public void test7(){
        KieServices kieServices = KieServices.Factory.get();
        KieContainer kieClasspathContainer = kieServices.getKieClasspathContainer();
        KieSession kieSession = kieClasspathContainer.newKieSession();
        int count = kieSession.fireAllRules(new RuleNameStartsWithAgendaFilter("rule_activationgroup"));
        System.out.println("条数："+count);
        kieSession.dispose();
    }

两个规则因为属于同一个分组，所以只有一个触发了。同一个分组中的多个规则如果都能够匹配成功，具体哪一个最终能够被触发可以通过salience属性确定。

6.agenda-group属性

agenda-group属性为议程分组，属于另一种可控的规则执行方式。用户可以通过设置agenda-group来控制规则的执行，只有获取焦点的组中的规则才会被触发。

第一步：创建规则文件/resources/rules/agendagroup.drl

package rules;
dialect  "mvel"

/*
    此规则文件用于测试agenda-group属性
*/
rule "rule_agendagroup_1"
    agenda-group "myagendagroup_aaa"
    when
    then
        System.out.println("规则rule_agendagroup_1触发");
end

rule "rule_agendagroup_2"
    agenda-group "myagendagroup_aaa"
    when
    then
        System.out.println("规则rule_agendagroup_2触发");
end
//========================================================
rule "rule_agendagroup_3"
    agenda-group "myagendagroup_2"
    when
    then
        System.out.println("规则rule_agendagroup_3触发");
end

rule "rule_agendagroup_4"
    agenda-group "myagendagroup_2"
    when
    then
        System.out.println("规则rule_agendagroup_4触发");
end

第二步：编写单元测试

 @Test
    public void test8() {
        KieServices kieServices = KieServices.Factory.get();
        KieContainer kieClasspathContainer = kieServices.getKieClasspathContainer();
        KieSession kieSession = kieClasspathContainer.newKieSession();
        //设置焦点，对应agenda-group分组中的规则才可能被触发
        kieSession.getAgenda().getAgendaGroup("myagendagroup_2").setFocus();
        int count = kieSession.fireAllRules();
        System.out.println("条数：" + count);
        kieSession.dispose();
    }

只有获取焦点的分组中的规则才会触发。与activation-group不同的是，activation-group定义的分组中只能够有一个规则可以被触发，而agenda-group分组中的多个规则都可以被触发。

疑问：对于指定分组的规则，的确只运行指定分组的规则，但是，对于没有设置指定分组的规则，只要符合过滤条件的也会执行。

7.auto-focus属性

auto-focus属性为自动获取焦点，取值类型为Boolean，默认值为false。一般结合agenda-group属性使用，当一个议程分组未获取焦点时，可以设置auto-focus属性来控制。

第一步：修改/resources/rules/agendagroup.drl文件内容如下

package rules;
dialect  "mvel"

/*
    此规则文件用于测试agenda-group属性
*/
rule "rule_agendagroup_1"
    agenda-group "myagendagroup_1"
    auto-focus true
    when
    then
        System.out.println("规则rule_agendagroup_1触发");
end

rule "rule_agendagroup_2"
    agenda-group "myagendagroup_1"
    when
    then
        System.out.println("规则rule_agendagroup_2触发");
end
//========================================================
rule "rule_agendagroup_3"
    agenda-group "myagendagroup_2"
    when
    then
        System.out.println("规则rule_agendagroup_3触发");
end

rule "rule_agendagroup_4"
    agenda-group "myagendagroup_2"
    when
    then
        System.out.println("规则rule_agendagroup_4触发");
end

第二步：编写单元测试

@Test
    public void test9() {
        KieServices kieServices = KieServices.Factory.get();
        KieContainer kieClasspathContainer = kieServices.getKieClasspathContainer();
        KieSession kieSession = kieClasspathContainer.newKieSession();
        //设置焦点，对应agenda-group分组中的规则才可能被触发
        int count = kieSession.fireAllRules();
        System.out.println("条数：" + count);
        kieSession.dispose();
    }

设置auto-focus属性为true的规则都触发了。

疑问：经验证，发现只要agenda-group内有一个规则的auto-focus属性为true，该组内的所有规则都会执行。

8.timer属性

timer属性可以通过定时器的方式指定规则执行的时间，使用方式有两种：

:::info

方式一：timer (int: ?)

:::

此种方式遵循java.util.Timer对象的使用方式，第一个参数表示几秒后执行，第二个参数表示每隔几秒执行一次，第二个参数为可选。

:::info

方式二：timer(cron: )

:::

此种方式使用标准的unix cron表达式的使用方式来定义规则执行的时间。

第一步：创建规则文件/resources/rules/timer.drl

package rules;
dialect  "mvel"

import java.text.SimpleDateFormat
import java.util.Date
/*
    此规则文件用于测试timer属性
*/
rule "rule_timer_1"
    timer (5s 2s) //含义：5秒后触发，然后每隔2秒触发一次
    when
    then
        System.out.println("规则rule_timer_1触发，触发时间为：" +
                         new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
end

rule "rule_timer_2"
    timer (cron:0/1 * * * * ?) //含义：每隔1秒触发一次
    when
    then
        System.out.println("规则rule_timer_2触发，触发时间为：" +
                         new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
end

第二步：编写单元测试

 @Test
    public void test10() throws InterruptedException {
        KieServices kieServices = KieServices.Factory.get();
        KieContainer kieClasspathContainer = kieServices.getKieClasspathContainer();
        final KieSession kieSession = kieClasspathContainer.newKieSession();
        new Thread(new Runnable() {
            public void run() {
        //启动规则引擎进行规则匹配，直到调用halt方法才结束规则引擎
                kieSession.fireUntilHalt(new RuleNameStartsWithAgendaFilter("rule_timer"));
            }
        }).start();
        Thread.sleep(10000);
        //结束规则引擎
        kieSession.halt();
        kieSession.dispose();
    }

注意：单元测试的代码和以前的有所不同，因为我们规则文件中使用到了timer进行定时执行，需要程序能够持续一段时间才能够看到定时器触发的效果。

结果打印：

9.date-effective与date-expires属性

date-effective属性用于指定规则的生效时间，即只有当前系统时间大于等于设置的时间或者日期规则才有可能触发。默认日期格式为：dd-MMM-yyyy。用户也可以自定义日期格式。
date-expires属性用于指定规则的失效时间，即只有当前系统时间小于设置的时间或者日期规则才有可能触发。默认日期格式为：dd-MMM-yyyy。用户也可以自定义日期格式。

二者也可以单独使用

第一步：编写规则文件/resources/rules/dateeffective.drl

package rules;
dialect  "mvel"

/*
    此规则文件用于测试date-effective属性
*/
rule "rule_dateeffective_1"
date-effective "2020-08-01 10:00"
date-expires "2020-10-01 10:00"
    when
    then
        System.out.println("规则rule_dateeffective_1触发");
end

第二步：编写单元测试

@Test
    public void test11()  {
        System.setProperty("drools.dateformat","yyyy-MM-dd HH:mm");
        KieServices kieServices = KieServices.Factory.get();
        KieContainer kieClasspathContainer = kieServices.getKieClasspathContainer();
        KieSession kieSession = kieClasspathContainer.newKieSession();
        int count = kieSession.fireAllRules(new RuleNameEqualsAgendaFilter("rule_dateeffective_1"));
        System.out.println("条数：" + count);
        kieSession.dispose();
    }

6.Drools高级语法

1、global全局变量

:::tips

global关键字用于在规则文件中定义全局变量，它可以让应用程序的对象在规则文件中能够被访问。可以用来为规则文件提供数据或服务。

:::

语法结构为：global 对象类型对象名称

在使用global定义的全局变量时有两点需要注意：

对象类型为包装类型

如果对象类型为包装类型时，在一个规则中改变了global的值，那么只针对当前规则有效，对其他规则中的global不会有影响。可以理解为它是当前规则代码中的global副本，规则内部修改不会影响全局的使用。

第一步：编写global.drl

package testglobal
/*
    此规则文件用于测试global全局变量
*/
global java.lang.Integer count //定义一个包装类型的全局变量
 
rule "rule_global_1"
    when
    then
        count += 10;//对于包装类型的全局变量的修改只针对当前规则生效
        System.out.println("规则：rule_global_1触发了、、、");
        System.out.println("全局变量count计算之后的值为： " + count);
end
 
rule "rule_global_2"
    when
    then
        System.out.println("规则：rule_global_2触发了、、、");
        System.out.println("全局变量count计算之后的值为： " + count);
end

第二部，测试

@Test
    public void GlobalTest() {
        KieServices kieServices = KieServices.Factory.get();
        KieContainer kieContainer = kieServices.getKieClasspathContainer();
        KieSession kieSession = kieContainer.newKieSession();
        Integer count = 10;
        kieSession.setGlobal("count", count);
        kieSession.fireAllRules();
        kieSession.dispose();
        System.out.println("测试完成之后count：" + count);
    }

结果

对象是JavaBean类型的

:::tips

如果对象类型为集合类型或JavaBean时，在一个规则中改变了global的值，对java代码和所有规则都有效。

:::

package rules
import com.drools.entity.*

global java.util.List myGlobalList

rule "global_1"
when
     eval(true)
then
    myGlobalList.add("Global全局变量测试1");
    System.out.println("Global全局变量测试1");
end

rule "global_2"
when
     eval(true)
then
    myGlobalList.add("Global全局变量测试2");
    System.out.println("Global全局变量测试2");
end

rule "global_3"
when
     eval(true)
then
    myGlobalList.add("Global全局变量测试3");
    System.out.println("Global全局变量测试3");
end

测试

    @Test
    public void GlobalTest() {
        KieServices kieServices = KieServices.Factory.get();
        KieContainer kieContainer = kieServices.getKieClasspathContainer();
        KieSession kieSession = kieContainer.newKieSession();
        List<String> list = new ArrayList<>();
        kieSession.setGlobal("myGlobalList", list);
        kieSession.fireAllRules();
        kieSession.dispose();
        System.out.println("测试完成之后list：" + list);
    }

结果

2、query查询

query查询提供了一种查询working memory中符合约束条件的Fact对象的简单方法。它仅包含规则文件中的LHS部分，不用指定“when”和“then”部分并且以end结束。具体语法结构如下：

:::info

query 查询的名称(可选参数)

LHS

end

:::

具体操作步骤：

第一步：编写规则文件/resources/rules/query.drl

package rules
import com.drools.entity.*
    /*
此规则文件用于测试query查询
*/

    //不带参数的查询
    //当前query用于查询Working Memory中age>10的Student对象
 query "query_1"
    $student:Student(age > 10)
end

    
 query "query_2"(String sname)
        $student:Student(age > 5 && name == sname)
 end

第二步：编写单元测试

 @Test
    public void QueryTest() {
//        开启KieServices服务
        KieServices kieServices = KieServices.Factory.get();
        KieContainer kieContainer = kieServices.getKieClasspathContainer();
//        新建会话对象，用于和规则引擎交互
        KieSession kieSession = kieContainer.newKieSession();
//        不带参数的查询
        Student s1 = new Student();
        s1.setAge(21);
        kieSession.insert(s1);
        QueryResults rows = kieSession.getQueryResults("query_1");
        for (QueryResultsRow row : rows) {
            Student student = (Student) row.get("$student");
            System.out.println(student);
        }
        System.out.println("------------------------------------------------");
//        带参数的查询
        Student s2 = new Student();
        s2.setAge(31);
        s2.setName("lisi");
        kieSession.insert(s2);
        QueryResults rows2 = kieSession.getQueryResults("query_2", "lisi");
        for (QueryResultsRow row : rows2) {
            Student student = (Student) row.get("$student");
            System.out.println(student);
        }
//        执行全部的规则
        kieSession.fireAllRules();
//        关闭会话
        kieSession.dispose();

//        System.out.println("测试完成之后count：" + count);
    }

3、function函数

function关键字用于在规则文件中定义函数，就相当于java类中的方法一样。可以在规则体中调用定义的函数。使用函数的好处是可以将业务逻辑集中放置在一个地方，根据需要可以对函数进行修改。

函数定义的语法结构如下：

:::info

function 返回值类型函数名(可选参数){

逻辑代码

}

:::

具体操作步骤：

第一步：编写规则文件/resources/rules/function.drl

package rules
import com.drools.entity.Student
/*
    此规则文件用于测试function函数
*/
 
//定义一个函数
function String sayHello(String name)
{
    return "hello " + name;
}
 
rule "rule_function_1"
    when
        $student:Student(name != null)
    then
        //调用上面定义的函数
        String ret = sayHello($student.getName());
        System.out.println(ret);
end

第二步：编写单元测试

 @Test
    public void FunctionTest() {
//        开启KieServices服务
        KieServices kieServices = KieServices.Factory.get();
        KieContainer kieContainer = kieServices.getKieClasspathContainer();
//        新建会话对象，用于和规则引擎交互
        KieSession kieSession = kieContainer.newKieSession();
//        带参数的查询
        Student s2 = new Student();
        s2.setAge(31);
        s2.setName("李大爷");
        kieSession.insert(s2);
//        执行全部的规则
        kieSession.fireAllRules();
//        关闭会话
        kieSession.dispose();
    }

4、LHS加强

在规则体中的LHS部分是介于when和then之间的部分，主要用于模式匹配，只有匹配结果为true时，才会触发RHS部分的执行。

4.1、复合值限制in/not in

复合值限制是指超过一种匹配值的限制条件，类似于SQL语句中的in关键字。Drools规则体中的LHS部分可以使用in或者not in进行复合值的匹配。具体语法结构如下：

:::tips

Object(field in (比较值1,比较值2...))

:::

举例：

$s:Student(name in ("张三","李四","王五"))
$s:Student(name not in ("张三","李四","王五"))

4.2、条件元素eval

eval用于规则体的LHS部分，并返回一个Boolean类型的值。语法结构如下：

:::info

eval(表达式)

:::

举例：

:::tips

eval(true)

eval(false)

eval(1 == 1)

:::

4.3、条件元素not

not用于判断Working Memory中是否存在某个Fact对象，如果不存在则返回true，如果存在则返回false。语法结构如下：

:::info

not Object(可选属性约束)

:::

举例：

:::tips

not Student()

not Student(age < 10)

:::

4.4、条件元素exists

exists的作用与not相反，用于判断Working Memory中是否存在某个Fact对象，如果存在则返回true，不存在则返回false。语法结构如下：

exists Object(可选属性约束)

举例：

:::info

exists Student()

exists Student(age < 10 && name != null)

:::

在LHS部分进行条件编写时并没有使用exists也可以达到判断Working Memory中是否存在某个符合条件的Fact元素的目的，那么我们使用exists还有什么意义？

两者的区别：当向Working Memory中加入多个满足条件的Fact对象时，使用了exists的规则执行一次，不使用exists的规则会执行多次。

例如：

规则文件(只有规则体)

rule "使用exists的规则"
    when
        exists Student()
    then
        System.out.println("规则：使用exists的规则触发");
end

rule "没有使用exists的规则"
    when
        Student()
    then
        System.out.println("规则：没有使用exists的规则触发");
end

Java代码：

kieSession.insert(new Student());
kieSession.insert(new Student());
kieSession.fireAllRules();

上面第一个规则只会执行一次，因为Working Memory中存在两个满足条件的Fact对象，第二个规则会执行两次。

4.5、规则继承

:::info

规则之间可以使用extends关键字进行规则条件部分的继承，类似于java类之间的继承。

:::

例如：

rule "rule_1"
    when
        Student(age > 10)
    then
        System.out.println("规则：rule_1触发");
end

rule "rule_2" extends "rule_1" //继承上面的规则
    when
        /*
        此处的条件虽然只写了一个，但是从上面的规则继承了一个条件，
        所以当前规则存在两个条件，即Student(age < 20)和Student(age > 10)
        */
        Student(age < 20) 
    then
        System.out.println("规则：rule_2触发");
end

需要注意的是，只继承条件

5、RHS加强

RHS部分是规则体的重要组成部分，当LHS部分的条件匹配成功后，对应的RHS部分就会触发执行。一般在RHS部分中需要进行业务处理。

在RHS部分Drools为我们提供了一个内置对象，名称就是drools。

5.1、halt

halt方法的作用是立即终止后面所有规则的执行。

package testhalt
rule "rule_halt_1"
    when
    then
        System.out.println("规则：rule_halt_1触发");
        drools.halt();//立即终止后面所有规则执行
end

//当前规则并不会触发，因为上面的规则调用了halt方法导致后面所有规则都不会执行
rule "rule_halt_2"
    when
    then
        System.out.println("规则：rule_halt_2触发");
end

2、getWorkingMemory

getWorkingMemory方法的作用是返回工作内存对象。

package testgetWorkingMemory
rule "rule_getWorkingMemory"
    when
    then
        System.out.println(drools.getWorkingMemory());
end

3、getRule

getRule方法的作用是返回规则对象。

package testgetRule
rule "rule_getRule"
    when
    then
        System.out.println(drools.getRule());
end

6、规则文件编码规范

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

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

7.SpringBoot整合Drools

1.导入所需的依赖

<!-- drools规则引擎 -->
<dependency>
  <groupId>org.drools</groupId>
  <artifactId>drools-core</artifactId>
  <version>7.6.0.Final</version>
</dependency>
<dependency>
  <groupId>org.drools</groupId>
  <artifactId>drools-templates</artifactId>
  <version>7.6.0.Final</version>
</dependency>
<dependency>
  <groupId>org.drools</groupId>
  <artifactId>drools-compiler</artifactId>
  <version>7.6.0.Final</version>
</dependency>
<dependency>
  <groupId>org.kie</groupId>
  <artifactId>kie-spring</artifactId>
  <version>7.6.0.Final</version>
</dependency>
<dependency>
  <groupId>org.kie</groupId>
  <artifactId>kie-api</artifactId>
  <version>7.6.0.Final</version>
</dependency>

2.创建Drools的配置类DroolsConfig

/**
* @BelongsProject:Drools
* @BelongsPackage:com.drools.config
* @Description:Drools的配置类
* @Version:1.0
*/
@Configuration
public class DroolsConfig {
        //    指定规则文件的目录
        private static final String RULES_PATH = "rules/";
        private final KieServices kieServices = KieServices.Factory.get();

        @Bean
    // 保证spring容器里只有一个类似的Bean
        @ConditionalOnMissingBean
        public KieFileSystem kieFileSystem() throws IOException {
            KieFileSystem kieFileSystem = kieServices.newKieFileSystem();
            PathMatchingResourcePatternResolver resourcePatternResolver =
                new PathMatchingResourcePatternResolver();
            Resource[] files = resourcePatternResolver.getResources("classpath*:" + RULES_PATH + "*.*");

            String path = null;
            for (Resource file : files) {
                path = RULES_PATH + file.getFilename();
                kieFileSystem.write(ResourceFactory.newClassPathResource(path, "UTF-8"));
            }
            return kieFileSystem;
        }

        @Bean
        @ConditionalOnMissingBean
        public KieContainer kieContainer() throws IOException {
            KieRepository kieRepository = kieServices.getRepository();
            kieRepository.addKieModule(kieRepository::getDefaultReleaseId);
            KieBuilder kieBuilder = kieServices.newKieBuilder(kieFileSystem());
            kieBuilder.buildAll();
            return kieServices.newKieContainer(kieRepository.getDefaultReleaseId());
        }

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

        @Bean
        @ConditionalOnMissingBean
        public KModuleBeanFactoryPostProcessor kModuleBeanFactoryPostProcessor() {
            return new KModuleBeanFactoryPostProcessor();
        }
    }

3.编写规则文件

package rules
import com.drools.entity.*

rule "rule_1"
when
  $order:Order(originalPrice>100)
then
  $order.setRealPrice(120D);
  System.out.println("第一条规则");
end

4、编写Service层

/**
 * @BelongsProject:Drools
 * @BelongsPackage:com.drools.service
 * @Description:TODO
 * @Version:1.0
 */
@Service
public class RuleService {
    @Autowired
    private KieBase kieBase;

    public Order executeRule(Order order) {
//        获取KieSession会话
        KieSession kieSession = kieBase.newKieSession();
//        插入事实对象
        kieSession.insert(order);
//        执行规则引擎
        kieSession.fireAllRules();
//        关闭会话
        kieSession.dispose();
        return order;
    }
}