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

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

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

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

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

 1 package com.nonbankcard.drools.module;
 2
 3
 4
 5 /**
 6  *
 7  * 在当前的设计模式中:
 8  * (1)它作为规则匹配的发起者,它内部引用了执行器代理,执行器
 9  * (2)执行器引用了它
10  * (3)它提交一个命令,交给执行器代理,执行器代理交给执行器线程异步处理
11  *
12  *在drools中
13  * (1)把规则库理解成一个数据库,规则匹配的入口,类比jdbc的一个链接对象
14  * (2)它引用ruleBase(规则库)
15  * (3)RuleBase(规则库)里也引用了它
16  * @author sxf
17  *
18  */
19 public class StatefulSession implements WorkingMemory{
20
21     /**
22      * 业务执行器的代理
23      */
24     private DefaultExecutorService executorService;
25
26     public StatefulSession(DefaultExecutorService executorService ){
27         this.executorService=executorService;
28     }
29
30
31
32     /**
33      * 异步插入命令,执行命令
34      * @param object
35      * @return
36      */
37     public Future asyncInsert(final Command command) {
38         this.executorService.submit(command);
39         return (Future) command;
40     }
41
42
43     /**
44      * 是否得到执行规则
45      */
46     @Override
47     public String isGetRule() {
48
49         return "我得到了执行规则,name=[sxf]";
50     }
51
52
53
54
55 }

View Code

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

 1 package com.nonbankcard.drools.module;
 2 /**
 3  * 业务命令执行代理
 4  * @author sxf
 5  *
 6  */
 7 public class DefaultExecutorService {
 8
 9     //线程类
10     private Thread thread;
11
12     /**
13      * 业务命令真正的执行者线程
14      *
15      */
16     private CommandExecutor commandExecutor;
17     /**
18      * 命令执行器是否已经开始执行
19      */
20     private boolean runing;
21
22     /**
23      * 空构造
24      */
25     public DefaultExecutorService(){
26
27     }
28
29     /**
30      * 构造函数
31      */
32     public DefaultExecutorService(CommandExecutor commandExecutor){
33         this.commandExecutor=commandExecutor;
34     }
35
36
37
38     /**
39      * (1)给业务命令执行代理提交命令
40      * (2)其实内部是交给真正的线程执行(CommandExecutor)
41      * @param command
42      * @return
43      */
44     public Future submit(Command command){
45         if(!runing){
46             //启动命令执行器
47             startUp();
48         }
49
50         //交给真正的命令执行器执行
51         return (Future) this.commandExecutor.submint(command);
52     }
53
54
55     /**
56      * 启动真正的命令执行器
57      */
58     public void startUp(){
59         //启动命令执行器的线程
60         this.thread=new Thread(this.commandExecutor);
61         this.thread.start();
62         //将命令执行器的状态设置为启动
63         this.runing=true;
64     }
65
66
67      public void shutDown() {
68              //关闭命令执行器的线程
69             this.commandExecutor.shutDown();
70             //关闭当前命令执行代理的标识
71             this.runing = false;
72             //释放真正命令执行器的引用,让线程体被Gc回收
73             this.thread = null;
74         }
75
76     public CommandExecutor getCommandExecutor() {
77         return commandExecutor;
78     }
79
80     public void setCommandExecutor(CommandExecutor commandExecutor) {
81         this.commandExecutor = commandExecutor;
82     }
83
84
85
86
87 }

View Code

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

 1 package com.nonbankcard.drools.module;
 2
 3 import java.util.concurrent.BlockingQueue;
 4
 5 /**
 6  *业务命令执行器
 7  * @author sxf
 8  *
 9  */
10 public class CommandExecutor implements Runnable {
11
12     /**
13      * 阻塞队列
14      */
15     private BlockingQueue<Command> queue;
16
17     /**
18      * 这个引用,就是statefulSession的引用
19      */
20     private WorkingMemory WorkingMemory;
21
22     /**
23      * 命令执行的标识
24      */
25     private boolean running;
26
27
28
29     public CommandExecutor(StatefulSession session){
30         this.WorkingMemory=session;
31     }
32
33     /**
34      * 给命令执行器提交一个命令
35      * @param command
36      */
37     public Future submint(Command command){
38         //把命令放到队列里,等待线程执行
39         this.queue.offer(command);
40         //此处在下一个版本升级的时候,返回这个命令。
41         //可以从这个命令里获取命令的执行结果
42         return (Future) command;
43     }
44
45
46     /**
47      * 业务命令执行器的线程体
48      */
49     @Override
50     public void run() {
51         this.running=true;
52
53         while(this.running){
54             try {
55                 //从队列中取出命令
56                 Command command=queue.take();
57                 //执行命令,传入的就是statefulSession
58                 command.execute(WorkingMemory);
59             } catch (InterruptedException e) {
60                 e.printStackTrace();
61             }
62         }
63
64     }
65
66     /**
67      * 关闭命令执行线程
68      */
69     public void shutDown(){
70         this.running=false;
71     }
72
73 }

