规则引擎：Drools与JRuleEngine

最新推荐文章于 2024-09-18 16:41:57 发布
最新推荐文章于 2024-09-18 16:41:57 发布
阅读量1.7k 收藏
点赞数
分类专栏： 规则引擎 文章标签： 引擎 import constants exception attributes string

 

规则引擎：Drools与JRuleEngine


译文：《规则引擎：Drools与JRuleEngine》
译者：chszs
作者：Vivek Tomar
原文：《Rule engine : Drools / JRuleEngine》
原文见http://www.naxos-software.de/blog/index.php?/archives/78-Rule-engine-Drools-JRuleEngine.html

一、规则引擎
规则引擎有助于基于存储在规则中的知识和推理来执行判断。这些规则基本上只有条件和动作，别无它物。

规则引擎的优点：
1、分隔应用程序的条件和控制流
(1) 规则都存储在单独的文件。
(2) 规则可以被技术人士和商业人士修改的。
(3) 规则改变后应用程序不必重新部署。
(4) 使用集中的规则使得应用程序更易于管理和维护。
 
2、规则替换了代码中的if else语句
(1) 规则脚本更容易提取。
(2) 即使是非技术人员也能轻易地遵循规则。
(3) 集中可以解决问题，而不是实现。
(4) 与实现代码相比，规则聚团更容易编写。 

3、为什么作决定能很容易地概念化

总结：规则有助于消除代码中大量的if else语句，使代码更易于维护。

二、Drools介绍
Drools是一个开源实现。它是一个Java库，以Apache许可证发布，其二进制代码或源码下载均有效。

推理机的核心是一个规则引擎。它执行模式匹配，在执行动作中做出决策。RETE算法用于模式匹配。 

知识被表述为规则。规则有两个主要部分：条件和动作。

例如：
如果用户（年龄>17），那么System.out.println("User is greater then 17");

在人工智能系统，主要有两种响应的方法。
1、正向链（Forward Chaining）
这是基于事实根据的。在工作区域检查中规则。当规则条件为真的规则不再有时，模式匹配结束。

2、反向链（Backward Chaining）
只检查规则的动作可以匹配目标的规则。如果满足条件，然后进行评估。

3、兼容JDK1.4，且需要下面的库。
(1) drools-all-jdk1.4.2.1.jar
(2) xercesImpl-2.6.2.jar
(3) antlr-2.7.5.jar
(4) janino-2.3.2.jar

4、代码示例（ApplyRule.java）

 

view plain copy to clipboard print ?
  1. /*  
  2.   /* $Header$  
  3.   */  
  4.   
  5.   package com.vivek.drools.example;   
  6.   
  7.   import java.io.IOException;   
  8.   import java.io.InputStream;   
  9.   import org.apache.commons.logging.Log;   
  10.   import org.apache.commons.logging.LogFactory;   
  11.   import org.drools.FactException;   
  12.   import org.drools.IntegrationException;   
  13.   import org.drools.RuleBase;   
  14.   import org.drools.WorkingMemory;   
  15.   import org.drools.io.RuleBaseLoader;   
  16.   import org.xml.sax.SAXException;   
  17.   
  18.   /**  
  19.   * Demonstration of a sample rule using Java.  
  20.   *  
  21.   * @version <tt>$Revision: 1.0 $</tt>  
  22.   * @author <a href="mailto:{vivek.tomar@naxos-software.de}" mce_href="mailto:{vivek.tomar@naxos-software.de}">{Vivek Tomar}</a>.  
  23.   */  
  24.   
  25.   public class ApplyRule {   
  26.   
  27.   // Constants -----------------------------------------------------   
  28.   
  29.   static Log log = LogFactory.getLog(ApplyRule.class.getName());   
  30.   private static final String RULE_FILE = "/rules/rules.drl";   
  31.   //private static final String RULE_IS_TURNOVER_INSURABLE = "turnoverInsurable";   
  32.   //private static final String RULE_IS_TURNOVER_NOT_INSURABLE = "turnoverNotInsurable";   
  33.   
  34.   // Attributes ----------------------------------------------------   
  35.   
  36.   private double turnover = 1000000;   
  37.   
  38.   // Constructors --------------------------------------------------   
  39.   
  40.   public ApplyRule () {   
  41.   try {   
  42.   InputStream in = this.getClass().getResourceAsStream(RULE_FILE);   
  43.   RuleBase ruleBase = RuleBaseLoader.loadFromInputStream(in);   
  44.   WorkingMemory workingMemory = ruleBase.newWorkingMemory();   
  45.   workingMemory.assertObject(this);   
  46.   // Fire specific rule   
  47.   //workingMemory.fireAllRules(new RuleNameEqualsAgendaFilter(RULE_IS_TURNOVER_INSURABLE));   
  48.   
  49.   //Fire all rules   
  50.   workingMemory.fireAllRules();   
  51.   } catch (IntegrationException e) {   
  52.   e.printStackTrace();   
  53.   } catch (FactException e) {   
  54.   e.printStackTrace();   
  55.   } catch (SAXException e) {   
  56.   e.printStackTrace();   
  57.   } catch (IOException e) {   
  58.   e.printStackTrace();   
  59.   }   
  60.   }   
  61.   
  62.   // Public --------------------------------------------------------   
  63.   
  64.   public static void main (String args[]) {   
  65.   new ApplyRule();   
  66.   }   
  67.   
  68.   public double getTurnover () {   
  69.   return turnover;   
  70.   }   
  71.   
  72.   public void setTurnover (double turnover) {   
  73.   this.turnover = turnover;   
  74.   }   
  75.   
  76.   public void printCompanyInsurable () {   
  77.   log.info("******************************");   
  78.   log.info("This company is Insurable.");   
  79.   log.info("******************************");   
  80.   }   
  81.   
  82.   public void printCompanyNotInsurable () {   
  83.   log.info("==============================");   
  84.   log.info("This company is not Insurable.");   
  85.   log.info("==============================");   
  86.   }   
  87.   }  



