规则引擎Drools介绍、使用及SpringBoot整合Drools

红太狼 2022-09-11 07:14 577阅读 0赞

### 规则引擎Drools介绍、使用及SpringBoot整合Drools ###

*  一、Drools介绍
 *   *  1.1 优点
     *  1.2 架构
     *   *  1.2.1 Drools引擎的核心组件
         *  1.2.2 规则引擎工作流程简述
     *  1.3 Drools语法
     *   *  1.3.1 规则文件
         *   *   *  1.3.1.1. 规则详情
                 *   *  1. 属性详情
                     *  2. 条件部分- LHS
                     *  3. 结果部分- RHS
                 *  1.3.1.2 Drools关键词
                 *  1.3.1.3 Drools方法定义
                 *  1.3.1.4 Drools声明类型
                 *   *  1. 声明类类型
                     *  2. 声明枚举类型
                     *  3. 声明元数据类型
     *  1.4 设计
     *  1.5 Drools vs ILog vs Jess vs Mandarax
     *   *  1.5.1 推理方式
 *  二、Drools使用
 *   *  2.1 Drools的基本使用
     *  2.2 Drools基础语法
     *   *  2.2.1 规则文件构成
         *  2.2.2 规则体语法结构
         *  2.2.3 注释
         *  2.2.4 Pattern模式匹配
         *  2.2.5 比较操作符
         *   *  2.2.5.1 语法
             *  2.2.5.2 操作步骤
         *  2.2.6 执行指定规则
         *  2.2.7 关键字
         *  2.2.8 Drools内置方法
         *   *  2.2.8.1 update方法
             *  2.2.8.2 insert方法
             *  2.2.8.3 retract方法
     *  2.3 规则属性attributes
     *   *  2.3.1 enabled属性
         *  2.3.2 dialect属性
         *  2.3.3 salience属性
         *  2.3.4 no-loop属性
         *  2.3.5 activation-group属性
         *  2.3.6 agenda-group属性
         *  2.3.7 auto-focus属性
         *  2.3.8 timer属性
         *  2.3.9 date-effective属性
         *  2.3.10 date-expires属性
     *  2.4 Drools高级语法
     *   *  2.4.1 global全局变量
         *  2.4.2 query查询
         *  2.4.3 function函数
         *  2.4.4 LHS加强
         *   *  2.4.4.1 复合值限制in/not in
             *  2.4.4.2 条件元素eval
             *  2.4.4.3 条件元素not
             *  2.4.4.4 条件元素exists
             *  2.4.4.5 规则继承
         *  2.4.5 RHS加强
         *   *  2.4.5.1 halt
             *  2.4.5.2 getWorkingMemory
             *  2.4.5.3 getRule
         *  2.4.6 规则文件编码规范（重要）
 *  三、SpringBoot整合Drools

*  [Drools介绍与使用][Drools]

# 一、Drools介绍 #

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

Drools使用 Rete 算法对所编写的规则求值。Drools 允许使用声明方式表达业务逻辑。

可以使用非 XML 的本地语言编写规则，从而便于学习和理解。并且，还可以将 Java 代码直接嵌入到规则文件中，这令 Drools 的学习更加吸引人。