View Code

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

 1 package com.nonbankcard.drools.module;
 2 /**
 3  * 命令接口
 4  * @author sxf
 5  *
 6  */
 7 public interface Command {
 8
 9     /**
10      * 执行命令的接口定义
11      * @param workingMemory==>这里传的就是StatefulSession
12      */
13     public void execute(WorkingMemory workingMemory);
14 }

View Code

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

 1 package com.nonbankcard.drools.module;
 2 /**
 3  * 命令执行结果查询
 4  * @author sxf
 5  *
 6  */
 7 public interface Future {
 8     /**
 9      * 命令是否执行
10      * @return
11      */
12     public boolean isDone();
13     /**
14      * 获取命令执行结果
15      * @return
16      */
17     public Object getDoneResult();
18     /**
19      * 获取命令执行的异常信息
20      * @return
21      */
22     public Exception getDoneingException();
23 }

View Code

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

 1 package com.nonbankcard.drools.module;
 2 /**
 3  * 激活规则的命令
 4  * @author sxf
 5  *
 6  */
 7 public class FireRuleCommand  implements Command,Future{
 8     /**
 9      * 命令是否被执行
10      */
11     private volatile boolean done;
12     /**
13      * 命令执行过程中的异常
14      */
15     private Exception     e;
16     /**
17      * 命令的执行结果
18      */
19     private Object object;
20
21
22     /**
23      * 执行命令
24      */
25     @Override
26     public void execute(WorkingMemory workingMemory) {
27         try {
28             //模拟执行命令
29             Thread.sleep(1000L);
30             object=workingMemory.isGetRule();
31         } catch (Exception e) {
32             //给命令赋值执行异常
33             this.e=e;
34         }
35         //表示命令已经执行
36         this.done=done;
37     }
38
39
40     /**
41      * 命令是否执行
42      */
43     @Override
44     public boolean isDone() {
45         return this.done;
46     }
47
48     /**
49      * 获取命令的执行结果
50      */
51     @Override
52     public Object getDoneResult() {
53         return this.object;
54     }
55
56     /**
57      * 获取命令执行过程中的异常
58      */
59     @Override
60     public Exception getDoneingException() {
61         return this.e;
62     }
63
64
65
66 }

View Code

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

 1 package com.nonbankcard.drools.module;
 2 /**
 3  * 【1】statefulSession实现的接口
 4  * 【2】在drools里该接口的作用
 5  * (1)定义了关于获取最终fact匹配上规则要执行的议程
 6  * (2)定义了激活规则的方法
 7  * (3)定义了匹配过程中需要执行的Handler等内容
 8  * @author sxf
 9  *
10  */
11 public interface WorkingMemory {
12
13     /**
14      * 是否得到匹配规则
15      * @return
16      */
17     public String isGetRule();
18
19 }

View Code

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

 1 package com.nonbankcard.drools.module;
 2 /**
 3  * statefulSession的启动过程
 4  * @author sxf
 5  *
 6  */
 7 public class StateFulSessionTest {
 8
 9     public static void main(String[] args) {
10
11
12         //生成一个业务命令执行代理
13         DefaultExecutorService executorService=new DefaultExecutorService();
14
15         //生成一个statefulSession
16         StatefulSession session=new StatefulSession(executorService);
17
18         //生成真正执行命令的线程体
19         CommandExecutor commandExecutor=new CommandExecutor(session);
20
21         //将真正执行命令的线程体放入业务命令执行代理
22         executorService.setCommandExecutor(commandExecutor);
23
24
25         //sesssion初始化完毕。可以开始做规则匹配的任务了
26         //初始化一个命令
27         FireRuleCommand fireCommand=new FireRuleCommand();
28
29         //session可以异步添加命令
30         Future  future=(Future) session.asyncInsert(fireCommand);
31
32     }
33
34 }

View Code

 

时间: 2024-11-25 14:49:43

【java规则引擎】之Drools引擎中模拟ReteooStatefulSession内部设计结构的相关文章

【java规则引擎】drools6.5.0版本中kmodule.xml解析

kmodule.xml文件存放在src/main/resources/META-INF/文件夹下. 1 <?xml version="1.0" encoding="UTF-8"?> 2 <kmodule xmlns="http://jboss.org/kie/6.0.0/kmodule"> 3 <kbase name="rules" packages="rules"> 4

【java规则引擎】一个基于drools规则引擎实现的数学计算例子