规则定义（rules.drl）

 

 

view plain copy to clipboard print ?
  1.   <?xml version="1.0"?>  
  2. <rule-set name="cheese rules"  
  3.   xmlns="http://drools.org/rules"  
  4.   xmlns:java="http://drools.org/semantics/java"  
  5.   xmlns:xs="http://www.w3.org/2001/XMLSchema-instance"  
  6.   xs:schemaLocation="http://drools.org/rules rules.xsd   
  7.   http://drools.org/semantics/java java.xsd">  
  8. <rule name="turnoverInsurable">  
  9. <parameter identifier="applyRule">  
  10. <class>com.vivek.drools.example.ApplyRule</class>  
  11. </parameter>  
  12. <java:condition>applyRule.getTurnover() > 2000000 </java:condition>  
  13. <java:consequence>  
  14.   applyRule.printCompanyInsurable();   
  15. </java:consequence>  
  16. </rule>  
  17. <rule name="turnoverNotInsurable">  
  18. <parameter identifier="applyRule">  
  19. <class>com.vivek.drools.example.ApplyRule</class>  
  20. </parameter>  
  21. <java:condition>applyRule.getTurnover() < 2000000 </java:condition>  
  22. <java:consequence>  
  23.   applyRule.printCompanyNotInsurable();   
  24. </java:consequence>  
  25. </rule>  
  26. </rule-set>  



三、JRuleEngine介绍
JRuleEngine是一个基于Java的规则引擎，遵循JSR94规范，版本1.1。

1、JRuleEngine共同特征： 
(1) 在JRuleEngine输入对象被称为事实，而输出对象被称为结论。 
(2) 一个类的方法可直接从规则中调用。 

2、JRuleEngine基于前向链算法。

3、规则是类org.jruleengine.rule.RuleImpl的对象，它们以下列方式载入：
(1) 可以从XML文件中读入
(2) 通过RuleImpl对象创建，也可以取自数据库。

4、会话是客户端和规则引擎之间的运行时的胶水。会话与单一的规则执行集相关。会话规则的类型：
(1) 一个有状态的规则会话可持续很长时间，可一次又一次地查询。
(2) 一个无状态的规则给出了实现，但只能持续一定时期。

5、JRuleEngine需要两个库：
(1) jsr94.jar
(2) jruleengine.jar

6、添加这些文件到您应用程序的类路径。

7、通过实例化一个有状态的规则会话（StatefulRuleSession）或无状态的规则会话（StatelessRuleSession）来使用这个库。

8、代码例子(ApplyRule.java)

 

 