官网：[http://www.drools.org/\#][http_www.drools.org]  
官方文档：[http://www.drools.org/learn/documentation.html][http_www.drools.org_learn_documentation.html]

## 1.1 优点 ##

*  非常活跃的社区支持
 *  易用
 *  快速的执行速度
 *  在 Java 开发人员中流行
 *  与 Java Rule Engine API（JSR 94）兼容

## 1.2 架构 ##

Drools 是业务逻辑集成平台，被分为4个项目：

*  Drools Guvnor (BRMS/BPMS)：业务规则管理系统
 *  Drools Expert (rule engine)：规则引擎，drools的核心部分
 *  Drools Flow (process/workflow)：工作流引擎
 *  Drools Fusion (cep/temporal reasoning)：事件处理

### 1.2.1 Drools引擎的核心组件 ###

▶Rules：所有的业务规则和决策表都叫做规则。所有的规则都由规则条件校验（LHS 或conditions）和逻辑处理（RHS 或 actions）两部分组成；
    
    ▶Facts：业务数据或者称之为“事实”。所有加入到规则引擎的数据或者规则产生的数据都叫“事实”，规则引擎会根据规则或决策表过滤和加工这些数据。
    
    ▶Production memory：生产内存。当程序运行时，用于存储rules。
    
    ▶Working memory：工作内存。当程序运行时，所有facts都存储在这里。
    
    ▶Agenda：在规则引擎中注册和排序所有匹配实例（符合规则条件的数据 和 这一规则（或 一组规则）被称之为匹配实例），并激活匹配实例。

### 1.2.2 规则引擎工作流程简述 ###

1、当业务数据被加入到规则引擎中后，它们会以一个或多个“事实”的形式被存储在工作内存中；

2、这些“事实”会与存储在生产内存中规则集合依次匹配，以确定哪些数据符合规则条件；

3、符合条件的数据与相应的规则组成 匹配实例被注册到agenda，然后依据规则的优先级等规则冲突策略对 匹配实例进行排序，以确定这些匹配实例的执行顺序并激活它们。

## 1.3 Drools语法 ##

### 1.3.1 规则文件 ###

规则文件可以使用 .drl文件，也可以是xml文件，这里我们使用drl文件

![img][]

规则文件

package：对一个规则文件而言，package是必须定义的，必须放在规则文件第一行，package的名字是随意的，不必必须对应物理路径，跟java的package的概念不同，这里只是逻辑上的一种区分

如：
    package com.sankuai.meituan.waimai.drools.demo

import：导入规则文件需要使用到的外部规则文件或者变量，这里的使用方法跟java相同，但是不同于java的是，这里的import导入的不仅仅可以是一个类，也可以是这个类中的某一个可访问的静态方法

import com.drools.demo.point.PointDomain;

rule：定义一个具体规则。rule “ruleName”。一个规则可以包含三个部分：

*  **`属性部分：`** 定义当前规则执行的一些属性等，比如是否可被重复执行、过期时间、生效时间等。
 *  **`条件部分（LHS）：`** 定义当前规则的条件，如 when Message(); 判断当前workingMemory中是否存在Message对象。
 *  **`结果部分(RHS)：`** 即当前规则条件满足后执行的操作，可以直接调用Fact对象的方法来操作应用。这里可以写普通java代码

![img][img 1]

rule部分

rule "ruleName"
         no-loop true
    
     <span class="hljs-keyword">when</span>
         $message<span class="hljs-symbol">:Message</span>(status == <span class="hljs-number">0</span>)
    
     <span class="hljs-keyword">then</span>
         System.out.println(<span class="hljs-string">"fit"</span>);
         $message.setStatus(<span class="hljs-number">1</span>);
         update($message);

##### 1.3.1.1. 规则详情 #####

###### 1. 属性详情 ######

*  **no-loop：** `定义当前的规则是否不允许多次循环执行，默认是false`；当前的规则只要满足条件，可以无限次执行。什么情况下会出现一条规则执行过一次又被多次重复执行呢？drools提供了一些api，可以对当前传入workingMemory中的Fact对象进行修改或者个数的增减，比如上述的update方法，就是将当前的workingMemory中的Message类型的Fact对象进行属性更新，这种操作会触发规则的重新匹配执行，可以理解为Fact对象更新了，所以规则需要重新匹配一遍，那么疑问是之前规则执行过并且修改过的那些Fact对象的属性的数据会不会被重置？结果是不会，已经修改过了就不会被重置，update之后，之前的修改都会生效。当然对Fact对象数据的修改并不是一定需要调用update才可以生效，简单的使用set方法设置就可以完成，这里类似于java的引用调用，所以何时使用update是一个需要仔细考虑的问题，一旦不慎，极有可能会造成规则的死循环。上述的no-loop true，即设置当前的规则，只执行一次，如果本身的RHS部分有update等触发规则重新执行的操作，也不要再次执行当前规则。  
    但是其他的规则会被重新执行，岂不是也会有可能造成多次重复执行，数据紊乱甚至死循环？答案是使用其他的标签限制，也是可以控制的：lock-on-active true
 *  **lock-on-active**：lock-on-active true 通过这个标签，可以控制当前的规则只会被执行一次，因为一个规则的重复执行不一定是本身触发的，也可能是其他规则触发的，所以这个是no-loop的加强版
 *  **date-expires**：设置规则的过期时间，默认的时间格式：“日-月-年”
 *  **date-effective**：设置规则的生效时间，时间格式同上。
 *  **duration**：规则定时，duration 3000，3秒后执行规则
 *  **salience**：优先级，数值越大越先执行，这个可以控制规则的执行顺序。

![img][img 2]

**rule attributes**

###### 2. 条件部分- LHS ######

*  **when**：规则条件开始。条件可以单个，也可以多个，多个条件一次排列  
    如：当前规则只有在这三个条件都匹配的时候才会执行RHS部分

when
          eval(true)
          $customer:Customer()
          $message:Message(status==0)

*  **eval(true)**：是一个默认的api，true 无条件执行，类似于 while(true)
 *  **操作符**：`>`、`>=`、`<`、`<=`、`==`、`!=`、`contains`、`not contains`、`memberOf`、`not memberOf`、`matches`、`not matches`

![img][img 3]

操作符

>  *  **contains：** 对比是否包含操作，操作的被包含目标可以是一个复杂对象也可以是一个简单的值  
>     `Person( fullName not contains "Jr" )`
>  *  not contains：与contains相反。
>  *  memberOf：判断某个Fact属性值是否在某个集合中，与contains不同的是他被比较的对象是一个集合，而contains被比较的对象是单个值或者对象  
>     `CheeseCounter( cheese memberOf $matureCheeses )`
>  *  **not memberOf**：与memberOf正好相反
>  *  **matches**：正则表达式匹配  
>     `Cheese( type matches "(Buffalo)?\\S*Mozarella" )`  
>     **`注意：`** `就像在Java中，写为字符串的正则表达式需要转义“\”`
>  *  not matches：与matches正好相反

###### 3. 结果部分- RHS ######

当规则条件满足，则进入规则结果部分执行，结果部分可以是纯java代码

*  **then：**

then
         System.out.println("OK"); //会在控制台打印出ok
    end

*  insert：往当前workingMemory中插入一个新的Fact对象，会触发规则的再次执行，除非使用no-loop限定
 *  update：更新
 *  modify：修改，与update语法不同，结果都是更新操作
 *  retract：删除

rule "Rule 03" 
          when 
              $number : Number( ) 
              not Number( intValue < $number.intValue ) 
          then 
              System.out.println("Number found with value: " + $number.intValue() ); 
              retract( $number );
    end

##### 1.3.1.2 Drools关键词 #####

<table> 
 <thead> 
  <tr> 
   <th align="center">关键词</th> 
   <th>描述</th> 
   <th>详情</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">lock-on-active</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">date-effective</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">date-expires</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">no-loop</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">auto-focus</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">activation-group</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">agenda-group</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">ruleflow-group</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">entry-point</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">duration</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">package</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">import</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">dialect</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">salience</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">enabled</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">attributes</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">rule</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">extend</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">when</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">then</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">template</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">query</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">declare</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">function</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">global</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">eval</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">not</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">in</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">or</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">and</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">exists</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">forall</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">accumulate</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">collect</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">from</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">action</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">reverse</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">result</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">end</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">over</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">init</td> 
   <td></td> 
   <td>-</td> 
  </tr> 
 </tbody> 
</table>

##### 1.3.1.3 Drools方法定义 #####

*  **function**

function String hello(String name) { 
          return "Hello "+name+"!";
    }

##### 1.3.1.4 Drools声明类型 #####

*  declare：声明类型

>  *  声明Class、Enum etc类型
>  *  声明元数据

###### 1. 声明类类型 ######

declare  Address 
        number : int 
        streetName : String 
        city : String
    end

###### 2. 声明枚举类型 ######

declare enum DaysOfWeek
        SUN("Sunday"),MON("Monday"),TUE("Tuesday"),WED("Wednesday"),THU("Thursday"),FRI("Friday"),SAT("Saturday"); 
        fullName : String
    end

###### 3. 声明元数据类型 ######

元数据可以被分配给在Drools中几个不同的结构：

*  fact types
 *  fact attributes
 *  rules

定义格式：
    @metadata_key(metadata_value)
    例子：
    @author( Bob )
    import java.util.Date
    declare Person
    @author( Bob )
    @dateOfCreation( 01-Feb-2009 )
    name : String @key @maxLength( 30 )
    dateOfBirth : Date address : Address
    end

**声明元数据类级别 关键词**

*  `@role( <fact | event> )`

import some.package.StockTick
    declare StockTick 
        @role ( event )
    end

*  `@typesafe( <boolean> )`
 *  `@timestamp( <attribute name> )`

declare VoiceCall 
        @role( event ) 
        @timestamp( callDateTime )
    end

*  `@duration( <attribute name> )`
 *  `@expires( <time interval> )`
 *  `@propertyChangeSupport`
 *  `@propertyReactive`

**声明元数据属性级别 关键词**

*  `@key`

>     两个方面影响：
> 
>  *  `根据@key作为类标识符，类比较以 @key 的字段为准`
>  *  `根据@key字段生成构造函数`

declare Person 
        firstName : String @key 
        lastName : String @key 
        age : int
    end

*  `@position`

declare Cheese 
        name : String @position(1) 
        shop : String @position(2) 
        price : int @position(0)
    end

## 1.4 设计 ##

![img][img 4]

## 1.5 Drools vs ILog vs Jess vs Mandarax ##

<table> 
 <thead> 
  <tr> 
   <th align="center"></th> 
   <th>优点</th> 
   <th></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">Drools</td> 
   <td>开源、社区非常活跃、易使用、免费、JSR94兼容（JSR94是Java Rule Engine API)、支持Java、强大的工具集</td> 
   <td>只支持一种推理方式、安全性不够</td> 
  </tr> 
  <tr> 
   <td align="center">ILog</td> 
   <td>性能高（电信领域使用）、易使用</td> 
   <td>商业产品、不开源</td> 
  </tr> 
  <tr> 
   <td align="center">Jess</td> 
   <td>支持2种推理方式（正向链和反向链）、很强的表示、推理能力、支持AOP</td> 
   <td>不开源、无规则管理工具、不易使用</td> 
  </tr> 
  <tr> 
   <td align="center">Mandarax</td> 
   <td>开源、免费、支持Java</td> 
   <td>JSR94不兼容（JSR94是Java Rule Engine API）、已经不更新、社区不活跃、并且文档不全</td> 
  </tr> 
 </tbody> 
</table>

### 1.5.1 推理方式 ###

*  正向链推理：一条由问题开始搜索，并得到其解答的链称为正向链推理。
 *  反向链推理：一条由假设回推到支持该假设的事实的链称为反向链推理。

# 二、Drools使用 #

## 2.1 Drools的基本使用 ##

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

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

如果我们使用IDEA开发drools应用，IDEA中已经集成了drools插件。如果使用eclipse开发drools应用还需要单独安装drools插件。

drools API开发步骤如下：

[![5][]][5 1]

## 2.2 Drools基础语法 ##

### 2.2.1 规则文件构成 ###

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

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

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

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

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

### 2.2.2 规则体语法结构 ###

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

规则体语法结构如下：

rule "ruleName"
        attributes
        when
            LHS 
        then
            RHS
    end

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

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

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

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

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

**RHS**(Right Hand Side)：是规则的后果或行动部分的通用名称。 （右手边）

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

### 2.2.3 注释 ###

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

单行注释用"//“进行标记，多行注释以”/*“开始，以”*/"结束。如下示例：

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

### 2.2.4 Pattern模式匹配 ###

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

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

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

例如我们的入门案例中：

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

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

1、工作内存中必须存在Order这种类型的Fact对象-----类型约束

2、Fact对象的originalPrice属性值必须小于200------属性约束

3、Fact对象的originalPrice属性值必须大于等于100------属性约束

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

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

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

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

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

### 2.2.5 比较操作符 ###

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

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

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

#### 2.2.5.1 语法 ####

*  **contains | not contains语法结构**
    
    Object(Field\[Collection/Array\] contains value)
    
    Object(Field\[Collection/Array\] not contains value)
 *  **memberOf | not memberOf语法结构**
    
    Object(field memberOf value\[Collection/Array\])
    
    Object(field not memberOf value\[Collection/Array\])
 *  **matches | not matches语法结构**
    
    Object(field matches “正则表达式”)
    
    Object(field not matches “正则表达式”)

contain是前面包含后面，memberOf是后面包含前面。

#### 2.2.5.2 操作步骤 ####

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

package com.itheima.drools.entity;
    import java.util.List;
    
    /** * 实体类 * 用于测试比较操作符 */
    public class ComparisonOperatorEntity { 
        private String names;
        private List<String> list;
    
        public String getNames() { 
            return names;
        }
    
        public void setNames(String names) { 
            this.names = names;
        }
    
        public List<String> getList() { 
            return list;
        }
    
        public void setList(List<String> list) { 
            this.list = list;
        }
    }

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

package comparisonOperator
    import com.itheima.drools.entity.ComparisonOperatorEntity
    /* 当前规则文件用于测试Drools提供的比较操作符 */
    
    //测试比较操作符contains
    rule "rule_comparison_contains"
        when
            ComparisonOperatorEntity(names contains "张三")
            ComparisonOperatorEntity(list contains names)
        then
            System.out.println("规则rule_comparison_contains触发");
    end
    
    //测试比较操作符not contains
    rule "rule_comparison_notContains"
        when
            ComparisonOperatorEntity(names not contains "张三")
            ComparisonOperatorEntity(list not contains names)
        then
            System.out.println("规则rule_comparison_notContains触发");
    end
    
    //测试比较操作符memberOf
    rule "rule_comparison_memberOf"
        when
            ComparisonOperatorEntity(names memberOf list)
        then
            System.out.println("规则rule_comparison_memberOf触发");
    end
    
    //测试比较操作符not memberOf
    rule "rule_comparison_notMemberOf"
        when
            ComparisonOperatorEntity(names not memberOf list)
        then
            System.out.println("规则rule_comparison_notMemberOf触发");
    end
    
    //测试比较操作符matches
    rule "rule_comparison_matches"
        when
            ComparisonOperatorEntity(names matches "张.*")
        then
            System.out.println("规则rule_comparison_matches触发");
    end
    
    //测试比较操作符not matches
    rule "rule_comparison_notMatches"
        when
            ComparisonOperatorEntity(names not matches "张.*")
        then
            System.out.println("规则rule_comparison_notMatches触发");
    end

第三步：编写单元测试

//测试比较操作符
    @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);
    
        kieSession.fireAllRules();
        kieSession.dispose();
    }

