Drools规则引擎demo

一、eclipse安装drools插件

      1、插件下载地址：http://download.jboss.org/drools/release/7.22.0.Final/

   

2、将下载完的插件解压到本地

3、打开eclipse，选择help-> install new software。打开后点击Add按键，在弹出的对话框内点击Local按键，选择E:\SoftWare\drools\droolsjbpm-tools-distribution-7.22.0.Final\binaries

一直next（下一步）即可

4、重启eclipse，进入window下的preference，对Drools添加Runtime。点击Add，在弹出的对话框点击Browse，添加之前解压文件目录下的E:\SoftWare\drools\droolsjbpm-tools-distribution-7.22.0.Final\binaries文件夹，点击确定即可

 

二、创建drools的maven项目

    1、新建maven工程

2、添加maven依赖

<dependency>
   <groupId>org.drools</groupId>
   <artifactId>drools-core</artifactId>
   <version>7.0.0.Final</version>
</dependency>
    <dependency>
   <groupId>org.drools</groupId>
   <artifactId>drools-compiler</artifactId>
   <version>7.0.0.Final</version>
</dependency>
<dependency>
   <groupId>org.drools</groupId>
   <artifactId>drools-decisiontables</artifactId>
   <version>7.0.0.Final</version>
</dependency>
<dependency>
   <groupId>org.drools</groupId>
   <artifactId>drools-templates</artifactId>
   <version>7.0.0.Final</version>
</dependency>

3、创建实体类

package com.hundsun.bean;

public class Student {
	 //年龄
    private Integer age;
    
    private String responses;

	public Integer getAge() {
		return age;
	}

	public void setAge(Integer age) {
		this.age = age;
	}

	public String getResponses() {
		return responses;
	}

	public void setResponse(String responses) {
		this.responses = responses;
	}
    
	
	
    
}

4、创建studentrule.drl文件

import com.hundsun.bean.Student

rule "A"
 //条件Conditions即LHS（left hand side）
 when
  $student: Student(age<=18);
  //结果Actions即RHS（right hand side或者consequence）
  
 then 
  System.out.println("未成年人");
  $student.setResponse("未成年人");
end

rule "B"
 when
  $student: Student(age>20,age<=30);
 then
  System.out.println("已经二十多岁了");
  $student.setResponse("已经二十多岁了");
end

5、创建GetKnowledgeBaseUtil

package com.hundsun.utils;

import java.util.Collection;

import org.kie.api.io.ResourceType;
import org.kie.internal.KnowledgeBase;
import org.kie.internal.KnowledgeBaseFactory;
import org.kie.internal.builder.KnowledgeBuilder;
import org.kie.internal.builder.KnowledgeBuilderError;
import org.kie.internal.builder.KnowledgeBuilderErrors;
import org.kie.internal.builder.KnowledgeBuilderFactory;
import org.kie.internal.definition.KnowledgePackage;
import org.kie.internal.io.ResourceFactory;

public class GetKnowledgeBaseUtil {
	/* 读取规则 放入规则库 */
	public static KnowledgeBase readKnowledgeBase() {

		/* 通过规则收集工厂 派出一个规则收集者来 */
		KnowledgeBuilder knowledgeBuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();

		/* 通过规则收集者 收集规则 */
		knowledgeBuilder.add(ResourceFactory.newClassPathResource("studentrule.drl"), ResourceType.DRL);

		/* 获得规则收集者 收集规则过程中的错误 */
		KnowledgeBuilderErrors errors = knowledgeBuilder.getErrors();

		/* 如果error集大于0 说明有错误 */
		if (errors.size() > 0) {

			/* 遍历error集合 */
			for (KnowledgeBuilderError error : errors) {
				/* 打印输出错误 */
				System.out.println("我是规则收集者，收集过程中遇到" + error + "错误");
			}
			throw new IllegalArgumentException("Could not parse knowledge");
		}

		/* 规则收集者将 规则打包 */
		Collection<KnowledgePackage> knowledgePackages = knowledgeBuilder.getKnowledgePackages();

		/* 通过知识库工厂 new一个知识库来加载规则 */
		KnowledgeBase knowledgeBase = KnowledgeBaseFactory.newKnowledgeBase();

		/* 用知识库加载规则 */
		knowledgeBase.addKnowledgePackages(knowledgePackages);

		/* 返回知识库 */
		return knowledgeBase;
	}
}

6、编写启动类App

package com.hundsun.drools;

import java.util.Collection;

import org.kie.api.io.ResourceType;
import org.kie.internal.KnowledgeBase;
import org.kie.internal.KnowledgeBaseFactory;
import org.kie.internal.builder.KnowledgeBuilder;
import org.kie.internal.builder.KnowledgeBuilderError;
import org.kie.internal.builder.KnowledgeBuilderErrors;
import org.kie.internal.builder.KnowledgeBuilderFactory;
import org.kie.internal.definition.KnowledgePackage;
import org.kie.internal.io.ResourceFactory;
import org.kie.internal.runtime.StatefulKnowledgeSession;

import com.hundsun.bean.Student;
import com.hundsun.utils.GetKnowledgeBaseUtil;

/**
 * Hello world!
 *
 */