view plain copy to clipboard print ?
  1. /*  
  2. * $Header$  
  3. */  
  4. package com.vivek.jruleengine.example;   
  5.   
  6. import java.io.InputStream;   
  7. import java.util.ArrayList;   
  8. import java.util.HashMap;   
  9. import java.util.List;   
  10.   
  11. import javax.rules.RuleRuntime;   
  12. import javax.rules.RuleServiceProvider;   
  13. import javax.rules.RuleServiceProviderManager;   
  14. import javax.rules.StatelessRuleSession;   
  15. import javax.rules.admin.RuleAdministrator;   
  16. import javax.rules.admin.RuleExecutionSet;   
  17.   
  18. import org.apache.commons.logging.Log;   
  19. import org.apache.commons.logging.LogFactory;   
  20.   
  21. /**  
  22. * Demonstration of a sample rule using Java.  
  23. *  
  24. * @version <tt>$Revision: 1.0 $</tt>  
  25. * @author <a href="mailto:{vivek.tomar@naxos-software.de}" mce_href="mailto:{vivek.tomar@naxos-software.de}">{Vivek Tomar}</a>.  
  26. */  
  27. public class ApplyRule {   
  28.   
  29. // Constants -----------------------------------------------------   
  30.   
  31. static Log log = LogFactory.getLog(ApplyRule.class.getName());   
  32. private static final String RULE_FILE = "/rules/rules.xml";   
  33.   
  34. // Attributes ----------------------------------------------------   
  35.   
  36. private double turnover = 1000000;   
  37.   
  38. // Constructors --------------------------------------------------   
  39.   
  40. public ApplyRule () {   
  41.   
  42. try {   
  43. // Load the rule service provider of the reference   
  44. // implementation.   
  45. // Loading this class will automatically register this   
  46. // provider with the provider manager.   
  47. Class.forName("org.jruleengine.RuleServiceProviderImpl");   
  48.   
  49. // Get the rule service provider from the provider manager.   
  50. RuleServiceProvider serviceProvider = RuleServiceProviderManager.getRuleServiceProvider("org.jruleengine");   
  51.   
  52. // get the RuleAdministrator   
  53. RuleAdministrator ruleAdministrator = serviceProvider.getRuleAdministrator();   
  54. log.info("Administration API");   
  55. log.info("======================");   
  56. log.info("Acquired RuleAdministrator: ");   
  57.   
  58. // get an input stream to a test XML ruleset   
  59. // This rule execution set is part of the TCK.   
  60. InputStream inStream = this.getClass().getResourceAsStream(RULE_FILE);   
  61.     
  62.   
  63. // parse the ruleset from the XML document   
  64. RuleExecutionSet res1 =   
  65. ruleAdministrator.getLocalRuleExecutionSetProvider(null).createRuleExecutionSet(inStream, null);   
  66. inStream.close();   
  67. log.info("Loaded RuleExecutionSet: ");   
  68.   
  69. // register the RuleExecutionSet   
  70. String uri = res1.getName();   
  71. ruleAdministrator.registerRuleExecutionSet(uri, res1, null);   
  72. log.info("Bound RuleExecutionSet to URI: " + uri);   
  73.   
  74. RuleRuntime ruleRuntime = serviceProvider.getRuleRuntime();   
  75. log.info("Acquired RuleRuntime: ");   
  76.   
  77. // create a StatelessRuleSession   
  78. StatelessRuleSession statelessRuleSession = (StatelessRuleSession)   
  79. ruleRuntime.createRuleSession(uri, new HashMap(),   
  80. RuleRuntime.STATELESS_SESSION_TYPE);   
  81.   
  82. log.info("Got Stateless Rule Session: " + statelessRuleSession);   
  83.   
  84. // call executeRules with some input objects   
  85.   
  86. // Create a input list.   
  87. List input = new ArrayList();   
  88. input.add(this);   
  89.   
  90. // Print the input.   
  91. log.info("Calling rule session with the following data");   
  92. log.info("Customer turnover input: " + this.getTurnover());   
  93.   
  94. // Execute the rules without a filter.   
  95. List results = statelessRuleSession.executeRules(input);   
  96.   
  97. // Release the session.   
  98. statelessRuleSession.release();   
  99. log.info("Released Stateless Rule Session.");   
  100.   
  101. } catch (NoClassDefFoundError e) {   
  102. if (e.getMessage().indexOf("Exception") != -1) {   
  103. log.error("Error: The Rule Engine Implementation could not be found.");   
  104. } else {   
  105. log.error("Error: " + e.getMessage());   
  106. }   
  107. } catch (Exception e) {   
  108. e.printStackTrace();   
  109. }   
  110. }   
  111.   
  112. // Public --------------------------------------------------------   
  113.   
  114. public static void main (String args[]) {   
  115. new ApplyRule();   
  116. }   
  117.   
  118. public double getTurnover () {   
  119. return turnover;   
  120. }   
  121.   
  122. public void setTurnover (double turnover) {   
  123. this.turnover = turnover;   
  124. }   
  125.   
  126. public void printCompanyInsurable () {   
  127. log.info("******************************");   
  128. log.info("This company is Insurable.");   
  129. log.info("******************************");   
  130. }   
  131.   
  132. public void printCompanyNotInsurable () {   
  133. log.info("==============================");   
  134. log.info("This company is not Insurable.");   
  135. log.info("==============================");   
  136. }   
  137. }  

 