### 2.2.6 执行指定规则 ###

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

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

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);
    
    //通过规则过滤器实现只执行指定规则
    kieSession.fireAllRules(new RuleNameEqualsAgendaFilter("rule_comparison_memberOf"));
    
    kieSession.dispose();

### 2.2.7 关键字 ###

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

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

硬关键字包括：true false null

软关键字包括：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

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

### 2.2.8 Drools内置方法 ###

规则文件的`RHS`部分的主要作用是通过**插入，删除或修改工作内存中的Fact数据**，来达到控制规则引擎执行的目的。Drools提供了一些方法可以用来操作工作内存中的数据，\*\*操作完成后规则引擎会重新进行相关规则的匹配，\*\*原来没有匹配成功的规则在我们修改数据完成后有可能就会匹配成功了。

创建如下实体类：

package com.itheima.drools.entity;
    
    import java.util.List;
    
    /** * 学生 */
    public class Student { 
        private int id;
        private String name;
        private int age;
        
        public int getId() { 
            return id;
        }
    
        public void setId(int id) { 
            this.id = id;
        }
    
        public String getName() { 
            return name;
        }
    
        public void setName(String name) { 
            this.name = name;
        }
    
        public int getAge() { 
            return age;
        }
    
        public void setAge(int age) { 
            this.age = age;
        }
    }

