心内求法

Holbrook的个人博客

0%

Drools规则描述语言快速手册

Posted on Edited on In

在规则引擎中，通常会使用某种表述性的语言（而不是编程语言）来描述规则。
所以规则描述语言也是规则引擎的一个重要组成部分。

目前在规则描述语言方面，并没有一个通用的标准获得规则引擎厂商的广泛支持，大部分规则描述语言都是厂商私有的。
大体来说，规则语言可以分为结构化的（Structured)和基于标记的（Markup，通常为xml）。

常见的规则描述语言包括：

  • srl(Structured Rule Language) : Fair Isaac（以前是Blaze Software）定义的结构化规则描述语言
  • drl(Drools Rule Language) : Jboss（以前是drools.org)定义的结构化规则描述语言
  • RuleML(Rule Markup Language）: www.ruleml.org定义的xml规则描述语言
  • SRML(Simple Rule Markup Language): xml规则描述语言
  • BRML(Business Rules Markup Language):xml规则描述语言
  • SWRL（A Semantic Web Rule Language):www.daml.org定义的xml规则描述语言

不管是哪种规则描述语言，都需要描述一组条件以及在此条件下执行的操作（即规则）。

概览

下面是一个drl的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package com.sample

import com.sample.DroolsTest.Message;

rule "Hello World"
    when
        m : Message( status == Message.HELLO, myMessage : message )
    then
        System.out.println( myMessage );
        m.setMessage( "Goodbye cruel world" );
        m.setStatus( Message.GOODBYE );
        update( m );
end

rule "GoodBye"
    when
        Message( status == Message.GOODBYE, myMessage : message )
    then
        System.out.println( myMessage );
end

完整的drl文件会包含以下几个部分：

  • package 声明
  • imports
  • declares
  • globals
  • functions
  • queries
  • rules

package和import声明

与Java语言类似，drl的头部需要有package和import的声明。

规则文件当中必须要有一个 package 声明,同时 package 声明必须要放在规则文件的第一行。

规则定义

drl中，一个规则的标准结构如下：

1
2
3
4
5
6
7
rule "name"
    attributes
    when
        LHS
    then
        RHS
end

一个规则通常包括三个部分:属性部分(attribute)、条件 部分(LHS)和结果部分(RHS)。

条件部分(LHS)

在 LHS 当中,可以包含多个条件,如果 LHS 部分没空的话,那么引擎会自动添加一 个 eval(true)的条件。

多个条件之间之间用可以使用 and 或 or 来进行连接。默认是 and 关系。

每个条件的语法为：

[绑定变量名:]Object([field 约束])

“绑定变量名”是可选的。绑定的变量可以在该LHS后续的条件中引用。

“field 约束”是指当前对象里相关字段的条件限制, 多个约束之间可以用“&&”(and)、“||”(or)和“,”(and)来连接。

举例如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
when
   $customer:Customer()
then
    ……


when
   $customer:Customer(age>20,gender==􏰃male􏰃)
    Order(customer==$customer,price>1000)
then
    ……