最近在研究JBPM工作流引擎,发现JBPM是基于Drools的,官方文档查看得知Drools是一款规则引擎.兴趣之下,仔细了解了下 Drools,Drools作为JBoss出品的一款开源推理和规则引擎,被广泛的应用在各个领域,如JBPM也是基于Drools的.一般我们使用规则 引擎的前提和场景是:业务规则频繁变化!如果业务规则稳定则无需应用规则引擎的,实际中诸如移动通信商.银行等领域则广泛的使用了规则引擎,主要是为了适 应频繁变更的规则,但又不需要影响业务逻辑代码. 在看了官方的一些文档介绍后,

【java规则引擎】drools6.5.0中kie的概论

什么是KIE? KIE是jBoss里面一些相关项目的统称,下图就是KIE代表的一些项目,其中我们比较熟悉的就有jBPM和Drools. 这些项目都有一定的关联关系,并且存在一些通用的API,比如说涉及到构建(building).部署(deploying)和加载 (loading)等方面的,这些API就都会以KIE作为前缀来表示这些是通用的API.前面看到的一些KieServices. KieContainer.KieSession类就都是KIE的公共API. 总的来说,就是jBoss通过KIE将

【java规则引擎】之Drools之Rete算法

一:规则引擎--->规则引擎的核心是Pattern Matcher(模式匹配器).不管是正向推理还是反向推理,首先要解决一个模式匹配的问题. --->对于规则的模式匹配,可以定义为: 一个规则是一组模式的集合.如果事实/假设的状态符合该规则的所有模式,则称为该规则是可满足的. 模式匹配的任务就是将事实/假设的状态与规则库中的规则一一匹配,找到所有可满足的规则. 二:什么是模式匹配 对于模式匹配我们都应该不陌生,我们经常使用的正则表达式就是一种模式匹配. 正则表达式是一种"模式(pat

Java规则引擎与其API应用详解

详解 本文对Java规则引擎与其API(JSR-94)及相关实现做了较详细的介绍,对其体系结构和API应用有较详尽的描述,并指出Java规则引擎,规则语言,JSR-94的相互关系,以及JSR-94的不足之处和展望 本文对Java规则引擎与其API(JSR-94)及相关实现做了较详细的介绍,对其体系结构和API应用有较详尽的描述,并指出Java规则引擎,规则语言,JSR-94的相互关系,以及JSR-94的不足之处和展望 复杂企业级项目的开发以及其中随外部条件不断变化的业务规则(business l

jboss规则引擎KIE Drools 6.3.0-高级讲授篇

在生产环境怎么用BRMS 回溯BRMS开发教程中的那张"业务变现加速器"架构图,考虑下面的问题 业务开发人员开发规则 IT人员提供FACT 关键在于"全动态" SQL语句改了怎么办?不重启 DAO层改了怎么办?不重启 Mybatis的配置文件改了怎么办?不重启 按照上次的<jboss规则引擎KIE Drools 6.3.0 Final 教程>,一起来看一个实际的场景 如何熊掌与鱼兼得? 做到以下几点是否就可以"全得"? 规则更改不重启

详解什么是Java规则引擎(上)

问题描述 本文对Java规则引擎与其API(JSR-94)及相关实现做了较详细的介绍,对其体系结构和API应用有较详尽的描述,并指出Java规则引擎,规则语言,JSR-94的相互关系,以及JSR-94的不足之处和展望 复杂企业级项目的开发以及其中随外部条件不断变化的业务规则(businesslogic),迫切需要分离商业决策者的商业决策逻辑和应用开发者的技术决策,并把这些商业决策放在中心数据库或其他统一的地方,让它们能在运行时(即商务时间)可以动态地管理和修改从而提供软件系统的柔性和适应性.规则

Java规则引擎工作原理及其应用

摘 要 Java规则引擎是一种嵌入在Java程序中的组件,它的任务是把当前提交给引擎的Java数据对象与加载在引擎中的业务规则进行测试和比对,激活那些符合当前数据状态下的业务规则,根据业务规则中声明的执行逻辑,触发应用程序中对应的操作. 引言 目前,Java社区推动并发展了一种引人注目的新技术--Java规则引擎(Rule Engine).利用它就可以在应用系统中分离商业决策者的商业决策逻辑和应用开发者的技术决策,并把这些商业决策放在中心数据库或其他统一的地方,让它们能在运行时可以动态地管理和修

Java规则引擎与其API(JSR-94)

简介:本文对Java规则引擎与其API(JSR-94)及相关实现做了较详细的介绍,对其体系结构和API应用 有较详尽的描述,并指出Java规则引擎,规则语言,JSR-94的相互关系,以及JSR-94的不足之处和展望 复杂企业级项目的开发以及其中随外部条件不断变化的业务规则(business logic),迫切需要分离 商业决策者的商业决策逻辑和应用开发者的技术决策,并把这些商业决策放在中心数据库或其他统一的地 方,让它们能在运行时(即商务时间)可以动态地管理和修改从而提供软件系统的柔性和适应性.