#### 2.2.8.1 update方法 ####

**update方法的作用是更新工作内存中的数据，并让相关的规则重新匹配。** （要避免死循环）

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

package student
    import com.itheima.drools.entity.Student
    
    /* 当前规则文件用于测试Drools提供的内置方法 */
    
    rule "rule_student_age小于10岁"
        when
            $s:Student(age < 10)
        then
            $s.setAge(15);
            update($s);//更新数据，导致相关的规则会重新匹配
            System.out.println("规则rule_student_age小于10岁触发");
    end
    
    rule "rule_student_age小于20岁同时大于10岁"
        when
            $s:Student(age < 20 && age > 10)
        then
            $s.setAge(25);
            update($s);//更新数据，导致相关的规则会重新匹配
            System.out.println("规则rule_student_age小于20岁同时大于10岁触发");
    end
    
    rule "rule_student_age大于20岁"
        when
            $s:Student(age > 20)
        then
            System.out.println("规则rule_student_age大于20岁触发");
    end

第二步：编写单元测试

KieServices kieServices = KieServices.Factory.get();
    KieContainer kieClasspathContainer = kieServices.getKieClasspathContainer();
    KieSession kieSession = kieClasspathContainer.newKieSession();
    
    Student student = new Student();
    student.setAge(5);
    
    //将数据提供给规则引擎，规则引擎会根据提供的数据进行规则匹配，如果规则匹配成功则执行规则
    kieSession.insert(student);
    
    kieSession.fireAllRules();
    kieSession.dispose();

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

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

