Tutorialspoint Drools 教程
来源：易百教程
Drools教程™
任何Java企业级应用可以分成三个部分 −
- UI – 用户界面（前端）
- 服务层连接到数据库
- 业务层
我们有一些框架，用来处理UI和业务层在一起，例如，Spring和Struts。然而，我们没有一个标准的方式来处理业务逻辑，直到Drools的出现。
Drools是什么?
Drools是一个业务逻辑集成平台（BLip）。它是用Java编写。它是由JBoss和红帽公司扩展支持，并实现Rete模式匹配算法的一个开源项目。
通俗地说，Drools是一种工具，使我们能够分离内部业务流程，找到逻辑和数据的集合。我们需要注意的两个重要关键词是逻辑和数据。
Drools的被分成两个主要部分：编写和运行系统。
- 制作: 制作过程涉及创建规则文件（.DRL文件）。
- 运行时: 它涉及到创建工作存储器和处理活化。
什么是规则引擎？
Drools is Rule Engine or a Production Rule System that uses the rule-based approach to implement and Expert System. Expert Systems are knowledge-based systems that use knowledge representation to process acquired knowledge into a knowledge base that can be used for reasoning.
A Production Rule System is Turing complete with a focus on knowledge representation to express propositional and first-order logic in a concise, non-ambiguous and declarative manner.
The brain of a Production Rules System is an Inference Engine that can scale to a large number of rules and facts. The Inference Engine matches facts and data against Production Rules – also called Productions or just Rules – to infer conclusions which result in actions.
A Production Rule is a two-part structure that uses first-order logic for reasoning over knowledge representation. A business rule engine is a software system that executes one or more business rules in a runtime production environment.
A Rule Engine allows you to define “What to Do” and not “How to do it.”
What is a Rule?
Rules are pieces of knowledge often expressed as, "When some conditions occur, then do some tasks."
When
<
Condition
is
true
>
Then
<
Take
desired
Action
>
The most important part of a Rule is its when part. If the when part is satisfied, the thenpart is triggered.
rule
<rule_name>
<attribute>
<value>
when
<conditions>
then
<actions>
end
Pattern Matching
The process of matching the new or existing facts against Production Rules is called Pattern Matching, which is performed by the Inference Engine. There are a number of algorithms used for Pattern Matching including:
Linear
Rete
Treat
Leaps
Drools Implements and extends the Rete Algorithm. The Drools Rete implementation is called ReteOO, signifying that Drools has an enhanced and optimized implementation of the Rete algorithm for object-oriented systems.
Advantages of a Rule Engine
Declarative Programming
Rules make it easy to express solutions to difficult problems and get the solutions verified as well. Unlike codes, Rules are written in less complex language; Business Analysts can easily read and verify a set of rules.
Logic and Data Separation
The data resides in the Domain Objects and the business logic resides in the Rules. Depending upon the kind of project, this kind of separation can be very advantageous.
Speed and Scalability
The Rete OO algorithm on which Drools is written is already a proven algorithm. With the help of Drools, your application becomes very scalable. If there are frequent change requests, one can add new rules without having to modify the existing rules.
Centralization of Knowledge
By using Rules, you create a repository of knowledge (a knowledge base) which is executable. It is a single point of truth for business policy. Ideally, Rules are so readable that they can also serve as documentation.
Tool Integration
Tools such as Eclipse provide ways to edit and manage rules and get immediate feedback, validation, and content assistance. Auditing and debugging tools are also available.
本站代码下载：http://www.yiibai.com/siteinfo/download.html
本文属作者原创，转载请注明出处：易百教程 » Drools教程
Drools Eclipse插件 - Drools教程™
下面是安装Drools插件的先决条件：
- Java 1.5 (以上) SE JDK
- Eclipse 4.2 (或以上版本)和Drools插件
由于Drools是用Java编写的一个BRMS(业务规则管理系统)，我们将涵盖如何添加所需的插件本节。考虑到最大的Java用户在使用Eclipse，让我们来看看如何在Eclipse中添加Drools5.x.0插件。
第1步：下载二进制文件
从以下链接下载二进制文件：
http://download.jboss.org/drools/release/5.3.0.Final/
下载完成后，将文件解压缩到硬盘。
第2步：安装软件
启动Eclipse并点击 help→install new software. 点击添加为显示在下面的屏幕截图。
此后，单击本地如下图所示，选择"…/binaries/org.drools.updatesite".
选择Drools和jBPM，然后单击下一步。
再次单击下一步。此后，接受条款和许可协议，并单击Finish。
当点击完成，软件安装开始：
后安装成功，会得到如下对话框：
单击"Ok"。当Eclipse重新启动后，到Windows → Preferences
你可以在preferences看到Drools。现在Drools插件安装完成了。
本站代码下载：http://www.yiibai.com/siteinfo/download.html
本文属作者原创，转载请注明出处：易百教程 » Drools Eclipse插件
Drools运行时 - Drools教程™
Drools运行系统必须指示编辑器使用Drools jar特定版本运行程序。可以运行程序/应用程序在不同的Drools运行时。
点击 Windows → Preference → Drools → Installed Drools Runtime. 然后单击添加如下面的屏幕截图。
此后，点击创建一个新的Drools Runtime，如下图所示。
输入路径，到您下载的二进制文件的文件夹 droolsjbpm-tools-distribution-5.3.0.Final.zip
点击OK并提供Drools运行一个名称。 Drools运行时现在即可创建。
本站代码下载：http://www.yiibai.com/siteinfo/download.html
本文属作者原创，转载请注明出处：易百教程 » Drools运行时
创建Drools程序(入门) - Drools教程™
要创建一个基本的Drools的程序，打开Eclipse。到 File → New → Project.
选择Drools项目。给一个合适的名称项目。例如，DroolsTest。
下一个屏幕会提示您选择想要在Drools项目中的一些文件。
选择第2个文件。第一文件是一个.drl文件(Drools的规则文件)，第二文件是用于装载和执行的HelloWorld规则的Java类。
点击 Next → Finish.
一旦点击Finish(完成)，<DroolsTest>项目在工作区中创建。打开Java类，然后右键点击并运行Java应用程序。你会看到输出如下所示：
下一步，我们将讨论中经常使用的一个规则引擎的一些术语。
本站代码下载：http://www.yiibai.com/siteinfo/download.html
本文属作者原创，转载请注明出处：易百教程 » 创建Drools程序(入门)
Drools常用术语 - Drools教程™
规则
规则引擎，在其中指定条件 (如果 ‘a’ 那么 ‘b’).
概况
概况是其上的规则将在行动中的数据。从Java的角度来看，概况是POJO(普通Java对象)。
会话
在Drools中基于知识是会话的核心部件用来触发的规则。 这是知识的会话保存所有的规则和其他资源。基于知识会话从知识库创建。
对于规则引擎的工作，概况插入了会话，并在满足条件时，随后触发规则。Session有两种类型：
- 无状态知识会话
- 状态知识会话
议程
这是一个逻辑概念。议程就是激活正在等待被触发的合乎逻辑的地方。
激活
激活是当时的部分规则。激活被放置在相应的规则被触发议事日程。
本站代码下载：http://www.yiibai.com/siteinfo/download.html
本文属作者原创，转载请注明出处：易百教程 » Drools常用术语
Drools规则编写 - Drools教程™
如果有在看Hello World项目(Sample.drl)的默认规则，也有很多使用的关键字，我们现在将一个一个地来解释。
Sample.drl
- 包: 每一个规则开始包的名称。包充当规则命名空间。包内的规则名称必须是唯一的。在规则中包类似于Java包。
- Import语句: 要应用规则的任何fact，这些fact都需要导入。例如，com.sample.DroolsTest.Message; 在上面的例子。
- 规则定义: 它由规则名称，条件和后果。 Drools的关键字：rule, when, then, 以及 end. 在上述的例子中，规则名 “Hello World” 和 “GoodBye”. when 部分是两个规则中的条件，then 部分是后果.在规则的术语, when 部分也被称为LHS（左手侧）以及 then 部分作为规则的RHS（右手边）。
现在让我们来看看在用于装载的Drools并执行规则的Java文件中使用的术语。
知识库
知识库是管理规则，流程，和内部类型的集合的接口. 它包含在包 org.drools.KnowledgeBase 内. 在Drools中，这些被统称为knowledge definitions 或 knowledge. 知识定义被分成 knowledge packages. 知识的定义可以被添加或删除. 知识库的主要目的是为存储和重新使用它们，因为它们的创建是昂贵的。知识库提供了创造知识的会话方法。
知识会话
知识会话从知识库检索。它是用于与Drools的引擎进行交互的主要接口。知识会话有两种类型：
- 无状态知识会话
- 有状态知识会话
无状态会话知识
无状态会话知识是一个无状态的会话，形成最简单的使用情况，不会利用推断。一个无状态的会话可以被称为像一个函数，它传递了一些数据，然后将接收回来了一定的成效。无状态会话的常见例子包括：
- 验证
- 这个人有资格获得抵押贷款？
- 计算
- 计算按揭保险费。
- 路由和过滤
- 过滤传入的消息，如电子邮件，到文件夹中。
- 发送传入的消息到目的地
状态知识会话
状态会话更长保留，并允许随着时间的推移反复变化。一些常见的用例有状态会话包括：
- 监控
- 现货市场监测和分析半自动买盘。
- 诊断
- 故障排除，医疗诊断
- 物流
- 包裹跟踪和交付供应
知识生成器
KnoledgeBuilder接口负责构建从知识的定义（规则，流程，类型）一个KnowledgePackage。它包含在 org.drools.builder.KnowledgeBuilder 包内. 知识的定义可以是各种格式。如果使用构建有任何问题，KnowledgeBuilder将报告通过这两种方法的错误： hasErrors 以及 getError.
下图说明了过程
在上面的例子中，因为我们正在采取无状态会话知识的一个简单的例子，我们已经插入了事实的会话，然后fireAllRules()方法被调用，你会看到输出结果。
如果有状态会话的知识，一旦规则被激发，有状态的知识会话对象必须调用方法Dispose()释放会话以避免内存泄漏。
本站代码下载：http://www.yiibai.com/siteinfo/download.html
本文属作者原创，转载请注明出处：易百教程 » Drools规则编写
Drools规则语法 - Drools教程™
正如你看到的.drl(规则文件)都有自己的语法，让我们盖这个章介绍规则语法的某些部分。
在规则中的条件
规则可以包含很多的条件和模式，如：
- Account (balance == 200)
- Customer (name == “Vivek”)
上述条件检查帐户余额是200或客户名称是 “Vivek”.
在规则中的变量
在Drools中的变量名称以美元($)符号开始。
- $account : Account( )
- $account is the variable for Account() class
Drools可与所有本地Java类型，甚至枚举工作。
在规则中的注释
特殊字符，# 或 //，可用于标记单行注释。
对于多行注释，请使用以下格式：
/*
Another line
.........
.........
*/
全局变量
全局变量分配给会话变量。它们可用于各种原因如下：
- 对于输入参数(可从会话定制会话。例如，常量值)。
- 对于输出参数(例如，报告，规则可以写一些消息给全局报表变量)。
- 切入点的服务，如日志记录，这可以在规则中使用。
在规则中的函数
函数是一个方便的功能。它们可以在条件和后果使用。函数代表的替代工具/辅助类。例如，
function
double
calculateSquare
(
double
value
)
{
return
value
*
value
;
}
方言
方言指定任何代码的表达是在条件或因此所使用的语法。它包括返回值，evals,内联evals，谓词突性表达式，后果，并依此类推。默认值是Java。目前，Drools支持多了一个叫做方言MVEL。默认方言可以指定在包级别如下：
package
org
.
mycompany
.
somePackage
dialect
"mvel"
MVEL 方言
MVEL是基于Java的应用程序的表达式语言。它支持字段和方法/getter访问。它是基于Java的语法。
突显
突显是规则语法的一个非常重要的特点。突显使用的冲突解决策略，以决定哪些规则首先触发。默认情况下，它是主要标准。
我们可以用突性来定义的击发规则的顺序。突显有一个属性，这需要一个返回数字类型为int（正数和负数是有效）的任何表达式。该值越高，就越有可能的规则将被拾起的冲突解决策略触发。
salience
(
$account
.
balance
*
5
)
默认的显着值是0分配显着值只有一些规则时，我们应该记住这一点。
有很多的规则语法等特性/参数，但我们只涵盖了重要的位置。
规则后果关键词
规则后果关键字是规则“then”的一部分使用的关键字。
- Modify – fact属性可在随后部分的规则进行修改。
- Insert – 基于一些条件，如果true，可以插入一个新的事实到规则引擎会话。
- Retract – 如果一个特定的条件是一个true的规则，则不采取其他任何就事实，可以从规则引擎收回特定事实。
注意：它被认为是一个非常不好的做法，有一个条件逻辑（if语句）规则的后果之内。大多数时候，一个新的规则应该被创建。
本站代码下载：http://www.yiibai.com/siteinfo/download.html
本文属作者原创，转载请注明出处：易百教程 » Drools规则语法
Drools简单项目 - Drools教程™
在本章中，我们将创建一个Drools项目下列问题说明：
根据不同的城市和各类产品(城和产品的组合)，找出当地税务相关的城市。
我们将有两个DRL文件为我们的Drools项目。这两个文件的DRL将意味着两个城市在考虑(Pune和Nagpur)和四类产品(杂货，药品，手表和奢侈品)。
- 在这两个城市的药品税被认为是零。
- 杂货，我们假设了2卢比在Pune和1卢比在Nagpur的一种税。
我们已经使用了相同的售价以证明不同的输出。请注意，所有的规则都被触发了应用。
这里是模型用来保存每个项目类型：
package
com
.
sample
;
import
java
.
math
.
BigDecimal
;
public
class
ItemCity
{
public
enum
City
{
PUNE
,
NAGPUR
}
public
enum
Type
{
GROCERIES
,
MEDICINES
,
WATCHES
,
LUXURYGOODS
}
private
City
purchaseCity
;
private
BigDecimal
sellPrice
;
private
Type
typeofItem
;
private
BigDecimal
localTax
;
public
City
getPurchaseCity
()
{
return
purchaseCity
;
}
public
void
setPurchaseCity
(
City
purchaseCity
)
{
this
.
purchaseCity
=
purchaseCity
;
}
public
BigDecimal
getSellPrice
()
{
return
sellPrice
;
}
public
void
setSellPrice
(
BigDecimal
sellPrice
)
{
this
.
sellPrice
=
sellPrice
;
}
public
Type
getTypeofItem
()
{
return
typeofItem
;
}
public
void
setTypeofItem
(
Type
typeofItem
)
{
this
.
typeofItem
=
typeofItem
;
}
public
BigDecimal
getLocalTax
()
{
return
localTax
;
}
public
void
setLocalTax
(
BigDecimal
localTax
)
{
this
.
localTax
=
localTax
;
}
}
DRL文件
正如前面所说，我们已经用了两个DRL文件在这里：Pune.drl 和Nagpur.drl.
Pune.drl
这是对Pune执行规则的DRL文件。
// created on: Dec 24, 2014
package
droolsexample
// list any import classes here.
import
com
.
sample
.
ItemCity
;
import
java
.
math
.
BigDecimal
;
// declare any global variables here
dialect
"java"
rule
"Pune Medicine Item"
when
item
:
ItemCity
(
purchaseCity
==
ItemCity
.
City
.
PUNE
,
typeofItem
==
ItemCity
.
Type
.
MEDICINES
)
then
BigDecimal
tax
=
new
BigDecimal
(
0.0
);
item
.
setLocalTax
(
tax
.
multiply
(
item
.
getSellPrice
()));
end
rule
"Pune Groceries Item"
when
item
:
ItemCity
(
purchaseCity
==
ItemCity
.
City
.
PUNE
,
typeofItem
==
ItemCity
.
Type
.
GROCERIES
)
then
BigDecimal
tax
=
new
BigDecimal
(
2.0
);
item
.
setLocalTax
(
tax
.
multiply
(
item
.
getSellPrice
()));
end
Nagpur.drl
这是对Nagpur市执行规则的DRL文件。
// created on: Dec 26, 2014
package
droolsexample
// list any import classes here.
import
com
.
sample
.
ItemCity
;
import
java
.
math
.
BigDecimal
;
// declare any global variables here
dialect
"java"
rule
"Nagpur Medicine Item"
when
item
:
ItemCity
(
purchaseCity
==
ItemCity
.
City
.
NAGPUR
,
typeofItem
==
ItemCity
.
Type
.
MEDICINES
)
then
BigDecimal
tax
=
new
BigDecimal
(
0.0
);
item
.
setLocalTax
(
tax
.
multiply
(
item
.
getSellPrice
()));
end
rule
"Nagpur Groceries Item"
when
item
:
ItemCity
(
purchaseCity
==
ItemCity
.
City
.
NAGPUR
,
typeofItem
==
ItemCity
.
Type
.
GROCERIES
)
then
BigDecimal
tax
=
new
BigDecimal
(
1.0
);
item
.
setLocalTax
(
tax
.
multiply
(
item
.
getSellPrice
()));
end
我们已经写了基于城市的DRL文件，因为它为我们提供了可扩展性，以在以后添加任意数量的规则文件，如果被添加了新的城市。
为了证明所有的规则都可以从我们的规则文件触发，我们已经使用了两种类型的产品（药物和杂货）; 药是免税和杂货征税按城市。
我们的测试类加载规则文件，插入事实到会话，并产生输出。
Droolstest.java
package
com
.
sample
;
import
java
.
math
.
BigDecimal
;
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
.
runtime
.
StatefulKnowledgeSession
;
import
com
.
sample
.
ItemCity
.
City
;
import
com
.
sample
.
ItemCity
.
Type
;
/* This is a sample class to launch a rule. */
public
class
DroolsTest
{
public
static
final
void
main
(
String
[]
args
)
{
try
{
// load up the knowledge base
KnowledgeBase
kbase
=
readKnowledgeBase
();
StatefulKnowledgeSession
ksession
=
kbase
.
newStatefulKnowledgeSession
();
ItemCity
item1
=
new
ItemCity
();
item1
.
setPurchaseCity
(
City
.
PUNE
);
item1
.
setTypeofItem
(
Type
.
MEDICINES
);
item1
.
setSellPrice
(
new
BigDecimal
(
10
));
ksession
.
insert
(
item1
);
ItemCity
item2
=
new
ItemCity
();
item2
.
setPurchaseCity
(
City
.
PUNE
);
item2
.
setTypeofItem
(
Type
.
GROCERIES
);
item2
.
setSellPrice
(
new
BigDecimal
(
10
));
ksession
.
insert
(
item2
);
ItemCity
item3
=
new
ItemCity
();
item3
.
setPurchaseCity
(
City
.
NAGPUR
);
item3
.
setTypeofItem
(
Type
.
MEDICINES
);
item3
.
setSellPrice
(
new
BigDecimal
(
10
));
ksession
.
insert
(
item3
);
ItemCity
item4
=
new
ItemCity
();
item4
.
setPurchaseCity
(
City
.
NAGPUR
);
item4
.
setTypeofItem
(
Type
.
GROCERIES
);
item4
.
setSellPrice
(
new
BigDecimal
(
10
));
ksession
.
insert
(
item4
);
ksession
.
fireAllRules
();
System
.
out
.
println
(
item1
.
getPurchaseCity
().
toString
()
+
" "
+
item1
.
getLocalTax
().
intValue
());
System
.
out
.
println
(
item2
.
getPurchaseCity
().
toString
()
+
" "
+
item2
.
getLocalTax
().
intValue
());
System
.
out
.
println
(
item3
.
getPurchaseCity
().
toString
()
+
" "
+
item3
.
getLocalTax
().
intValue
());
System
.
out
.
println
(
item4
.
getPurchaseCity
().
toString
()
+
" "
+
item4
.
getLocalTax
().
intValue
());
}
catch
(
Throwable
t
)
{
t
.
printStackTrace
();
}
}
private
static
KnowledgeBase
readKnowledgeBase
()
throws
Exception
{
KnowledgeBuilder
kbuilder
=
KnowledgeBuilderFactory
.
newKnowledgeBuilder
();
kbuilder
.
add
(
ResourceFactory
.
newClassPathResource
(
"Pune.drl"
),
ResourceType
.
DRL
);
kbuilder
.
add
(
ResourceFactory
.
newClassPathResource
(
"Nagpur.drl"
),
ResourceType
.
DRL
);
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
;
}
}
如果你运行这个程序，它的输出将如下所示：
PUNE 0
PUNE 20
NAGPUR 0
NAGPUR 10
对于这两种Pune的和Nagpur，当时该项目是一个医药，当地税务为零;而当该项目是一个杂货店的产品，该税是按城市的。更多的规则可以在DRL文件的其他产品中添加。这仅仅是一个示例程序。
调用外部函数形成DRL文件
在这里，我们将演示如何从DRL文件的Java文件调用静态函数。
首先，创建一个类HelloCity.java在同一个包com.sample中。
package
com
.
sample
;
public
class
HelloCity
{
public
static
void
writeHello
(
String
name
)
{
System
.
out
.
println
(
"HELLO "
+
name
+
"!!!!!!"
);
}
}
此后，添加import语句在DRL文件来调用从DRL文件writeHello方法。在下面的代码块中，修改DRL文件Pune.drl以黄色突出显示。
// created on: Dec 24, 2014
package
droolsexample
// list any import classes here.
import
com
.
sample
.
ItemCity
;
import
java
.
math
.
BigDecimal
;
import
com
.
sample
.
HelloCity
;
//declare any global variables here
dialect
"java"
rule
"Pune Medicine Item"
when
item
:
ItemCity
(
purchaseCity
==
ItemCity
.
City
.
PUNE
,
typeofItem
==
ItemCity
.
Type
.
MEDICINES
)
then
BigDecimal
tax
=
new
BigDecimal
(
0.0
);
item
.
setLocalTax
(
tax
.
multiply
(
item
.
getSellPrice
()));
HelloCity
.
writeHello
(
item
.
getPurchaseCity
().
toString
());
end
rule
"Pune Groceries Item"
when
item
:
ItemCity
(
purchaseCity
==
ItemCity
.
City
.
PUNE
,
typeofItem
==
ItemCity
.
Type
.
GROCERIES
)
then
BigDecimal
tax
=
new
BigDecimal
(
2.0
);
item
.
setLocalTax
(
tax
.
multiply
(
item
.
getSellPrice
()));
end
再次运行程序，其输出将如下所示：
HELLO PUNE!!!!!!
PUNE 0
PUNE 20
NAGPUR 0
NAGPUR 10
现在，在输出的差被标记为黄色，显示在Java类的静态方法的输出。
其优点调用Java方法是，我们可以用Java编写的任何效用/辅助函数，并从DRL文件调用相同。
本站代码下载：http://www.yiibai.com/siteinfo/download.html
本文属作者原创，转载请注明出处：易百教程 » Drools简单项目
Drools调试 - Drools教程™
有不同的方法来调试Drools项目。在这里，我们将编写一个实用工具类，知道哪些规则正在被触发或发射。
通过这种方法，可以检查所有的规则都在Drools项目得到触发。这里是我们的工具类
Utility.java
package
com
.
sample
;
import
org
.
drools
.
spi
.
KnowledgeHelper
;
public
class
Utility
{
public
static
void
help
(
final
KnowledgeHelper
drools
,
final
String
message
){
System
.
out
.
println
(
message
);
System
.
out
.
println
(
"\nrule triggered: "
+
drools
.
getRule
().
getName
());
}
public
static
void
helper
(
final
KnowledgeHelper
drools
){
System
.
out
.
println
(
"\nrule triggered: "
+
drools
.
getRule
().
getName
());
}
}
第一种方法帮助打印规则一起，可以通过为String通过DRL文件中的一些额外的信息触发。
第二条规则助手打印特定的规则是否被触发。
我们增加了在每个DRL文件中的实用方法之一。我们在DRL文件(Pune.drl)还增加了导入函数。在当时的部分规则，我们已经加入了效用函数调用。下面修改Pune.drl。改变以蓝色显示。
Modified Pune.drl
//created on: Dec 24, 2014
package
droolsexample
//list any import classes here.
import
com
.
sample
.
ItemCity
;
import
java
.
math
.
BigDecimal
;
import
com
.
sample
.
HelloCity
;
import
function
com
.
sample
.
Utility
.
helper
;
// declare any global variables here
dialect
"java"
rule
"Pune Medicine Item"
when
item
:
ItemCity
(
purchaseCity
==
ItemCity
.
City
.
PUNE
,
typeofItem
==
ItemCity
.
Type
.
MEDICINES
)
then
BigDecimal
tax
=
new
BigDecimal
(
0.0
);
item
.
setLocalTax
(
tax
.
multiply
(
item
.
getSellPrice
()));
HelloCity
.
writeHello
(
item
.
getPurchaseCity
().
toString
());
helper
(
drools
);
end
rule
"Pune Groceries Item"
when
item
:
ItemCity
(
purchaseCity
==
ItemCity
.
City
.
PUNE
,
typeofItem
==
ItemCity
.
Type
.
GROCERIES
)
then
BigDecimal
tax
=
new
BigDecimal
(
2.0
);
item
.
setLocalTax
(
tax
.
multiply
(
item
.
getSellPrice
()));
helper
(
drools
);
end
同样地，我们已经添加在第二个DRL文件（Nagpur.drl）其他效用函数。这里是修改后的代码：
修改后的 Nagpur.drl
// created on: Dec 26, 2014
package
droolsexample
// list any import classes here.
import
com
.
sample
.
ItemCity
;
import
java
.
math
.
BigDecimal
;
import
function
com
.
sample
.
Utility
.
help
;
//declare any global variables here
dialect
"java"
rule
"Nagpur Medicine Item"
when
item
:
ItemCity
(
purchaseCity
==
ItemCity
.
City
.
NAGPUR
,
typeofItem
==
ItemCity
.
Type
.
MEDICINES
)
then
BigDecimal
tax
=
new
BigDecimal
(
0.0
);
item
.
setLocalTax
(
tax
.
multiply
(
item
.
getSellPrice
()));
help
(
drools
,
"added info"
);
end
rule
"Nagpur Groceries Item"
when
item
:
ItemCity
(
purchaseCity
==
ItemCity
.
City
.
NAGPUR
,
typeofItem
==
ItemCity
.
Type
.
GROCERIES
)
then
BigDecimal
tax
=
new
BigDecimal
(
1.0
);
item
.
setLocalTax
(
tax
.
multiply
(
item
.
getSellPrice
()));
help
(
drools
,
"info"
);
end
再次运行程序，它应该产生以下的输出：
info
rule triggered: Nagpur Groceries Item
added info
rule triggered: Nagpur Medicine Item
rule triggered: Pune Groceries Item
HELLO PUNE!!!!!!
rule triggered: Pune Medicine Item
PUNE 0
PUNE 20
NAGPUR 0
NAGPUR 10
这两个工具函数被调用，它显示了特定规则是否被调用与否。在上述的例子中，所有的规则都被调用，但在企业应用程序中，该实用程序函数可以是真正有用的调试，并找出一个特定规则是否被触发或没有。
使用Debug透视图在Eclipse
可以将Drools的应用程序的执行过程中调试规则。可以在规则的后果添加断点，每当这样的断点的规则的执行过程中遇到，执行暂时停止。然后，可以检查该点调用Java应用程序，并使用在Eclipse提供正常的调试选项。
创建DRL文件断点，只需双击创建一个断点行。记住，只能在当时的部分规则的创建一个断点。断点可以通过双击在DRL编辑器中的断点被删除。
采用断点后，需要将应用程序作为Drools的应用程序进行调试。 Drools的断点（以DRL文件的断点），如果应用程序正在调试的Drools的应用程序将只工作。这里是如何需要做的是相同的：
调试应用程序作为Drools的应用程序，会看到如图所示的下面的截图DRL文件中的控制：
可以在该调试点看到的变量和所述对象的当前值。同一控制F6移动到下一行和F8跳转到下一个调试点也适用在这里。通过这种方式，可以调试Drools的应用程序。
注：在Drools中的应用调试的角度来看只有当方言是MVEL直到Drools5.x
本站代码下载：http://www.yiibai.com/siteinfo/download.html
