什么是Drools？
drools也叫JBoss Rules(JBoss Rules 的前身是Codehaus的一个开源项目叫Drools),是一种开源业务规则引擎。业务规则简单点说就是如果你在代码里需要写很多的if-else才能实现，这个时候可以考虑用JBoss Rules业务规则引擎。例如：银行的信用卡积分，当你消费的时候，银行会按照你消费的金额给你一定的积分，假设有以下规则：
- 如果消费日期是你的生日月，积分3倍发放
- 如果新开卡用户在三个自然月内，积分会按照2倍发放
- 如果是周末消费，积分按照1.5倍发放
- 当月消费10次以上，消费金额2倍积分额外加100积分
- 以上规则冲突时取最大值
而且这样的规则还会经常变动，比如生日月积分按照4倍发放等。类似于这样的业务场景，利用规则引擎会方便很多。
Drools的一个示例
上文的规则用Drools规则引擎实现，准备工作很简单，到官网上去下载jar包，这里用的是5.5.final版。
定义一个简单接口：
package com.taobao.matrix.drools;
import java.util.List;
public interface PointIssueEngine {
void init();
void executeRuleEngine(List其中用到的PointDO这个DO类定义如下：
package com.taobao.matrix.drools;
public class PointDO {
// 用户姓名
private String userName;
// 是否是生日月
private boolean birthdayMonth;
// 三个月内新用户
private boolean newMemberIn3Months;
// 是否周末
private boolean weekend;
// 月消费次数
private int countOfMonth;
//积分
private long point;
//消费金额
private long consumeTotal;
//是否已发放
private boolean issue;
public void print(){
System.out.println(String.format("%s is issued %s point!", userName,point));
}
//setter&getter methods....
}
接口实现类：
package com.taobao.matrix.drools;
import java.util.List;
import org.drools.KnowledgeBase;
import org.drools.KnowledgeBaseFactory;
import org.drools.builder.KnowledgeBuilder;
import org.drools.builder.KnowledgeBuilderConfiguration;
import org.drools.builder.KnowledgeBuilderFactory;
import org.drools.builder.ResourceType;
import org.drools.io.ResourceFactory;
import org.drools.runtime.StatefulKnowledgeSession;
import org.drools.runtime.rule.AgendaFilter;
public class PointIssueEngineImpl implements PointIssueEngine {
public PointIssueEngineImpl() {
init();
}
KnowledgeBase knowledgeBase;
@Override
public void init() {
KnowledgeBuilderConfiguration config = KnowledgeBuilderFactory
.newKnowledgeBuilderConfiguration();
config.setProperty("drools.dump.dir", "d:\\drools\\");// 这里可以将经过antlr词法分析生成的java源代码dump下来
System.setProperty("drools.dateformat", "yyyy-MM-dd HH:mm:ss");
KnowledgeBuilder knowledgeBuilder = KnowledgeBuilderFactory
.newKnowledgeBuilder(config);
knowledgeBuilder.add(ResourceFactory.newClassPathResource("point.drl"),
ResourceType.DRL);
if (knowledgeBuilder.hasErrors()) {// very important otherwise you don't
// what wrong with you rules!!
throw new RuntimeException("rule has error!pls check it!"
+ knowledgeBuilder.getErrors());
}
knowledgeBase = KnowledgeBaseFactory.newKnowledgeBase();
knowledgeBase.addKnowledgePackages(knowledgeBuilder
.getKnowledgePackages());
}
@Override
public void executeRuleEngine(List}
定义一个规则文件：point.drl
package com.taobao.matrix.drl;
import com.taobao.matrix.drools.PointDO;
import com.taobao.matrix.drools.Promotion;
//new member in 3 months
rule newMemberIn3Months
salience 9
no-loop true //对于本规则引起的fact变化(例如调用update，modify等)，只执行一次，但对于其他规则引起的无效
activation-group "issue" //一个执行规则组，在同一个组内，只能有一个规则被执行
lock-on-active true //no-loop的增强版，其他规则引起的工作内存中的fact变化时，规则也被执行一次
when
$pointDO:PointDO(newMemberIn3Months==true) && $promotion:Promotion(inPromotion==true)
then
System.out.println("execute newMemberIn3Months rule!!");
$pointDO.setPoint($pointDO.getConsumeTotal()*2+$promotion.getPoint());
//$pointDO.setUserName("cat");//不会引起规则重新执行
modify($pointDO){setUserName("cat"),setIssue(true)}; //modify修改属性会引起规则重新执行
end
//consume at weekend
rule consumeAtWeekend
salience 8
activation-group "issue"
lock-on-active true
when
$pointDO:PointDO(weekend == true)
then
System.out.println("execute consumeAtWeekend rule!!");
$pointDO.setPoint($pointDO.getConsumeTotal()*2);
$pointDO.setIssue(true);
modify($pointDO){setUserName("cat"),setIssue(true)};
end
//consume more than 10 times
rule consumeGT10Times
salience 11
no-loop true
lock-on-active true
activation-group "issue"
when
$pointDO:PointDO(countOfMonth>=10)
then
System.out.println("execute rule 10 times!!");
$pointDO.setPoint($pointDO.getPoint()+88);
$pointDO.setIssue(true);
modify($pointDO){setUserName("cat"),setIssue(true)};
end
//生日月
rule birthdayPoint
salience 0
no-loop false
lock-on-active true
activation-group "issue"
when
$pointDO : PointDO(birthdayMonth == true)
then
System.out.println("execute birthday month!");
$pointDO.setPoint(($pointDO.getConsumeTotal())*3);
//$pointDO.setWeekend(false);
//update($pointDO);
$pointDO.setIssue(true);
modify($pointDO){setUserName("cat"),setIssue(true)};
end
最后需要一个启动的main函数：
package com.taobao.matrix.drools;
import java.util.Arrays;
public class Main {
/**
* @param args
*/
public static void main(String[] args) {
PointIssueEngine engine = new PointIssueEngineImpl();
PointDO point = new PointDO();
point.setConsumeTotal(1000);
point.setBirthdayMonth(true);
point.setNewMemberIn3Months(true);
point.setCountOfMonth(10);
point.setWeekend(true);
point.setUserName("Tom");
Promotion promotion = new Promotion();
engine.executeRuleEngine(Arrays.asList(point,promotion));
System.out.println("发放消费积分:"+point.getUserName()+":" + point.getPoint());
}
}
Drools的大概执行过程
主要分为规则收集、规则编译、规则执行。首先把drl规则文件加载，通过antlr进行词法、语法分析，进而生成java源文件，这里可以通过配置将中间生成的java类dump到磁盘上，同时用jdt(这个是eclipse的编译工具，默认就是这个)或者JANINO进行编译成class文件存在hashmap里供RETE算法调用。
规则文件格式
package XXXX
import XXX.XXX.DO;
rule ruleName
salience 9
no-loop true //对于本规则引起的fact变化(例如调用update，modify等)，只执行一次，但对于其他规则引起的无效
activation-group "issue" //一个执行规则组，在同一个组内，只能有一个规则被执行
lock-on-active true //no-loop的增强版，其他规则引起的工作内存中的fact变化时，规则也被执行一次
when
LHS(Left Hand Size)条件
then
RHS(Right Hand Size)执行动作
end
- package 和java里面的包是一样的，最后生成的java源文件按照这个路径组织存在
- import 和java里面的一样，在rule里面用到的object都必须事先import进来
- rule-end 定义一个规则
规则属性
- salience int类型，优先级，当有多个条件(LHS)满足时，执行RHS的顺序，优先级高的先执行，默认随机执行
- no-loop true|false 对于本规则引起的fact变化(例如调用update，modify等)，只执行一次，但对于其他规则引起的无效
- activation-group "issue" 一个执行规则组，在同一个组内，只能有一个规则被执行
- lock-on-active true no-loop的增强版，其他规则引起的工作内存中的fact变化时，规则也被执行一次
- ......
宏函数
- insert 往workingMemory中插入一个fact，会引起规则引擎重新检查LHS，执行RHS
- update 更改一个fact，会引起规则引擎重新检查LHS，执行RHS
- modify 与update用法不同，效果一直，如果是直接操作fact的set方法不会引起规则引擎重新运行
- retract 从workingMemory中删除一个fact
- 在规则文件中同样可以定义类(使用declare关键字)，定义函数(function)
Drools使用的RETE算法
Rete 算法是一个用来实现产生式规则系统的高效模式匹配算法。
Rete算法由 Carnegie Mellon University 的Dr Charles L. Forgy设计发明，
RETE算法的思想
RETE算法是一个用于产生式系统的高效模式匹配算法,在一个产生式系统中，被处理的数据叫做working memory，用于判定的规则分为两个部分LHS（left-hand-side）和RHS（right hand side），分别表示前提和结论。主要流程可以分为以下步骤：
- Match：找出符合LHS部分的working memory集合
- Confilict resolution：选出一个条件被满足的规则
- Act：执行RHS的内容
- 回1
RETE算法主要改进Match的处理过程，通过构建一个网络进行匹配，是一个有向无环图。
一张经典的RETE算法图
简要说明：这张图是根据规则文件生成的，这时还没有进入计算运行，当有fact进来的时候，按照这张图的走向进行匹配
这里有一个简单版的解释说明