当前位置：文档库 › Drools规则引擎的使用总结

Drools规则引擎的使用总结

前一段时间在开发了一个做文本分析的项目。在项目技术选型的过程中，尝试使用了 Drools

规则引擎。让它来作为项目中有关模式分析和关键词匹配的任务。但后来，因为某种原因, 还是撇开

了 Drools 。现将这个过程中使用 Drools 的一些经验和心得记录下来。（一）什么时候应该使用规则引擎 ~这实际是一个技术选型的问题。

但这个问题又似乎是一个很关键的问题

（一旦返工的话, 你就知道这个问题是多么重要了）。不知大家有没有过这样的经验和体会。往往在项目开始的时候，总会遇到应该选用什么技术？是不是应该使用最新的技术？或者应该选用什么技术呢（PS :

现在计算机软件中的各种技术层出不穷，具有类似功能的技术很多

）？

不管怎么样，这些问题总会困扰着我。比如，这次的这个项目。项目要求是要在一些文件中（这些log 文件都是很大的应用系统所产生的，但由于legacy 的原因，log 本身的维护

和规范工作一直没有得到改善，所以想借助于一些外部应用对这些

log 做以分析和清洗）

抽取出有用的信息。

于是，第一个想到的就是，这是一个文本挖掘类的项目。但又想，要抽取有用信息，必须得建立一些规则或 pattern （模式）。所以，我第一个想到了规则引擎。因为这里面要建立好多规则，而这些规则可以独立于代码级别（

引擎去解析和执行。另一个重要的原因是，我原来用

过，比较熟悉。这样，也可以节省开发时间吧。于是，好不犹豫的就开始做了 Demo....

但事实上，在经历了一个多星期的编码、

测试后，我发现运用规则引擎实在是太笨拙了。

（1）首先必须建立一些数据模型。通过这些模型来

refer 规则文件中的LHS 和Action 。

（2 ）还要考虑规则的 conflict 。如果有一些规则同时被触发，就要考虑设定规则的优先级或者

是设定activiation-group 来保证在一个group 中的规则只有一个规则可以被触发。

（3）对于流'规则group ruleflow-group 的使用。如果要控制在 workingmemory 中的规

则被触发的顺序，则可以将这些规则分组。然后，通过规则建模的方式来实现。但这也添加

了一定的effort 。修改或者更新不大方便。

~所以，基于上述体会，我更认为规则引擎更适用于那些对非流程性规则匹配的应用。当然，Drools 也支持对流程性规则的建模过程。但，这也许不是最好的方式。（二） Drools 规则引擎的使用杂记

（1） Fact 的变更监听。在Drools 里，如果一个Fact 通过规则而改变，则需将这种改变通知

给规则引擎。这里，一般有两种方式：显式和隐式。

显式---在drl 文件中通过 up date 、modify 来通知；在程序中，通过 Fact 的引用调用 modifyObject

等方法来实现。

隐式---通过在Java bea n 实现property Liste ner In terface

来让引擎自动监听到属性

值的变化。我更习惯于这种方式。因为，一般看来凡是在规则引擎中添加到 fact 都是希望

引擎来帮你进行管理的。所以，那它自己看到 fact 的变化是种很省事的办法。也很简单，

就是用Java bean property 监听的方式。

通过 StatefulSession 来注册。调用 StatefulSession

的某个 instanee 的 insert （ Object ，true ）实现。而这个 object

是一个java bean 。其中，要实现

P rivate final Prop ertyCha ngeS upport cha nges

Prop ertyCha ngeS upp ort( this );

