Drools7.0规则文件

一个标准的规则文件的格式为已“.drl”结尾的文本文件,因此可以通过记事本工具进行编辑。规则放置于规则文件当中,一个规则文件可以放置多条规则。在规则文件当中也可以存放用户自定义的函数、数据对象及自定义查询等相关在规则当中可能会用到的一些对象。

从架构角度来讲,一般将同一业务的规则放置在同一规则文件,也可以根据不同类型处理操作放置在不同规则文件当中。不建议将所有的规则放置与一个规则文件当中。分开放置,当规则变动时不至于影响到不相干的业务。读取构建规则的成本业务会相应减少。

标准规则文件的结构如下:

package package-name

imports

globals

functions

queries

rules

package:在一个规则文件当中package是必须的,而且必须放置在文件的第一行。package 的名字是随意的,不必必须对应物理路径,这里跟java的package的概念不同,只是逻辑上的区分,但建议与文件路径一致。同一的package下定义的function和query等可以直接使用。

比如,上面实例中package的定义:

package com.rules

import:导入规则文件需要的外部变量,使用方法跟java相同。像java的是import一样,还可以导入类中的某一个可访问的静态方法。(特别注意的是,某些教程中提示import引入静态方法是不同于java的一方面,可能是作者没有用过java的静态方法引入。)另外,目前针对Drools7版本,static和function关键字的效果是一样的。

import static com.secbro.drools.utils.DroolsStringUtils.isEmpty;
import function com.secbro.drools.utils.DroolsStringUtils.isEmpty;

rules:定义一个条规则。rule “ruleName”。一条规则包含三部分:属性部分、条件部分和结果部分。rule规则以rule开头,以end结尾。

属性部分:定义当前规则执行的一些属性等,比如是否可被重复执行、过期时间、生效时间等。

条件部分,简称LHS,即Left Hand Side。定义当前规则的条件,处于when和then之间。如when Message();判断当前workingMemory中是否存在Message对象。LHS中,可包含0~n个条件,如果没有条件,默认为eval(true),也就是始终返回 true。

结果部分,简称RHS,即Right Hand Side,处于then和end之间,用于处理满足条件之后的业务逻辑。可以使用LHS部分定义的变量名、设置的全局变量、或者是直接编写Java 代码。

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

RHS部分,提供了一些对当前Working Memory实现快速操作的宏函数或对象,比如 insert/insertLogical、update/modify和retract等。利用这些函数可以实现对当前Working Memory中的Fact对象进行新增、修改或删除操作;如果还要使用Drools提供的其它方法,可以使用另一个外宏对象drools,通过该对象可以使用更多的方法;同时Drools 还提供了一个名为kcontext的宏对象,可以通过该对象直接访问当前Working Memory的 KnowledgeRuntime。

标准规则的结构示例:

rule "name"
    attributes
    when
        LHS
    then 
        RHS
    end

LHS为空示例:

rule "name"
when 
then 
end

no-loop

定义当前的规则是否不允许多次循环执行,默认是 false,也就是当前的规则只要满足条件,可以无限次执行。什么情况下会出现规则被多次重复执行呢?下面看一个实例:

package com.rules

import com.secbro.drools.model.Product;

rule updateDistcount
    no-loop false
    when
        productObj:Product(discount > 0);
    then
        productObj.setDiscount(productObj.getDiscount() + 1);
        System.out.println(productObj.getDiscount());
        update(productObj);
    end

其中Product对象的discount属性值默认为1。执行此条规则时就会发现程序进入了死循环。也就是说对传入当前workingMemory中的FACT对象的属性进行修改,并调用update方法就会重新触发规则。从打印的结果来看,update之后被修改的数据已经生效,在重新执行规则时并未被重置。当然对Fact对象数据的修改并不是一定需要调用update才可以生效,简单的使用 set 方法设置就可以完成,但仅仅调用set方法时并不会重新触发规则。所以,对insert、retract、update方法使用时一定要慎重,否则极可能会造成死循环。

可以通过设置no-loop为true来避免规则的重新触发,同时,如果本身的RHS部分有insert、retract、update等触发规则重新执行的操作,也不会再次执行当前规则。

上面的设置虽然解决了当前规则的不会被重复执行,但其他规则还是会收到影响,比如下面的例子:

package com.rules