#### 2.2.8.2 insert方法 ####

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

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

package student
    import com.itheima.drools.entity.Student
    
    /* 当前规则文件用于测试Drools提供的内置方法 */
    
    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
    
    rule "rule_student_age小于10岁"
        when
            $s:Student(age < 10)
        then
            $s.setAge(15);
            update($s);
            System.out.println("规则rule_student_age小于10岁触发");
    end
    
    rule "rule_student_age小于20岁同时大于10岁"
        when
            $s:Student(age < 20 && age > 10)
        then
            $s.setAge(25);
            update($s);
            System.out.println("规则rule_student_age小于20岁同时大于10岁触发");
    end
    
    rule "rule_student_age大于20岁"
        when
            $s:Student(age > 20)
        then
            System.out.println("规则rule_student_age大于20岁触发");
    end

第二步：编写单元测试

KieServices kieServices = KieServices.Factory.get();
    KieContainer kieClasspathContainer = kieServices.getKieClasspathContainer();
    KieSession kieSession = kieClasspathContainer.newKieSession();
    
    Student student = new Student();
    student.setAge(10);
    
    //将数据提供给规则引擎，规则引擎会根据提供的数据进行规则匹配，如果规则匹配成功则执行规则
    kieSession.insert(student);
    
    kieSession.fireAllRules();
    kieSession.dispose();

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

#### 2.2.8.3 retract方法 ####

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

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

package student
    import com.itheima.drools.entity.Student
    
    /* 当前规则文件用于测试Drools提供的内置方法 */
    
    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
    
    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
    
    rule "rule_student_age小于10岁"
        when
            $s:Student(age < 10)
        then
            $s.setAge(15);
            update($s);
            System.out.println("规则rule_student_age小于10岁触发");
    end
    
    rule "rule_student_age小于20岁同时大于10岁"
        when
            $s:Student(age < 20 && age > 10)
        then
            $s.setAge(25);
            update($s);
            System.out.println("规则rule_student_age小于20岁同时大于10岁触发");
    end
    
    rule "rule_student_age大于20岁"
        when
            $s:Student(age > 20)
        then
            System.out.println("规则rule_student_age大于20岁触发");
    end

第二步：编写单元测试

KieServices kieServices = KieServices.Factory.get();
    KieContainer kieClasspathContainer = kieServices.getKieClasspathContainer();
    KieSession kieSession = kieClasspathContainer.newKieSession();
    
    Student student = new Student();
    student.setAge(10);
    
    //将数据提供给规则引擎，规则引擎会根据提供的数据进行规则匹配，如果规则匹配成功则执行规则
    kieSession.insert(student);
    
    kieSession.fireAllRules();
    kieSession.dispose();

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

## 2.3 规则属性attributes ##

前面我们已经知道了规则体的构成如下：

rule "ruleName"
        attributes
        when
            LHS
        then
            RHS
    end