public void add PropertyChangeListener(final PropertyChangeListener l) { this.cha nges.add Prop ertyCha

ngeListe ner( l );

log

放到一个单独的drl 文件里）并可以用规则

=new

this.cha nges.fire Prop ertyCha nge （ "te mp", null,this.te mp ）;

（2）规则触发的优先级、组设置

往往，在设计我们自己的规则时，要考虑规则的触发条件。这不仅限于LHS 的条件部分, 还有规则本身被触发的有些设置等等。这里，列出一些比较常用和有效的规则优先级设置方—

式，以及需要注意的地方。

A. 通过Salienee 方式。此值可正可负。越大优先级越高，也会被引擎首先执行。

通过ruleflow-group 方式。实际上，使用这种方式也就是在使用建立规则流的方式。在

Eclipse 3.3 中，Drools 提供了建立规则流的插件。要在两个文件

（当然，插件会帮助你建立这些）。

克

New

Select a wizard

Wizards:

|typs filter text

出凸CVS

□ & Dr&ols

r- -O Declfibn Table

;? DoiTiain Specific Language ■ 0 Guided Rule

.吨 RuleFlow File

■

-Q Rule Project

Q Rule Resoir 匚e

e EfChpse Made ling Frameu^crk

D Example EMF McMJe'l Creation VVizarcte

选择 RuleFlow File 。

这里，需要注意的一点是要在启动规则引擎的时候，加入启动

drl 的同级目录中建立 rf 和rfm

Nejit >

Fl, ash

Cancel

rule flow 的代码。

P ublic void removeProp ertyCha ngeListe nerfinal Prop ertyCha ngeListe ner I) {

Inpu tStreamReader source = new Inpu tStreamReader(RuleMa nager.class

.getResourceAsStream(rule_ path));

P ackageBuilder builder = new P ackageBuilder(); builder.add PackageFromDrl(source);

builder.addRuleFlow (new Inpu tStreamReader(RuleMa nager.class

.getResourceAsStream(rule_fl ow_p ath)));

Package pkg = builder.get Package 。；

RuleBase ruleBase = RuleBaseFactory. newRuleBase(); ruleBase.add Package (p kg);

然后，在每次启动规则引擎的时候，调用如下方法：

StatefulSessi on ss;

ss.start Pro cess(flow Progress) ss.fireAllRules();

这个rule flow 图中，显示了一个简单的规则流。如

RSA 就是一个rule-flow 的名字。在这

个rule set 中可以设定一组rules 。这样，就可以分开规则执行的顺序。在于的另一个

drl 文件中定义这些组的名字。通过关键字

ruleflow-group

来表

明。

C.通过activation-group 的方式。通过这种方式，可以

exclude 一组rule 中一旦有一个

rule 被invoke ，而其它 rule 不会被 execute 。同时，可以搭配使用 salienee 关键字来标明每个rule 的

优先级，这样就能够使得你想要的一般性概念的 D.在使用ruleflow-group 的时候要注意使用 lock-on-active true 关键字在每个 rule 。这

flow 的名字。

rf 和rfm 同名

rule 先被匹配执行。

样可以避免一旦有rule被触发，不会造成循环匹配执行。

E.如果在LHS部分，需要调用某个方法来返回真、假值作为判断的一个条件，那么可以=

用eval函数。

女0, eval(pattern.matched(5,$line.getCurrLine()))

其中，pattern是某个加入到workingmemory 中的一个实例。matched是这个实例所代表类的一个方法。它返回boolean类型。

(3)Drools规则引擎的使用感受

总之，Drools还是一个很不错的开源规则引擎。现在v4.0以上的版本已经比以前的版本

在速度上有了很大的提升。可以作为我们一般应用程序系统的中间件产品(那些规则不是很经常改变的系统，已经非流程类规则)。但是，这其中还是需要一些额外的effort来学习它的使用文档以及整体架构，有一定的学习曲线。

最后，我想一个较好的对于技术使用的Practice就是：首先知道它能为你做什么，它最

好的应用领域，然后再去深入。

(PS:如果谁有使用Drools的问题，可以联系我！一起讨论！)

题外话：

Drools是规则引擎，主要是用于实现基于规则的专家系统的。而专家系统是什么，要解决什么样的问题，可能大家不是很清楚。所以在解决问题是，要首先有个全面的了解才行。如果只是流程型的东西，可以考虑工作流引擎实现。

另外，对话引擎是很复杂的，涉及很多技术，NPL、推理机、知识库，甚至包含整个人工遛能领域的技术。而其中每个技术又有不同的理论和方法，选择哪个，又如何组合这些技术也

是很复杂的。

基于条件匹配方式的规则引擎必定存在一个抽象分析的过程，

而且你很难控制流程式的逻辑

的执行。

我们做的VisualRules也称做一个规则引擎产品，但是我们不是按照条件匹配的方式来做的。我们是顺序执行的。因此可以通过分支来实现决定规则执行的轨迹，甚至可以做循环类的规则。另外可以直接在规则中操作数据库，以便于提取一些参数以及存取操作。

其实最开始我们研发这个产品时，也碰到匹配算法将规则配置变得非常难，研究挺长时间的

程序员要设计规则都觉得分析的难度挺大。不要说将来的维护人员或者业务人员。

Drools 规则引擎

Drools规则引擎 1. 概述: Drools分为两个主要部分：构建（Authoring）和运行时（Runtime）。构建的过程涉及到.drl或.xml规则文件的创建，它们被读入一个解析器，使用ANTLR 3 语法进行解析。解析器对语法进行正确性的检查，然后产生一种中间结构“descr”，descr 用AST来描述规则。AST然后被传到PackageBuilder，由PackagBuilder来产生Packaged对象。PackageBuilder还承担着一些代码产生和编译的工作，这些对于产生Package对象都时必需的。Package对象是一个可以配置的，可序列化的，由一个或多个规则组成的对象。下图阐明了上述过程： Figure 1.1 Authoring Components RuleBase 是一个运行时组件，它包含了一个或多个 Package 对象。可以在任何时刻将一个 Package 对象加入或移出 RuleBase 对象。一个 RuleBase 对象可以在任意时刻实例化一个或多个 WorkingMemory 对象，在它的内部保持对这些WorkingMemory 的弱引用。 WorkingMemory 由一系列子组件组成。当应用程序中的对象被 assert 进 WorkingMemory ，可能会导致一个或多个 Activation 的产生，然后由 Agenda 负责安排这些 Activation 的执行。下图说明了上述过程：

Figure 1.2 . Runtime Components 2．构建（Authoring）：主要有三个类用来完成构建过程：DrlParser, XmlParser 和 PackageBuilder。两个解析器类从传入的Reader实例产生descr AST模型。PackageBuilder提供了简便的API，使你可以忽略那两个类的存在。这两个简单的方法是：“addPackageFromDrl”和“addPackageFromXml”，两个都只要传入一个Reader 实例作为参数。下面的例子说明了如何从classpath中的xml和drl文件创建一个Package对象。注意：所有传入同一个PackageBuilder实例的规则源，都必须是在相同的package 命名空间（namespace）中。 PackageBuilder builder = new PackageBuilder(); builder.addPackageFromDrl( new InputStreamReader( getClass().getResourceAsStream( " package1.drl" ) ) ); builder.addPackageFromXml( new InputStreamReader( getClass().getResourceAsStream( " package2.drl" ) ) ); Package pkg = builder.getPackage();

ILOG规则引擎系统运维手册

ILOG 规则引擎系统运维手册一、 ILOG 规则引擎系统介绍 ? 为什么使用ILOG 规则引擎系统？保险行业是大量业务规则的处理过程，投承保规则、保费计算规则、核保规则、核批规则、费用规则、核赔规则。。。业务规则无所不在，且随着行业监管、市场环境、业务管理等因素不断变化。业务规则管理混乱、业务规则变更过分依赖技术人员，业务人员无法单独完成业务规则变更，维护成本高昂，由此带来的问题： ? 业务规则变更周期长、成本高 ? 规则重用性差 ? 业务规则知识随着时间被淡忘基于ILOG 的规则管理，可实现： ? 业务规则与保险应用剥离，业务规则易于管理 ? 使用集中规则库进行管理，业务人员可单独变更业务规则 ? 实现历史规则追溯 ? 规则可重用 ? 缩短新业务发布周期 ? ILOG 在都邦保险的运用 Ilog 规则引擎系统目前维护的规则有车险核保规则和车险费用规则。自动核保规则是指根据某些核保因子判断当前保单是否能够自动核保通过或者不能够自动核保通过的规则。其中，不能够自动核保通过的规则，一般又分为数据校验规则、打回出单规则以及自动核保校验规则（转人工核保）等。人工核保权限规则是指在人工核保环节，不同级别的核保员具有不同的核保权限，配置不同级别的核保员核保权限的规则就是人工核保权限规则。 ? 产品组件 Rule Studio （规则开发环境）用于对基于规则的应用程序进行编码、调试和部署； Rule Execution Server （规则执行服务器） RES 执行部署的规则应用，业务规则调用的组件，并包括一个web 的管理控制台，业务人员/技术人员编写的业务规则只有部署在规则的执行环境中才能被执行，才能起到作用；核保规则自动核保规则人工核保规则 ——维护各核保级别的权限打回出单（数据校验或拒保）规则转人工核保规则自动核保通过规则

规则引擎研究-整理

规则引擎研究——Rete算法介绍一、R ETE概述 Rete算法是一种前向规则快速匹配算法，其匹配速度与规则数目无关。Rete是拉丁文，对应英文是net，也就是网络。Rete算法通过形成一个rete网络进行模式匹配，利用基于规则的系统的两个特征，即时间冗余性（Temporalredundancy）和结构相似性（structuralsimilarity），提高系统模式匹配效率。二、相关概念 2.1事实（FACT）：事实：对象之间及对象属性之间的多元关系。为简单起见，事实用一个三元组来表示：（identifier^attributevalue），例如如下事实： w1:(B1^onB2)w6:(B2^colorblue) w2:(B1^onB3)w7:(B3^left-ofB4) w3:(B1^colorred)w8:(B3^ontable) w4:(B2^ontable)w9:(B3^colorred) w5:(B2^left-ofB3) 2.2规则（RULE）: 由条件和结论构成的推理语句，当存在事实满足条件时，相应结论被激活。一条规则的一般形式如下： (name-of-this-production LHS/*oneormoreconditions*/ --> RHS/*oneormoreactions*/ ) 其中LHS为条件部分，RHS为结论部分。下面为一条规则的例子： (find-stack-of-two-blocks-to-the-left-of-a-red-block (^on) (^left-of) (^colorred) -->

...RHS... ) 2.3模式（PATTEN）：模式：规则的IF部分，已知事实的泛化形式，未实例化的多元关系。 (^on) (^left-of) (^colorred) 三、模式匹配的一般算法规则主要由两部分组成：条件和结论，条件部分也称为左端（记为LHS,left-handside），结论部分也称为右端（记为RHS,right-handside）。为分析方便，假设系统中有N条规则，每个规则的条件部分平均有P个模式，工作内存中有M个事实，事实可以理解为需要处理的数据对象。规则匹配，就是对每一个规则r,判断当前的事实o是否使LHS(r)=True，如果是，就把规则r的实例r(o)加到冲突集当中。所谓规则r的实例就是用数据对象o的值代替规则r的相应参数，即绑定了数据对象o的规则r。规则匹配的一般算法： 1)从N条规则中取出一条r； 2)从M个事实中取出P个事实的一个组合c； 3)用c测试LHS(r)，如果LHS(r（c）)=True，将RHS(r（c）)加入冲突集中； 4)取出下一个组合c，goto3； 5)取出下一条规则r，goto2；四、RETE算法 Rete算法的编译结果是规则集对应的Rete网络,如下图。Rete网络是一个事实可以在其中流动的图。Rete网络的节点可以分为四类：根节点（root）、类型节点（typenode）、alpha节点、beta节点。其中，根结点是一个虚拟节点，是构建rete网络的入口。类型节点中存储事实的各种类型，各个事实从对应的类型节点进入rete网络。 4.1建立RETE网络 Rete网络的编译算法如下： 1)创建根； 2)加入规则1(Alpha节点从1开始，Beta节点从2开始)； a.取出模式1，检查模式中的参数类型，如果是新类型，则加入一个类型节点；

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

