Java Drools5.1 规则流基础【示例】 -

mywaylife

浏览: 123241 次
性别:
来自: 广州

最近访客更多访客>>

loginboot

zdj444

kindherated

changfengwuhen

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

Java Drools5.1 规则流基础【示例】

博客分类：

Drools

一、问题描述

假设雇员Employ有：

           学历信息 eduInfo,   简历信息 resume,

           考核信息 annualExam 和奖惩信息 awardPunish；

要确定其：

           基本工资 basicSalary，职务工资 dutySalary，

           分红金额 bonus 和总工资 totalSalary.

规则如下：

【1】学历决定基本工资（basicSalary）：

                       ====>本科1500研究生2500

【2】简历决定职务工资(dutySalary) :

                       ====>技术2000管理4500

【3】年度考核决定分红(bonus)：

                       ====>分红总金额1000

                       ==>考核结果：

                        ==>优秀100%（1000）；良好90%（900）；

                                       合格60%（600）；不合格0%（0）；

【4】奖惩决定计算最终工资与【123】项工资之和的比例：

                       ====>奖励：*110%（+10%）

                       ====>惩罚：*90%（-10%）

                       ====>无：*100%（0%）

【5】计算总工资：（【1】+【2】+【3】）*【4】

二、问题分析

1.基本流程：

P【计算基本工资，计算职务工资，计算分红，计算奖惩比例】

                    ====>计算总工资(根据奖惩情况)

其中，P[i,...,k]表示任务i,...,k并发执行，====>表示顺序执行。

即有：P[1,2,3, 4] ===> 5

三、概要设计

【1】类Employ的设计：

【2】规则文件的编写和组织：

                ==>学历规则文件：EduInfoRule.drl

                ==>简历规则文件：ResumeRule.drl

                ==>分红规则文件：BonusRule.drl

                ==>奖惩规则文件：AwardPunish.drl

                ==>计算总工资规则：TotalRule.drl

【3】规则文件的组合（规则流）：

                 ==>EduInfo.drl含规则组basic_salary

                 ==>ResumeRule.drl含规则组duty_salary

                 ==>BonusRule.drl含规则组bonus_salary

                 ==>AwardPunish.drl含规则组award_punish

                  ==>TotalRule.drl含规则组sum_salary

组合方式：

[start]---> P[basic_sal ary , duty_salary, bonus_salary, award_punish]

                  --->sum_salary ---> [end]

其中：P表示并发，--->表示顺序【规则流图在后面的实现中给出】

【4】编写测试文件：EmployTest.java

四、详细设计

【1】使用EclipseIDE作为开发环境，drools5.1作为规则引擎

【2】为简单起见，Employ类的属性作了简化处理，

             eduInfo, resume , annualExam,   awardPunish均为String,

                   basic{duty,bonus,total}_salary , percent作为double类型。

五、规则文件及规则流

              EduInfoRule.drl:

package myrules;
import sample.Employ;
 
rule"Bachelor"
      ruleflow-group"basic_salary"
when
   emp:Employ(eduInfo =="bachelor");
then
   System.out.println("execrule Bachelor ... ");
   emp.setBasicSalary(1500);
end

rule"Master"
      ruleflow-group"basic_salary"
when
   emp:Employ(eduInfo=="master")
then
   System.out.println("execrule Master ... ");
   emp.setBasicSalary(2500);
end

Resume.drl

package myrules
import sample.Employ;

rule"Technician"
       ruleflow-group"duty_salary"
when
   emp:Employ(resume=="tech")
then
   System.out.println("execrule Technician ... ");
  emp.setDutySalary(2000);
end

rule"Manager"
      ruleflow-group"duty_salary"
when
   emp:Employ(awardPunish=="manager")
then
   System.out.println("execrule manager ... ");
   emp.setDutySalary(4500);
end

BonusRule.drl

package myrules
import sample.Employ;

rule"Excellent"
      ruleflow-group"bonus_salary"