when
    Customer(age>20 || (gender=='male' && city==‘sh'))
then
    ……

约束中可以使用的比较操作符包括：

1
>、>=、<、<=、= =、!=、contains、not contains、 memberof、not memberof、matches、not matches

举例如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
when
   $order:Order();
   $customer:Customer(age >20, orders contains$order);
then
    ……


when
   $order:Order(name memberOf orderNames); # orderNames为数组或集合类型
then
    ……

when
   $customer:Customer(name matches "李.*"); # 正则表达式匹配
then
    ……

结果部分(RHS)

RHS 部分定义了当LHS满足是要进行的操作。

RHS中可以编写代码，可以使用 LHS 部分当中定义的绑定变量名以及drl头部定义的全局变量。

在 RHS 当中虽然可以直接编写 Java 代码,但不建议在代码当中有条件判断,如果需要条件判断,那么请重新考虑将其放在 LHS 当中,否则就违背了使用规则的初衷。

使用宏函数

RHS中可以使用宏函数对工作空间(Working Memory)进行操作。当调用宏函数后，所有未设置“no-loop”属性的规则都会被重新匹配，符合条件的重新触发。

宏函数包括：

  • insert：将一个 Fact 对象插入到当前的 Working Memory
  • update：对当前 Working Memory 中的 Fact 进行更新
  • retract ：从 Working Memory 中删除某个 Fact 对象

这些宏函数都是StatefulSession中定义的方法。

举例如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
when
    ……
then
    Customer cus=new Customer();
    cus.setName("张三");
    insert(cus);


when
   $customer:Customer(name=="张三",age<10);
then
   $customer.setAge($customer.getAge()+1);
    update($customer);


when
   $customer:Customer(name=="张三",age<10);
then
    Customer customer=new Customer();
    customer.setName("张三");
    customer.setAge($customer.getAge()+1);

    # 用新对象替换Working Memory中的旧对象
    update(drools.getWorkingMemory().getFactHandleByIdentity($customer),customer);


when
   $customer:Customer(name=="张三");
then
    retract($customer);

modify代码块

modify代码块用于快速修改并更新(update)某个 Fact 对象的多个属性。语法及例子如下：

1
2
3
4
5
6
7
8
9
10
11
12
modify(fact-expression){
    <修改 Fact 属性的表达式>[,<修改 Fact 属性的表达式>*]
}


when
   $customer:Customer(name=="张三",age==20);
then
    modify($customer){
        setId("super man"),
        setAge(30)
    }

drools宏对象

通过使用 drools 宏对象可以实现在规则文件里直接访问 Working Memory, 从而获取对当前的 Working Memory 的更多控制。

drools 宏对象的常用方法包括：

  • drools.getWorkingMemory()：获取当前的 WorkingMemory 对象
  • drools.halt()：在当前规则执行完成后,不再执行 其它未执行的规则。
  • drools.getRule()：得到当前的规则对象
  • drools.insert(new Object)：向当前的 WorkingMemory 当中插入 指定的对象,功能与宏函数 insert 相同。
  • drools.update(new Object)：更新当前的 WorkingMemory 中指定 的对象,功能与宏函数 update 相同。
  • drools.update(FactHandle Object)：更新当前的 WorkingMemory 中指定 的对象,功能与宏函数 update 相同。
  • drools.retract(new Object)：从当前的 WorkingMemory 中删除指 定的对象,功能与宏函数 retract 相 同。

例如：

1
2
3
4
5
6
when
    eval(true);
then
    Customer cus=new Customer();
    cus.setName("张三");
    drools.insert(cus)

kcontext宏对象

kcontext 也是 Drools 提供的一个宏对象,它的作用主要是用来得到当前的 KnowledgeRuntime 对象,KnowledgeRuntime 对象可以实现与引擎的各种交互。

规则属性

主要的规则属性如下：

13 个: auto-focus、、lock-on-active、no-loop、 ruleflow-group、、when。

  • salience

    设置规则执行的优先级,数字越大越先执行，数字相同的使用随机顺序。默认值为0，可以设置为负数。

  • no-loop

    默认为false。设置为true时，表示该规则只会被引擎检查一次。引擎内部对Fact更新时，忽略本规则的再次检查。

  • date-effective

    设置规则的开始生效日期。默认接受“dd-MMM-yyyy”格式的字符串。可以用代码修改日期格式，如：

    System.setProperty("drools.dateformat","yyyy-MM-dd")。

  • date-expires

    设置规则的过期日期。格式与date-effective相同。

  • enabled

    默认为true。设置规则是否可用。

  • dialect

    设置规则中使用的编程语言。默认为java，还可以设置为mvel。通过drools.getRule().getDialect()可以获取该属性的设置。

  • duration

    延迟指定的时间后，在 另一个线程中 触发规则。单位为毫秒。

  • activation-group

    为规则划指定一个活动组（组名为字符串）。同一个活动组中的规则只执行一个，根据优先级(salience)来决定执行哪一个规则。

  • agenda-group 和 auto-focus

    为规则指定一个议程(agenda)组。指定了议程组的规则只有在该议程组得到焦点时才被触发。但如果规则同时指定了auto-focus属性为true，则该规则自动得到焦点。

    指定议程组焦点可以通过回话(session)：

    1
    2
    session.getAgenda().getAgendaGroup("GROUP_NAME").setFocus();
    session.fireAllRules();

    也可以实现org.drools.runtime.rule.AgendaFilter 接口：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package test;
import org.drools.runtime.rule.Activation;
import org.drools.runtime.rule.AgendaFilter;

public class TestAgendaFilter implements AgendaFilter {
    private String startName;
    public TestAgendaFilter(String startName){
        this.startName=startName;
    }
    public boolean accept(Activation activation) {
        String ruleName=activation.getRule().getName();
        if(ruleName.startsWith(this.startName)){
            return true;
        }else{
            return false;
        }
    }
}

  • ruleflow-group

    指定规则流组。

  • lock-on-active

    当在规则上使用 ruleflow-group 属性或 agenda-group 属性的时候,将 lock-on-action 属性 的值设置为 true,可能避免因某些 Fact 对象被修改而使已经执行过的规则再次被激活执行。lock-on-active 是 no-loop 的增强版属性，在规则流中很有用。

举例如下：

1
2
3
4
rule "rule1"
    salience 1
    when
    ……

注释

Drools 当中注释的写法与编写 Java 类的注 释的写法完全相同,注释的写法分两种:单行注释与多行注释。

单行注释可以采用“#”或者“//”来进行标记， 多行注释以“/”开始,以“/”结束。

例如：

1
2
3
4
5
6
7
8
9
/* 规则rule1的注释
这是一个测试用规则
*/
rule "rule1"
    when
        eval(true) #没有条件判断
    then
        System.out.println("rule1 execute"); //仅仅是输出
end

类型声明

可以在规则文件中定义Fact类型，而不需要编写Java类。比如：

1
2
3
4
5
6
7
8
9
10
11
declare Address
    city : String
    addressName : String
end

declare Person
    name:String
    birthday:Date
    address:Address //使用declare声明的对象作为address属性类型
    order:Order //使用名为Order的JavaBean作为order属性类型
end

在KnowledgeBase中可以获取规则文件中定义的Fact类型，比如：

1
2
3
4
5
//获取规则文件当中定义的Address对象并对其进行实例化
FactType addressType=knowledgeBase.getFactType("test","Address");
Object add=addressType.newInstance();
addressType.set(add, "city","Beijing");
addressType.set(add, "addressName","Capital");

在声明中还可以定义元数据。可以为 Fact 对象、Fact对象的属性或者是规则来定义元数据,元数据定义采用的是“@”符号开头。

比如：

1
2
3
4
5
6
declare User
    @createTime(2009-10-25)
    username : String @maxLenth(30)
    userid : String @key
    birthday : java.util.Date
end

元数据的获取？(TODO)

全局变量（TODO）

函数和import function

函数的定义和使用

函数是定义在规则文件当中一代码块,作用是将在规则文件当中若干个规则都会用到的业务操作封装起来,实现业务代码的复用,减少规则编写的工作量。
函数的可见范围是函数所在的规则文件。

函数以function定义，可以是void，也可以有返回值。例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package test
import java.util.List;
import java.util.ArrayList;
/*
一个测试函数
用来向Customer对象当中添加指定数量的Order对象的函数
*/

function void setOrder(Customer customer,int orderSize) {
    List ls=new ArrayList();
    for(int i=0;i< orderSize;i++){
        Order order=new Order();
        ls.add(order);
    }
    customer.setOrders(ls);
}

/*
测试规则
*/
rule "rule1" when
   $customer :Customer();
then
    setOrder($customer,5);
    System.out.println("rule 1 customer has order size:"+$customer.getOrders().size());
end

/*
测试规则
*/
rule "rule2" when
   $customer :Customer();
then
    setOrder($customer,10);
    System.out.println("rule 2 customer has order size:"+$customer.getOrders().size());
end

引入静态方法

实际应用当中,可以考虑使用在 Java 类当中定义静态方法的办法来替代在规则文件当 中定义函数。

Drools 提供了一个特殊的 import 语句:import function,通过该 import 语句,可以实现将一个 Java 类中静态方法引入到一个规则文件当中,使得该文件当中的规 则可以像使用普通的 Drools 函数一样来使用 Java 类中某个静态方法。

比如：

1
2
3
4
5
6
package test;
public class RuleTools {
    public static void printInfo(String name){
        System.out.println("your name is :"+name);
    }
}
1
2
3
4
5
6
7
8
9
10
11
package test
import function test.RuleTools.printInfo;
/*
测试规则
*/
rule "rule1"
    when
        eval(true);
    then
        printInfo("test import function");
end

查询定义

查询用于根据条件在当前的 WorkingMemory 当中查找 Fact。Drools 当中查询可分为两种:一种是不需要外部传入参数;一种是需要外部传入参 数。

如：

1
2
3
4
5
6
7
query "testQuery"
    customer:Customer(age>30,orders.size >10)
end

query "testQuery2"(int$age,String$gender)
    customer:Customer(age>$age,gender==$gender)
end

通过session可以在外部调用规则文件中的查询，比如：

1
2
3
4
5
6
7
8
9
10
……
QueryResults queryResults=statefulSession.getQueryResults("testQuery");
for(QueryResultsRow qr:queryResults){
    Customer cus=(Customer)qr.get("customer"); //打印查询结果
    System.out.println("customer name :"+cus.getName());
}

QueryResults queryResults2=statefulSession.getQueryResults("testQuery2", new Object[]{new Integer(20),"F"});

……