Java规则引擎工作原理及其应用作者：缴明洋谭庆平出处：计算机与信息技术责任编辑：方舟[ 2006-04-06 08:18 ] Java规则引擎是一种嵌入在Java程序中的组件，它的任务是把当前提交给引擎的Java数据对象与加载在引擎中的业务规则进行测试和比对摘要Java规则引擎是一种嵌入在Java程序中的组件，它的任务是把当前提交给引擎的Java数据对象与加载在引擎中的业务规则进行测试和比对，激活那些符合当前数据状态下的业务规则，根据业务规则中声明的执行逻辑，触发应用程序中对应的操作。引言目前，Java社区推动并发展了一种引人注目的新技术——Java规则引擎（Rule Engine）。利用它就可以在应用系统中分离商业决策者的商业决策逻辑和应用开发者的技术决策，并把这些商业决策放在中心数据库或其他统一的地方，让它们能在运行时可以动态地管理和修改，从而为企业保持灵活性和竞争力提供有效的技术支持。规则引擎的原理 1、基于规则的专家系统（RBES）简介 Java规则引擎起源于基于规则的专家系统，而基于规则的专家系统又是专家系统的其中一个分支。专家系统属于人工智能的范畴，它模仿人类的推理方式，使用试探性的方法进行推理，并使用人类能理解的术语解释和证明它的推理结论。为了更深入地了解Java规则引擎，下面简要地介绍基于规则的专家系统。RBES包括三部分：Rule Base（knowledge base）、Working Memory（fact base）和Inference Engine。它们的结构如下系统所示：图1 基于规则的专家系统构成如图1所示，推理引擎包括三部分：模式匹配器（Pattern Matcher）、议程（Agenda）和执行引擎（Execution Engine）。推理引擎通过决定哪些规则满足事实或目标，并授予规则优先级，满足事实或目标的规则被加入议程。模式

Drools规则引擎开发说明