when
  emp: Employ(annualExam=="excellent")
then
   System.out.println("execrule Excellent ... ");
  emp.setBonus(1000*1.0);
end

rule"Good"
       ruleflow-group"bonus_salary"
when
  emp: Employ(annualExam=="good")
then
   System.out.println("execrule Good ... ");
  emp.setBonus(1000*0.9);
end

rule"Common"
      ruleflow-group"bonus_salary"
when
  emp: Employ(annualExam=="common")
then
   System.out.println("execrule Common ... ");
  emp.setBonus(1000*0.6);
end

rule"failing"
       ruleflow-group"bonus_salary"
when
  emp: Employ(annualExam=="failing")
then
   System.out.println("execrule failing ... ");
  emp.setBonus(1000*0.0);
end

AwardPunish.drl

packagemyrules
importsample.Employ;

rule"Award"
       ruleflow-group"award_punish"
when
   emp:Employ(awardPunish=="award")
then
   System.out.println("execrule Award ... ");
  emp.setPercent(1.10);
end

rule"Punishment"
       ruleflow-group"award_punish"
when
   emp:Employ(awardPunish=="punish")
then
   System.out.println("execrule Punishment ... ");
  emp.setPercent(0.90);
end

rule"None"
      ruleflow-group"award_punish"
when
   emp:Employ(awardPunish=="none")
then
   System.out.println("execrule None ... ");
  emp.setPercent(1.00);
end

TotalRule.drl

package myrules
import sample.Employ;

rule"Total"
  ruleflow-group"sum_salary"
when
   emp: Employ()
then
   System.out.println("execrule Total ... ");
   double total =emp.getBasicSalary() + emp.getDutySalary() +
                 emp.getBonus();                               
   emp.setTotalSalary(total*emp.getPercent());
end

注意：

[1]Split结点类型为OR，约束选择alwaystrue.表示选择其规则组中所有符合事实的规则进行并发执行；

[2] Join结点类型为AND，表示当且进当上述规则组均执行完毕后，才执行后面的规则或进程。

六、测试代码：

Employ:

package sample;

public class Employ {
	
	public static final double BONUS = 1000;
	
	private String eduInfo;
	private String resume;
	private String annualExam;
	private String awardPunish;
	
	private double basicSalary;
	private double dutySalary;
	private double bonus;
	private double percent;
	
	private double totalSalary;
    
	public String getEduInfo() {
		return eduInfo;
	}
	public void setEduInfo(String eduInfo) {
		this.eduInfo = eduInfo;
	}
	public String getResume() {
		return resume;
	}
	public void setResume(String resume) {
		this.resume = resume;
	}
	public String getAnnualExam() {
		return annualExam;
	}
	public void setAnnualExam(String annualExam) {
		this.annualExam = annualExam;
	}
	public String getAwardPunish() {
		return awardPunish;
	}
	public void setAwardPunish(String awardPunish) {
		this.awardPunish = awardPunish;
	}
	
	public double getBasicSalary() {
		return basicSalary;
	}
	public void setBasicSalary(double basicSalary) {
		this.basicSalary = basicSalary;
	}
	
	public double getDutySalary() {
		return dutySalary;
	}
	public void setDutySalary(double dutySalary) {
		this.dutySalary = dutySalary;
	}

	public double getBonus() {
		return bonus;
	}
	public void setBonus(double bonus) {
		this.bonus = bonus;
	}
	
	public double getPercent() {
		return percent;
	}
	public void setPercent(double percent) {
		this.percent = percent;
	}
	
	public double getTotalSalary() {
		return totalSalary;
	}
	public void setTotalSalary(double totalSalary) {
		this.totalSalary = totalSalary;
	}
    
    public String toString() {
    	return "[" + eduInfo + " " + resume + " " + annualExam + " " +
    	             awardPunish + " " + basicSalary + " " + dutySalary + " " +
    	             bonus + " " + totalSalary + "]";   
    }
    
}

EmployTest:

package sample;

import org.drools.KnowledgeBase;
import org.drools.KnowledgeBaseFactory;
import org.drools.builder.KnowledgeBuilder;
import org.drools.builder.KnowledgeBuilderError;
import org.drools.builder.KnowledgeBuilderErrors;
import org.drools.builder.KnowledgeBuilderFactory;
import org.drools.builder.ResourceType;
import org.drools.io.ResourceFactory;
import org.drools.logger.KnowledgeRuntimeLogger;
import org.drools.logger.KnowledgeRuntimeLoggerFactory;
import org.drools.runtime.StatefulKnowledgeSession;

public class EmployTest {
	
	public static void main(String[] args) {
		
		try {
			// load up the knowledge base
			KnowledgeBase kbase = readKnowledgeBase();
			StatefulKnowledgeSession ksession = kbase.newStatefulKnowledgeSession();
			KnowledgeRuntimeLogger logger = KnowledgeRuntimeLoggerFactory.newFileLogger(ksession, "test");
			// go !
			Employ emp = new Employ();
			emp.setEduInfo("master");
			emp.setResume("tech");
			emp.setAnnualExam("good");
			emp.setAwardPunish("award");
			ksession.insert(emp);
			ksession.startProcess("myrules.salary");
			ksession.fireAllRules();	
			System.out.println("Basic Salary: " + emp.getBasicSalary());
			System.out.println("Duty Salary: " + emp.getDutySalary());
			System.out.println("Bonus      : " + emp.getBonus());
			System.out.println("rate       : " + emp.getPercent());
			System.out.printf("Total Salary: %.0f" , emp.getTotalSalary());
			logger.close();
		} catch (Throwable t) {
			t.printStackTrace();
		}			
		
	}
		
	private static KnowledgeBase readKnowledgeBase() throws Exception {
		KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();
		kbuilder.add(ResourceFactory.newClassPathResource("rules/EduInfoRule.drl"), ResourceType.DRL);
		kbuilder.add(ResourceFactory.newClassPathResource("rules/ResumeRule.drl"), ResourceType.DRL);
		kbuilder.add(ResourceFactory.newClassPathResource("rules/BonusRule.drl"), ResourceType.DRL);
		kbuilder.add(ResourceFactory.newClassPathResource("rules/AwardPunish.drl"), ResourceType.DRL);
	    kbuilder.add(ResourceFactory.newClassPathResource("rules/TotalRule.drl"), ResourceType.DRL);
		kbuilder.add(ResourceFactory.newClassPathResource("rules/salary.rf"), ResourceType.DRF);
		KnowledgeBuilderErrors errors = kbuilder.getErrors();
		if (errors.size() > 0) {
			for (KnowledgeBuilderError error: errors) {
				System.err.println(error);
			}
			throw new IllegalArgumentException("Could not parse knowledge.");
		}
		KnowledgeBase kbase = KnowledgeBaseFactory.newKnowledgeBase();
		kbase.addKnowledgePackages(kbuilder.getKnowledgePackages());
		return kbase;
	}	

}

测试结果：

execrule Technician ...

execrule Master ...

execrule Good ...

execrule Award ...

execrule Total ...

BasicSalary: 2500.0

DutySalary: 2000.0

Bonus : 900.0

rate : 1.1

TotalSalary: 5940

七、总结

Javadrools规则流基础：

【1】掌握规则引擎的基本工作原理；

【2】掌握规则文件的编写；

【3】掌握规则流图的绘制及应用程序集成。

【4】掌握规则组合的两种基本方式【并发和顺序】的实现方式。

下一步：

【1】更复杂的规则组合；

【2】规则文件的组织、管理；

【3】规则文件的自动生成；

【4】用户自定义规则；

NOTE: 关于XP下的示例作了一些修改，主要增加了XML格式的规则流文件及一个简单的自动生成顺序规则流的方法。已经上传至CSDN下载，请在下面网址下载：http://download.csdn.net/source/3462802