规则引擎—Drools 语法第二天[学习笔记]

 

1.规则文件构成

在使用Drools工具时，我们需要在IDEA工具中编写DRL(规则)文件，eg：xxx.drl(在resource->rules文件包下)。

规则文件内容构成：

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

代码示例： 

//包名
//编写业务规则
//并不是真实包，而是一种逻辑概念
//比如买书优惠打折 语法
package book.discount


//导入
//因为需要用Order获取数据信息 需引入 语法
import com.rules.drools.entity.Order


//全局变量语法
global java.lang.Integer count//定义一个包装类型的全局变量
global java.util.List gList
global UserService userService


//自定义函数  语法
//在规则体中可以调用
function String sayHello(String name){
     return "hello!" + name;
}


//查询  语法
//定义一个查询Query语句
query "query_1"
    $s:Student(age == 50)
end


//规则体
//规则一 "规则名称"——规则名称不能相同
//价格在100元一下 无优惠
rule "book_discount_1"
    when
        $order:Order(originalPrice < 100)//模式匹配到规则引擎中(工作内存)
    then
        $order.setRealPrice($order.getOriginalPrice());
        System.out.println("成功匹配到规则一");
end


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

2.规则体 语法

2.1 规则体 

是规则文件的重要组成部分。

是进行业务规则判断，处理业务结果的部分。

2.2 规则体语法结构

//rule：关键字，标识规则开始，参数为规则的唯一标识
rule "规则名称"
//attributes：规则属性的总称 rule和when之间的参数，可写可不写 需要时用
     attributes
//when：关键字，后面跟规则的条件部分
     when
//LHS(Left Hand Side)：规则条件部分的通用名称。
//由0或多个条件元素组成。如果为空，则始终被视为true。
         LHS
//then：关键字，后面跟规则的结果部分
     then
//RHS(Right Hand Side)：规则的后果或行动部分的通用名称。
         RHS
//end：关键字 规则结束
end


rule "ruleName"
    attributes
    when
        LHS
    then
        RHS
end

2.3 Pattern模式匹配 

将Rule Base（规则库）和Working Memory（工作内存中的）Fact对象 进行模式匹配。

LHS定义规则条件并进行匹配。

Pattern又称为条件。可以为一个，也可以为多个。

Pattern语法结构：绑定变量名：Object（Field约束）

 eg：

rule "rule_1"
    when
//Student为类型约束   
//age为属性约束   
//$s为绑定变量名（既可以绑定在对象上，又可以绑定在属性上）
        
        $s:Student($a:age > 60 )
    then
        System.out.println($s.getName());
end

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

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

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

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

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

条件操作符

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

 前六个操作符与java语法中的一模一样。

2.4操作符语法

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

具体示例如下： 

第一步：创建实体类

package com.simia.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;
    }
}

第二步：编写DRL文件

package comparisonOperator
import com.simia.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.5 规则体关键字 

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