Drools规则动态更新在常规开发方式中，如果涉及规则的变更(比如将物流费用从6元调整为8元)，可以通过重新完成规则的开发并发布应用来更新。或在设计上，将可能变更的规则以配置(比如数据库)方式管理。发生规则变更时，只需修改配置即可。事实上，Drools提供了另一种规则更新的方式--扫描Maven仓库(本地或远程)来自动发现规则模块的更新。我们知道，Drools可以利用KieServices来创建基于classpath的KieContainer(即使用KieServices.newKieClasspathContainer()方法)。其实，KieServices还提供了从Maven 仓库加载并创建KieContainer的方法--newKieContainer(ReleaseId)。与通过classpath 创建KieContainer类似，使用Maven仓库加载的方法，会尝试读取对应jar包中的META-INF/kmodule.xml文件，基于此，我们可以完成KieSession的创建。我们通过一个简单的例子来观察规则的动态更新。在这个例子中，我们会将商品的折扣进行动态调整。我们需要构建规则，并安装到Maven仓库中--简单起见，我们将应用发布到本地Maven仓库中。首先，我们创建一个Maven项目: $mvn-B archetype:generate-DarchetypeGroupId=org.apache.maven.archetypes\ -DgroupId=com.sharp.rules-DartifactId=discount 如果没什么问题，我们可以得到一个名为discount的文件夹，其中的pom.xml看起来像这样: 4.0.0 com.sharp.rules discount jar 1.0-SNAPSHOT discount https://www.wendangku.net/doc/8d2080742.html, junit junit 3.8.1 test 在src/main/java/com/sharp/rules下创建Fact类: package com.sharp.rules; public class Commodity{ private double discount;

规则引擎解决方案调研报告-V1.0

中国XXXXXXXX系统 for J2EE 规则引擎解决方案调研报告 Version 1.0

目录 1.规则引擎4 1.1概述4 2.应用方案的一般实现5 2.1建立规则集7 2.2部署规则集7 2.3规则服务接口－JSR94 7 2.4对规则的计算7 2.5规则的过滤8 2.6使用计算结果8 3.现有的商业解决方案8 3.1ＩＬＯＧ新产品ＩＬＯＧＪＲｕｌｅｓ8 3.2操作人员已经显示提单列表错误!未定义书签。 4.其它解决方案10 4.1提单和报检单完成对碰10 5.评估11

规则引擎解决方案调研报告 1. 规则引擎规则引擎是解决可变的商业规则的问题的 1.1 概述规则引擎（Rules Engine）的运作机制是在内存中向对象应用一套规则。首先内存使用来自调用对象的输入，例如用户档案请求会话。这样，在任何规则实际激活之前，在内存中就已经有了一份用户档案的内容。规则只能在一个上下文环境中执行，上下文环境把规则集和内存关联起来。该环境提供了到Rules Engine的接口，Rules Engine控制着应用程序的规则部分与内存之间的关系。内存由生产规则（production rules）负责操作，生产规则包含在规则集里。，依照规则的左半边（left-hand sides，LHS）针对内存中的对象进行计算。如果内存中的对象与LHS中描述的模式匹配，就会触发规则的右半边（right-hand side，RHS）指定的操作。此外某些操作可能会在内存中加入新的对象。例如，规则 Classifier 对用户年龄进行测试，如果 USER.age > 45，就在内存中加入一个新的Classification 对象。生产系统的运行，要执行以下操作： 1.匹配: 估计规则的LHS，判断哪个规则与当前内存中的内容匹配。 2.冲突解决：选择一个LHS匹配的规则。如果没有规则匹配，就停止解释。 3.操作: 执行选中规则RHS中指定的动作。 4.返回第1步。规则会一直在内存中执行，直到冲突解决集变为0时才停止（也就是没有规则能激活了）。在Rules Engine停止之后，规则管理器组件会返回一个对象列表，列表中包含内存中仍然存在的对象。一个可能的场景就是，还剩下一个类型为“Classification”或“ContentQuery”的对象。 Rules Manager接着对剩下的对象进行迭代，用可选的对象过滤器过滤它们。过滤器可以有选择地忽略某些对象或者对某些对象进行变换。 1.2 规则引擎分类值得注意的是，存在不同类型的规则引擎，在决定如何应用一种工具之前理解这种工具的用途是极其重要的。当您跨业务规则领域进行调查研究时，您将注意到这些工具可以分为以下几类： ?简单业务规则（simple business rule）——通过一张简化的、直观的词汇表来表达并且是在应用程序或业务流程的可变性情况下调用的一种业务规则。这种规则引擎的一个很好的例子就是 ilog、Blaze 和 IBM 的 BRBeans。

Drools规则引擎的使用总结

