第2-4-3章 规则引擎Drools基础语法-业务规则管理系统-组件化-中台

目录

• 4. Drools基础语法
  • 4.1 规则文件构成
  • 4.2 规则体语法结构
  • 4.3 注释
  • 4.4 Pattern模式匹配
  • 4.5 比较操作符
    • 4.5.1 语法
    • 4.5.2 操作步骤
  • 4.6 执行指定规则
  • 4.7 关键字
  • 4.8 Drools内置方法
    • 4.8.1 update方法
    • 4.8.2 insert方法
    • 4.8.3 retract方法

4. Drools基础语法

全套代码及资料全部完整提供，点此处下载

4.1 规则文件构成

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

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

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

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

4.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：关键字，表示一个规则结束。

4.3 注释

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

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

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

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

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

4.5 比较操作符

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

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

4.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 \"正则表达式\")

4.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 test2(){
    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();
}

4.6 执行指定规则

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

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

//测试执行指定规则
    @Test
    public void test3(){
        KieServices kieServices = KieServices.Factory.get();
        //获得Kie容器对象
        KieContainer kieContainer = kieServices.newKieClasspathContainer();
        //从Kie容器对象中获取会话对象
        KieSession session = kieContainer.newKieSession();

        //Fact对象，事实对象
        ComparisonOperatorEntity fact = new ComparisonOperatorEntity();
        fact.setNames(\"李四\");

        List<String> list = new ArrayList<String>();
        list.add(\"张三2\");
        //list.add(\"李四\");

        fact.setList(list);

        session.insert(fact);

        //激活规则，由Drools框架自动进行规则匹配，如果规则匹配成功，则执行当前规则
        //使用框架提供的规则过滤器执行指定规则
        session.fireAllRules(new RuleNameEqualsAgendaFilter(\"rule_comparison_notcontains\"));
        //session.fireAllRules(new RuleNameStartsWithAgendaFilter(\"rule_\"));
        //关闭会话
        session.dispose();
    }

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

4.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;
    }
}

4.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();

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

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

4.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();

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

4.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();

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

全套代码及资料全部完整提供，点此处下载

来源：https://www.cnblogs.com/gitBook/p/16920769.html
本站部分图文来源于网络，如有侵权请联系删除。