1.Drools简单例子
首先是搭建一个可供进行Drools开发的框架。Jboss官方推荐使用Drools Eclipse IDE进行开发，但是我发现其插件的安装相当繁琐，对其他的组件依赖严重，而且里面新手能用到的东东不多，下面就偷懒来搭建一个demo。
此demo基于Maven3进行开发，没有用过Maven的同学还是希望先看看Maven的东西。当然，不用maven也是没有问题的，你需要用到的包如下图：
当然最好还是用maven。首先使用ecplise新建一个maven的工程：TestDrools，在其中Pom.xml中添加如下依赖：
<dependencies>
<dependency>
<groupId>org.drools</groupId>
<artifactId>drools-core</artifactId>
<version>5.2.0.M2</version>
</dependency>
<dependency>
<groupId>org.drools</groupId>
<artifactId>drools-compiler</artifactId>
<version>5.2.0.M2</version>
</dependency>
<dependency>
<groupId>com.thoughtworks.xstream</groupId>
<artifactId>xstream</artifactId>
<version>1.3.1</version>
</dependency>
</dependencies>
我们假定如下情景：网站伴随业务产生而进行的积分发放操作。比如支付宝信用卡还款奖励积分等。
我们定义一下发放规则：
积分的发放参考因素有：交易笔数、交易金额数目、信用卡还款次数、生日特别优惠等。
定义规则：
// 过生日，则加10分，并且将当月交易比数翻倍后再计算积分
// 2011-01-08 - 2011-08-08每月信用卡还款3次以上，每满3笔赠送30分
// 当月购物总金额100以上，每100元赠送10分
// 当月购物次数5次以上，每五次赠送50分
// 特别的，如果全部满足了要求，则额外奖励100分
// 发生退货，扣减10分
// 退货金额大于100，扣减100分
首先我们进入的Drools规则的编制阶段。这里采用drl文件定义规则，我们分别建立两个drl文件。
addpoint.drl：
package com.drools.demo.point
import com.jd.drools.test.PointDomain;
rule birthdayPoint
// 过生日，则加10分，并且将当月交易比数翻倍后再计算积分
salience 100
lock-on-active true
when
$pointDomain : PointDomain(birthDay == true)
then
$pointDomain.setPoint($pointDomain.getPoint()+10);
$pointDomain.setBuyNums($pointDomain.getBuyNums()*2);
$pointDomain.setBuyMoney($pointDomain.getBuyMoney()*2);
$pointDomain.setBillThisMonth($pointDomain.getBillThisMonth()*2);
$pointDomain.recordPointLog($pointDomain.getUserName(),"birthdayPoint");
end
rule billThisMonthPoint
// 2011-01-08 - 2011-08-08每月信用卡还款3次以上，每满3笔赠送30分
salience 99
lock-on-active true
date-effective "2011-01-08 23:59:59"
date-expires "2011-08-08 23:59:59"
when
$pointDomain : PointDomain(billThisMonth >= 3)
then
$pointDomain.setPoint($pointDomain.getPoint()+$pointDomain.getBillThisMonth()/3*30);
$pointDomain.recordPointLog($pointDomain.getUserName(),"billThisMonthPoint");
end
rule buyMoneyPoint
// 当月购物总金额100以上，每100元赠送10分
salience 98
lock-on-active true
when
$pointDomain : PointDomain(buyMoney >= 100)
then
$pointDomain.setPoint($pointDomain.getPoint()+ (int)$pointDomain.getBuyMoney()/100 * 10);
$pointDomain.recordPointLog($pointDomain.getUserName(),"buyMoneyPoint");
end
rule buyNumsPoint
// 当月购物次数5次以上，每五次赠送50分
salience 97
lock-on-active true
when
$pointDomain : PointDomain(buyNums >= 5)
then
$pointDomain.setPoint($pointDomain.getPoint()+$pointDomain.getBuyNums()/5 * 50);
$pointDomain.recordPointLog($pointDomain.getUserName(),"buyNumsPoint");
end
rule allFitPoint
// 特别的，如果全部满足了要求，则额外奖励100分
salience 96
lock-on-active true
when
$pointDomain:PointDomain(buyNums >= 5 && billThisMonth >= 3 && buyMoney >= 100)
then
$pointDomain.setPoint($pointDomain.getPoint()+ 100);
$pointDomain.recordPointLog($pointDomain.getUserName(),"allFitPoint");
End
subpoint.drl:
package com.drools.demo.point
import com.jd.drools.test.PointDomain;
rule subBackNumsPoint
// 发生退货，扣减10分
salience 10
lock-on-active true
when
$pointDomain : PointDomain(backNums >= 1)
then
$pointDomain.setPoint($pointDomain.getPoint()-10);
$pointDomain.recordPointLog($pointDomain.getUserName(),"subBackNumsPoint");
end
rule subBackMondyPoint
// 退货金额大于100，扣减100分
salience 9
lock-on-active true
when
$pointDomain : PointDomain(backMondy >= 100)
then
$pointDomain.setPoint($pointDomain.getPoint()-10);
$pointDomain.recordPointLog($pointDomain.getUserName(),"subBackMondyPoint");
End
这样我们就把开头所述的规则浓缩到这两个文件当中，Drools中可以使用PackageBuilder类来编译这两个文件。（具体用法在下面有体现）
接下来进入Drools的运行阶段。首先需要说明Drools中一个比较重要的概念：fact对象。
在Drools 当中是通过向WorkingMemory中插入Fact对象的方式来实现规则引擎与业务数据的交互，对于Fact对象就是普通的具有若干个属性及其对应的getter与setter方法的JavaBean对象。Drools除了可以接受用户在外部向WorkingMemory当中插入现成的Fact对象，还允许用户在规则文件当中定义一个新的Fact 对象, 在规则文件当中定义Fact 对象要以declare 关键字开头，以end 关键字结尾，中间部分就是该Fact 对象的属性名及其类型等信息的声明。
我们定义此例中的fact对象：PointDomain.java
/**
* 积分计算对象
* @author quzishen
*/
public class PointDomain {
// 用户名
private String userName;
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public boolean isBirthDay() {
return birthDay;
}
public void setBirthDay(boolean birthDay) {
this.birthDay = birthDay;
}
public long getPoint() {
return point;
}
public void setPoint(long point) {
this.point = point;
}
public int getBuyNums() {
return buyNums;
}
public void setBuyNums(int buyNums) {
this.buyNums = buyNums;
}
public int getBackNums() {
return backNums;
}
public void setBackNums(int backNums) {
this.backNums = backNums;
}
public double getBuyMoney() {
return buyMoney;
}
public void setBuyMoney(double buyMoney) {
this.buyMoney = buyMoney;
}
public double getBackMondy() {
return backMondy;
}
public void setBackMondy(double backMondy) {
this.backMondy = backMondy;
}
public int getBillThisMonth() {
return billThisMonth;
}
public void setBillThisMonth(int billThisMonth) {
this.billThisMonth = billThisMonth;
}
// 是否当日生日
private boolean birthDay;
// 增加积分数目
private long point;
// 当月购物次数
private int buyNums;
// 当月退货次数
private int backNums;
// 当月购物总金额
private double buyMoney;
// 当月退货总金额
private double backMondy;
// 当月信用卡还款次数
private int billThisMonth;
/**
* 记录积分发送流水，防止重复发放
* @param userName 用户名
* @param type 积分发放类型
*/
public void recordPointLog(String userName, String type){
System.out.println("增加对"+userName+"的类型为"+type+"的积分操作记录.");
}
}
规则有了，交互的对象也有了，我们需要实现一个workingMemory来装载这些对象进行运算。在Drools5 当中提供了两个对象与规则引擎进行交互：StatefulKnowledgeSession
和StatelessKnowledgeSession。本例中使用了StatefulKnowledgeSession进行交互。
前面说过一个RuleBase可以同时初始化多个Working Memory，而RuleBase是通过Drools中的
RuleBaseFactory产生的。我们先定义一个工厂类用于获取单例的RuleBase。
RuleBaseFacatory.java
/**
* RuleBaseFacatory 单实例RuleBase生成工具
* @author quzishen
*/
public class RuleBaseFacatory {
private static RuleBase ruleBase;
public static RuleBase getRuleBase(){
return null != ruleBase ? ruleBase : RuleBaseFactory.newRuleBase();
}
}
接下来定义一个定义积分规则接口，里面包含了初始化RuleBase、workingMemory以及执行规则的方法。
PointRuleEngine.java
/**
* 规则接口
* @author quzishen
*/
public interface PointRuleEngine {
/**
* 初始化规则引擎
*/
public void initEngine();
/**
* 刷新规则引擎中的规则
*/
public void refreshEnginRule();
/**
* 执行规则引擎
* @param pointDomain 积分Fact
*/
public void executeRuleEngine(final PointDomain pointDomain);
}
定义它的实现类，并封装main方法用于测试规则是否有效。
PointRuleEngineImpl.java
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.util.ArrayList;
import java.util.List;
import org.drools.RuleBase;
import org.drools.StatefulSession;
import org.drools.compiler.DroolsParserException;
import org.drools.compiler.PackageBuilder;
import org.drools.spi.Activation;
import com.jd.drools.test.PointDomain;
/**
* 规则接口实现类
* @author quzishen
*/
public class PointRuleEngineImpl implements PointRuleEngine {
private RuleBase ruleBase;
/* (non-Javadoc)
* @see com.drools.demo.point.PointRuleEngine#initEngine()
*/
public void initEngine() {
// 设置时间格式
System.setProperty("drools.dateformat", "yyyy-MM-dd HH:mm:ss");
ruleBase = RuleBaseFacatory.getRuleBase();
try {
PackageBuilder backageBuilder = getPackageBuilderFromDrlFile();
ruleBase.addPackages(backageBuilder.getPackages());
} catch (DroolsParserException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
}
/* (non-Javadoc)
* @see com.drools.demo.point.PointRuleEngine#refreshEnginRule()
*/
public void refreshEnginRule() {
ruleBase = RuleBaseFacatory.getRuleBase();
org.drools.rule.Package[] packages = ruleBase.getPackages();
for(org.drools.rule.Package pg : packages) {
ruleBase.removePackage(pg.getName());
}
initEngine();
}
/* (non-Javadoc)
* @see com.drools.demo.point.PointRuleEngine#executeRuleEngine(com.drools.demo.point.PointDomain)
*/
public void executeRuleEngine(final PointDomain pointDomain) {
if(null == ruleBase.getPackages() || 0 == ruleBase.getPackages().length) {
return;
}
StatefulSession statefulSession = ruleBase.newStatefulSession();
statefulSession.insert(pointDomain);
// fire
statefulSession.fireAllRules(new org.drools.spi.AgendaFilter() {
public boolean accept(Activation activation) {
return !activation.getRule().getName().contains("_test");
}
});
statefulSession.dispose();
}
/**
* 从Drl规则文件中读取规则
* @return
* @throws Exception
*/
private PackageBuilder getPackageBuilderFromDrlFile() throws Exception {
// 获取测试脚本文件
List<String> drlFilePath = getTestDrlFile();
// 装载测试脚本文件
List<Reader> readers = readRuleFromDrlFile(drlFilePath);
PackageBuilder backageBuilder = new PackageBuilder();
for (Reader r : readers) {
backageBuilder.addPackageFromDrl(r);
}
// 检查脚本是否有问题
if(backageBuilder.hasErrors()) {
throw new Exception(backageBuilder.getErrors().toString());
}
return backageBuilder;
}
/**
* @param drlFilePath 脚本文件路径
* @return
* @throws FileNotFoundException
*/
private List<Reader> readRuleFromDrlFile(List<String> drlFilePath) throws FileNotFoundException {
if (null == drlFilePath || 0 == drlFilePath.size()) {
return null;
}
List<Reader> readers = new ArrayList<Reader>();
for (String ruleFilePath : drlFilePath) {
readers.add(new FileReader(new File(ruleFilePath)));
}
return readers;
}
/**
* 获取测试规则文件
*
* @return
*/
private List<String> getTestDrlFile() {
List<String> drlFilePath = new ArrayList<String>();
drlFilePath
.add("D:\\myworkspace\\TestDrools\\target\\classes\\addpoint.drl");
drlFilePath
.add("D:\\myworkspace\\TestDrools\\target\\classes\\subpoint.drl");
return drlFilePath;
}
public static void main(String[] args) throws IOException {
PointRuleEngine pointRuleEngine = new PointRuleEngineImpl();
while(true){
InputStream is = System.in;
BufferedReader br = new BufferedReader(new InputStreamReader(is));
String input = br.readLine();
System.out.println("请输入命令：");
if(null != input && "s".equals(input)){
System.out.println("初始化规则引擎...");
pointRuleEngine.initEngine();
System.out.println("初始化规则引擎结束.");
}else if("e".equals(input)){
final PointDomain pointDomain = new PointDomain();
System.out.println("初始化规则引擎...");
pointRuleEngine.initEngine();
System.out.println("初始化规则引擎结束.");
pointDomain.setUserName("hello kity");
pointDomain.setBackMondy(100d);
pointDomain.setBuyMoney(500d);
pointDomain.setBackNums(1);
pointDomain.setBuyNums(5);
pointDomain.setBillThisMonth(5);
pointDomain.setBirthDay(true);
pointDomain.setPoint(0l);
pointRuleEngine.executeRuleEngine(pointDomain);
System.out.println("执行完毕BillThisMonth："+pointDomain.getBillThisMonth());
System.out.println("执行完毕BuyMoney："+pointDomain.getBuyMoney());
System.out.println("执行完毕BuyNums："+pointDomain.getBuyNums());
System.out.println("执行完毕规则引擎决定发送积分："+pointDomain.getPoint());
} else if("r".equals(input)){
System.out.println("刷新规则文件...");
pointRuleEngine.refreshEnginRule();
System.out.println("刷新规则文件结束.");
}
}
}
}
执行main方法，输入'e'，得到：
初始化规则引擎...
初始化规则引擎结束.
增加对hello kity的类型为birthdayPoint的积分操作记录.
增加对hello kity的类型为buyMoneyPoint的积分操作记录.
增加对hello kity的类型为buyNumsPoint的积分操作记录.
增加对hello kity的类型为allFitPoint的积分操作记录.
增加对hello kity的类型为subBackNumsPoint的积分操作记录.
增加对hello kity的类型为subBackMondyPoint的积分操作记录.
执行完毕BillThisMonth：10
执行完毕BuyMoney：1000.0
执行完毕BuyNums：10
执行完毕规则引擎决定发送积分：290
2.Droolsv API解释
Drools API可以分为三类：规则编译、规则收集和规则的执行
API:
1. KnowledgeBuilder规则编译：规则文件进行编译， 最终产生一批编译好的规则包(KnowledgePackage)供其它的应用程序使用
2. KnowledgeBase：提供的用来收集应用当中知识（knowledge）定义的知识库对象，在一个KnowledgeBase 当中可以包含普通的规则（rule）、规则流(rule flow)、函数定义(function)、用户自定义对象（type model）等
3. StatefulKnowledgeSession：是一种最常用的与规则引擎进行交互的方式，它可以与规则引擎建立一个持续的交互通道，在推理计算的过程当中可能会多次触发同一数据集。在用户的代码当中，最后使用完StatefulKnowledgeSession 对象之后，一定要调用其dispose()方法以释放相关内存资源。有状态的
4. StatelessKnowledgeSession：使用StatelessKnowledgeSession 对象时不需要再调用dispose()方法释放内存资源不能进行重复插入fact 的操作、也不能重复的调用fireAllRules()方法来执行所有的规则，对应这些要完成的工作在StatelessKnowledgeSession当中只有execute(…)方法，通过这个方法可以实现插入所有的fact 并且可以同时执行所有的规则或规则流，事实上也就是在执行execute(…)方法的时候就在StatelessKnowledgeSession内部执行了insert()方法、fireAllRules()方法和dispose()方法
5. Fact ：是指在Drools 规则应用当中，将一个普通的JavaBean 插入到规则的WorkingMemory当中后的对象规则可以对Fact 对象进行任意的读写操作，当一个JavaBean 插入到WorkingMemory 当中变成Fact 之后，Fact 对象不是对原来的JavaBean 对象进行Clone，而是原来JavaBean 对象的引用
6.
7.Drools规则
7.1规则文件
在 Drools 当中，一个标准的规则文件就是一个以“.drl”结尾的文本文件，标准的规则文件格式：
package package-name //包名是必须的，并放在第一行，包名对于规则文件中规则的管理只限于逻辑上的
imports
globals
functions
queries
rules
7.2规则语言
一个标准规则的结构
rule "name" //规则名称
attributes //属性部分
when
LHS //left hand sid条件部分
then
RHS //right hand sid结果部分
End
7.2.1条件部分
条件部分又被称之为Left Hand Side，简称为LHS，条件又称之为pattern（匹配模式）:在一个规则当中when与then 中间的部分就是LHS 部分。在LHS 当中，可以包含0~n 个条件，如果LHS 部分没空的话，那么引擎会自动添加一个eval(true)的条件，由于该条件总是返回true，所以LHS 为空的规则总是返回true，在Drools
当中在pattern 中没有连接符号，那么就用and 来作为默认连接，所以在该规则的LHS 部分中两个pattern 只有都满足了才会返回true。默认情况下，每行可以用“;”来作为结束符（和Java 的结束一样），当然行尾也可以不加“;”结尾。
约束连接：对于对象内部的多个约束的连接，可以采用“&&”（and）、“||”(or)和“,”(and)来实现，表面上看“,”与“&&”具有相同的含义，但是有一点需要注意，“，”与“&&”和“||”不能混合使用，也就是说在有“&&”或“||”出现的LHS 当中，是不可以有“，”连接符出现的，反之亦然。
1. 比较操作符：共计12种：
>、>=、<、<=、= =、!=、
contains、not contains、memberof、not memberof、matches、not matches
1) Contains：比较操作符contains 是用来检查一个Fact 对象的某个字段（该字段要是一个Collection或是一个Array 类型的对象）是否包含一个指定的对象
contains 只能用于对象的某个Collection/Array 类型的字段与另外一个值进行比较，作为比较的值可以是一个静态的值，也可以是一个变量(绑定变量或者是一个global 对象)
示例：
package test
rule "rule1"
when
$order:Order();
$customer:Customer(age >20, orders contains $order);
then
System.out.println($customer.getName());
end
2) Not Contains：与contains作用相反
3) Member Of ：是用来判断某个Fact 对象的某个字段是否在一个集合（Collection/Array）当中，用法与contains 有些类似，但也有不同，member of 前边是某个数据对象且一定要是一个变量(绑定变量或者是一个global 对象)，后边是数据对象集合：
示例：
package test
global String[] orderNames;
rule "rule1"
when
$order:Order(name memberOf orderNames);
then
System.out.println($order.getName());
End
4) Not member of：与member of作用相反
5) Matches: matches 是用来对某个Fact 的字段与标准的Java 正则表达式进行相似匹配，被比较的字符串可以是一个标准的Java 正则表达式，但有一点需要注意，那就是正则表达式字符串当中不用考虑“\”的转义问题
示例：
package test
import java.util.List;
rule "rule1"
when
$customer:Customer(name matches "李.*");
then
System.out.println($customer.getName());
end
6) not matches:与matches相反
结果部分：结果部分又被称之为Right Hand Side，简称为RHS，在一个规则当中then 后面部分就是RHS，只有在LHS 的所有条件都满足时RHS 部分才会执行, salience该属性的作用是通过一个数字来确认规则执行的优先级，数字越大，执行越靠前。
函数介绍：
ü Insert：作用与我们在Java类当中调用StatefulKnowledgeSession对象的insert 方法的作用相同，都是用来将一个Fact 对象插入到当前的Working Memory 当中。一旦调用insert宏函数，那么Drools会重新与所有的规则再重新匹配一次
ü insertLogical:作用与insert 类似，它的作用也是将一个Fact 对象插入到当前的WorkingMemroy 当中
ü update:用来实现对当前Working Memory 当中的Fact 进行更新。如果希望规则只执行一次，那么可以通过设置规则的no-loop属性为true 来实现
示例：
package test
import java.util.List;
query "query fact count"
Customer();
end
rule "rule1"
salience 2
when
eval(true);
then
Customer cus=new Customer();
cus.setName("张三");
cus.setAge(1);
insert(cus);
end
rule "rule2"
salience 1
when
$customer:Customer(name=="张三",age<10);
then
$customer.setAge($customer.getAge()+1);
update($customer);
System.out.println("----------"+$customer.getName());
End
示例说明：
调用update 宏函数更新Customer 对象后Working Memory 当中还只存在一个Customer 对象
ü retract：宏函数retract也是用来将Working Memory当中某个Fact对象从Working Memory当中删除
ü drools:宏对象可以实现在规则文件里直接访问Working Memory
常用方法说明：
|
方法名称 |
含义说明 |
|
getWorkingMemory() |
获取当前的WorkingMemory 对象 |
|
halt() |
在当前规则执行完成后，不再执行
其它未执行的规则。 |
|
getRule() |
得到当前的规则对象 |
|
insert(new Object) |
向当前的WorkingMemory 当中插入
指定的对象，功能与宏函数insert
相同 |
|
update(new Object) |
更新当前的WorkingMemory 中指定
的对象，功能与宏函数update 相同 |
|
update(FactHandle
Object) |
更新当前的WorkingMemory 中指定
的对象，功能与宏函数update 相同。 |
|
retract(new Object) |
从当前的WorkingMemory 中删除指
定的对象，功能与宏函数retract 相
同。 |
|
kcontext |
作用主要是用来得到当前的
KnowledgeRuntime 对象，KnowledgeRuntime 对象可以实现与引擎的各种交互 |
ü Modify：是一个表达式块，它可以快速实现对Fact 对象多个属性进行修改，修改完成后会自动更新到当前的Working Memory 当中
7.2.2属性部分
规则的属性共有13 个分别是：activation-group、agenda-group、auto-focus、date-effective、date-expires、dialect、duration、enabled、lock-on-active、no-loop、ruleflow-group、salience、when
1. Salience: 属性的值是一个数字，数字越大执行优先级越高，同时它的值可以是一个负数。默认情况下，规则的salience默认值为0，所以如果我们不手动设置规则的salience属性，那么它的执行顺序是随机的。
2. no-loop: 属性的值是一个布尔型，默认情况下规则的no-loop属性的值为false，如果no-loop 属性值为true，那么就表示该规则只会被引擎检查一次，如果满足条件就执行规则的RHS 部分
3. date-effective：在规则运行时，引擎会自动拿当前操作系统的时间与date-effective设置的时间值进行比对，只有当系统时间>=date-effective设置的时间值时，规则才会触发执行，否则执行将不执行。日期格式：dd-MM-yyyy
4. date-expires该属性的作用与date-effective属性恰恰相反，如果大于系统时间，那么规则就执行，否则就不执行。日期格式：dd-MM-yyyy
5. enabled: true执行该规则，false不执行该规则
6. dialect：该属性用来定义规则当中要使用的语言类型：mvel 和java，如果没有手工设置规则的dialect，默认使用的java 语言
7. duration: 该属性对应的值为一个长整型，单位是毫秒。如果设置了该属性，那么规则将在该属性值之后时间，在另外一个线程里触发
8. lock-on-active：该属性为boolean，当在规则上使用ruleflow-group属性或agenda-group属性的时候，将lock-on-action属性的值设置为true，可能避免因某些Fact 对象被修改而使已经执行过的规则再次被激活执行
9. activation-group该属性的作用是将若干个规则划分成一个组，用一个字符串来给这个组命名，这样在执 行的时候，具有相同 activation-group 属性的规则中只要有一个会被执行，其它的规则都将 不再执行。
10. agenda-group: agenda-group规则的调用与执行是通过StatelessSession 或StatefulSession 来实现的，一般的顺序是创建一个StatelessSession 或StatefulSession，将各种经过编译的规则的package添加到session当中，接下来将规则当中可能用到的Global 对象和Fact对象插入到Session 当中，最后调用fireAllRules 方法来触发、执行规则。在没有调用最后一步fireAllRules 方法之前，所有的规则及插入的Fact对象都存放在一个名叫Agenda 表的对象当中，这个Agenda表中每一个规则及与其匹配相关业务数据叫做Activation，在调用fireAllRules方法后，这些Activation会依次执行，这些位于Agenda表中的Activation的执行顺序在没有设置相关用来控制顺序的属性时（比如salience 属性），它的执行顺序是随机的，不确定的。Agenda Group是用来在Agenda的基础之上，对现在的规则进行再次分组，具体的分组方法可以采用为规则添加agenda-group属性来实现
11. auto-focus:它的作用是用来在已设置了agenda-group的规则上设置该规则是否可以自动独取Focus，如果该属性设置为true，那么在引擎执行时，就不需要显示的为某个Agenda Group设置Focus否则需要。
12. ruleflow-group: 在使用规则流的时候要用到ruleflow-group属性，该属性的值为一个字符串，作用是用来将规则划分为一个个的组，然后在规则流当中通过使用ruleflow-group 属性的值，从而使用对应的规则
7.2.3注释
1. 单行注释：采用“#”或者“//”来进行标记
2. 多行注释：以“/*”开始，以“*/”结束
7.3函数
函数的编写位置可以是规则文件当中package 声明后的任何地方
function void/Object functionName(Type arg...) {
/*函数体的业务代码*/
}
函数以function标记开头，可以有或无返回类型，然后定义方法名和参数，语法基本同java一致，不同规则文件的函数相互之间是不可见的。
示例：
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
7.4查询
查询是Drools 当中提供的一种根据条件在当前的WorkingMemory当中查找Fact 的方法，在Drools当中查询可分为两种：一种是不需要外部传入参数；一种是需要外部传入参数
7.4.1无参数查询
在Drools当中查询以query 关键字开始，以end 关键字结束，在package 当中一个查询要有唯一的名称，查询的内容就是查询的条件部分，条件部分内容的写法与规则的LHS 部分写法完全相同
示例：
query "testQuery"
customer:Customer(age>30,orders.size >10)
end
查询的调用是由StatefulSession完成的，通过调用StatefulSession对象的getQueryResults(String queryName)方法实现对查询的调用，该方法的调用会返回一个QueryResults对象，QueryResults是一个类似于Collection接口的集合对象，在它当中存放在若干个QueryResultsRow对象，通过QueryResultsRow可以得到对应的Fact对象，从而实现根据条件对当前WorkingMemory当中Fact 对象的查询
7.4.2参数查询
和函数一样，查询也可以接收外部传入参数
代码示例：
query "testQuery"(int $age,String $gender)
customer:Customer(age>$age,gender==$gender)
end
7.5对象定义
在 Drools当中，可以定义两种类型的对象：一种是普通的类型Java Fact 的对象；另一种是用来描述Fact 对象或其属性的元数据对象。
7.5.1 java Fact 对象
在Drools 当中是通过向WorkingMemory中插入Fact对象的方式来实现规则引擎与业务数据的交互，对于Fact对象就是普通的具有若干个属性及其对应的getter与setter方法的JavaBean对象。Drools除了可以接受用户在外部向WorkingMemory当中插入现成的Fact对象，还允许用户在规则文件当中定义一个新的Fact 对象, 在规则文件当中定义Fact 对象要以declare 关键字开头，以end 关键字结尾，中间部分就是该Fact 对象的属性名及其类型等信息的声明。
示例：
declare Address
city : String
addressName : String
end
7.5.2元数据定义
为Fact对象的属性或者是规则来定义元数据，元数据定义采用的是“@”符号开头，后面是元数据的属性名（属性名可以是任意的），然后是括号，括号当中是该元数据属性对应的具体值
示例：
@author(jacob)