前一段时间在开发了一个做文本分析的项目。在项目技术选型的过程中，尝试使用了 Drools 规则引擎。让它来作为项目中有关模式分析和关键词匹配的任务。但后来，因为某种原因, 还是撇开了 Drools 。现将这个过程中使用 Drools 的一些经验和心得记录下来。（一）什么时候应该使用规则引擎 ~这实际是一个技术选型的问题。但这个问题又似乎是一个很关键的问题（一旦返工的话, 你就知道这个问题是多么重要了）。不知大家有没有过这样的经验和体会。往往在项目开始的时候，总会遇到应该选用什么技术？是不是应该使用最新的技术？或者应该选用什么技术呢（PS : 现在计算机软件中的各种技术层出不穷，具有类似功能的技术很多）？不管怎么样，这些问题总会困扰着我。比如，这次的这个项目。项目要求是要在一些文件中（这些log 文件都是很大的应用系统所产生的，但由于legacy 的原因，log 本身的维护和规范工作一直没有得到改善，所以想借助于一些外部应用对这些 log 做以分析和清洗）抽取出有用的信息。于是，第一个想到的就是，这是一个文本挖掘类的项目。但又想，要抽取有用信息，必须得建立一些规则或 pattern （模式）。所以，我第一个想到了规则引擎。因为这里面要建立好多规则，而这些规则可以独立于代码级别（引擎去解析和执行。另一个重要的原因是，我原来用过，比较熟悉。这样，也可以节省开发时间吧。于是，好不犹豫的就开始做了 Demo.... 但事实上，在经历了一个多星期的编码、测试后，我发现运用规则引擎实在是太笨拙了。（1）首先必须建立一些数据模型。通过这些模型来 refer 规则文件中的LHS 和Action 。（2 ）还要考虑规则的 conflict 。如果有一些规则同时被触发，就要考虑设定规则的优先级或者是设定activiation-group 来保证在一个group 中的规则只有一个规则可以被触发。（3）对于流'规则group ruleflow-group 的使用。如果要控制在 workingmemory 中的规则被触发的顺序，则可以将这些规则分组。然后，通过规则建模的方式来实现。但这也添加了一定的effort 。修改或者更新不大方便。 ~所以，基于上述体会，我更认为规则引擎更适用于那些对非流程性规则匹配的应用。当然，Drools 也支持对流程性规则的建模过程。但，这也许不是最好的方式。（二） Drools 规则引擎的使用杂记（1） Fact 的变更监听。在Drools 里，如果一个Fact 通过规则而改变，则需将这种改变通知给规则引擎。这里，一般有两种方式：显式和隐式。显式---在drl 文件中通过 up date 、modify 来通知；在程序中，通过 Fact 的引用调用 modifyObject 等方法来实现。隐式---通过在Java bea n 实现property Liste ner In terface 来让引擎自动监听到属性值的变化。我更习惯于这种方式。因为，一般看来凡是在规则引擎中添加到 fact 都是希望引擎来帮你进行管理的。所以，那它自己看到 fact 的变化是种很省事的办法。也很简单，就是用Java bean property 监听的方式。通过 StatefulSession 来注册。调用 StatefulSession 的某个 instanee 的 insert （ Object ，true ）实现。而这个 object 是一个java bean 。其中，要实现 P rivate final Prop ertyCha ngeS upport cha nges Prop ertyCha ngeS upp ort( this ); public void add PropertyChangeListener(final PropertyChangeListener l) { this.cha nges.add Prop ertyCha ngeListe ner( l ); log 放到一个单独的drl 文件里）并可以用规则 =new

JAVA规则引擎 -- Drools

Drools是一个基于java的规则引擎，开源的，可以将复杂多变的规则从硬编码中解放出来，以规则脚本的形式存放在文件中，使得规则的变更不需要修正代码重启机器就可以立即在线上环境生效。 1、Drools语法开始语法之前首先要了解一下drools的基本工作过程，通常而言我们使用一个接口来做事情，首先要穿进去参数，其次要获取到接口的实现执行完毕后的结果，而drools也是一样的，我们需要传递进去数据，用于规则的检查，调用外部接口，同时还可能需要获取到规则执行完毕后得到的结果。在drools 中，这个传递数据进去的对象，术语叫Fact对象。Fact 对象是一个普通的java bean，规则中可以对当前的对象进行任何的读写操作，调用该对象提供的方法，当一个java bean插入到workingMemory中，规则使用的是原有对象的引用，规则通过对fact对象的读写，实现对应用数据的读写，对于其中的属性，需要提供getter setter访问器，规则中，可以动态的往当前workingMemory中插入删除新的fact对象。规则文件可以使用 .drl文件，也可以是xml文件，这里我们使用drl文件。规则语法： package：对一个规则文件而言，package是必须定义的，必须放在规则文件第一行。特别的是，package的名字是随意的，不必必须对应物理路径，跟java 的package的概念不同，这里只是逻辑上的一种区分。同样的package下定义的function和query等可以直接使用。比如：package com.drools.demo.point import：导入规则文件需要使用到的外部变量，这里的使用方法跟java相同，但是不同于java的是，这里的import导入的不仅仅可以是一个类，也可以是这个类中的某一个可访问的静态方法。比如： import com.drools.demo.point.PointDomain; import com.drools.demo.point.PointDomain.getById; rule：定义一个规则。rule "ruleName"。一个规则可以包含三个部分：属性部分：定义当前规则执行的一些属性等，比如是否可被重复执行、过期时间、生效时间等。条件部分，即LHS，定义当前规则的条件，如 when Message(); 判断当前workingMemory中是否存在Message对象。结果部分，即RHS，这里可以写普通java代码，即当前规则条件满足后执行的操作，可以直接调用Fact对象的方法来操作应用。

基于JAVA的规则引擎

基于Java的规则引擎

目录 1.简介 (3) 1.1业务规则 (3) 1.2规则引擎产生背景 (3) 2.规则引擎 (4) 2.1业务规则 (4) 2.2规则引擎 (4) 2.3规则引擎的使用方式 (4) 2.4规则引擎架构与推理 (5) 2.5规则引擎的算法 (6) 3.Java规则引擎 (7) 3.1Java规则引擎商业产品 (7) 3.2规则引擎产品特点分析 (8) 3.2.1IBM WebSphere ILOG JRules (8) 3.2.2Redhat JBoss Dools (11) 3.2.3JESS (11) 4.Java规则引擎API（JSR94） (13) 4.1简介 (13) 4.2简介Java规则引擎API体系结构 (13) 3.2.4规则管理API (13) 3.2.5运行时API (14) 4.3Java规则引擎API安全问题 (15) 4.4异常与日志 (15) 4.5JSR94小结 (16) 5规则语言 (17)

