drools规则引擎高级语法（九）

╰+攻爆jí腚メ 2023-02-15 10:16 84阅读 0赞

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

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

1 global全局变量

定义规则文件

<table> 
 <tbody> 
  <tr> 
   <td> <pre><code>package rules;

/*
    此规则文件用于测试global全局变量
*/

global java.lang.Integer count //定义一个包装类型的全局变量
global com.dream21th.drools.study.demo6.StudentService studentService //定义一个JavaBean类型的全局变量
global java.util.List gList //定义一个集合类型的全局变量

rule "demo6_global_1"
    when
    then
        count += 10; //全局变量计算，只对当前规则有效，其他规则不受影响
        studentService.study("yingyu");//调用全局变量的方法
        gList.add("apply");//向集合类型的全局变量中添加元素，Java代码和所有规则都受影响
        gList.add("pear");
        System.out.println("count=" + count);
        System.out.println("gList.size=" + gList.size());
end

rule "demo6_global_2"
    when
    then
        studentService.study("yuwen");
        System.out.println("count=" + count);
        System.out.println("gList.size=" + gList.size());
end
</code></pre> </td> 
  </tr> 
 </tbody> 
</table>

定义测试方法

<table> 
 <tbody> 
  <tr> 
   <td> <pre><code>@Test
public void test_enabled(){
    KieServices kieServices = KieServices.Factory.get();
    KieContainer kieClasspathContainer = kieServices.getKieClasspathContainer();
    //会话对象，用于和规则引擎交互
    KieSession kieSession = kieClasspathContainer.newKieSession();

//设置全局变量，名称和类型必须和规则文件中定义的全局变量名称对应
    kieSession.setGlobal("studentService",new StudentService());
    kieSession.setGlobal("count",5);
    List list = new ArrayList();//size为0
    kieSession.setGlobal("gList",list);

//激活规则引擎，如果规则匹配成功则执行规则
    kieSession.fireAllRules(new RuleNameStartsWithAgendaFilter("demo6_global"));

System.out.println(list.size());
    //关闭会话
    kieSession.dispose();
}</code></pre> </td> 
  </tr> 
 </tbody> 
</table>

运行结果

<table> 
 <tbody> 
  <tr> 
   <td>学习：yingyu<br> count=15<br> gList.size=2<br> 学习：yuwen<br> count=5<br> gList.size=2<br> 2</td> 
  </tr> 
 </tbody> 
</table>

2 query查询

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

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

LHS

end

具体操作步骤：

编写规则文件

<table> 
 <tbody> 
  <tr> 
   <td> <pre><code>package rules;

import  com.dream21th.drools.study.demo6.Student

/*
    此规则文件用于测试query查询
*/
//不带参数的查询
//当前query用于查询Working Memory中age&gt;10的Student对象
query "demo6_query_1"
    $student:Student(age &gt; 10)
end

//带有参数的查询
//当前query用于查询Working Memory中age&gt;10同时name需要和传递的参数name相同的Student对象
query "demo6_query_2"(String sname)
    $student:Student(age &gt; 20 &amp;&amp; name == sname)
end</code></pre> </td> 
  </tr> 
 </tbody> 
</table>

编写测试类

<table> 
 <tbody> 
  <tr> 
   <td> <pre><code> @Test
    public void test_query(){
        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("demo6_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("demo6_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();
    }</code></pre> </td> 
  </tr> 
 </tbody> 
</table>

测试结果

<table> 
 <tbody> 
  <tr> 
   <td>size=2<br> Student(name=张三, result=null, age=12, sex=null, subjects=null)<br> Student(name=王五, result=null, age=22, sex=null, subjects=null)<br> size=1<br> Student(name=王五, result=null, age=22, sex=null, subjects=null)</td> 
  </tr> 
 </tbody> 
</table>

3 function函数

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

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

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

//逻辑代码

}

具体操作步骤：

编写规则文件

<table> 
 <tbody> 
  <tr> 
   <td> <pre><code>package rules;

import  com.dream21th.drools.study.demo6.Student
/*
    此规则文件用于测试function函数
*/

//定义一个函数
function String sayHello(String name){
    return "hello " + name;
}

rule "demo6_function_1"
    when
        $student:Student(name != null)
    then
        //调用上面定义的函数
        String ret = sayHello($student.getName());
        System.out.println(ret);
end</code></pre> </td> 
  </tr> 
 </tbody> 
</table>

编写测试类

<table> 
 <tbody> 
  <tr> 
   <td> <pre><code>@Test
public void test_function(){
    KieServices kieServices = KieServices.Factory.get();
    KieContainer kieClasspathContainer = kieServices.getKieClasspathContainer();
    //会话对象，用于和规则引擎交互
    KieSession kieSession = kieClasspathContainer.newKieSession();

Student student = new Student();
    student.setName("小明");
    kieSession.insert(student);

//激活规则引擎，如果规则匹配成功则执行规则
    kieSession.fireAllRules(new RuleNameStartsWithAgendaFilter("demo6_function"));

//关闭会话
    kieSession.dispose();
}</code></pre> </td> 
  </tr> 
 </tbody> 
