【java规则引擎】之Drools引擎中模拟ReteooStatefulSession内部设计结构

　　该片文章只是抽取drools中java代码实现的一些代码结构，帮助我们理解drools是如何实现rete算法的。
　　该部分只是抽取ReteooStatefulSession工作过程中的代码架构

利用了多线程设计的一个代理模式（自己起的名字）

　　利用了23中设计模式中的命令模式

一：模拟drools中ReteooStatefulSession的实现对象StatefulSession

 package com.nonbankcard.drools.module;

 /**
  *
  * 在当前的设计模式中：
  * （1）它作为规则匹配的发起者，它内部引用了执行器代理，执行器
  * （2）执行器引用了它
  * （3）它提交一个命令，交给执行器代理，执行器代理交给执行器线程异步处理
  *
  *在drools中
  * （1）把规则库理解成一个数据库，规则匹配的入口，类比jdbc的一个链接对象
  * （2）它引用ruleBase（规则库）
  * （3）RuleBase（规则库）里也引用了它
  * @author sxf
  *
  */
 public class StatefulSession implements WorkingMemory{

     /**
      * 业务执行器的代理
      */
     private DefaultExecutorService executorService;

     public StatefulSession(DefaultExecutorService executorService ){
         this.executorService=executorService;
     }

     /**
      * 异步插入命令，执行命令
      * @param object
      * @return
      */
     public Future asyncInsert(final Command command) {
         this.executorService.submit(command);
         return (Future) command;
     }

     /**
      * 是否得到执行规则
      */
     @Override
     public String isGetRule() {

         return "我得到了执行规则，name=[sxf]";
     }

 }

二：模拟drools中DefaultExecutorService的实现对象DefaultExecutorService

 package com.nonbankcard.drools.module;
 /**
  * 业务命令执行代理
  * @author sxf
  *
  */
 public class DefaultExecutorService {

     //线程类
     private Thread thread;

     /**
      * 业务命令真正的执行者线程
      *
      */
     private CommandExecutor commandExecutor;
     /**
      * 命令执行器是否已经开始执行
      */
     private boolean runing;

     /**
      * 空构造
      */
     public DefaultExecutorService(){

     }

     /**
      * 构造函数
      */
     public DefaultExecutorService(CommandExecutor commandExecutor){
         this.commandExecutor=commandExecutor;
     }

     /**
      * （1）给业务命令执行代理提交命令
      * （2）其实内部是交给真正的线程执行（CommandExecutor）
      * @param command
      * @return
      */
     public Future submit(Command command){
         if(!runing){
             //启动命令执行器
             startUp();
         }

         //交给真正的命令执行器执行
         return (Future) this.commandExecutor.submint(command);
     }

     /**
      * 启动真正的命令执行器
      */
     public void startUp(){
         //启动命令执行器的线程
         this.thread=new Thread(this.commandExecutor);
         this.thread.start();
         //将命令执行器的状态设置为启动
         this.runing=true;
     }

      public void shutDown() {
              //关闭命令执行器的线程
             this.commandExecutor.shutDown();
             //关闭当前命令执行代理的标识
             this.runing = false;
             //释放真正命令执行器的引用，让线程体被Gc回收
             this.thread = null;
         }

     public CommandExecutor getCommandExecutor() {
         return commandExecutor;
     }

     public void setCommandExecutor(CommandExecutor commandExecutor) {
         this.commandExecutor = commandExecutor;
     }

 }