规则定义(rules.xml)

 

view plain copy to clipboard print ?
  1.   <?xml version="1.0" encoding="UTF-8"?>  
  2. <rule-execution-set>  
  3. <name>RuleExecutionSet1</name>  
  4. <description>Rule Execution Set</description>  
  5. <synonymn name="applyRule" class="com.vivek.jruleengine.example.ApplyRule" />  
  6. <rule name="turnoverInsurable" description="Check if turnover insurable" >  
  7. <if leftTerm="applyRule.getTurnover" op=">" rightTerm="2000000" />  
  8. <then method="applyRule.printCompanyInsurable()" />  
  9. </rule>  
  10. <rule name="turnoverNotInsurable" description="Check if turnover not insurable" >  
  11. <if leftTerm="applyRule.getTurnover" op="<" rightTerm="2000000" />  
  12. <then method="applyRule.printCompanyNotInsurable" />  
  13. </rule>  
  14. </rule-execution-set>  



结论：
Drools除了提供正常的规则引擎的能力，还有以下额外的优点：
(1) 无论是技术人士还是商业人士，Drools都是用户友好的，它提供了一个巨大的支持工具集。
(2) Drools的Reteoo算法可加速和可扩展。
(3) Drools提供的Eclipse插件带有自动完成智能感知和调试视图、规则流GUI等。
(4) 基于Web的工具（Guvnor）：是一个业务规则管理系统（BRMS），它提供了高级规则授权、版本控制和管理。

至于其他的规则引擎，我个人建议在项目中使用Drools，因为它有一个很大的支持社区。在IDE支持和基于Web的规则管理工具（Guvnor）也有很大优势。

 