</table>

4，LHS加强

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

复合值限制in/not in

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

举例：

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

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

条件元素eval

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

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

举例：

not Student()

not Student(age < 10)

条件元素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的规则会执行多次。

例如：

编写规则

<table> 
 <tbody> 
  <tr> 
   <td> <pre>package rules;

import  com.dream21th.drools.study.demo6.Student

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

/**
没有使用exists的规则
**/
rule "demo-exists-2"
    when
        Student()
    then
        System.out.println("规则：没有使用demo-exists-2的规则触发");
end</pre> </td> 
  </tr> 
 </tbody> 
</table>

编写测试代码

<table> 
 <tbody> 
  <tr> 
   <td> <pre>@Test
public void test_exists(){
    KieServices kieServices = KieServices.Factory.get();
    KieContainer kieClasspathContainer = kieServices.getKieClasspathContainer();
    //会话对象，用于和规则引擎交互
    KieSession kieSession = kieClasspathContainer.newKieSession();

Student student = new Student();
    kieSession.insert(student);

kieSession.insert(new Student());
    //激活规则引擎，如果规则匹配成功则执行规则
    kieSession.fireAllRules(new RuleNameStartsWithAgendaFilter("demo-exists"));

//关闭会话
    kieSession.dispose();
}</pre> </td> 
  </tr> 
 </tbody> 
</table>

测试结果

<table> 
 <tbody> 
  <tr> 
   <td>规则：使用demo-exists-1的规则触发<br> 规则：没有使用demo-exists-2的规则触发<br> 规则：没有使用demo-exists-2的规则触发</td> 
  </tr> 
 </tbody> 
</table>

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

规则继承

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

例如：

<table> 
 <tbody> 
  <tr> 
   <td> <pre>package rules;

import  com.dream21th.drools.study.demo6.Student

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

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

测试代码

<table> 
 <tbody> 
  <tr> 
   <td> <pre>@Test
public void test_extends(){
    KieServices kieServices = KieServices.Factory.get();
    KieContainer kieClasspathContainer = kieServices.getKieClasspathContainer();
    //会话对象，用于和规则引擎交互
    KieSession kieSession = kieClasspathContainer.newKieSession();

Student student = new Student();
    student.setAge(28);
    kieSession.insert(student);

//激活规则引擎，如果规则匹配成功则执行规则
    kieSession.fireAllRules(new RuleNameStartsWithAgendaFilter("demo6_extends"));

//关闭会话
    kieSession.dispose();
}</pre> </td> 
  </tr> 
 </tbody> 
</table>

触发结果

<table> 
 <tbody> 
  <tr> 
   <td>规则：demo6_extends_1触发</td> 
  </tr> 
 </tbody> 
</table>

因为规则2继承了规则1，所以规则2的触发条件是age大于10并且小于20 ，由于例子中的是28所以只触发了第一条规则

### RHS加强 ###

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

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

halt

<table> 
 <tbody> 
  <tr> 
   <td> <pre>package testhalt</pre> <pre>rule "rule_halt_1"</pre> <pre> &nbsp; &nbsp;when</pre> <pre> &nbsp; &nbsp;then</pre> <pre> &nbsp;      System.out.println("规则：rule_halt_1触发");</pre> <pre>        drools.halt();//立即终止后面所有规则执行</pre> <pre>end</pre> <pre></pre> <pre>//当前规则并不会触发，因为上面的规则调用了halt方法导致后面所有规则都不会执行</pre> <pre>rule "rule_halt_2"</pre> <pre> &nbsp; &nbsp;when</pre> <pre> &nbsp; &nbsp;then</pre> <pre> &nbsp;      System.out.println("规则：rule_halt_2触发");</pre> <pre>end</pre> </td> 
  </tr> 
 </tbody> 
</table>

getWorkingMemory

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

<table> 
 <tbody> 
  <tr> 
   <td> <pre>package testgetWorkingMemory</pre> <pre>rule "rule_getWorkingMemory"</pre> <pre> &nbsp; &nbsp;when</pre> <pre> &nbsp; &nbsp;then</pre> <pre> &nbsp;      System.out.println(drools.getWorkingMemory());</pre> <pre>end</pre> </td> 
  </tr> 
 </tbody> 
</table>

getRule

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

<table> 
 <tbody> 
  <tr> 
   <td> <pre>package testgetRule</pre> <pre>rule "rule_getRule"</pre> <pre> &nbsp; &nbsp;when</pre> <pre> &nbsp; &nbsp;then</pre> <pre> &nbsp;      System.out.println(drools.getRule());</pre> <pre>end</pre> </td> 
  </tr> 
 </tbody> 
</table>

### 规则文件编码规范 ###

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

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

代码地址：[https://gitee.com/dream21th/drools-study/tree/master/demo6][https_gitee.com_dream21th_drools-study_tree_master_demo6]

[https_gitee.com_dream21th_drools-study_tree_master_demo6]: https://gitee.com/dream21th/drools-study/tree/master/demo6