1.简介 1.1业务规则一个业务规则包含一组条件和在此条件下执行的操作．它们表示业务规则应用程序的一段业务逻辑。业务规则通常应该由业务分析人员和策略管理者开发和修改，但有些复杂的业务规则也可以由技术人员使用面向对象的技术语言或脚本来定制。业务规则的理论基础是：设置一个或多个条件，当满足这些条件时会触发一个或多个操作。 1.2规则引擎产生背景复杂企业级项目的开发以及其中随外部条件不断变化的业务规则（business logic），迫切需要分离商业决策者的商业决策逻辑和应用开发者的技术决策，并把这些商业决策放在中心数据库或其他统一的地方，让它们能在运行时（即商务时间）可以动态地管理和修改从而提供软件系统的柔性和适应性。规则引擎正是应用于上述动态环境中的一种解决方法。企业管理者对企业级IT系统的开发有着如下的要求： 1.为提高效率，管理流程必须自动化，即使现代商业规则异常复杂； 2.市场要求业务规则经常变化，IT系统必须依据业务规则的变化快速、低成本的更新； 3.为了快速、低成本的更新，业务人员应能直接管理IT系统中的规则，不需要程序开发人员参与。而项目开发人员则碰到了以下问题： 4程序=算法+数据结构，有些复杂的商业规则很难推导出算法和抽象出数据模型； 5软件工程要求从需求->设计->编码，然而业务规则常常在需求阶段可能还没有明确，在设计和编码后还在变化，业务规则往往嵌在系统各处代码中； 6对程序员来说，系统已经维护、更新困难，更不可能让业务人员来管理。基于规则的专家系统的出现给开发人员以解决问题的契机。规则引擎由基于规则的专家系统中的推理引擎发展而来。

规则引擎解决方案调研报告_V1.0

中国XXXXXXXX系统 for J2EE 错误！未指定书签。 Version 1.0

目录 1.规则引擎4 1.1概述4 2.应用方案的一般实现5 2.1建立规则集7 2.2部署规则集7 2.3规则服务接口－JSR94 7 2.4对规则的计算7 2.5规则的过滤8 2.6使用计算结果8 3.现有的商业解决方案8 3.1ＩＬＯＧ新产品ＩＬＯＧＪＲｕｌｅｓ8 3.2操作人员已经显示提单列表错误！未定义书签。 4.其它解决方案10 4.1提单和报检单完成对碰10 5.评估11

错误！未指定书签。 1. 规则引擎规则引擎是解决可变的商业规则的问题的 1.1 概述规则引擎（Rules Engine）的运作机制是在内存中向对象应用一套规则。首先内存使用来自调用对象的输入，例如用户档案请求会话。这样，在任何规则实际激活之前，在内存中就已经有了一份用户档案的内容。规则只能在一个上下文环境中执行，上下文环境把规则集和内存关联起来。该环境提供了到Rules Engine的接口，Rules Engine控制着应用程序的规则部分与内存之间的关系。内存由生产规则（production rules）负责操作，生产规则包含在规则集里。，依照规则的左半边（left-hand sides，LHS）针对内存中的对象进行计算。如果内存中的对象与LHS中描述的模式匹配，就会触发规则的右半边（right-hand side，RHS）指定的操作。此外某些操作可能会在内存中加入新的对象。例如，规则 Classifier 对用户年龄进行测试，如果 USER.age > 45，就在内存中加入一个新的Classification 对象。生产系统的运行，要执行以下操作： 1.匹配: 估计规则的LHS，判断哪个规则与当前内存中的内容匹配。 2.冲突解决：选择一个LHS匹配的规则。如果没有规则匹配，就停止解释。 3.操作: 执行选中规则RHS中指定的动作。 4.返回第1步。规则会一直在内存中执行，直到冲突解决集变为0时才停止（也就是没有规则能激活了）。在Rules Engine停止之后，规则管理器组件会返回一个对象列表，列表中包含内存中仍然存在的对象。一个可能的场景就是，还剩下一个类型为“Classification”或“ContentQuery”的对象。 Rules Manager接着对剩下的对象进行迭代，用可选的对象过滤器过滤它们。过滤器可以有选择地忽略某些对象或者对某些对象进行变换。 1.2 规则引擎分类值得注意的是，存在不同类型的规则引擎，在决定如何应用一种工具之前理解这种工具的用途是极其重要的。当您跨业务规则领域进行调查研究时，您将注意到这些工具可以分为以下几类：简单业务规则（simple business rule）——通过一张简化的、直观的词汇表来表达并且是在应用程序或业务流程的可变性情况下调用的一种业务规则。这种规则引擎的一个很好的例子就是 ilog、Blaze 和 IBM 的 BRBeans。

国内外主流工作流引擎及规则引擎分析

国内外主流工作流引擎及规则引擎分析2013年2月创新研发部

一.背景目前中心建成的“一大核心系统，七大共享平台”以及OA系统，对工作流应用程度高，但各系统实现工作流程管理没有建立在统一的工作流平台上，导致流程割裂、重复开发、不易于管理等问题。备付金管控项目涉及多个岗位之间工作的审核步骤，同时还要与多个系统进行交互，因此，为了提高管理效率，降低业务流转时间，同时还要结合农信银中心的总体IT战略规划，备付金管控项目技术组决定选择一款先进的工作流引擎和一款规则引擎，作为备付金管控项目的核心技术架构。二.原则备付金管控项目组通过梳理各信息系统流程现状和未来需求，形成农信银中心工作流平台的发展规划，从而更全面的满足农信银各项关键业务、更好的支撑现有和未来的信息系统建设。项目组充分研究国内外领先的工作流产品和案例，同厂商交流。从用户界面生成、流程建模、流程引擎、规则引擎、组织模型、模拟仿真、后端集成/SOA、变更及版本管理、移动设备解决方案、监控分析能力等多方面考察工作流产品，进行工作流产品选型。目前国内外的工作流引擎层出不穷，行业标准多种多样，通过对比不同工作流公司产品，本次工作流技术选型决定分析商业工作流引擎4款，开源工作流引擎2款。其中国际知名厂商的商业工作流引擎2款，本土厂商的商业工作流引擎2款。由于本次技术选型是以工作流引擎为主，选型工作将不再单独分析规则引擎，而是直接使用与所选工作流引擎搭配最好的或者是同一厂商的规则引擎。根据国内外知名度、厂商的规模和与符合农信银中心的SOA体系架构等原则，将选取以下6种工作流引擎与规则引擎进行研究与分析：

drools规则引擎的使用总结