本章节就是针对规则体的**attributes**属性部分进行讲解。Drools中提供的属性如下表(部分属性)：

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

### 2.3.1 enabled属性 ###

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

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

rule "rule_comparison_notMemberOf"
        //指定当前规则不可用，当前规则无论是否匹配成功都不会执行
        enabled false
        when
            ComparisonOperatorEntity(names not memberOf list)
        then
            System.out.println("规则rule_comparison_notMemberOf触发");
    end

### 2.3.2 dialect属性 ###

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

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

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

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

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

### 2.3.3 salience属性 ###

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

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

package test.salience
    
    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

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

package testsalience
    
    rule "rule_1"
        salience 9
        when
            eval(true)
        then
            System.out.println("规则rule_1触发");
    end
    
    rule "rule_2"
        salience 10
        when
            eval(true)
        then
            System.out.println("规则rule_2触发");
    end
    
    rule "rule_3"
        salience 8
        when
            eval(true)
        then
            System.out.println("规则rule_3触发");
    end

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

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

### 2.3.4 no-loop属性 ###

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

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

package testnoloop
    import com.itheima.drools.entity.Student
    /* 此规则文件用于测试no-loop属性 */
    rule "rule_noloop"
        when
            // no-loop true
            $student:Student(age == 25)
        then
            update($student);//注意此处执行update会导致当前规则重新被激活
            System.out.println("规则rule_noloop触发");
    end

第二步：编写单元测试

KieServices kieServices = KieServices.Factory.get();
    KieContainer kieClasspathContainer = kieServices.getKieClasspathContainer();
    KieSession kieSession = kieClasspathContainer.newKieSession();
    
    Student student = new Student();
    student.setAge(25);
    
    //将数据提供给规则引擎，规则引擎会根据提供的数据进行规则匹配，如果规则匹配成功则执行规则
    kieSession.insert(student);
    
    kieSession.fireAllRules();
    kieSession.dispose();

通过控制台可以看到，由于我们没有设置no-loop属性的值，所以发生了死循环。接下来设置no-loop的值为true再次测试则不会发生死循环。

### 2.3.5 activation-group属性 ###

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

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

package testactivationgroup
    /* 此规则文件用于测试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

第二步：编写单元测试

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

### 2.3.6 agenda-group属性 ###

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

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

package testagendagroup
    /* 此规则文件用于测试agenda-group属性 */
    rule "rule_agendagroup_1"
        agenda-group "myagendagroup_1"
        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

第二步：编写单元测试

KieServices kieServices = KieServices.Factory.get();
    KieContainer kieClasspathContainer = kieServices.getKieClasspathContainer();
    KieSession kieSession = kieClasspathContainer.newKieSession();
    
    //设置焦点，对应agenda-group分组中的规则才可能被触发
    kieSession.getAgenda().getAgendaGroup("myagendagroup_1").setFocus();
    
    kieSession.fireAllRules();
    kieSession.dispose();

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

### 2.3.7 auto-focus属性 ###

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

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

package testagendagroup
    
    rule "rule_agendagroup_1"
        agenda-group "myagendagroup_1"
        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"
        auto-focus true //自动获取焦点
        when
        then
            System.out.println("规则rule_agendagroup_3触发");
    end
    
    rule "rule_agendagroup_4"
        agenda-group "myagendagroup_2"
        auto-focus true //自动获取焦点
        when
        then
            System.out.println("规则rule_agendagroup_4触发");
    end

第二步：编写单元测试

通过控制台可以看到，设置auto-focus属性为true的规则都触发了。

注意：同一个组，只要有个设置auto-focus true 其他的设置不设置都无所谓啦。都会起作用的。

### 2.3.8 timer属性 ###

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

**方式一**：timer (int: ?)

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

**方式二**：timer(cron: )

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

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

package testtimer
    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

第二步：编写单元测试

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

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

### 2.3.9 date-effective属性 ###

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

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

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

第二步：编写单元测试

//设置日期格式
    System.setProperty("drools.dateformat","yyyy-MM-dd HH:mm");
    KieServices kieServices = KieServices.Factory.get();
    KieContainer kieClasspathContainer = kieServices.getKieClasspathContainer();
    KieSession kieSession = kieClasspathContainer.newKieSession();
    kieSession.fireAllRules();
    kieSession.dispose();

注意：上面的代码需要设置日期格式，否则我们在规则文件中写的日期格式和默认的日期格式不匹配程序会报错。

### 2.3.10 date-expires属性 ###

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

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

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

第二步：编写单元测试

注意：上面的代码需要设置日期格式，否则我们在规则文件中写的日期格式和默认的日期格式不匹配程序会报错。

## 2.4 Drools高级语法 ##

前面章节我们已经知道了一套完整的规则文件内容构成如下：

本章节我们就来学习其中的几个关键字。

### 2.4.1 global全局变量 ###

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

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

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

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

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

下面我们通过代码进行验证：

第一步：创建UserService类

package com.itheima.drools.service;
    
    public class UserService { 
        public void save(){ 
            System.out.println("UserService.save()...");
        }
    }