gundsoul
关注
专栏目录
规则引擎 Drools与JRuleEngine
hffyyg的博客
11-14 1804
规则引擎 Drools与JRuleEngine
Dredd:适用于Android的简单规则引擎
05-22
Dredd规则引擎 创建Dredd是一种分离应用程序业务逻辑的简单方法，以便创建最适合可视化甚至易于理解和维护的决策树模型。 我应该使用规则引擎吗？ 规则引擎就是要提供替代的计算模型。 它提供了生产规则列表，而不是通常的命令性模型，而是按条件和循环依次执行命令。 每个规则都有一个条件和一个动作-简单地说，您可以将其视为一堆if-then语句。 在许多地方，测试在这里常常被低估，但是隐式行为使测试更加重要-它需要使用生产数据来完成。 一个常见的讨论涉及将业务逻辑（即规则）封装在对象或服务中。 服务对于由业务流程精心安排的决策和合规性是有意义的。 如果需求，法规，策略或规则跨越模型中的许多类并且在流程中包含许多任务，则强烈建议使用外部化规则。 启发式使用规则引擎 随着标准数量的增加 随着一组标准变得更加动态 随着标准变得越来越复杂 为什么我不使用Drools？ 这个项目诞生于一个项目，
『.NET 高手必备』深入浅出RulesEngine：业务逻辑抽象新利器！
最新发布
许泽宇的技术分享
09-18 452
RulesEngine提供了丰富的工作流配置方式，你可以根据提供的模式定义存储规则，并选择如Azure Blob Storage、Cosmos DB、Azure App Configuration、Entity Framework、SQL Servers、文件系统等任意合适的存储方式。简单的说，使用RulesEngine就能让你把规则存放在系统核心逻辑之外的存储中，这意味着任何的规则变动都将不会影响到核心系统。抓住规则引擎RulesEngine，抽象你的业务逻辑，享受编程带来的便利吧！
规则引擎-规则流
06-07
我们在开发规则过程中，规则的执行顺序都是从上到下执行的。规则流是用来控制执行规则顺序的，我们可以在规则流程图中通过连线的方式，设置规则、规则集、决策表执行的顺序。需要注意的是在规则流程图中我们只能控制一级规则执行顺序，不能控制到规则集下面的子规则执行顺序。
一个神奇的研究方向:规则引擎
04-14
NULL 博文链接：https://flyqantas.iteye.com/blog/1450163
复习步骤22-26 规则引擎Drools（1）Drools介绍与运行
香帅的博客
05-09 564
规则引擎Drools（1）Drools介绍与运行 规则引擎 -- 作用，代码与业务规则分离，当业务规则改变，不影响我们代码，不需要修改代码，也是当业务变化，不需要或减少需要系统升级 --即将规则提取出来，实现代码于业务规则解耦，适应各种业务规则的技术，叫做规则引擎技术 Drools：介绍 https://www.yiibai.com/drools Drools安装：下载 ht...
drools-示例：Drools：规则引擎
02-14
** Drools：规则引擎简介 ** Drools 是一个开源的业务规则管理系统（BRMS），由 JBoss 社区开发并维护，它基于 Java 平台，提供了强大的规则引擎功能。Drools 可以帮助开发者将业务逻辑从应用程序代码中分离出来，...
规则引擎Drools入门实战案例
11-21
1、业务规则与系统代码分离，实现业务规则的集中管理 2、在不重启服务的情况下可随时对业务规则进行扩展和维护 3、可以动态修改业务规则，从而快速响应需求变更 4、规则引擎是相对独立的，只关心业务规则，使得...
规则引擎实战：Drools简介与优势
二、规则引擎的定义与标准 规则引擎，如BRMS（BusinessRuleManagementSystem），是从推理引擎演变而来的一种组件，它将业务决策从代码中解耦出来，允许使用预定义的规则模块进行决策。JSR-94是Java社区过程（JCP）...
Drools规则引擎从入门到精通
03-30
【Drools规则引擎从入门到精通】 Drools是一个强大的业务规则管理系统，它提供了业务规则引擎、Web创作工具（Drools Workbench）以及决策模型符号（DMN）的支持。作为一个开源项目，Drools使用Java编写，遵循Apache...
rule-engine:这是规则引擎的基本示例
03-16
规则引擎
JEngine：JEngine是针对Unity开发者设计的开箱即用的框架，封装了强大的功能，小白也能快速上手，轻松制作可以热更新的游戏| JEngine是为Unity程序员设计的简化且易于使用的框架，其中包含强大的功能，初学者可以快速启动并轻松制作可热更新的游戏
02-04
JENGINE v0.6.1 JEngine是针对Unity开发者设计的开箱即用的框架，封装了强大的功能，小白也能快速上手，轻松制作可以热更新的游戏 mater分支为开发者认为的可以正常使用，不会有太大问题的最新版本； 稳定版本请使用0.5.x分支； development分支为开发分支，欢迎叉在该分支进行修改并PR，也欢迎提交问题！ v0.6系列文档将在直播后发布到2020年12月11日，北京时间晚上9点进行JEngine0.6直播讲解，将讲解分解机制，与0.5版本的差异，功能使用等，敬请期待！开发！ QQ群： 现有项目使用JEngine热更新，并成功上架iOS 框架相关 主题 地址
Drools规则引擎小结
04-22
NULL 博文链接：https://wenxin2009.iteye.com/blog/1935409
贝叶斯网络推理机BNJ-Java实现
05-21
贝叶斯网络推理机BNJ-Java实现，在自己的研究工作中采用贝叶斯网络作为工具，需要实现原型系统或者做实验的有用
Rule Engine之Drools
好好学习
05-28 1191
转载自:http://www.blogjava.net/gumingcn/archive/2010/09/25/332860.html 对于做软件的人来说，唯一不变的就是变化。此为行业真理。而对于复杂业务系统的逻辑组件的定义不得不多考虑一下业务的可扩展性，来应对客户的变化。选择Rule Engine是一个不错的方案。 Drools 是用 Java 语言编写的开放源码规则引擎。Drools
android自定义引擎,自定义引擎机制说明
weixin_30578673的博客
05-26 206
自定义引擎机制说明概述AppCan开发服务平台应用引擎已经开源了，iOS或者Android开发者可以得到AppCan开发服务平台应用引擎的全部代码，根据自己的需求开发出适合自己的应用引擎，本说明用来指导开发者将自己的应用引擎上传到AppCan平台，在AppCan开发服务平台上使用自己的修改后的应用引擎。要重新修改应用引擎需要原生环境，即iOS应用引擎需要OSX系统和Xcode环境，Android应...
规则引擎php,规则引擎：Drools与JRuleEngine
weixin_39622710的博客
03-27 363
规则引擎：Drools与JRuleEngine译文：《规则引擎：Drools与JRuleEngine》译者：chszs作者：Vivek Tomar原文：《Rule engine : Drools / JRuleEngine》原文见http://www.naxos-software.de/blog/index.php?/archives/78-Rule-engine-Drools-JRuleEngi...
java rule_漫话规则引擎(4): Java规则引擎规范：JSR94
weixin_34169322的博客
02-16 287
packagecom.sample;importjava.io.FileReader;importjava.util.ArrayList;importjava.util.HashMap;importjava.util.List;importjavax.rules.ConfigurationException;importjavax.rules.RuleRuntime;importjavax.rul...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值