前一段时间在开发了一个做文本分析的项目。在项目技术选型的过程中，尝试使用了Drools 规则引擎。让它来作为项目中有关模式分析和关键词匹配的任务。但后来，因为某种原因，还是撇开了Drools。现将这个过程中使用Drools的一些经验和心得记录下来。（一）什么时候应该使用规则引擎这实际是一个技术选型的问题。但这个问题又似乎是一个很关键的问题（一旦返工的话，你就知道这个问题是多么重要了）。不知大家有没有过这样的经验和体会。往往在项目开始的时候，总会遇到应该选用什么技术是不是应该使用最新的技术或者应该选用什么技术呢（PS：现在计算机软件中的各种技术层出不穷，具有类似功能的技术很多）？不管怎么样，这些问题总会困扰着我。比如，这次的这个项目。项目要求是要在一些log文件中（这些log文件都是很大的应用系统所产生的，但由于legacy的原因，log 本身的维护和规范工作一直没有得到改善，所以想借助于一些外部应用对这些log做以分析和清洗）抽取出有用的信息。于是，第一个想到的就是，这是一个文本挖掘类的项目。但又想，要抽取有用信息，必须得建立一些规则或pattern（模式）。所以，我第一个想到了规则引擎。因为这里面要建立好多规则，而这些规则可以独立于代码级别（放到一个单独的drl文件里）并可以用规则引擎去解析和执行。另一个重要的原因是，我原来用过，比较熟悉。这样，也可以节省开发时间吧。于是，好不犹豫的就开始做了Demo.... 但事实上，在经历了一个多星期的编码、测试后，我发现运用规则引擎实在是太笨拙了。（1）首先必须建立一些数据模型。通过这些模型来refer规则文件中的LHS和Action。（2）还要考虑规则的conflict。如果有一些规则同时被触发，就要考虑设定规则的优先级或者是设定activiation-group来保证在一个group中的规则只有一个规则可以被触发。（3）对于‘流’规则group ruleflow-group的使用。如果要控制在workingmemory 中的规则被触发的顺序，则可以将这些规则分组。然后，通过规则建模的方式来实现。但这也添加了一定的effort。修改或者更新不大方便。

规则引擎原理

规则引擎原理本文对Java规则引擎与其API(JSR-94)及相关实现做了较详细的介绍，对其体系结构和API应用有较详尽的描述，并指出Java规则引擎,规则语言，JSR-94的相互关系,以及JSR-94的不足之处和展望。复杂企业级项目的开发以及其中随外部条件不断变化的业务规则(businesslogic),迫切需要分离商业决策者的商业决策逻辑和应用开发者的技术决策，并把这些商业决策放在中心数据库或其他统一的地方，让它们能在运行时（即商务时间）可以动态地管理和修改从而提供软件系统的柔性和适应性。规则引擎正是应用于上述动态环境中的一种解决方法。本文第一部分简要介绍了规则引擎的产生背景和基于规则的专家系统，第二部分介绍了什么是规则引擎及其架构和算法，第三部分介绍了商业产品和开源项目实现等各种Java规则引擎，第四部分对Java规则引擎API（JSR-94）作了详细介绍，讲解了其体系结构，管理API 和运行时API及相关安全问题，第五部分则对规则语言及其标准化作了探讨，第六部分给出了一个使用Java规则引擎API的简单示例，第七部分给予小结和展望。 1.介绍 1.1. 规则引擎产生背景企业管理者对企业级IT系统的开发有着如下的要求： (1)为提高效率，管理流程必须自动化，即使现代商业规则异常复杂 (2)市场要求业务规则经常变化，IT系统必须依据业务规则的变化快速、低成本的更新 (3)为了快速、低成本的更新，业务人员应能直接管理IT系统中的规则，不需要程序开发人员参与。而项目开发人员则碰到了以下问题: (1)程序=算法+数据结构，有些复杂的商业规则很难推导出算法和抽象出数据模型 (2)软件工程要求从需求->设计->编码，然而业务规则常常在需求阶段可能还没有明确，在设计和编码后还在变化，业务规则往往嵌在系统各处代码中 (3)对程序员来说，系统已经维护、更新困难，更不可能让业务人员来管理。基于规则的专家系统的出现给开发人员以解决问题的契机。规则引擎由基于规则的专家系统中的推理引擎发展而来。下面简要介绍一下基于规则的专家系统。

Drools5规则引擎介绍

Drools5规则引擎介绍 2011-7-27

目录 1 规则引擎介绍 (3) 1.1 什么是规则引擎 (3) 1.2 使用规则引擎的优势 (3) 1.3 什么场景适合使用规则引擎 (3) 2 Drools简介 (4) 2.1 Drools简介 (4) 2.2 Drools的使用场景 (4) 3 Drools的工作原理 (4) 3.1 规则的工作流程 (4) 3.2 Rete算法总结 (5) 4 Drools5的安装 (5) 4.1下载drools相关的组件 (5) 4.2 解压缩已下载文件并放入eclipse中 (5) 4.3 查看Drools是否安装成功 (6) 4.4配置drools的Runtime环境 (6) 5 创建第一个示例及代码分析 (7) 5.1 创建规则 (7) 5.2 代码分析(规则的编译和运行) (11) 5.2.1 KnowledgeBuilder (11) 5.2.2 KnowledgeBase (11) 5.2.3 StatefulKnowledgeSession (12) 5.2.4 StatelessKnowledgeSession (13) 5.2.5 Fact对象 (14) 6 规则 (14) 6.1 规则文件 (14) 6.2 规则语言 (15) 6.2.1 条件部分 (15) 6.2.2 结果部分 (16) 6.2.3 属性部分 (17) 6.2.4 函数 (17) 6.2.5 查询 (17) 6.2.6 对象定义 (18)

