`
jimmy.shine
  • 浏览: 396164 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

Drool(转)

阅读更多
什么是Drools
(译者增加:什么是Drools, 摘自drools.org)
Drools 是一个基于Charles Forgy's的Rete算法的,专为Java语言所设计的规则引擎。Rete算法应用于面向对象的接口将使基于商业对象的商业规则的表达更为自然。Drools是用Java写的,但能同时运行在Java和.Net上。

Drools
Drools 被设计为可插入式的语言实现。目前规则能用Java, Python和Groovy实现。更为重要的是,Drools提供了声明式程序设计(Declarative Programming),并且使用域描述语言(Domain Specific Languages (DSL))-专为你的问题域定义了某种模式的Xml, 它已经足够灵活到可以用来描述你的问题域。DSLs包含的XML元素(Element)和属性(Attribute)代表了问题域中各种要素。

(原文开始)
这 段时间企业级Java简直能让你睡着。有多少J2EE-EJB应用程序只是从网页提取数据并把它们存入到数据库中?但开发者真正应该开发和维护的却是他们 应用程序中复杂的商业逻辑。这个问题不仅仅适用于将要新应用,而且渐渐地,也适用于那些长期运行的商业核心应用,它们的内部逻辑也需要经常改变,而且往往 要求在一个非常短的时间内。

在以前的文章中,“用Drools让你的商业逻辑使用框架”,我介绍了Drools框架,展示了它如何用来组 织复杂的商业逻辑。Drool用一组简单的,众所周知的事物替换了许多缠杂的if…then表达式。如果你经历过和商业客户的会议,并为他们提出的想要实 现的东西的复杂程度搞得头痛,或许你应该考虑一下像Drools这样的规则引擎了。这篇文章将向你展示如何在企业级Java应用中使用Drools.

一路到底的框架

大 多数开发者都有自己喜爱的框架。无特定顺序,它们包括表现层框架(Struts, JSF, Cocoon和Spring),持久化框架(JDO, Hibernate, Cayenne and Entity Beans)以及结构框架(EJB, 又是Spring, Pico和Excalibur), 还有其它很多。每种框架都各有所长,给开发者提供子许多“即开即用”的功能。使用框架来部署应用意味着你避免了许多让人厌烦的细节,让你集中注意力到关键 之处。
到目前为直,在框架所能做的事中仍然有一个缺口,那就是商业逻辑没有框架。像EJB和Spring这样的工具虽好,但它们却几乎没有提及怎 么组织你的那些if …then语句。把Drools加到你的开发工具箱中意味着现在你可以“一路到底”的使用框架来构建你的应用程序。图1显示了这样的一个应用

image
图1. 用于Java应用的框架

这篇文章将基于我们已经了解的Drools框架的功能,这些功能可以让我们构建这样的一个应用。]

我什么时候应该使用规则引擎?
“如果你有一把锤子,那所有的东西都看起来都像钉子”,这句话在软件工程领域几乎成了陈词滥调了。虽然规则引擎能解决我们的许多问题,但确实值得认真考虑一下规则引擎对我们的企业级Java应用是否合适。需要问的问题有:

我的应用程序有多复杂?对于那些只是把数据从数据库中传入传出,并不做更多事情的应用程序,最好不要使用规则引擎。但是,当在Java中有一定量的商业逻辑处理的话,可以考虑Drools的使用。这是因为很多应用随着时间的推移越来越复杂,而Drools可以让你轻松应对这一切。

我的应用的生命周期有多久?这个问题的正确答案往往是“令人惊讶的长”――还记得那些认为他们的程序不会苟活到2000年的大型机的程序员吗?使用规则引擎将会在中长期得到好处。像这篇文章所展示的那样,甚至原型都能从Drools与灵活方法的组合中获益,让“原型系统”转化成生产系统。

我的应用需要改变吗?唯一能确定的是你的需求将会改变,无论是在开发过程中或是在开发完成以后。Drools使用一个或多个简单易配的XML文件帮你来应对这一切。

那么性能呢?
如 果你正在写一个企业级应用,很有可能它会扩展到成百(如果不是成千)的用户。你已经知道现有的Java和J2EE应用能做到这一点,但一个使用了 Drools的应用对这一压力的表现如何?答案是:“令人吃惊的好”。大多数开发者只是因为不愿“失控”而依赖于他人的代码(比如:某种框架),想想这 个:Drools不仅可以让你的应用和“传统”的编程方法一样快,甚至可以更快,看下面:

避免糟糕的代码:Drools引导开发者去做“正确的事”。你可以确定你正在写的代码是好的,但你的开发伙伴呢?你可以同样这样说吗?使用框架可以让你更轻松地写出更快,更好的代码。

优化过的框架:你有多少次看见商业逻辑重复地从数据库中提取相同的信息,从而降低了整个应用的速度?如果正确使用的话,Drools不仅仅能够记住信息,而且还能记住以往使用该信息进行测试的结果,从而大幅提升应用的速度。

Rete算法: 很多次我们并不是真正需要使用“if”条件。被Drools实现的Rete算法,可以用一个优化的方法替换掉所有的“if…then”表达式。需要重点提 及的是:Rete算法在使用更多的内存来降低运行时延迟方面作了折衷。当然这在现代的应用服务器中并不是一个问题,我们也并不推荐你在移动手机上使用 Drools!

我们到哪里了?

在 我们上一篇文章中,我们写了一个基于Drools引擎的简单的股票交易程序。我们实现了不同的商业规则,展示了我们可以如何迅速地改变规则去适应商业需 求,并且JUnit测试给了我们高度自信可以确认系统确实是像我们设想的那样运作的。但是这个应用几乎没有用户介面,而且用硬编码代替了数据库。为了把我 们的程序提升到企业级的水平,我们需要增加两个主要的东西。

● 某种用户介面,最理想的是基于标准的Web表现层的框架。
● 一个数据存取对象(DAO)让Drools与数据库(或其它后端)交互。

从现有表现框架中实现规则引擎

大 多数企业级Java应用是通过Web介面进行交互的,其中最被广泛使用的Web表现层框架是Apache的Struts。理想的结果是:我们写的应用可以 从表现层知道它下面的应用层,而不是通过相反的方向。它的好处在于不仅仅可以使我们将来变换其它的表现层(比如Ajax或web service界面),而且意味着示例代码可以非常容易地应用于其它像Spring的框架。

下面的代码片断演示了始何从Web表现层调用 商业逻辑(通过规则引擎),并根据返回结果显示不同的页面。这一例子中,我们使用了一个Struts行为,但其代码是和使用其它表现层框架甚至一个 Servlet或一个Jsp页面是很类似的。这个片断使用了struts-config.xml配置文件,JSP页面来上传/显示数据,并且生成WAR文 件来进行布署。片断展示了怎样把规则引擎和web框架集成使用。

java 代码
 
  1. import javax.servlet.http.HttpServletRequest;  
  2. import javax.servlet.http.HttpServletResponse;  
  3. import org.apache.struts.action.Action;  
  4. import org.apache.struts.action.ActionForm;  
  5. import org.apache.struts.action.ActionForward;  
  6. import org.apache.struts.action.ActionMapping;  
  7. import BusinessLayer;  
  8. /** 
  9.  * Sample Struts action with Pseudocode 
  10.  * 使用伪代码的Struts行为示例 
  11.  */  
  12. public class SampleStrutsAction extends Action{  
  13.          
  14.   /** 
  15.    * Standard Struts doPerfom method  
  16.    * 标准的Struts doPerform方法 
  17.    */  
  18.   public ActionForward doPerform(  
  19.                 ActionMapping mapping,  
  20.                     ActionForm form,  
  21.                     HttpServletRequest request,  
  22.                     HttpServletResponse response)  
  23.         throws InvalidEntryPointException {  
  24. //Local Variables  
  25. //本地变量  
  26.     StockOffer userOffer =null;  
  27.           
  28. //Get any previous values from the session  
  29. //从session取得以前的数据  
  30.     userOffer=(StockOffer)request.getSession()  
  31.            .getAttribute("PREVIOUS_STOCK_OFFER");  
  32.                   
  33. //create this object if it is null  
  34. //如为null则创建新对象  
  35.     if (null==userOffer){  
  36.       userOffer = new StockOffer();  
  37.     }  
  38. //Update with the incoming values   
  39. //用上送的数据更新  
  40. //These values match those on the form        
  41. //这些数据是与form中的数据相对应的  
  42.     userOffer.setStockName(request.  
  43.                 getParameterValue("STOCK_NAME"));  
  44.     userOffer.setStockPrice(request  
  45.                .getParameterValue("STOCK_PRICE"));  
  46.     userOffer.setStockQuantity(request  
  47.                .getParameterValue("STOCK_QTY"));  
  48.                                   
  49. //Reset the output value  
  50. //重置输出数据  
  51.     userOffer.setRecommendPurchase(null);  
  52. //Call the Business Layer  
  53. //调用商业层  
  54.     BusinessLayer  
  55.               .evaluateStockPurchase(userOffer);          
  56.                   
  57. //Forward to the appropriate page   
  58. //转向合适的页面  
  59.     if ("YES".equals(  
  60.       testOffer.getRecommendPurchase()){  
  61.         return mapping.findForward("YES_WEB_PAGE");  
  62.     }   
  63. //otherwise default to the no page  
  64. //否则指向无此页面  
  65.           return mapping.findForward("NO_WEB_PAGE");  
  66.   }  
  67. }  



这个例子包含了几个东西。经常,我们需要的数据是用户通过好几个网页传来的,因此在这一例子中展示了通过session中的StockOffer对象来保存过去以来的数据。

下一步,如果用户改变了一些值,我们更新StockOffer对象。然后我们重置了rcommendPurchase标志用以在调用商业逻辑层之前清除以前的结果。最后我们使用商业逻辑层的返回来决定让用户转向哪一页面。

在 这一例子中,需要注意我们将商业逻辑(买或不买一支股票)与表现层逻辑(决定转向哪一页面)分离开来。这将使我们可以在不同的应用中重用我们的商业规则。 另外,看一下状态信息(用户已经告知我们的东西)是存储在Session中的StockOffer对象中的,并没有在商业层中。这样就保证了商业层的无状 态性,这将使整个应用更具扩展性和性能。

集成规则引擎与数据库层

到 目前为止,我们的应用已经有一个web表现层和一个商业层的规则引擎,但还没有方法与数据库进行交互。这一节的例子将展示如何实现。我们的例子是基于数据 访问对象(DAO)模式的,它把所有与数据库(或后端数据源)交互的代码包装在了一个可插入,可配置的类中。同样的,这一例子一样适用于其它持久性框  架,比如Hibernate和Cayenne。
关于如何组织数据导有几个要点:

● 应该只有商业层与数据层交互。如果表现层(前端)需要一些数据,它首先应通过商业层。这将使我们的代码更容易组织和阅读。
● 尽可能地,我们应让我们的数据层无状态-我们应该在其它的地方存放客户端数据(比如:web前端的session,就像前面的例子)。这不同于我们可以在 这一层做的数据缓存。两者的区别在于状态信息经常是用户定义的,而我们在数据层缓存的数据应该是整个应用共享的。这样的层次提升了性能。
● 我们应该让商业逻辑决定数据是否需要――如不需要,提取数据的调用就不应该执行。

为了实现我们简单的数据访问对象,我们创建三个新对象:StockNameDao, DaoImplementation,和 DaoFactory

StockNameDao是一个定义了两个方法的接口:getStockName()返回一个我们可以处理的股票名称的列表,isOnStockList()检查一个给定的股票是否在处理列表中。我们的商业层在需要这些信息时会调用这些方法。

DaoImplementation是StockNameDao的一个实现。这里的数据是硬编码的,但我们可以通过查询数据库或通过像Bloomberg这样的web service提取信息。

DaoFactory 我们用来生成合适的StockNameDao实例。不直接创建对象而使用这一小骤的好处在于,它充许我们在运行时刻决定使用哪一个DAO实现(这是像 Spring这样的框架特别擅长的).一个factory(工厂)可以返回多种类型的DAO(比如:StockNameDao, StockPriceDao, StockHistoryDao),这意味着我们可以通过我们的DaoFactory,让规则自己决定需要什么数据和DAO.

这是StockNameDao接口:

java 代码
 
  1. /** 
  2.  * Defines a Data Access Object - a non data  
  3.  * source specific way of obtaining data. 
  4.  * 定义一个数据存取对象-一种非数据源获取数据的方法 
  5.  */   
  6. public interface StockNameDao {  
  7.   /** 
  8.    * Get a list of stock names for the application  
  9.    * @return String[] array of stock names 
  10.    * 得到一个股票名字的列表 
  11.    * 返回股票名称的String[]数组 
  12.    */  
  13.   public String [] getStockNames();  
  14.           
  15.   /** 
  16.    * Check if our stock is on the list 
  17.    * 检查股票是否在列表中 
  18.    * @param stockName 
  19.    * @return 
  20.    */  
  21.   public boolean isOnStockList(String stockName);  
  22. }  

And here's the DaoImplementation:
这是DaoImplementation:

java 代码
 
  1. /** 
  2.  * Concrete Definition of a Data Access Object  
  3.  * 数据存取对象的具体定义 
  4.  */   
  5. public class DaoImplementation  
  6.                         implements StockNameDao {  
  7.   /** 
  8.    * Constructor with package level access only  
  9.    * to encourage use of factory method 
  10.    * 这里的构造器只是让你使用工厂(factory)方法 
  11.    */  
  12.   DaoImplementation(){}  
  13.   /** 
  14.    * Get a list of stock names for the app. 
  15.    * This is a hard coded sample  
  16.    * normally we would get this from 
  17.    * a database or other datasource. 
  18.    * 得到一个股票名字的列表,这只是一个硬编码的例子,一般来 
  19.   * 说我们应该从数据库或其它数据源取得数据 
  20.    * @return String[] array of stock names 
  21.    */  
  22.   public String[] getStockNames() {  
  23.     String[] stockNames=  
  24.       {"XYZ","ABC","MEGACORP","SOMEOTHERCOMPANY"};  
  25.     
  26.     return stockNames;  
  27.   }  
  28.           
  29.   /** 
  30.    * Check if our stock is on the list  
  31.    * 检查我们的股票是否在列表中 
  32.    * @param stockName 
  33.    * @return true / false as appropriate 
  34.    */  
  35.   public boolean isOnStockList(String stockName){  
  36.                   
  37. //Get our list of stocks    
  38. //获取股票列表            
  39.     String stockList[] = getStockNames();  
  40.                   
  41.     //Loop and see if our stock is on it  
  42. // done this way for clarity . not speed!  
  43. //循环看股票是否存在,这样做是为了清晰不是速度!  
  44.     for (int a=0; a
  45.         if(stockList[a].equals(stockName)){  
  46.           return true;  
  47.         }  
  48.     }  
  49.                   
  50.     //Default return value  
  51.     return false;         
  52.   }  
  53. }  



简单的DaoFactory,只是返回DaoImplementation:

java 代码
 
  1. package net.firstpartners.rp;  
  2. /** 
  3.  * Factory Method to get the Data Access Object. 
  4.  * Normally we could replace this with a  
  5.  * framework like Spring or Hibernate  
  6.  * 得到数据存取对象的工厂方法,通常我们可以将它替换为像Spring或 
  7. *  Hibernatte这样的框架 
  8.  */  
  9. public class DaoFactory {  
  10.   /** 
  11.    * Get the stock name Dao 
  12.    * This sample is hardcoded - in reality  
  13.    * we would make this configurable / cache 
  14.    * instances of the Dao as appropriate 
  15.    * 得到股票名字的Dao,这个例子是硬编码的-实际上我们可以让它成为 
  16.   * 可配的,缓存的合适的Dao对象。 
  17.    * @return an instance of StockNameDao 
  18.    */  
  19.   public static StockNameDao getStockDao(){  
  20.         return new DaoImplementation();  
  21.   }  
  22. }  



现在我们有了简单的DAO实现来作为我们的数据库层,那如何将它与Drools商业层集成在一起呢?最新的商业规则文件,BusinessLayer.xml将会向我们展示:

xml 代码
 
  1. xml version="1.0"?>  
  2. <rule-set name="BusinessRulesSample"  
  3.   xmlns="http://drools.org/rules"  
  4.   xmlns:java="http://drools.org/semantics/java"  
  5.   xmlns:xs="  
  6.         http://www.w3.org/2001/XMLSchema-instance"  
  7.   xs:schemaLocation="  
  8.         http://drools.org/rules rules.xsd  
  9.   http://drools.org/semantics/java java.xsd">  
  10.   <!---->  
  11.   <java:import>  
  12.     java.lang.Object  
  13.   <!---->java:import>  
  14.   <java:import>  
  15.     java.lang.String  
  16.   <!---->java:import>  
  17.   <java:import>  
  18.     net.firstpartners.rp.StockOffer  
  19.   <!---->java:import>  
  20.   <java:import>  
  21.     net.firstpartners.rp.DaoFactory  
  22.   <!---->java:import>  
  23.   <java:import>  
  24.     net.firstpartners.rp.StockNameDao  
  25.   <!---->java:import>  
  26.   <!---->  
  27.   <!---->  
  28.   <!---->  
  29.   <!---->  
  30.   <!---->  
  31.   <!---->  
  32.   <!---->  
  33.   <!---->>  
  34.   
  35.   <application-data   
  36.     identifier="daoFactory">DaoFactory  
  37.   <!---->application-data>  
  38.   <!---->  
  39.  <!---->  
  40.   <!---->     
  41.   <!---->      
  42.   <java:functions>  
  43.     public void printStock(  
  44.       net.firstpartners.rp.StockOffer stock)  
  45.       {  
  46.           System.out.println(  
  47.           "Name:"+stock.getStockName()  
  48.           +" Price: "+stock.getStockPrice()       
  49.           +" BUY:"+stock.getRecommendPurchase());  
  50.       }   
  51.   <!---->java:functions>  
  52.   <!---->     
  53. <!---->      
  54.   <rule name="XYZCorp" salience="-1">  
  55.     <!---->   
  56. <!---->  
  57. <!---->  
  58.     <parameter identifier="stockOffer">  
  59.       <class>StockOffer<!---->class>  
  60.     <!---->parameter">  
  61.     <!---->  
  62. <!---->     
  63. <!---->        
  64.     <java:condition>  
  65.       stockOffer.getStockName().equals("XYZ")  
  66.     <!---->java:condition>   
  67.     <java:condition>  
  68.       stockOffer.getRecommendPurchase() == null  
  69.     <!---->java:condition>  
  70.     <java:condition>  
  71.       stockOffer.getStockPrice() > 10  
  72.     <!---->java:condition>  
  73.           
  74.     <!---->  
  75. <!---->  
  76. <!---->  
  77.     <java:consequence>  
  78.         stockOffer.setRecommendPurchase(  
  79.         StockOffer.NO);   
  80.         printStock(stockOffer);  
  81.     <!---->java:consequence>  
  82.   <!---->rule>  
  83.   <!---->  
  84.   <!---->    
  85.   <!---->       
  86.   <rule name="Stock Price Not Negative">  
  87.     <!---->  
  88. <!---->  
  89. <!---->     
  90.     <parameter identifier="stockOffer">  
  91.       <class>StockOffer<!---->class>  
  92.     <!---->parameter>  
  93. <!---->  
  94. <!---->      
  95.     <java:condition>  
  96.       stockOffer.getStockPrice() < 0  
  97.     <!---->java:condition>  
  98.     
  99. <!---->  
  100. <!---->  
  101.     <java:consequence>  
  102.       stockOffer.setRecommendPurchase  
  103.         (StockOffer.NO);          
  104.       printStock(stockOffer);  
  105.     <!---->java:consequence>  
  106.   <!---->rule>  
  107.   <!---->     
  108. <!---->       
  109.   <rule name="Stock Price Low Enough">  
  110.   <!---->  
  111. <!---->  
  112.     <parameter identifier="stockOffer">  
  113.       <class>StockOffer<!---->class>  
  114.     <!---->parameter>  
  115.       
  116. <!---->  
  117. <!---->  
  118.     <java:condition>  
  119.       daoFactory.getStockDao().isOnStockList(  
  120.         stockOffer.getStockName())  
  121.     <!---->java:condition>  
  122.           
  123.     <java:condition>  
  124.       stockOffer.getRecommendPurchase() == null  
  125.     <!---->java:condition>  
  126.     <java:condition>  
  127.       stockOffer.getStockPrice() < 100  
  128.     <!---->java:condition>  
  129. <!---->  
  130. <!---->  
  131.     <java:consequence>  
  132.         stockOffer.setRecommendPurchase(  
  133.           StockOffer.YES);        
  134.           printStock(stockOffer);  
  135.     <!---->java:consequence>  
  136.   <!---->rule>  
  137. <!---->rule-set>  



为了与数据访问层集成,该文件(相对于上一篇文章)有几处改变:
● 在最上面,我们有几个新的<java:import>来把StockNameDao, DaoImplementation, 和 DaoFactory类引入系统。
● 我们有一个新的标记<application-data>,它把DaoFactory的实例赋给一个变量。<application-data>标记类似于参数,只不过它是运用于所有商业规则,而不只是一个。
● “股价足够低”的规则有一个新条件,它用DaoFactory和StockNameDao来检查股票是否在处理列表中。

我 们又一次运行BusinessRulesTest(模拟器)。模拟单元测试没有问题,既使我们改变了程序的结构,我们仍然没有改变它在做什么。从输出的日 志来看,我们可以看到我们的商业规则使用StockNameDao作为他们评估的一部份,并且 DaoImplementation.isOnStockList()被调用了。
虽然这个例子展示的是从数据源读取信息,其实写信息也是一样的原 理。如果某个规则决定应该做的话。区别在于我们的DAO将会有一些setSomeInformation()的方法,一旦条件满足,这个方法将会在商业规 则的<java:consequence>部分被调用。

总结
这 篇文章中,我们展示了大多数Java服务器端的应用有的三层:表现层,商业逻辑层和数据持久化层。当框架被广泛地使用在表现层和持久层中,直到目前为止还 没有框架可以包装低级的商业逻辑。就像我们在这些例子中看的,Drools和JSR-94是降低java应用复杂度,提高开发速度的理想候选者。我希望这 些例程能鼓励你去进一步接近规则引擎,他们将会为你的应用的开发和维护节省不少时间。
资源
</java:consequence></application-data></application-data></java:import>
分享到:
评论

相关推荐

    Drool中文使用文档

    Drool中文使用文档 Drool是一个基于规则的系统,用于业务规则管理和决策支持。 Drool 4.0 是从之前的 Drools 3.0.x 系列以来的一次主要更新,帶来了许多新的特性和改进。 语言表达式增强 Drool 4.0 引入了许多新...

    drool

    《 Drools:Java规则引擎深度解析 》 Drools,作为一款强大的开源规则引擎,是Java开发领域中处理业务规则的重要工具。它基于规则推理和决策支持,为复杂业务逻辑提供灵活、高效的解决方案。本文将深入探讨Drools的...

    Drool规则引擎在实现业务逻辑中的应用

    ### Drools规则引擎在实现业务逻辑中的应用 #### 引言 随着企业级Java应用的日益复杂,业务逻辑的管理变得越来越困难。传统的做法是在Java代码中直接编写业务规则,这种方式虽然直观,但在应对需求变更时显得...

    Drool的测试程序

    **Drools测试程序详解** Drools是一个强大的、开源的业务规则管理系统(BRMS),它基于Java平台,提供了一种高效、灵活的方式来管理和执行业务规则。Drools以其易于使用、高性能和丰富的功能,被广泛应用于金融、...

    drool的jar包

    Drools是一个强大的Java规则引擎,它以开源的形式提供,旨在处理业务逻辑的复杂性和变化。这个工具的核心理念是将企业规则从硬编码的软件中分离出来,使其能够以易于理解和管理的规则脚本形式存储在文件中。...

    drool, 自动内存泄漏检测和分析.zip

    drool 是一个开源项目,专注于自动内存泄漏检测和分析。在软件开发中,尤其是Java应用程序,内存泄漏是一个常见的问题,可能导致系统性能下降,甚至服务崩溃。drool 提供了一种智能解决方案,帮助开发者及时发现并...

    Drool资料大全

    Drools,全称为Red Hat Decision Manager,是Java平台上的一个开源规则引擎,它属于Business Rule Management System (BRMS) 的一种。这个标题为“Drools资料大全”的压缩包文件,显然包含了全面的Drools技术开发...

    Drool最新 中文文档

    Drools是一款强大的Java规则引擎,它允许开发者在应用程序中嵌入复杂的业务规则,并通过声明式的方式进行管理。Drools 7.0是其一个重要的版本,提供了丰富的功能和改进,尤其对于初学者和经验丰富的开发人员来说,...

    jboss drool5.1中文使用说明

    **JBoss Drools 5.1 中文使用说明** Drools 是一个开源的规则引擎,它提供了基于Java的业务规则管理系统(BRMS),帮助企业快速实施复杂的业务逻辑。本文档将详细阐述JBoss Drools 5.1版本的使用方法和特性。...

    springbootruleengine:Spring Boot Drool应用程序支持动态规则加载而无需停止应用程序

    Spring Boot Drool规则引擎Spring Boot Drool应用程序支持动态加载规则而无需停止应用程序Cahce规则会话使用REST API加载规则问题陈述集中规则引擎以支持全球市场功能支持如果任何规则引擎规则应反映在系统中○REST ...

    polymer-drool

    var drool = require ( 'drool' ) ; var webdriver = drool . webdriver ; var controlFlow = webdriver . promise . controlFlow ( ) ; var driver = drool . start ( { chromeOptions : 'no-sandbox' } ) ; var ...

    drools-insurance.rar_drool_drools_dslr drools_insurance_java dro

    在这个名为“drools-insurance.rar”的压缩包中,我们看到与Drools相关的多个元素,包括“drool”,“drools”,“dslr_drools”以及“java_drools”标签,这表明它可能包含一个使用Drools规则引擎处理保险评估案例...

    springboot整合Drools规则引擎,实现高效的业务规则

    Drools引擎简介 1、基础简介 Drools是一个基于java的规则引擎,开源的,可以将复杂多变的规则从硬编码中解放出来,以规则脚本的形式存放在文件中,使得规则的变更不需要修正代码重启机器就可以立即在线上环境生效。...

    Drool-开源

    好吧,这是一个起始的Web日志,将包含许多功能。 它将以几种脚本语言php(current),perl,jsp和asp编写。 您是否不想利用对内容的控制权。

    规则引擎drools详细讲义.zip

    规则引擎drools详细讲义 与springboot整合 与activiti整合

    Protege4.0使用说明及问题整理

    ### Protege4.0使用说明及问题整理 #### 一、OWL子语言概述 OWL (Web Ontology Language) 是一种用于定义和共享本体的语言,主要用于描述网络资源的语义结构。它支持三种子语言:OWL Lite、OWL DL 和 OWL Full。...

    drools 5 Demo

    《drools 5 Demo》是基于规则引擎drools的一个演示项目,它包含了drools Expert和drools Flow两个组件的综合示例。drools是一个强大的、开源的业务规则管理系统(BRMS),它允许开发者以声明式的方式定义业务规则,...

    drools从字符串中动态加载规则

    ### Drools从字符串中动态加载规则 在使用Drools规则引擎时,有时我们需要实现更加灵活的规则管理方式。例如,在开发过程中,我们可能希望不通过每次修改代码或重启服务来更新业务规则,而是能够在运行时动态地更改...

    Drools7.25中文文档.7z

    《Drools 7.25中文文档》是针对Java开发者的重要参考资料,它详细阐述了Drools这一强大规则引擎的使用方法。Drools是一个开源的业务规则管理系统,它基于Java平台,允许开发者轻松地在应用程序中实现复杂的业务规则...

    Drools5.0.1 eclipse插件

    Drools是一款强大的规则引擎,它允许开发人员在Java应用程序中使用规则逻辑,实现复杂的业务决策。Drools 5.0.1是该框架的一个版本,提供了许多增强的功能和改进,以支持企业级的决策管理系统。...

Global site tag (gtag.js) - Google Analytics