Drools Study

2013-04-23 本文已影响1787人哦啦

什么是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<Object> 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<Object> list) {

    StatefulKnowledgeSession session = knowledgeBase
            .newStatefulKnowledgeSession();

    for (Object obj : list) {
        session.insert(obj);
    }
    session.fireAllRules(new AgendaFilter() {
        @Override
        public boolean accept(org.drools.runtime.rule.Activation activation) {

            System.out.println("excute rule Name is :"
                    + activation.getRule().getName());
            return true;// 控制规则的执行与否
        }
    });
    session.dispose();

}

}

定义一个规则文件：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进来的时候，按照这张图的走向进行匹配
这里有一个简单版的解释说明