1 规则引擎介绍 1.1 什么是规则引擎规则引擎是基于规则的专家系统的核心部分，主要由三部分组成：规则库(Knowledge base)+Working Memory(Fact base)+推理机(规则引擎)，规则引擎根据既定事实和知识库按照一定的算法执行推理逻辑得到正确的结果。规则引擎由推理引擎发展而来，是一种嵌入在应用程序中的组件，实现了将业务决策从应用程序代码中分离出来，并使用预定义的语义模块编写业务决策。接受数据输入，解释业务规则，并根据业务规则做出业务决策。目前，市面上应用产生了众多的规则引擎。开源规则引擎的代表是Drools；商业规则引擎的代表是ILog。 1.2 使用规则引擎的优势能够将业务规则从技术实现中提取出来，实现技术和业务分离，开发人员处理技术、业务分析人员定义业务规则，各自做自己所擅长的事情。 1.3 什么场景适合使用规则引擎虽然规则引擎能解决我们的许多问题，但我们还需要认真考虑一下规则引擎对我们的项目本身是否是合适的。需要关注的点有： ? 我的应用程序有多复杂? 对于那些只是把数据从数据库中传入传出，并不做更多事情的应用程序，最好不要使用规则引擎。但是，当在Java中有一定量的商业逻辑处理的话，可以考虑Drools的使用。这是因为很多应用随着时间的推移越来越复杂，而Drools可以让你更轻松应对这一切。 ? 我的应用的生命周期有多久？如果我们应用的生命周期很短，也没有必要使用Drools，使用规则引擎将会在中长期得到好处。

Drools开发教程、规则引擎

Drools5规则引擎规则引擎开发开发教程教程教程高杰上海锐道信息技术有限公司 2009-8-20

1.学习前的准备 Drools是一款基于Java的开源规则引擎，所以在使用Drools之前需要在开发机器上安装好JDK环境，Drools5要求的JDK版本要在1.5或以上。 1.1. 开发环境搭建大多数软件学习的第一步就是搭建这个软件的开发环境，Drools也不例外。本小节的内容就是介绍如何搭建一个Drools5的开发、运行、调试环境。 1.1.1.下载开发工具 Drools5提供了一个基于Eclipse3.4的一个IDE开发工具，所以在使用之前需要到https://www.wendangku.net/doc/8d2080742.html,网站下载一个 3.4.x版本的Eclipse，下载完成之后，再到https://www.wendangku.net/doc/8d2080742.html,/drools/downloads.html网站，下载Drools5的Eclipse插件版IDE及Drools5的开发工具包，如图1-1所示。

图1-1 除这两个下载包以外，还可以把Drools5的相关文档、源码和示例的包下载下来参考学习使用。将下载的开发工具包及IDE包解压到一个非中文目录下，解压完成后就可以在Eclipse3.4上安装Drools5提供的开发工具IDE了。 1.1. 2.安装Drools IDE 打开Eclipse3.4所在目录下的links目录（如果该目录不存在可以手工在其目录下创建一个links目录），在links目录下创建一个文本文件，并改名为drools5-ide.link，用记事本打开该文件，按照下面的版本输入Drools5 Eclipse Plugin文件所在目录： path=D:\\eclipse\\drools-5.0-eclipse-all 这个值表示Drools5 Eclipse Plugin文件位于D盘eclipse目录下的drools-5.0-eclipse-all 下面，这里有一点需要注意，那就是drools-5.0-eclipse-all文件夹下必须再包含一个eclipse 目录，所有的插件文件都应该位于该eclipse目录之下，接下来要在win dos下重启Eclipse 3.4，检验Drools5 IDE是否安装成功。进入win dos，进入Eclipes3.4所在目录，输入eclipse –clean启动Eclipse3.4。启动完成

规则引擎(DROOLS)培训资料v1.0.0

规则引擎(DROOLS)培训 DROOLS培训（5天）目的：重点讲解DROOLS是什么、能做什么、工作流程、怎么用到系统中，让学习人员可以对DROOLS有个全面初步的了解，并能够用DROOLS进行简单的系统开发。参加人员：需要使用DROOLS进行系统设计和开发或者对DROOLS感兴趣的同事。主讲人员：

第一章 DROOLS 入门第 1 节什么是DROOLS 如何组织企业应用中的业务逻辑，如果靠手工的代码来解决。随着大量业务规则的变化，导致应用程序不停的变更，如何能找到一种解决商业逻辑的架构，来解决当商务规则不停的变化时，可以保证我们的应用系统具有较好的柔韧性，可以适应特定的商务规则的变化，而无需修改我们的应用系统。Drools就是这样的一个应用在商务逻辑层的架构。 CODEHAUS的一个开源项目叫Drools，Drools是为Java量身定制的基于RETE算法的规则引擎的实现。具有了OO接口的RETE,使得商业规则有了更自然的表达。Drools是用Java写的，但能同时运行在Java 和.Net上。最近被纳入JBOSS门下，更名为JBOSS Rules，成为了JBOSS应用服务器的规则引擎。 RETE算法是CHARLES FORGY在1979年发明的。RETE是唯一的，效率与执行规则数目无关的决策支持算法。For the uninitiated, that means it can scale to incorporate and execute hundreds of thousands of rules in a manner which is an order of magnitude more efficient then the next best algorithm。 RETE应用于生产系统已经有很多年了，但在Java开源软件中并没有得到广泛应用，直到DROOLS的出现。第 2 节 DROOLS能做什么大多数web和企业Java应用可以分成三个部分：一个和用户交互的前台, 一个和后台系统，例如数据库交互的服务层，以及他们中间的业务逻辑。现在使用框架构建前台和后台系统已经成为普遍共识(例如, Struts, Cocoon, Spring, Hibernate, JDO, 和 Entity Beans), 但却没有一个标准的方法来构建业务逻辑。一些框架，例如 EJB 和 Spring 只在一个高层实现业务逻辑，但对于我们组织逻辑代码没有任何帮助，所以，为什么没有一个框架来替换冗繁，易错的if...then语句呢，这个框架应该和其它前台或后台框架一样，易于配置，具有可读性和重用性。Drools 规则引擎，这个就是来解决我们上述问题的框架。