三：模拟drools中CommandExecutor的实现对象CommandExecutor

 package com.nonbankcard.drools.module;

 import java.util.concurrent.BlockingQueue;

 /**
  *业务命令执行器
  * @author sxf
  *
  */
 public class CommandExecutor implements Runnable {

     /**
      * 阻塞队列
      */
     private BlockingQueue<Command> queue;

     /**
      * 这个引用，就是statefulSession的引用
      */
     private WorkingMemory WorkingMemory;

     /**
      * 命令执行的标识
      */
     private boolean running;

     public CommandExecutor(StatefulSession session){
         this.WorkingMemory=session;
     }

     /**
      * 给命令执行器提交一个命令
      * @param command
      */
     public Future submint(Command command){
         //把命令放到队列里，等待线程执行
         this.queue.offer(command);
         //此处在下一个版本升级的时候，返回这个命令。
         //可以从这个命令里获取命令的执行结果
         return (Future) command;
     }

     /**
      * 业务命令执行器的线程体
      */
     @Override
     public void run() {
         this.running=true;

         while(this.running){
             try {
                 //从队列中取出命令
                 Command command=queue.take();
                 //执行命令,传入的就是statefulSession
                 command.execute(WorkingMemory);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }

     }

     /**
      * 关闭命令执行线程
      */
     public void shutDown(){
         this.running=false;
     }

 }

四：模拟drools中Command的实现对象Command

 package com.nonbankcard.drools.module;
 /**
  * 命令接口
  * @author sxf
  *
  */
 public interface Command {

     /**
      * 执行命令的接口定义
      * @param workingMemory==>这里传的就是StatefulSession
      */
     public void execute(WorkingMemory workingMemory);
 }

五：模拟drools中Future的实现对象Future

 package com.nonbankcard.drools.module;
 /**
  * 命令执行结果查询
  * @author sxf
  *
  */
 public interface Future {
     /**
      * 命令是否执行
      * @return
      */
     public boolean isDone();
     /**
      * 获取命令执行结果
      * @return
      */
     public Object getDoneResult();
     /**
      * 获取命令执行的异常信息
      * @return
      */
     public Exception getDoneingException();
 }

六：模拟drools中FireAllRules的实现对象FireRuleCommand

 package com.nonbankcard.drools.module;
 /**
  * 激活规则的命令
  * @author sxf
  *
  */
 public class FireRuleCommand  implements Command,Future{
     /**
      * 命令是否被执行
      */
     private volatile boolean done;
     /**
      * 命令执行过程中的异常
      */
     private Exception     e;
     /**
      * 命令的执行结果
      */
     private Object object;

     /**
      * 执行命令
      */
     @Override
     public void execute(WorkingMemory workingMemory) {
         try {
             //模拟执行命令
             Thread.sleep(1000L);
             object=workingMemory.isGetRule();
         } catch (Exception e) {
             //给命令赋值执行异常
             this.e=e;
         }
         //表示命令已经执行
         this.done=done;
     }

     /**
      * 命令是否执行
      */
     @Override
     public boolean isDone() {
         return this.done;
     }

     /**
      * 获取命令的执行结果
      */
     @Override
     public Object getDoneResult() {
         return this.object;
     }

     /**
      * 获取命令执行过程中的异常
      */
     @Override
     public Exception getDoneingException() {
         return this.e;
     }

 }

七：模拟drools中WorkingMemory的实现对象WorkingMemory

 package com.nonbankcard.drools.module;
 /**
  * 【1】statefulSession实现的接口
  * 【2】在drools里该接口的作用
  * （1）定义了关于获取最终fact匹配上规则要执行的议程
  * （2）定义了激活规则的方法
  * （3）定义了匹配过程中需要执行的Handler等内容
  * @author sxf
  *
  */
 public interface WorkingMemory {

     /**
      * 是否得到匹配规则
      * @return
      */
     public String isGetRule();

 }

八：模拟drools中ReteooStatefulSession启动的实现过程，该过程隐藏在drools中的org.drools.reteoo.ReteooRuleBase.newStatefulSession()方法中

 package com.nonbankcard.drools.module;
 /**
  * statefulSession的启动过程
  * @author sxf
  *
  */
 public class StateFulSessionTest {

     public static void main(String[] args) {

         //生成一个业务命令执行代理
         DefaultExecutorService executorService=new DefaultExecutorService();

         //生成一个statefulSession
         StatefulSession session=new StatefulSession(executorService);

         //生成真正执行命令的线程体
         CommandExecutor commandExecutor=new CommandExecutor(session);

         //将真正执行命令的线程体放入业务命令执行代理
         executorService.setCommandExecutor(commandExecutor);

         //sesssion初始化完毕。可以开始做规则匹配的任务了
         //初始化一个命令
         FireRuleCommand fireCommand=new FireRuleCommand();

         //session可以异步添加命令
         Future  future=(Future) session.asyncInsert(fireCommand);

     }

 }