public class App {
	public static void main(String[] args) {
		// 通过readKnowledgeBase方法得到带规则的知识库
		KnowledgeBase knowledgeBase = GetKnowledgeBaseUtil.readKnowledgeBase();
		/* 通过知识库创建一个会话 */
		StatefulKnowledgeSession ksession = knowledgeBase.newStatefulKnowledgeSession();
		try {
			Student student = new Student();
			student.setAge(17);

			/* 将数据 专业名词叫 fact事实 加入到会话 */
			ksession.insert(student);
			Student student1 = new Student();
			student1.setAge(25);
			ksession.insert(student1);

			/* 执行所有的规则 与事实进行匹配,如果匹配到几条规则，a就等于几 */
			int a = ksession.fireAllRules();
			if (a > 0) {
				System.out.println(a);
				System.out.println(student.getResponses());
				System.out.println(student1.getResponses());
			}
			
		} finally {
			/* 关闭会话 */
			ksession.dispose();
		}
	}

	
}

7、执行启动类

 

三、由于KnowledgeBase类已经过期，下面介绍另一种写法

    1、编写studentrule.drl文件

2、编写KieSessionFactory

package com.hundsun.utils;

import org.kie.api.KieBase;
import org.kie.api.KieServices;
import org.kie.api.builder.KieBuilder;
import org.kie.api.builder.KieFileSystem;
import org.kie.api.builder.Message;
import org.kie.api.event.rule.DebugRuleRuntimeEventListener;
import org.kie.api.io.Resource;
import org.kie.api.io.ResourceType;
import org.kie.api.runtime.KieContainer;
import org.kie.api.runtime.KieSession;
import org.kie.api.runtime.StatelessKieSession;
import org.kie.internal.builder.KnowledgeBuilder;
import org.kie.internal.builder.KnowledgeBuilderError;
import org.kie.internal.builder.KnowledgeBuilderErrors;
import org.kie.internal.builder.KnowledgeBuilderFactory;
import org.kie.internal.io.ResourceFactory;

public class KieSessionFactory {
	private static KieSession kieSession;
	/**
	 * 创建KieSession单例对象
	 * @return
	 * @throws Exception
	 */
	public static KieSession get() throws Exception {
		 
	    try {
	    	if (kieSession != null) {
	            kieSession.dispose();
	            kieSession = null;
	          }
	      KieServices kieServices = KieServices.Factory.get();
	      KieFileSystem kfs = kieServices.newKieFileSystem();
	      Resource resource = kieServices.getResources().newClassPathResource("rules/studentrule.drl");
	      resource.setResourceType(ResourceType.DRL);
	      kfs.write(resource);
	      
	      KieBuilder kieBuilder = kieServices.newKieBuilder(kfs).buildAll();
	      if (kieBuilder.getResults().getMessages(Message.Level.ERROR).size() > 0) {
	        throw new Exception();
	      }
	      
	      KieContainer kieContainer = kieServices.newKieContainer(kieServices.getRepository().getDefaultReleaseId());
	      KieBase kBase = kieContainer.getKieBase();
	      kieSession = kBase.newKieSession();
	      return kieSession;
	 
	    } catch (Exception ex) {
	      throw ex;
	    }
	 
	  }
	
	/**
	   * 
	   * @title disposeKieSession
	   * @description TODO (清空对象)
	   * @return void
	   */
	  public static void disposeKieSession() {
	    if (kieSession != null) {
	      kieSession.dispose();
	      kieSession = null;
	    }
	 
	  }
	  
	  public static KieSession newKieSession(String classPath) throws Exception {
		  
		    KieServices kieServices = KieServices.Factory.get();
		    KieFileSystem kfs = kieServices.newKieFileSystem();
		    Resource resource = kieServices.getResources().newClassPathResource(classPath);
		    resource.setResourceType(ResourceType.DRL);
		    kfs.write(resource);
		    KieBuilder kieBuilder = kieServices.newKieBuilder(kfs).buildAll();
		    if (kieBuilder.getResults().getMessages(Message.Level.ERROR).size() > 0) {
		      throw new Exception();
		    }
		    KieContainer kieContainer = kieServices.newKieContainer(kieServices.getRepository().getDefaultReleaseId());
		    KieBase kBase = kieContainer.getKieBase();
		    KieSession kieSession = kBase.newKieSession();
		    kieSession.addEventListener(new DebugRuleRuntimeEventListener());
		    return kieSession;
		 
		  }
		 
		  public static StatelessKieSession newStatelessKieSession(String classPath) throws Exception {
		    KieServices kieServices = KieServices.Factory.get();
		    KieFileSystem kfs = kieServices.newKieFileSystem();
		    Resource resource = kieServices.getResources().newClassPathResource(classPath);
		    resource.setResourceType(ResourceType.DRL);
		    kfs.write(resource);
		    KieBuilder kieBuilder = kieServices.newKieBuilder(kfs).buildAll();
		    if (kieBuilder.getResults().getMessages(Message.Level.ERROR).size() > 0) {
		      throw new Exception();
		    }
		    KieContainer kieContainer = kieServices.newKieContainer(kieServices.getRepository().getDefaultReleaseId());
		    KieBase kBase = kieContainer.getKieBase();
		    StatelessKieSession kiesession = kBase.newStatelessKieSession();
		    return kiesession;
		 
		  }
}

3、编写App2

package com.hundsun.drools;

import org.kie.api.runtime.KieSession;

import com.hundsun.bean.Student;
import com.hundsun.utils.KieSessionFactory;

public class App2 {
	public static void main(String[] args) throws Exception {
        
        KieSession kieSession2 = KieSessionFactory.get();
        Student student1 = new Student();
        student1.setAge(17);
        Student student2 = new Student();
        student2.setAge(25);
        kieSession2.insert(student1);
        kieSession2.insert(student2);
        kieSession2.fireAllRules();
        
        KieSessionFactory.disposeKieSession();

	}
	
	
}

4、执行启动类