import com.secbro.drools.model.Product;

rule updateDistcount
    no-loop true
    when
        productObj:Product(discount > 0);
    then
        productObj.setDiscount(productObj.getDiscount() + 1);
        System.out.println(productObj.getDiscount());
        update(productObj);
    end

rule otherRule
    when
    productObj : Product(discount > 1);
    then
    System.out.println("被触发了" + productObj.getDiscount());
    end

此时执行会发现,当第一个规则执行update方法之后,规则otherRule也会被触发执行。如果注释掉update方法,规则otherRule则不会被触发。那么,这个问题是不是就没办法解决了?当然可以,那就是引入lock-on-active true属性。

lock-on-active 当在规则上使用ruleflow-group属性或agenda-group属性的时候,将lock-on-active 属性的值设置为true,可避免因某些Fact对象被修改而使已经执行过的规则再次被激活执行。可以看出该属性与no-loop属性有相似之处,no-loop属性是为了避免Fact被修改或调用了insert、retract、update之类的方法而导致规则再次激活执行,这里的lock-on-active 属性起同样的作用,lock-on-active是no-loop的增强版属性,它主要作用在使用ruleflow-group属性或agenda-group属性的时候。lock-on-active属性默认值为false。与no-loop不同的是lock-on-active可以避免其他规则修改FACT对象导致规则的重新执行。

因FACT对象修改导致其他规则被重复执行示例:

package com.rules

import com.secbro.drools.model.Product;

rule rule1
    no-loop true
    when
        obj : Product(discount > 0);
    then
        obj.setDiscount(obj.getDiscount() + 1);
        System.out.println("新折扣为:" + obj.getDiscount());
        update(obj);
    end

rule rule2
    when
        productObj : Product(discount > 1);
    then
        System.out.println("其他规则被触发了" + productObj.getDiscount());
    end

执行之后打印结果为:

新折扣为:2
其他规则被触发了2
第一次执行命中了2条规则!

其他规则(rule2)因FACT对象的改变而被出发了。

通过lock-on-active属性来避免被其他规则更新导致自身规则被重复执行示例:

package com.rules

import com.secbro.drools.model.Product;

rule rule1
    no-loop true
    when
        obj : Product(discount > 0);
    then
        obj.setDiscount(obj.getDiscount() + 1);
        System.out.println("新折扣为:" + obj.getDiscount());
        update(obj);
    end

rule rule2
    lock-on-active true
    when
        productObj : Product(discount > 1);
    then
        System.out.println("其他规则被触发了" + productObj.getDiscount());
    end

很明显在rule2的属性部分新增了lock-on-active true。执行结果为:

新折扣为:2
第一次执行命中了1条规则!

标注了lock-on-active true的规则不再被触发。

ruleflow-group 在使用规则流的时候要用到ruleflow-group属性,该属性的值为一个字符串,作用是将规则划分为一个个的组,然后在规则流当中通过使用ruleflow-group属性的值,从而使用对应的规则。该属性会通过流程的走向确定要执行哪一条规则。在规则流中有具体的说明。

代码实例

package com.rules

rule "test-ruleflow-group1"
    ruleflow-group "group1"
    when
    then
        System.out.println("test-ruleflow-group1 被触发");
    end
rule "test-ruleflow-group2"
    ruleflow-group "group1"
    when
    then
        System.out.println("test-ruleflow-group2 被触发");
    end

salience

用来设置规则执行的优先级,salience属性的值是一个数字,数字越大执行优先级越高,同时它的值可以是一个负数。默认情况下,规则的salience默认值为0。如果不设置规则的salience属性,那么执行顺序是随机的。 示例代码:

package com.rules

rule salience1
    salience 3
    when
    then
        System.out.println("salience1 被执行");
    end

rule salience2

    salience 5
    when
    then
        System.out.println("salience2 被执行");
    end

执行结果:

salience2 被执行
salience1 被执行

显然,salience2的优先级高于salience1的优先级,因此被先执行。

Drools还支持动态saline,可以使用绑定绑定变量表达式来作为salience的值。比如:

package com.rules

import com.secbro.drools.model.Product

rule salience1
    salience sal
    when
        Product(sal:discount);
    then
        System.out.println("salience1 被执行");
    end

这样,salience的值就是传入的FACT对象Product的discount的值了。