第二步：编写规则文件/resources/rules/global.drl

package testglobal
    /* 此规则文件用于测试global全局变量 */
    
    global java.lang.Integer count //定义一个包装类型的全局变量
    global com.itheima.drools.service.UserService userService //定义一个JavaBean类型的全局变量
    global java.util.List gList //定义一个集合类型的全局变量
    
    rule "rule_global_1"
        when
        then
            count += 10; //全局变量计算，只对当前规则有效，其他规则不受影响
            userService.save();//调用全局变量的方法
            gList.add("itcast");//向集合类型的全局变量中添加元素，Java代码和所有规则都受影响
            gList.add("itheima");
            System.out.println("count=" + count);
            System.out.println("gList.size=" + gList.size());
    end
    
    rule "rule_global_2"
        when
        then
            userService.save();
            System.out.println("count=" + count);
            System.out.println("gList.size=" + gList.size());
    end

第三步：编写单元测试

KieServices kieServices = KieServices.Factory.get();
    KieContainer kieClasspathContainer = kieServices.getKieClasspathContainer();
    KieSession kieSession = kieClasspathContainer.newKieSession();
    
    //设置全局变量，名称和类型必须和规则文件中定义的全局变量名称对应
    kieSession.setGlobal("userService",new UserService());
    kieSession.setGlobal("count",5);
    List list = new ArrayList();//size为0
    kieSession.setGlobal("gList",list);
    
    kieSession.fireAllRules();
    kieSession.dispose();
    
    //因为在规则中为全局变量添加了两个元素，所以现在的size为2
    System.out.println(list.size());

注意：

后面的代码中定义了全局变量以后，前面的test都需要加，不然会出错。

### 2.4.2 query查询 ###

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

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

具体操作步骤：

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

package testquery
    import com.itheima.drools.entity.Student
    /* 此规则文件用于测试query查询 */
    
    //不带参数的查询
    //当前query用于查询Working Memory中age>10的Student对象
    query "query_1"
        $student:Student(age > 10)
    end
    
    //带有参数的查询
    //当前query用于查询Working Memory中age>10同时name需要和传递的参数name相同的Student对象
    query "query_2"(String sname)
        $student:Student(age > 20 && name == sname)
    end

第二步：编写单元测试

KieServices kieServices = KieServices.Factory.get();
    KieContainer kieClasspathContainer = kieServices.getKieClasspathContainer();
    KieSession kieSession = kieClasspathContainer.newKieSession();
    
    Student student1 = new Student();
    student1.setName("张三");
    student1.setAge(12);
    
    Student student2 = new Student();
    student2.setName("李四");
    student2.setAge(8);
    
    Student student3 = new Student();
    student3.setName("王五");
    student3.setAge(22);
    
    //将对象插入Working Memory中
    kieSession.insert(student1);
    kieSession.insert(student2);
    kieSession.insert(student3);
    
    //调用规则文件中的查询
    QueryResults results1 = kieSession.getQueryResults("query_1");
    int size = results1.size();
    System.out.println("size=" + size);
    for (QueryResultsRow row : results1) { 
        Student student = (Student) row.get("$student");
        System.out.println(student);
    }
    
    //调用规则文件中的查询
    QueryResults results2 = kieSession.getQueryResults("query_2","王五");
    size = results2.size();
    System.out.println("size=" + size);
    for (QueryResultsRow row : results2) { 
        Student student = (Student) row.get("$student");
        System.out.println(student);
    }
    //kieSession.fireAllRules();
    kieSession.dispose();

### 2.4.3 function函数 ###

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

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

function 返回值类型 函数名(可选参数){ 
        //逻辑代码
    }

具体操作步骤：

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

package testfunction
    import com.itheima.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

第二步：编写单元测试

### 2.4.4 LHS加强 ###

前面我们已经知道了在规则体中的LHS部分是**介于when和then之间的部分**，主要用于模式匹配，只有匹配结果为true时，才会触发RHS部分的执行。本章节我们会针对LHS部分学习几个新的用法。

#### 2.4.4.1 复合值限制in/not in ####

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

**Object(field in (比较值1,比较值2…))**

举例：

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

#### 2.4.4.2 条件元素eval ####

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

**eval(表达式)**

举例：

eval(true)
    eval(false)
    eval(1 == 1)

#### 2.4.4.3 条件元素not ####

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

**not Object(可选属性约束)**

举例：

not Student()
    not Student(age < 10)

#### 2.4.4.4 条件元素exists ####

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

**exists Object(可选属性约束)**

举例：

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对象，第二个规则会执行两次。

#### 2.4.4.5 规则继承 ####

规则之间可以使用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

### 2.4.5 RHS加强 ###

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

在RHS部分Drools为我们提供了一个内置对象，名称就是drools。本小节我们来介绍几个drools对象提供的方法。

#### 2.4.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.4.5.2 getWorkingMemory ####

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

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

#### 2.4.5.3 getRule ####

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

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