agenda-group 规则的调用与执行是通过StatelessKieSession或KieSession来实现的,一般的顺序是创建一个StatelessKieSession或KieSession,将各种经过编译的规则添加到session当中,然后将规则当中可能用到的Global对象和Fact对象插入到Session当中,最后调用fireAllRules 方法来触发、执行规则。

在没有调用fireAllRules方法之前,所有的规则及插入的Fact对象都存放在一个Agenda表的对象当中,这个Agenda表中每一个规则及与其匹配相关业务数据叫做Activation,在调用fireAllRules方法后,这些Activation会依次执行,执行顺序在没有设置相关控制顺序属性时(比如salience属性),它的执行顺序是随机的。

Agenda Group是用来在Agenda基础上对规则进行再次分组,可通过为规则添加agenda-group属性来实现。agenda-group属性的值是一个字符串,通过这个字符串,可以将规则分为若干个Agenda Group。引擎在调用设置了agenda-group属性的规则时需要显示的指定某个Agenda Group得到Focus(焦点),否则将不执行该Agenda Group当中的规则。

规则代码:

package com.rules

 rule "test agenda-group"

    agenda-group "abc"
    when
    then
        System.out.println("规则test agenda-group 被触发");
    end
rule otherRule

    when
    then
        System.out.println("其他规则被触发");
    end

调用代码:

KieServices kieServices = KieServices.Factory.get();
KieContainer kieContainer = kieServices.getKieClasspathContainer();
KieSession kSession = kieContainer.newKieSession("ksession-rule");

kSession.getAgenda().getAgendaGroup("abc").setFocus();
kSession.fireAllRules();
kSession.dispose();

执行以上代码,打印结果为:

规则test agenda-group 被触发
其他规则被触发

如果将代码kSession.getAgenda().getAgendaGroup(“abc”).setFocus()注释掉,则只会打印出:

其他规则被触发

很显然,如果不设置指定AgendaGroup获得焦点,则该AgendaGroup下的规则将不会被执行。

auto-focus 在agenda-group章节,我们知道想要让AgendaGroup下的规则被执行,需要在代码中显式的设置group获得焦点。而此属性可配合agenda-group使用,代替代码中的显式调用。默认值为false,即不会自动获取焦点。设置为true,则可自动获取焦点。

对于规则的执行的控制,还可以使用org.kie.api.runtime.rule. AgendaFilter来实现。用户可以实现该接口的accept方法,通过规则当中的属性值来控制是否执行规则。

方法体如下:

boolean accept(Match match);

在该方法当中提供了一个Match参数,通过该参数可以获得当前正在执行的规则对象和属性。该方法要返回一个布尔值,返回true就执行规则,否则不执行。

auto-focus使用示例代码

规则代码:

package com.rules

 rule "test agenda-group"

    agenda-group "abc"
    auto-focus true

    when
    then
        System.out.println("规则test agenda-group 被触发");
    end

执行规则代码:

KieServices kieServices = KieServices.Factory.get();
KieContainer kieContainer = kieServices.getKieClasspathContainer();
KieSession kSession = kieContainer.newKieSession("ksession-rule");
kSession.fireAllRules();
kSession.dispose();

执行结果:

规则test agenda-group 被触发

这里,我们没有在代码中显式的让test agenda-group获取焦点,但规则同样被执行了,说明属性配置已生效。

AgendaFilter代码实例

规则文件代码:

package com.rules

 rule "test-agenda-group"

    when
    then
        System.out.println("规则test-agenda-group 被触发");
    end

rule other

    when
    then
        System.out.println("规则other被触发");
    end

实现的MyAgendaFilter代码:

package com.secbro.drools.filter;

import org.kie.api.runtime.rule.AgendaFilter;
import org.kie.api.runtime.rule.Match;

/**
 * Created by zhuzs on 2017/7/19.
 */
public class MyAgendaFilter implements AgendaFilter{

    private String ruleName;

    public MyAgendaFilter(String ruleName) {
        this.ruleName = ruleName;
    }

    @Override
    public boolean accept(Match match) {
        return match.getRule().getName().equals(ruleName) ? true : false;
}
// 省略getter/setter方法
}

测试方法:

KieServices kieServices = KieServices.Factory.get();
KieContainer kieContainer = kieServices.getKieClasspathContainer();
KieSession kSession = kieContainer.newKieSession("ksession-rule");

AgendaFilter filter = new MyAgendaFilter("test-agenda-group");
kSession.fireAllRules(filter);
kSession.dispose();

执行结果:

规则test-agenda-group 被触发

在执行规则的Filter中传入的规则名称为test-agenda-group,此规则被执行。而对照组的规则other,却未被执行。

activation-group 该属性将若干个规则划分成一个组,统一命名。在执行的时候,具有相同activation-group 属性的规则中只要有一个被执行,其它的规则都不再执行。可以用类似salience之类属性来实现规则的执行优先级。该属性以前也被称为异或(Xor)组,但技术上并不是这样实现的,当提到此概念,知道是该属性即可。

实例代码:

package com.rules

 rule "test-activation-group1"
    activation-group "foo"
    when
    then
        System.out.println("test-activation-group1 被触发");
    end

rule "test-activation-group2"
    activation-group "foo"
    salience 1
    when
    then
        System.out.println("test-activation-group2 被触发");
    end

执行规则之后,打印结果:

test-activation-group2 被触发

以上实例证明,同一activation-group优先级高的被执行,其他规则不会再被执行。

dialect

该属性用来定义规则(LHS、RHS)当中要使用的语言类型,可选值为“java”或“mvel”。默认情况下使用java语言。当在包级别指定方言时,这个属性可以在具体的规则中覆盖掉包级别的指定。

dialect "mvel"

date-effective 该属性是用来控制规则只有在到达指定时间后才会触发。在规则运行时,引擎会拿当前操作系统的时间与date-effective设置的时间值进行比对,只有当系统时间大于等于date-effective设置的时间值时,规则才会触发执行,否则执行将不执行。在没有设置该属性的情况下,规则随时可以触发。 date-effective的值为一个日期型的字符串,默认情况下,date-effective可接受的日期格式为“dd-MMM-yyyy”。例如2017 年7 月20 日,在设置为date-effective值时,如果操作系统为英文的,那么应该写成“20-Jul-2017”;如果是中文操作系统则为“20-七月-2017”。 目前在win10操作系统下验证,中文和英文格式均支持。而且在上面日期格式后面添加空格,添加其他字符并不影响前面日期的效果。

示例代码:

package com.rules

rule "test-date"
//    date-effective "20-七月-2017 aa"
//    date-effective "20-七月-2017"
//    date-effective "20-Jul-2017aaa"
    date-effective "20-Jul-2017"
    when
    then
        System.out.println("规则被执行");
    end

值得注意的是以上注释掉的格式均能成功命中规则与后面的字符无关,因为默认时间格式只取字符串的指定位数进行格式化。

晋级用法:上面已经提到了,其实针对日期之后的时间是无效的。那么如果需要精确到时分秒改如何使用呢?可以通过设置drools的日期格式化来完成任意格式的时间设定,而不是使用默认的格式。在调用代码之前设置日期格式化格式:

System.setProperty("drools.dateformat", "yyyy-MM-dd HH:mm");

在规则文件中就可以按照上面设定的格式来传入日期:

date-effective "2017-07-20 16:31"

date-expires

此属性与date-effective的作用相反,用来设置规则的过期时间。时间格式可完全参考date-effective的时间格式。引擎在执行规则时会检查属性是否设置,如果设置则比较当前系统时间与设置时间,如果设置时间大于系统时间,则执行规则,否则不执行。实例代码同样参考date-effective。

duration

已废弃。设置该属性,规则将指定的时间之后在另外一个线程里触发。属性值为一个长整型,单位是毫秒。如果属性值设置为0,则标示立即执行,与未设置相同。

enabled

设置规则是否可用。true:表示该规则可用;false:表示该规则不可用。

###规则的条件部分,即LHS部分:

when:规则条件开始。条件可以单个,也可以多个,多个条件一次排列,比如

when

​ eval(true)

​ $customer:Customer()

​ $message:Message(status==0)

上述罗列了三个条件,当前规则只有在这三个条件都匹配的时候才会执行RHS部分,三个条件中第一个

**eval(true):**是一个默认的api,true 无条件执行,类似于 while(true)