### 2.4.6 规则文件编码规范（重要） ###

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

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

# 三、SpringBoot整合Drools #

具体操作步骤：

第一步：创建maven工程drools\_springboot并配置pom.xml

<?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">
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starters</artifactId>
            <version>2.0.6.RELEASE</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
        <groupId>com.itheima</groupId>
        <artifactId>drools_springboot</artifactId>
        <version>1.0-SNAPSHOT</version>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-aop</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
            </dependency>
            <dependency>
                <groupId>commons-lang</groupId>
                <artifactId>commons-lang</artifactId>
                <version>2.6</version>
            </dependency>
            
            <dependency>
                <groupId>org.drools</groupId>
                <artifactId>drools-core</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.drools</groupId>
                <artifactId>drools-templates</artifactId>
                <version>7.6.0.Final</version>
            </dependency>
            <dependency>
                <groupId>org.kie</groupId>
                <artifactId>kie-api</artifactId>
                <version>7.6.0.Final</version>
            </dependency>
            <dependency>
                <groupId>org.kie</groupId>
                <artifactId>kie-spring</artifactId>
                <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>
                <version>7.6.0.Final</version>
            </dependency>
        </dependencies>
        <build>
            <finalName>${project.artifactId}</finalName>
            <resources>
                <resource>
                    <directory>src/main/java</directory>
                    <includes>
                        <include>**/*.xml</include>
                    </includes>
                    <filtering>false</filtering>
                </resource>
                <resource>
                    <directory>src/main/resources</directory>
                    <includes>
                        <include>**/*.*</include>
                    </includes>
                    <filtering>false</filtering>
                </resource>
            </resources>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>2.3.2</version>
                    <configuration>
                        <source>1.8</source>
                        <target>1.8</target>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    </project>

第二步：创建/resources/application.yml文件

server:
      port: 8080
    spring:
      application:
        name: drools_springboot

第三步：创建规则文件/resources/rules/helloworld.drl

package helloworld
    rule "rule_helloworld"
        when
            eval(true)
        then
            System.out.println("规则：rule_helloworld触发...");
    end

第四步：编写配置类DroolsConfig

package com.itheima.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.api.runtime.KieSession;
    import org.kie.internal.io.ResourceFactory;
    import org.kie.spring.KModuleBeanFactoryPostProcessor;
    import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
    import org.springframework.core.io.support.ResourcePatternResolver;
    import org.springframework.core.io.Resource;
    import java.io.IOException;
    /** * 规则引擎配置类 */
    @Configuration
    public class DroolsConfig { 
        //指定规则文件存放的目录
        private static final String RULES_PATH = "rules/";
        private final KieServices kieServices = KieServices.Factory.get();
        @Bean
        @ConditionalOnMissingBean
        public KieFileSystem kieFileSystem() throws IOException { 
            KieFileSystem kieFileSystem = kieServices.newKieFileSystem();
            ResourcePatternResolver 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 kiePostProcessor() { 
            return new KModuleBeanFactoryPostProcessor();
        }
    }

第五步：创建RuleService类

package com.itheima.drools.service;
    
    import org.kie.api.KieBase;
    import org.kie.api.runtime.KieSession;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    @Service
    public class RuleService { 
        @Autowired
        private KieBase kieBase;
        public void rule(){ 
            KieSession kieSession = kieBase.newKieSession();
            kieSession.fireAllRules();
            kieSession.dispose();
        }
    }

第六步：创建HelloController类

package com.itheima.drools.controller;
    
    import com.itheima.drools.service.RuleService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    @RequestMapping("/hello")
    public class HelloController { 
        @Autowired
        private RuleService ruleService;
        @RequestMapping("/rule")
        public String rule(){ 
            ruleService.rule();
            return "OK";
        }
    }

第七步：创建启动类DroolsApplication

package com.itheima.drools;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @SpringBootApplication
    public class DroolsApplication { 
        public static void main(String[] args) { 
            SpringApplication.run(DroolsApplication.class,args);
        }
    }

第八步：启动服务，访问http://localhost:8080/hello/rule

[Drools]: https://www.cnblogs.com/jpfss/p/10870002.html
[http_www.drools.org]: https://link.jianshu.com?t=http://www.drools.org/#
[http_www.drools.org_learn_documentation.html]: https://link.jianshu.com?t=http://www.drools.org/learn/documentation.html
[img]: /images/20220828/91f892d56ce8411caae8d87a7793169e.png
[img 1]: /images/20220828/a5ee321ed9314c16892902dd688c6a9b.png
[img 2]: /images/20220828/a3cb268b827040eb88613356e4ba0d7d.png
[img 3]: /images/20220828/dee8760f1aa145d1b3fa5761c4c458fa.png
[img 4]: /images/20220828/adf221c7175b4f88a1e1e2aad28a91d9.png
[5]: /images/20220828/78f24c7d359c49eca0fb0081bb99f073.png
[5 1]: https://typora-oss.oss-cn-beijing.aliyuncs.com/5.png