$message:Message(status==0) 这句话标示的:当前的workingMemory存在Message类型并且status属性的值为0的Fact对象,这个对象通常是通过外部java代码插入或者自己在前面已经执行的规则的RHS部分中insert进去的。

前面的$message代表着当前条件的引用变量,在后续的条件部分和RHS部分中,可以使用当前的变量去引用符合条件的FACT对象,修改属性或者调用方法等。可选,如果不需要使用,则可以不写。

条件可以有组合,比如:

Message(status==0 || (status > 1 && status <=100))

RHS中对Fact对象private属性的操作必须使用getter和setter方法,而RHS中则必须要直接用.的方法去使用,比如

$order:Order(name=="qu")
$message:Message(status==0 && orders contains $order && $order.name=="qu")

特别的是,如果条件全部是 &&关系,可以使用“,”来替代,但是两者不能混用

如果现在Fact对象中有一个List,需要判断条件,如何判断呢?

看一个例子:

Message {
        int status;
        List<String> names;
}
$message:Message(status==0 && names contains "网易" && names.size >= 1)

上述的条件中,status必须是0,并且names列表中含有“网易”并且列表长度大于等于1

contains:对比是否包含操作,操作的被包含目标可以是一个复杂对象也可以是一个简单的值。

Drools提供了十二中类型比较操作符:

> >= < <= == != contains / not contains / memberOf / not memberOf /matches/ not matches

**not contains:**与contains相反。

memberOf:判断某个Fact属性值是否在某个集合中,与contains不同的是他被比较的对象是一个集合,而contains被比较的对象是单个值或者对象。

not memberOf:正好相反。

matches:正则表达式匹配,与java不同的是,不用考虑'/'的转义问题

not matches:正好相反。

在条件中,可以任何返回结果为布尔类型的java表达式。当然,java表达式也可以和增强的表达式进行结合使用,比如属性访问。可以通过使用括号来更改计算优先级,如在任一逻辑或数学表达式中。

Person( age > 100 && ( age % 10 == 0 ) )

也可以直接使用java提供的工具方法来进行操作计算:

Person( Math.round( weight / ( height * height ) ) < 25.0 )

在使用的过程中需要注意,在LHS中执行的方法只能是只读的,不能在执行方法过程中改变改变FACT对象的值,否则会影响规则的正确执行。

Person( incrementAndGetAge() == 10 ) //不要像这样在比较的过程中更新Fact对象

另外,FACT对象的相关状态除了被在working memory中进行更新操作,不应该每次调用时状态会发生变化。

Person( System.currentTimeMillis() % 1000 == 0 ) // 不要这样实现

标准Java运算符优先级也适用,请参见下面的运算符优先级列表。所有的操作符都有标准的Java语义,除了==和!=。它们的null安全的,就相当于java中比较两个字符串时把常量字符串放前面调用equals方法的效果一样。

约束条件的比较过程中是会进行强制类型转换的,比如在数据计算中传入字符串“10”,则能成功转换成数字10进行计算。但如果,此时传入的值无法进行转换,比如传了“ten”,那么将会抛出异常。

绑定变量 一个属性可以绑定到一个变量:

// 2 person的age属性值相同
Person( $firstAge : age ) // 绑定
Person( age == $firstAge ) // 约束表达式

前缀$只是个通用惯例,在复杂规则中可以通过它来区分变量和属性。为了向后兼容,允许(但不推荐)混合使用约束绑定和约束表达式。

// 不建议这样写
Person( $age : age * 2 < 100 )

// 推荐(分离绑定和约束表达式)
Person( age * 2 < 100, $age : age )

使用操作符“==”来绑定变量,Drools会使用散列索引来提高执行性能。

内部类分组访问 通常情况,我们访问一个内部类的多个属性时会有如下的写法:

Person( name == "mark", address.city == "london", address.country == "uk" )

Drools提供的分组访问可以更加方便进行使用:

Person( name == "mark", address.( city == "london", country == "uk") )

注意前缀’.’是用来区分嵌套对象约束和方法调用所必需的。

内部强制转换 在使用内部类的时候,往往需要将其转换为父类,在规则中可以通过“#”来进行强制转换:

Person( name == "mark", address#LongAddress.country == "uk" )

上面的例子将Address强制转换为LongAddress.,这样使得getter方法变得可用。如果无法强制转换,表达式计算的结果为false。强制转换也支持全路径的写法:

Person( name == "mark", address#org.domain.LongAddress.country == "uk" )

多次内部转换语法:

Person( name == "mark", address#LongAddress.country#DetailedCountry.population > 10000000 )

也可以使用instanceof操作符进行判断,判断之后将进一步使用该属性进行比较。

Person( name == "mark", address instanceof LongAddress, address.country == "uk" )

日期字符 规则语法中除了支持JAVA标准字符,同时也支持日期字符。Drools默认支持的日期格式为“dd-mmm-yyyy”,可以通过设置系统变量“drools.dateformat”的值来改变默认的日期格式。

Cheese( bestBefore < "27-Oct-2009" )

List和Map的访问 访问List:

// 和childList(0).getAge() == 18效果相同
Person( childList[0].age == 18 )

根据key访问map:

// 和credentialMap.get("jsmith").isValid()相同
Person( credentialMap["jsmith"].valid )

&&和|| 约束表达式可以通过&&和||来进行判断比较,此处用法与标准Java相似,当组合使用时,可通过括号来划分优先级。

Person( age > 30 && < 40 )
Person( age ( (> 30 && < 40) ||(> 20 && < 25) ) )
Person( age > 30 && < 40 || location == "london" )

DRL特殊操作符 “< ⇐ > >=”操作符用于属性的比较是按照默认的排序,比如日期属性使用小于号标示可以按照日期排序,当使用在String字符串的比较时,则按照字母顺序进行排序。此操作符仅适用于可比较的属性。

Person( firstName < $otherFirstName )
Person( birthDate < $otherBirthDate )

“!.”提供了一个默认空校验的操作。当使用此操作符时,会先校验当前对象是否为null,如果不为null再调用其方法或获得其属性进行判断。一旦当前操作对象为null,则相当于结果为false。

Person( $streetName : address!.street )

// 上面的写法相当于
Person( address != null, $streetName : address.street )

matches操作符可使用Java的正则表达式进行字符串的匹配,通常情况下是对字符串进行匹配,但也支持变量值为正确的表达式的方式。此操作符仅适用于字符串属性。如果属性值为null,匹配的结果始终为false。

Cheese( type matches "(Buffalo)?\S*Mozzarella" )

not matches方法与matches相同,唯一不同的是返回的结果与之相反。

Cheese( type not matches "(Buffalo)?\S*Mozzarella" )

contains操作符判断一个集合属性或元素是否包含指定字符串或变量值。仅适用于集合属性。也可以用于替代String.contains()来检查约束条件。not contains用法与之相同,结果取反。

CheeseCounter( cheeses contains "stilton" ) // 包含字符串
CheeseCounter( cheeses contains $var ) // 包含变量

Cheese( name contains "tilto" )
Person( fullName contains "Jr" )
String( this contains "foo" )

memberOf用来检查属性值是否为集合,此集合的表示必须为变量。not memberOf使用方法相同,结果取反。

CheeseCounter( cheese memberOf $matureCheeses )

soundslike的效果与matches相似,但它用来检查一个字符串的发音是否与指定的字符十分相似(使用英语发音)。

// 匹配 "fubar" 或 "foobar"
Cheese( name soundslike 'foobar' )

str操作用来比较一个字符串是否以指定字符串开头或结尾,有可以用于比较字符串的长度。

Message( routingValue str[startsWith] "R1" )
Message( routingValue str[endsWith] "R2" )
Message( routingValue str[length] 17 )

in和notin用来匹配一组数据中是否含一个或多个匹配的字符串,使用的方法与数据库中in的使用方法相似。待匹配的数据可以是字符串、变量。

Person( $cheese : favouriteCheese )
Cheese( type in ( "stilton", "cheddar", $cheese ) )

运算符优先级

操作类型操作符备注
(嵌套/空安全)属性访问.!.非标准java语义
List/Map访问[ ]非标准java语义
约束绑定:非标准java语义
乘除*/%
加减+-
移位<<>>>>>
关系<>⇐>=instanceof
==!=未使用标准java语义,某些语义相当于equals。
非短路AND&
非短路异或^
非短路包含OR|
逻辑与&&
逻辑或||
三元运算符? :
逗号分隔,相当于and,非标准java语义

###规则的结果部分

RHS是满足LHS条件之后进行后续处理部分的统称,该部分包含要执行的操作的列表信息。RHS主要用于处理结果,因此不建议在此部分再进行业务判断。如果必须要业务判断需要考虑规则设计的合理性,是否能将判断部分放置于LHS,那里才是判断条件应该在的地方。同时,应当保持RHS的精简和可读性。 如果在使用的过程中发现需要在RHS中使用AND或OR来进行操作,那么应该考虑将一根规则拆分成多个规则。

RHS的主要功能是对working memory中的数据进行insert、update、delete或modify操作,Drools提供了相应的内置方法来帮助实现这些功能,可以是纯java代码,比如:

then

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

end

当然也可以调用Fact的方法,比如 $message.execute();操作数据库等等一切操作。

结果部分也有drools提供的方法:

insert:往当前workingMemory中插入一个新的Fact对象,会触发规则的再次执行,除非使用no-loop限定;

insert的作用与在Java 类当中调用KieSession的insert方法效果一样,都是将Fact对象插入到当前的Working Memory当中,基本用法格式如下:

insert(newSomething());

调用insert之后,规则会进行重新匹配,如果没有设置no-loop为true或lock-on-active为true的规则,如果条件满足则会重新执行。update、modify、delete都具有同样的特性,因此在使用时需特别谨慎,防止出现死循环。 规则文件insert.drl

package com.rules

import com.secbro.drools.model.Product

rule "insert-check"
    salience 1
    when
       p : Product(type == GOLD);
     then
        System.out.println("insert-check:insert Product success and it's type is " + p.getType());
     end

rule "insert-action"
    salience 2
    when
    then
        System.out.println("insert-action : To insert the Product");
        Product p = new Product();
        p.setType(Product.GOLD);
        insert(p);
    end

测试代码:

@Test
public void commonTest(){
    KieServices kieServices = KieServices.get();
    KieContainer kieContainer = kieServices.getKieClasspathContainer();
    KieSession kieSession = kieContainer.newKieSession("ksession-rule");
    int count = kieSession.fireAllRules();
    kieSession.dispose();
    System.out.println("Fire " + count + " rules!");
}

打印日志:

insert-action : To insert the Product
insert-check:insert Product success and it's type is GOLD
Fire 2 rules!

根据优先级首先执行insert操作的规则,然后执行结果检测。

update:update函数可对Working Memory中的FACT对象进行更新操作,与StatefulSession中的update的作用基本相同。查看KnowledgeHelper接口中的update方法可以发现,update函数有多种参数组合的使用方法。在实际使用中更多的会传入FACT对象来进行更新操作。

atar

modify:修改,与update语法不同,结果都是更新操作,modify是基于结构化的更新操作,它将更新操作与设置属性相结合,用来更改FACT对象的属性。语法格式如下:

modify ( <fact-expression> ) {
    <expression> [ , <expression> ]*
}

其中fact-expression必须是FACT对象的引用,expression中的属性必须提供setter方法。在调用setter方法时,不必再写FACT对象的引用,编译器会自动添加。

rule "modify stilton"
when
    $stilton : Cheese(type == "stilton")
then
    modify( $stilton ){
        setPrice( 20 ),
        setAge( "overripe" )
    }
end

delete:删除,将Working Memory中的FACT对象删除,与kession中的retract/delete方法效果一样。同时delete函数和retract效果也相同,但后者已经被废弃。

retract:删除

RHS部分除了调用Drools提供的api和Fact对象的方法,也可以调用规则文件中定义的方法,方法的定义使用 function 关键字

function void console {

System.out.println();

StringUtils.getId();// 调用外部静态方法,StringUtils必须使用import导入,getId()必须是静态方法

}

Drools还有一个可以定义类的关键字:

declare 可以再规则文件中定义一个class,使用起来跟普通java对象相似,你可以在RHS部分中new一个并且使用getter和setter方法去操作其属性。

declare Address @author(quzishen) // 元数据,仅用于描述信息

@createTime(2011-1-24) city : String @maxLengh(100) postno : int end

上述的**'@'**是什么呢?是元数据定义,用于描述数据的数据~,没什么执行含义

你可以在RHS部分中使用Address address = new Address()的方法来定义一个对象。

# Drools 

评论

Your browser is out-of-date!

Update your browser to view this website correctly. Update my browser now

×