亚洲AV无码国产精品永久一区,亚洲福利在线观看,亚洲AV无码专区在线亚

junky — Thu, 28 Jun 2007 00:57:00 GMT

规则引擎��?/strong>
      Java规则引擎是推理引擎的一�U�，它�v源于��Z��规则的专家系�l��?br>      Java规则引擎��业务决�{�从应用�E�序代码中分��d��来，�q��用预定义的语义模块编写业务决�{�。Java规则引擎接受数据输入�Q�解释业务规则，�q�根据规则作��Z��务决�{�。从�q�个意义上来��_��它是软�g�Ҏ��学在"��x��点分��?上的一个重要的�q�展�?br>      JSR-94规范定义了独立于厂商的标准API�Q�开发�h员可以通过�q�个标准的API使用Java规则引擎规范的不同��品实现。但值得注意的是�Q�这个规范�ƈ没有强制�l�一规则定义的语法，因此�Q�当需要将应用�U�L��到其他的Java规则引擎实现�Ӟ��可能需要变换规则定义�?/div>

��Z��规则的专家系�l�（RBES�Q?br>       专家�pȝ��是�h工智能的一个分支，它模仿�h�cȝ��推理方式�Q��用试探性的�Ҏ��q�行推理�Q��ƈ使用人类能理解的术语解释和证明它的推理结论。专家系�l�有很多分类�Q�神�l�网�l�、基于案例推理和��Z��规则�pȝ��{��?br>       规则引擎则是��Z��规则的专家系�l�的一部分。�ؓ了更深入的了解Java规则引擎�Q�下面简要地介绍��Z��规则的专家系�l�（RBES�Q��?/div>

RBES的技术架�?br>       RBES包括三部分：Rule Base�Q�knowledge base�Q�、Working Memory�Q�fact base�Q�和Rule Engine�Q�推理引擎）。它们的�l�构如下所�C�：

200)this.width=200" border=0>

       如上图所�C�，规则引擎包括三部分：Pattern Matcher、Agenda和Execution Engine。Pattern Matcher军_��选择执行哪个规则�Q�何时执行规则；Agenda��理PatternMatcher挑选出来的规则的执行次序；Execution Engine负责执行规则和其他动作�?/div>

RBES的推理（规则�Q�引�?br>       和�h�cȝ��思维相对应，规则引擎存在两者推理方式：演绎法（Forward-Chaining�Q�和归纳法（Backward-Chaining�Q�。演�l�法从一个初始的事实出发�Q�不断地应用规则得出�l�论�Q�或执行指定的动作）。而归�U�x��则是从假讑և�发，不断地寻扄��合假讄��事实�?br>       Rete��法是目前效率最高的一个Forward-Chaining推理��法�Q�Drools��目是Rete��法的一个面向对象的Java实现�?br>       规则引擎的推理步骤如下：
       1. ��初始数据（fact�Q�输入Working Memory�?br>       2. 使用Pattern Matcher比较规则�Q�rule�Q�和数据�Q�fact�Q��?br>       3. 如果执行规则存在冲突�Q�conflict�Q�，卛_��时激�z�M��多个规则�Q�将冲突的规则放入冲�H�集合�?br>       4. 解决冲突�Q�将�Ȁ�zȝ��规则按顺序放入Agenda�?br>       5. 使用规则引擎执行Agenda中的规则。重复步�?�?�Q�直到执行完毕所有Agenda中的规则�?/div>

JSR 94�Q�Java规则引擎API
       ��Z��规则�~�程是一�U�声明式的编�E�技术，�q�种技术让你可以��用试探性的规则而不是过�E�性的指��o来解决问题。规则引擎是一个��Y件模块，它决定了如何��规则作用于推理数据。在保险业和金融服务业都�q�泛��C��用了��Z��规则的编�E�技术，当需要在大量的数据上应用复杂的规则时�Q�规则引擎技术特别有用�?br>       Java规则引擎API由javax.rules包定义，是访问规则引擎的标准企业�U�API。Java规则引擎API允许客户�E�序使用�l�一的方式和不同厂商的规则引擎��品交互，��像使用JDBC�~�写独立于厂商访问不同的数据库��品一栗��Java规则引擎API包括创徏和管理规则集合的机制�Q�在Working Memory中添加，删除和修改对象的机制�Q�以及初始化�Q�重�|�和执行规则引擎的机制�?/div>

使用Java规则引擎API
       Java规则引擎API把和规则引擎的交互分��Z��c�：��理�z�d��和运行时�z�d��。管理活动包括实例化规则引擎和装载规则。而运行时�z�d��包括操作Working Memory和执行规则。如果你在J2SE环境中��用Java规则引擎�Q�你可能需要在代码中执行以上所有的�z�d��。相反，在J2EE环境中，Java规则引擎的管理活动是应用服务器的一部分。JSR 94的参考实现包括了一个JCA�q�接器，用于通过JNDI获得一个RuleServiceProvider�?/div>

讄��规则引擎
       Java规则引擎的管理活动阶�D�开始于查找一个合适的javax.rules.RuleServiceProvider对象�Q�这个对象是应用�E�序讉K��规则引擎的入口。在J2EE环境中，你可能可以通过JNDI获得RuleServiceProvider。否则，你可以��用javax.rules.RuleServiceProviderManager�c�：
           javax.rules.RuleServiceProviderManager class:

           String implName = "org.jcp.jsr94.ri.RuleServiceProvider";
           Class.forName(implName);
           RuleServiceProvider serviceProvider = RuleServiceProviderManager.getRuleServiceProvider(implName);
       一旦拥有了RuleServiceProvider对象�Q�你可以获得一个javax.rules.admin.RuleAdministrator�c�R��从RuleAdministrator�c�M��Q�你可以得到一个RuleExecutionSetProvider�Q�从�c�d��可以知道�Q�它用于创徏javax.rules.RuleExecutionSets对象。RuleExecutionSet基本上是一个装入内存的�Q�准备好执行的规则集合�?br>       包javax.rules.admin包括两个不同的RuleExecutionSetProvider�c�R��RuleExecutionSetProvider�c�L��w�包括了从Serializable对象创徏RuleExecutionSets的方法，因此在规则引擎位于远�E�服务器的情况下�Q�仍然可以��用RuleExecutionSetProvider�c�，构造器的参数可以通过RMI来传递。另一个类是LocalRuleExecutionSetProvider�Q�包含了其他�Ҏ��Q�用于从非Serializable资源�Q�如java.io.Reader�Q�本地文�Ӟ��创徏RuleExectionSets。假设拥有了一个RuleServiceProvider对象�Q�你可以从本地文件rules.xml文�g创徏一个RuleExectionSet对象。如以下的代码所�C�：
          RuleAdministrator admin = serviceProvider.getRuleAdministrator();
          HashMap properties = new HashMap();
          properties.put("name", "My Rules");
          properties.put("description", "A trivial rulebase");

          FileReader reader = new FileReader("rules.xml");
          RuleExecutionSet ruleSet = null;
          try {
               LocalRuleExecutionSetProvider lresp =
               admin.getLocalRuleExecutionSetProvider(properties);

               ruleSet = lresp.createRuleExecutionSet(reader, properties);
          } finally {
               reader.close();
          }
       接下来，你可以��用RuleAdministrator注册获得的RuleExecutionSet�Q��ƈ�l�它分配一个名�U�。在�q�行�Ӟ��你可以用同一个名�U�创��Z��个RuleSession�Q�该RuleSession使用了这个命名的RuleExecutionSet。参见下面的例子�Q?br>admin.registerRuleExecutionSet("rules", ruleSet, properties);

执行规则引擎
       在运行时阶段�Q�你可以参见一个RuleSession对象。RuleSession对象基本上是一个装载了特定规则集合的规则引擎实例。你从RuleServiceProvider得到一个RuleRuntime对象�Q�接下来�Q�从javax.rules.RuleRuntime得到RuleSession对象�?br>       RuleSession分�ؓ两类�Q�stateful和stateless。它们具有不同的功能。StatefulRuleSession的Working Memory能够在多个方法调用期间保存状态。你可以在多个方法调用期间在Working Memory中加入多个对象，然后执行引擎�Q�接下来�q�可以加入更多的对象�q�再�ơ执行引擎。相反，StatelessRuleSession�c�L��不保存状态的�Q��ؓ了执行它的executeRules�Ҏ��Q�你必须为Working Memory提供所有的初始数据�Q�执行规则引擎，得到一个内容列表作��回倹{�?br>       下面的例子中�Q�我们创��Z��个StatefulRuleSession实例�Q�添加两个对象（一个Integer和一个String�Q�到Working Memory�Q�执行规则，然后得到Working Memory中所有的内容�Q�作为java.util.List对象�q�回。最后，我们调用release�Ҏ��清理RuleSession�Q?br>         RuleRuntime runtime = rsp.getRuleRuntime();
         StatefulRuleSession session = (StatefulRuleSession)
         runtime.createRuleSession("rules", properties,
         RuleRuntime.STATEFUL_SESSION_TYPE);
         session.addObject(new Integer(1));
         session.addObject("A string");
         session.executeRules();
         List results = session.getObjects();
         session.release();

集成JSR 94产品实现
       支持JSR 94规范的��品实现既有收费的商业产品�Q�也有免费的开源项目。目前最为成熟，功能最强大的商业��品是ILOG公司的JRules�Q�该公司也是JSR 94规范的积极推动者之一。支持JSR 94规范的开源项目目前很��，只有Drools和JLisa��目。值得注意的是�Q�Jess不是开源项目，它可以免费用于学术研�IӞ��但用于商业用途则要收贏V�?br>
JSR 94的��品实�?/strong>
        Java规则引擎商业产品有：
           l. ILOG公司的JRules
          2. BlazeSoft公司的Blaze
          3. Rules4J
          4. Java Expert System Shell �Q�JESS�Q?br>        开源项目的实现包括�Q?br>          l. Drools��目

         2. JLisa��目
         3. OFBiz Rule Engine�Q�不支持JSR 94�Q?br>         4. Mandarax�Q�目前不支持JSR 94�Q?/div>

使用Spring集成
       集成Java规则引擎的目标是�Q��用标准的Java规则引擎API��装不同的实玎ͼ�屏蔽不同的��品实现细节。这样做的好处是�Q�当替换不同的规则引擎��品时�Q�可以不必修改应用代码�?br> ��装JSR94实现

       RuleEngineFacade�c�d��装Java规则引擎�Q��用ruleServiceProviderUrl和ruleServiceProviderImpl两个参数�Q�屏蔽了不同产品的配�|�。代码如下：
       public class RuleEngineFacade {

                private RuleAdministrator ruleAdministrator;
                private RuleServiceProvider ruleServiceProvider;
                private LocalRuleExecutionSetProvider ruleSetProvider;
                private RuleRuntime ruleRuntime;

                // configuration parameters
                private String ruleServiceProviderUrl;
                private Class ruleServiceProviderImpl;

          public void setRuleServiceProviderUrl(String url) {
                this.ruleServiceProviderUrl = url;
          }
           public void setRuleServiceProviderImpl(Class impl) {
                this.ruleServiceProviderImpl = impl;
          }
           public void init() throws Exception {
               RuleServiceProviderManager.registerRuleServiceProvider(
                ruleServiceProviderUrl, ruleServiceProviderImpl);

                ruleServiceProvider = RuleServiceProviderManager.getRuleServiceProvider(ruleServiceProviderUrl);

                ruleAdministrator = ruleServiceProvider.getRuleAdministrator();
                ruleSetProvider = ruleAdministrator.getLocalRuleExecutionSetProvider(null);
          }

          public void addRuleExecutionSet(String bindUri,InputStream resourceAsStream)
                    throws Exception {

                Reader ruleReader = new InputStreamReader(resourceAsStream);
                RuleExecutionSet ruleExecutionSet =
                ruleSetProvider.createRuleExecutionSet(ruleReader, null);

                ruleAdministrator.registerRuleExecutionSet(bindUri,ruleExecutionSet,null);
         }

        public StatelessRuleSession getStatelessRuleSession(String key)
                   throws Exception {

                ruleRuntime = ruleServiceProvider.getRuleRuntime();
                return (StatelessRuleSession) ruleRuntime.createRuleSession(key, null, RuleRuntime.STATELESS_SESSION_TYPE);
        }

        public StatefulRuleSession getStatefulRuleSession(String key)
                 throws Exception {

                ruleRuntime = ruleServiceProvider.getRuleRuntime();
                return (StatefulRuleSession) ruleRuntime.createRuleSession(
                key, null, RuleRuntime.STATEFUL_SESSION_TYPE);
         }

        public RuleServiceProvider getRuleServiceProvider() {
                return this.ruleServiceProvider;
        }
    }

    ��装规则
        Rule�c�d��装了具体的业务规则，它的输入参数ruleName是定义规则的配置文�g名，�q�依赖于RuleEngineFacade�l��g。代码如下：
    public class Rule {

         private String ruleName;
         private RuleEngineFacade engineFacade;

         public void init() throws Exception {
              InputStream is = Rule.class.getResourceAsStream(ruleName);
             engineFacade.addRuleExecutionSet(ruleName, is);
             is.close();
       }

        public void setRuleName(String name) {
             this.ruleName = name;
        }

       public void setEngineFacade(RuleEngineFacade engine) {
            this.engineFacade = engine;
        }

       public StatelessRuleSession getStatelessRuleSession()
                     throws Exception {
            return engineFacade.getStatelessRuleSession(ruleName);
        }

       public StatefulRuleSession getStatefuleRuleSession()
                     throws Exception {
            return engineFacade.getStatefulRuleSession(ruleName);
        }
    }

    �l�装规则�l��g
       �l�装规则的配�|�文件如下：


          http://drools.org/


           org.drools.jsr94.rules.RuleServiceProviderImpl



          /test/fibonacci.drl





    ��试用例
       最后，我们�~�写��试用例�Q�代码如下：
public class JSRTest extends TestCase {

      ApplicationContext ctx = null;

     protected void setUp() throws Exception {
           super.setUp();
           ctx = new FileSystemXmlApplicationContext("testrule.xml");
      }
     public void testGetRuleSession() throws Exception {
           Rule rule = (Rule)ctx.getBean("fibonacci");
           assertNotNull(rule.getStatefuleRuleSession());
           assertNotNull(rule.getStatelessRuleSession());
      }
      public void testStatelessRule() throws Exception {
           Rule rule = (Rule)ctx.getBean("fibonacci");
           Fibonacci fibonacci = new Fibonacci(50);
           List list = new ArrayList();
           list.add(fibonacci);
           StatelessRuleSession session = rule.getStatelessRuleSession();
           session.executeRules(list);
           session.release();
      }
      public void testStatefulRule() throws Exception {
            Rule rule = (Rule)ctx.getBean("fibonacci");
            Fibonacci fibonacci = new Fibonacci(50);
            StatefulRuleSession session = rule.getStatefuleRuleSession();
            session.addObject(fibonacci);
            session.executeRules();
            session.release();
       }
}

       �q�行��试用例�Q�出现绿条，��试通过�?/div>

规则定义语言之间的变�?/strong>
       因�ؓJSR 94规范�q�没有强制统一规则定义的语法，因此�Q�当需要将应用�U�L��到其他的Java规则引擎实现�Ӟ��可能需要变换规则定义，如将Drools�U�有的DRL规则语言转换成标准的ruleML�Q�Jess规则语言转换成ruleML�{�。这个工作一般由XSLT转换器来完成�?/div>

junky 2007-06-28 08:57 发表评论

drools之helloworld

junky — Thu, 28 Jun 2007 00:57:00 GMT
所有项目都是被需求变更篏�ȝ��Q�eXtreme Programing提供了一�U�哲学，一�U�态度�Q�但更实际的�Q�是那些能够应付需求变更的技术�?
比如用OLAP支持复杂报表的快速定�Ӟ��用script语言如Groovy支持客户自定义公式，
�q�有Rule Engine�Q�我们一天到晚挂在口上的亲爱的商业规则�?
Rule Engine�q�不新鲜�Q�但通常只要一些名词已�l��够把所有普通项目组震退�Q�CLisp、Rete、前向推�?... 惟有Drools�Q�终于把java和xml带回我们�w�边�Q�让规则引擎��单到和JSP一样可以进入所有的�E�序�l��?

先看一�D늲��又实用的HelloWorld�Q�由两部分组成，一个是调用规则的test.jsp �Q?

//讄��一个测试用的VO
Vo vo = new Vo();
vo.setPoStatus("A:draft");

//��d��规则
RuleBase ruleBase = RuleBaseBuilder.buildFromURL("rule.drl");

//把vo攑օ�WorkingMemory中�ƈ执行
WorkingMemory workingMemory = ruleBase.newWorkingMemory( );
workingMemory.assertObject( vo );
workingMemory.fireAllRules( );

//昄��l�果
out.print(po.getPoStatus());

一个是规则文�grule.drl�Q?

com.ito.vo

vo.getStatus().equals("A:draft")

vo.setStatus("B:order");

整个规则分成三段�Q?�W�一�D�定义刚刚放入的对象�Q?�W�二�D는�Java语法判断条�g�Q?�W�三�D��ؓ条�g�W�合时的执行语句
真的非常��单吧

�l�过��范围的试用�Q�发现没有这么简单，因�ؓDrools主要提供了一个RETE的规则匹配算法和一个Script Engine�Q�具体怎么用，�q�很靠自己。如果drl文�g的定义方式和RETE��法能够使条件的表达大大��化，那么它就是有用的。否则，一�D�重构后的代码能够达到和drl文�g�总�的功能。所以，�q�是要多看点基础�Q�把Business Rules用在正确的地斏V�?

提供一个eclipse的插�?url: http://www.zymose.com/index.html

junky 2007-06-28 08:57 发表评论

Drools- 商务逻辑框架的选择

junky — Wed, 27 Jun 2007 10:16:00 GMT
作者：保罗.布朗
译�?greenbright

版权声明�Q��Q何获得Matrix授权的网站，转蝲时请务必以超链接形式标明文章原始出处和作者信息及本声�?/span>
作�?保罗.布朗;greenbright
原文地址:http://www.onjava.com/pub/a/onjava/2005/08/03/drools.html
中文地址:http://www.matrix.org.cn/resource/article/44/44046_Drools+Framework+Business.html
关键词： Drools Framework Business

大多数网�l�及企业�U�Jave应用可以分�ؓ三部分：和用户交互的前端�Q�和后端�pȝ��Q�比如数据库�Q�交互的服务层和�q�两部分之间的商务逻辑层。通常使用框架�Q�像Struts, Cocoon, Spring, Hibernate, JDO, 和实体Beans�Q�可以实现前端和后端的功能，但对于商务逻辑层却没有一个标准的构徏�Ҏ��。像EJB和Spring只能在高端实现商务逻辑构徏�Q�但却不能组�l�代码。如果我们��用在配置性，可读性和重用性方面带我们极大利益的框架代曉K��些纷�J�复杂的if...then语句�Q�那不是很好吗？在其他领域我们已�l�验证了�q�种利益。这��文章徏议��?a target=_new>Drools规则引擎作�ؓ框架来解决问题�?br>
下面的代码是我们试图避免的问题的例子。说明一个典型Java应用中的一些商务逻辑�?br>
if ((user.isMemberOf(AdministratorGroup)
      && user.isMemberOf(teleworkerGroup))
     || user.isSuperUser(){
         // 更多对特�D�案例的��?br>         if((expenseRequest.code().equals("B203")
           ||(expenseRequest.code().equals("A903")
                        &&(totalExpenses<200)
                &&(bossSignOff> totalExpenses))
           &&(deptBudget.notExceeded)) {
               //付款
           } else if {
               //��查许多其他的条�g
           }
} else {
     //更多商务逻辑
}

我们都曾�l�历�q�相�c�M��或者更为复杂的商务逻辑。当试图在Java中采用标准方法来实施商务逻辑�Ӟ��有很多问题随之而来�?br>·        如果商务人员提出需要在本已很难理解的代码中加入另外一个表单（"C987"�Q�怎么办？一旦所有的最初开发�h员都在开发中�Q�你愿意成�ؓ一个维护�h员吗�Q?br>·        如何��认�q�些规则的正��与否？�Ҏ��术�h员来��_��从来不关注商务�h员）�Q�检查规则的正确性是非常困难的。那么，有什么方法论来测试商务逻辑那？
许多应用有着�c�M��的商务逻辑。如果其中一个规则发生了变化�Q�我们能够确认所有系�l�中的相关部分都要改变吗�Q�如果一个新应用使用了一些规则，但是也加入了一些新规则�Q�我们需要彻底重写逻辑吗？
·        商务逻辑嵌入在Java代码中，每次哪怕是很小的改变都需要再�~�译/再部�|�这些代码，�q�些商务逻辑�Ҏ��配置�?
·        如果其他的（脚本�Q�语�a�惛_�^衡现有投资在商务规则逻辑中怎么办？

J2EE/EJB和倒置控制的框�Ӟ��像Spring, Pico和Avalon�Q�让我们有能力在高端�l�织代码。他们很提供很好的重用性，配置性和安全性，但却不能替代上面例子中的“意大利面条式代码”。理惛_��Q�无论我们选择那个框架�Q�不仅要和J2EE应用�Q�而且要和通常Java�~�程(J2SE—标准版�?及广泛��用的表现和持�l�性框架相一致。这�U�框架让我们能够做到�Q?br>·        商务用户很容易的��d��验证商务逻辑�?br>·        在应用中�Q�商务规则是可重用的和可配置的�?br>·        在重负荷下，框架是可扩展的和性能良好的�?br>·        Java�~�程人员对已存在的前端（Struts, Spring�Q�和后端框架�Q�对象关�p�L��）很容易��用这�U�框架�?br>
另一个问题是在不同的应用中，�l�织��面�Q�数据库讉K��和商务逻辑的方法也是多�U�多��L��。我们的框架能够处理�q�个问题�Q��ƈ能始�l�提升代码的重用性。理惛_��Q�我们的应用使用“适用所有方式的框架”。以�q�种方式使用框架�Q�能够让我们许多的应用构建的更好�Q�让我们可以仅关注那些对用户更有价值的部分�?br>
规则引擎的营�?/span>

如何解决�q�个问题�? 一个解��x��案是使用规则引擎。规则引擎是�l�织商务逻辑的框架。它让开发者集中精力在他们有把握的事情上，而不是在一些低�U�机制上作决定�?br>通常�Q�商务用户对那些能让他们理解是正��的事情感到更加舒服�Q�相对于那些诸如�?span style="COLOR: blue">if...then 形式来表辄��事情。你从商务专安��里听到的一些事情如�?br>·        “10A表单用于甌��过200�Ƨ元的花�?”
·        “我们仅对数量1万或��过1万的交易提供分成.”
·        “��过10m英镑的采购需要公司�ȝ��的批�?”

通过��x��于商务用��L��道是正确的事情上�Q�而不是怎样用Jave代码来表辑֮��Q�上面的说明比以前我们的代码例子要清楚的多。尽��他们已�l�很清楚了，我们仍然需要一�U�机�Ӟ��这些规则应用到商务用户已知和作军_��的事实中厅R��这�U�机制就是规则引擎�?br>
相关文章�Q?/span>
在企业��Java应用中��用Drools
企业�U�Java应用开发者在表现和持�l�层有很多好的框架可供选择。但对于处在中间层的商务逻辑有好的框架吗�Q�你希望每次�l�理�l�你一个新的命令就不得不重�~�译那些复杂的if ... then 意大利面条代码吗�Q�这��文章中�Q�保�|�布朗推荐的Drools的规则引擎或许是完成�q�类��d��的最好选择�?br>
Jave规则引擎

JSR 94- javax.rules API制定了与规则引擎交互的通用标准�Q�就像JDBC能够与各�U�类型的数据库交互。JSR-94�q�不是详�l�说明实际规则到底是怎么写的�Q�而是最大限度的使用Java规则引擎来做�q�种详细说明�?br>·        Jess可能是最成熟的Java规则引擎�Q�有很多好的工具�Q�包括Eclipse�Q�和文档。然而它是一个商业��品，�q�且它的规则是以序言样式�W�号写的�Q�这对许多Java�~�程者都是一个挑战�?br>·        Jena是开源框�Ӟ��始于HP.它有规则引擎�Q��ƈ且对那些��x��于语义的�|�页特别支持。但它�ƈ不完全遵守JSR-94�?br>·        Drools是完全遵守JSR-94的规则引擎。而且是Apache模式许可下的完全开源框架。它不仅用大家熟知的Java 和XML语法来表�C��则，而且有很强的用户和开发者团体。本文章中的例子中，我们��用Drools。Drools使用像Java的语法，�q�且有最开攄��许可�?br>
用Drools开始开发Java应用

惌��一下这�U�情景：��在��M��q�篇文章几分钟后�Q�你的老板让你�l�股��交易应用徏原型。尽��商务用戯��没有定义好商务逻辑�Q�一个可以想到的好主意就是用规则引擎来实现。最�l�的�pȝ��通过�|�络讉K��Q��ƈ且需要和后端数据库和信息�pȝ��交流。�ؓ了开始��用这个框�Ӟ��需要下载Drools框架�Q�有依赖性）。如�?所�C�，在你喜欢的IDE中徏一个新��目�q�确保所有的.jars文�g都被引用了�?br>

�?。运行Drools必需的类�?br>
�׃��潜在可能的巨大损失，如果我们的股��交易系�l�想要成功，在系�l�中循序渐进的��用一�p�d��模拟器就昑־�很重要。这��L��模拟器能够让你确信，即��规则改变了，��q��l�的作的军_��也是正确的。我们将借用灉|��工具��q��一些工��P��q�用JUnit框架作�ؓ模拟器�?br>
如下例所�C�，我们所写的�W�一�D�代码是Junit��试/模拟器。尽��我们不能测试所有输入系�l�的值的�l�合�Q�由��试��L��什么都不测好。在�q�个例子中，所有的文档和classes�Q�包括单元测试）又在一个文件夹/包中�Q�但事实上，由应该创建合适的包和文�g夹结构。在代码中，我们用Log4j代替System.out调用�?br>
清单1:

import junit.framework.TestCase;
/*
* 应用中商务规则的JUnit��试
        * �q�也扮演商务规则�?#8220;模拟�?#8220;-让我们说明输入，��验输出；�q�在代码�?布前看看是否辑ֈ�我的期望倹{�?br>*/
public class BusinessRuleTest extends TestCase {
/**
*股票购买��试
*/
  public void testStockBuy() throws Exception{

//用模拟值创��?br>    StockOffer testOffer = new StockOffer();
    testOffer.setStockName("MEGACORP");
    testOffer.setStockPrice(22);
    testOffer.setStockQuantity(1000);

//�q�行规则
    BusinessLayer.evaluateStockPurchase(testOffer);

        //辑ֈ�我们的期望吗�Q?br>    assertTrue(
      testOffer.getRecommendPurchase()!=null);

    assertTrue("YES".equals(
      testOffer.getRecommendPurchase()));
   }
}

�q�是个基本Junit��试�Q�我们知道这个简单系�l�应该买�q�所有�h��g��?00�Ƨ元的股��。很昄��Q�没有数据类�Q�StockOffer.java�Q�和商务层类�Q�BusinessLayer.java�Q�这个测试用例是不能�~�译成功的�?br>
清单2:

/**
*�C�Z��商务逻辑的正�?br>*�q�个��单示例里�Q�所有的商务逻辑都包含在一个类中�?br>*但在现实中，按需要代理给其他的类�?br>*/
public class BusinessLayer {

        /**
   *评�h购买�q�支股票是否是个好主�?br>   *@参数 stockToBuy
   *@return 如果推荐购买股票�q�回真，否则�q�回�?br>   */
  public static void evaluateStockPurchase
    (StockOffer stockToBuy){
                return false;
  }
}
StockOffer�c�d��下所�C�：
/**
* ��单的JavaBean保存StockOffer倹{�?br>* 一�?#8217;股票��Z�h’��是别�h卖出股票�Q�公司股份）所�l�出的�h根{�?br>*/
public class StockOffer {

  //帔R��
  public final static String YES="YES";
  public final static String NO="NO";

  //内部变量
  private String stockName =null;
  private int stockPrice=0;
  private int stockQuantity=0;
  private String recommendPurchase = null;

/**
   * @�q�回股票名称
   */

  public String getStockName() {
        return stockName;
  }
/**
   * @参数 stockName 讄��股票名称.
   */
  public void setStockName(String stockName) {
        this.stockName = stockName;
  }
/**
   * @return �q�回股票��h��.
   */

  public int getStockPrice() {
        return stockPrice;
  }
/**
   * @参数 stockPrice讄��股票��h��.
   */

  public void setStockPrice(int stockPrice) {
        this.stockPrice = stockPrice;
  }
/**
   * @return �q�回股票数量.
   */

  public int getStockQuantity() {
        return stockQuantity;
  }
/**
   * @参数 stockQuantity 讄��股票数量.
   */

  public void setStockQuantity(int stockQuantity){
        this.stockQuantity = stockQuantity;
  }
/**
   * @return �q�回��购买.
   */

  public String getRecommendPurchase() {
        return recommendPurchase;
  }
}

在我们熟悉的IDE的Junit中运行BusinessRuleTest。如果你不太熟悉Junit�Q�可以从Junit�|�站获取更多信息。如�?所�C�，毫不奇怪的是，�׃��没有准备好适当的商务逻辑�Q�测试在�W�二个申明处��p�|了。这个确信了模拟�?单元��试重点加强了他们应该有的问题�?br>

�?。Junit��试�l�果

用规则描�q�商务逻辑

现在�Q�我们需要描�q�C��些商务逻辑�Q�像“如果股票��h��低于100�Ƨ元�Q�应该购买�?#8221;
�q�样我们��修改BusinessLayer.java为：

清单3:

import java.io.IOException;
import org.drools.DroolsException;
import org.drools.RuleBase;
import org.drools.WorkingMemory;
import org.drools.event.DebugWorkingMemoryEventListener;
import org.drools.io.RuleBaseLoader;
import org.xml.sax.SAXException;
/**
*�C�Z��商务逻辑的正�?br>*�q�个��单示例里�Q�所有的商务逻辑都包含在一个类中�?br>*但在现实中，按需要代理给其他的类�?br>*@作�?�~�省
*/
public class BusinessLayer {
//包含规则文�g的名�?br>  private static final String BUSINESS_RULE_FILE=
                              "BusinessRules.drl";
        //内部处理的规则基��
  private static RuleBase businessRules = null;
/**
* 如果�q�没有装载商务规则的话就装蝲它�?br>*@抛出异常 -通常从这里恢�?br>*/
  private static void loadRules()
                       throws Exception{
    if (businessRules==null){
      businessRules = RuleBaseLoader.loadFromUrl(
          BusinessLayer.class.getResource(
          BUSINESS_RULE_FILE ) );
    }
  }

/**
   *评�h是否购买�q�支股票
   *@参数 stockToBuy
   *@return 如果推荐购买股票�q�回真，否则�q�回�?br>   *@抛出异常
   */
  public static void evaluateStockPurchase
       (StockOffer stockToBuy) throws Exception{

//��保商务规则被装�?br>    loadRules();
//一些程序进行的日志
    System.out.println( "FIRE RULES" );
    System.out.println( "----------" );
        //了解以前�q�行的状�?br>    WorkingMemory workingMemory
            = businessRules.newWorkingMemory();
//��规则集可以��d��调试侦听�?br>    workingMemory.addEventListener(
      new DebugWorkingMemoryEventListener());
        //让规则引擎了解实�?br>    workingMemory.assertObject(stockToBuy);
        //让规则引擎工�?br>    workingMemory.fireAllRules();
  }
}

�q�个�c�L��许多重要的方法：
·        loadRules()�Ҏ��装蝲BusinessRules.drl文�g中的规则�?br>·        更新的evaluateStockPurchase()�Ҏ��评�h�q�些商务规则。这个方法中需要注意的是：
·        同一个RuleSet可以被重复��用（内存中的商务规则是无状态的�Q��?br>·        �׃��以我们的知识我们知道什么是正确的，每次评�h我们使用一个新的WorkingMemory�c�R��在内存中用assertObject()�Ҏ��存放已知的实事（作�ؓJava对象�Q��?br>·        Drools有一个事件侦听模式，能让我们“看到“事�g模式内到底发生了什么事情。在�q�里我们用它打印��试信息。Working memory�cȝ��fireAllRules()�Ҏ��让规则被评�h和更斎ͼ�在这个例子中�Q�stock offer�Q��?br>
再次�q�行例子之前�Q�我们需要创建如下BusinessRules.drl文�g�Q?br>
清单4:

  xmlns="http://drools.org/rules"
  xmlns:java="http://drools.org/semantics/java"
  xmlns:xs
    ="http://www.w3.org/2001/XMLSchema-instance"
  xs:schemaLocation
    ="http://drools.org/rules rules.xsd
  http://drools.org/semantics/java java.xsd">


    java.lang.Object


    java.lang.String


    net.firstpartners.rp.StockOffer



    public void printStock(
      net.firstpartners.rp.StockOffer stock)
        {
        System.out.println("Name:"
          +stock.getStockName()
          +" Price: "+stock.getStockPrice()
          +" BUY:"
          +stock.getRecommendPurchase());
        }






      StockOffer




      stockOffer.getRecommendPurchase() == null


      stockOffer.getStockPrice() < 100



        stockOffer.setRecommendPurchase(
                              StockOffer.YES);
          printStock(stockOffer);



�q�个规则文�g有几个有意思的部分�Q?br>·        在XML-Schema定义被引入Java对象后，我们也把它引入到我们的规则中。这些对象来自于所需的Java�c�d��?br>·        功能和标准的Java代码相结合。这��L��话，我们��可以通过功能日志了解到底发生了什么�?br>·        规则讄��可以包括一个或多个规则�?br>·        每条规则可以有参敎ͼ�StockOffer�c�）。需要满��一个或多个条�g�Q��ƈ且当条�g满��时就执行相应的结果�?br>
修改�Q�编译了代码后，再运行Junit��试模拟器。这�ơ，如图3所�C�，商务规则被调用了�Q�逻辑评�h正确�Q�测试通过。祝贺—你已经创徏了你的第一个基于规则的应用�Q?br>

�?。成功的Junit��试

灉|��的规�?/span>

刚徏好系�l�，你示范了上面的原型给商务用户�Q�这时他们想起先前忘了给你提到几个规则了。新规则之一是当数量是负值时�Q�不能够交易股票。你�?#8220;没问题，”�Q�然后回��C��的��位，借可靠的知识�Q�你能迅速的改进�pȝ��?br>�W�一件要做的事情是更��C��的模拟器�Q�把下面的代码加到BusinessRuleTest.java:

清单5:

/**
*��试买股��确保系�l�不接受负�?br>*/
  public void testNegativeStockBuy()
                                throws Exception{
//用模拟值创��?br>      StockOffer testOffer = new StockOffer();
        testOffer.setStockName("MEGACORP");
        testOffer.setStockPrice(-22);
        testOffer.setStockQuantity(1000);
//�q�行规则
        BusinessLayer
              .evaluateStockPurchase(testOffer);
//是否辑ֈ�我们的期望？
        assertTrue("NO".equals(
          testOffer.getRecommendPurchase()));
}

�q�是为商务用��h��q�的新规则的��试。如果测试这个Junit��试�Q�如预期的新��试��p�|了。我们需要加�q�个新规则到.drl文�g中，如下所�C��?br>
清单6:





      StockOffer



      stockOffer.getStockPrice() < 0



      stockOffer.setRecommendPurchase(
                                  StockOffer.NO);
      printStock(stockOffer);



�q�个规则的和前一个类��|��期望不同�Q�测试负��|��?lt;java:consequence>讄��购买为No。再�ơ运行测�?模拟器，�q�次��试通过�?br>
�q�样的话�Q�如果你习惯使用�q�程�~�程�Q�象大多数Java �~�程者）�Q�或�怽�会发愁挠��_��一个文件包含两个独立的商务规则�Q�而且我们也没有告诉规则引擎这两个规则哪个更重要。然而，股票��h��Q?22�Q�也�W�合两个规则�Q�它��于0也小�?00�Q�。不论如何，我们得到了正��的�l�果�Q�即使交换规则的��序。这是怎么工作的那�Q?br>
下面控制台输出的摘录帮助我们明白到底发生了什么。我们看��C��个规则都被触发了�Q�[activationfired]行）�q�且Recommend Buy先被�|��ؓYes然后被置为No。Drools是如何以正确的顺序来触发�q�些规则的那�Q�如果你看Stock Price Low Enough规则�Q�就会看到其中的一个条件recommendPurchase()是null.�q�就��以让Drools军_��Stock Price Low Enough规则应该先于Stock Price Not Negative规则触发。这个过�E�就是冲�H�解��x��案�?br>
清单7:

FIRE RULES
----------
[ConditionTested: rule=Stock Price Not Negative;
  condition=[Condition: stockOffer.getStockPrice()
  < 0]; passed=true; tuple={[]}]
[ActivationCreated: rule=Stock Price Not Negative;
  tuple={[]}]
[ObjectAsserted: handle=[fid:2];
   object=net.firstpartners.rp.StockOffer@16546ef]
[ActivationFired: rule=Stock Price Low Enough;
   tuple={[]}]
[ActivationFired: rule=Stock Price Not Negative;
   tuple={[]}]
Name:MEGACORP Price: -22 BUY:YES
Name:MEGACORP Price: -22 BUY:NO

如果你是个过�E�编�E�者，无论你认��是多聪明�Q�你仍然不能完全的信��d��。这是�ؓ什么我们��用单元测�?模拟器：“辛苦�?#8221;Junit��试�Q��用通用Java代码�Q�保证规则引擎用我们��x��的行来做军_��。（不要��p��上亿在一些无价值的股票上！�Q�同�Ӟ��规则引擎的强大和灉|��性让我们能够�q�速开发商务逻辑�?br>�E�后�Q�我们将看到更多冲突解决�Ҏ��的经典的方式�?br>
冲突解决�Ҏ��

在商务这边，��Z��真的印象深刻�q�别开始通过可能的选择来思考。他们看到XYZ公司股票的问题�ƈ且决定执行一条新规则:如果XYZ公司的股价低�?0�Ƨ元�Q�就仅仅买XYZ公司的股��?br>象上�ơ，加测试到模拟器中�Q�在规则文�g中加入新的商务规则，如下所列。首先，在BusinessRuleTest.java中添加新�Ҏ��?br>
清单8:

/**
*��保�pȝ��pȝ��在XYZ公司股�h便宜时就购买他们的股��?br>*/
public void testXYZStockBuy() throws Exception{
//用模拟值创��?br>  StockOffer testOfferLow = new StockOffer();
  StockOffer testOfferHigh = new StockOffer();

  testOfferLow.setStockName("XYZ");
  testOfferLow.setStockPrice(9);
  testOfferLow.setStockQuantity(1000);

  testOfferHigh.setStockName("XYZ");
  testOfferHigh.setStockPrice(11);
  testOfferHigh.setStockQuantity(1000);
//�q�行规则
  BusinessLayer.evaluateStockPurchase(
    testOfferLow);
  assertTrue("YES".equals(
    testOfferLow.getRecommendPurchase()));

  BusinessLayer.evaluateStockPurchase(
    testOfferHigh);
  assertTrue("NO".equals(
    testOfferHigh.getRecommendPurchase()));
}

然后�Q�在BusinessRules.drl中加个新<规则>:

清单10:




     StockOffer



     stockOffer.getStockName().equals("XYZ")


     stockOffer.getRecommendPurchase() == null


     stockOffer.getStockPrice() > 10




     stockOffer.setRecommendPurchase(
       StockOffer.NO);
     printStock(stockOffer);



注意到商务规则文件中�Q�规则名字后�Q�我们设�|�salience�?1�Q�比如，到现在我们说明的所有规则中的最低优先��Q�。系�l�冲�H�（意味着Drools在触发那个规则的��序上作军_��Q�的大多数规则给��Z��达到的规则的条件。缺省的军_��Ҏ��如下�Q?
·        显著�?如上列出的我们分配的倹{�?
·        崭新性：我们使用规则的次数�?
·        复杂性：�W�一�ơ触发的更复杂的特定规则�?
·        装蝲��序�Q�那个规则被装蝲的顺序�?br>如果我们不说明这个例子中规则的显著性，��会发生的是�Q?
·        XYZ公司规则�Q?#8220;如果股票��h��过10�Ƨ元买XYZ”�Q�将被首先触发（推荐买标记的状态被�|��ؓNo�Q��?
·        然后是更多的普通规则被触发�Q?#8220;买所有低�?00的股��?#8221;�Q�，推荐买标记的状态被�|��ؓyes�?br>
�q�将得到我们不期望的�l�果。然而，我们的例子设�|�了显著性因素，用例及商务规则就会如我们期望的运行了�?br>
大多数情况下�Q�书写清楚的规则且设�|�显著性将为Drools提供��_��的信息来选择触发规则的顺序。有�Ӟ��我们��x��个的改变解决规则冲突的方式。以下是一个如何改变的例子�Q�其中我告诉规则引擎首先触发最��单的规则。要注意的是�Q�改变冲�H�解��x��案是要小心，因�ؓ它能�Ҏ��的改变规则引擎的规则—用清楚的写得恰当的规则能预先解册��多问题�?br>
清单11:

//生成冲突解决者的列表
  ConflictResolver[] conflictResolvers =
    new ConflictResolver[] {
      SalienceConflictResolver.getInstance(),
      RecencyConflictResolver.getInstance(),
        SimplicityConflictResolver.getInstance(),
        LoadOrderConflictResolver.getInstance()
    };
//包装成合成解册��?br>  CompositeConflictResolver resolver =
    new CompositeConflictResolver(
      conflictResolvers);
//当装载规则时�Q�说明这个解册��?br>  businessRules = RuleBaseLoader.loadFromUrl(
    BusinessLayer.class.getResource(
      BUSINESS_RULE_FILE),resolver);

对于我们的简单的应用�Q�由Junit��试驱动�Q�我们不需要改变Drools解决规则冲突的方式。了解冲�H�解��x��案是如何工作的对我们是非常有帮助的，��其是当应用需要满��x��复杂根严格的需求试�?br>
�l�论

�q�篇文章��了许多编�E�者遇到过的问题：如何定制复杂的商务逻辑。我们示范了一个用Drools��x��案的��单应用�ƈ介绍了基于规则编�E�的概念�Q�包括在�q�行时这些规则是如何被处理的。稍后，接下来的文章��以�q�些为基��来展�C�在企业�U�Java应用中是如何使用它的�?br>

资源
·下蝲例子所有源代码:源代�?/font>
·Matrix-Java开发者社�?http://www.matrix.org.cn
·onjava.com:onjava.com
·Drools��目主页
·Drools规则信息
·“Drools和规则引擎介�l?#8221;由Drools��目领导
·Drools规则计划文�g
·JSR-94, Java规则引擎�Q�概�?
·Jess Jave规则引擎
·Jena语义和规则引�?/font>
·JSR-94主页
·Jess在Action主页
·“商务规则思想”�Q�基于Jess�Q?/font>
·“规则�pȝ��的一般介�l?#8221;
·“Rete��法的Jess执行”

保尔布朗已经通过FirstPartners.net�|�站��Z��业��Java咨询了约7�q�的旉��?br>

junky 2007-06-27 18:16 发表评论

在你的企业��java应用中��用Drools

junky — Wed, 27 Jun 2007 10:09:00 GMT
版权声明�Q�可以�Q意�{载，转蝲时请务必以超链接形式标明文章原始出处和作者信息及本声�?br>原文地址:
http://www.onjava.com/pub/a/onjava/2005/08/24/drools.html
中文地址:
http://www.matrix.org.cn/resource/article/43/43782_Drools.html
关键词： Drools J2ee

什么是Drools
(译者增加：什么是Drools, 摘自drools.org)
Drools 是一个基于Charles Forgy's的Rete��法的，专�ؓJava语言所设计的规则引擎。Rete��法应用于面向对象的接口��Z��商业对象的商业规则的表达更�ؓ自然。Drools是用Java写的�Q�但能同时运行在Java�?Net上�?br>
Drools
Drools 被设计�ؓ可插入式的语�a�实现。目前规则能用Java, Python和Groovy实现。更为重要的是，Drools提供了声明式�E�序设计(Declarative Programming),�q�且使用域描�q�语�a�(Domain Specific Languages (DSL))�Q�专��Z��的问题域定义了某�U�模式的Xml, 它已�l��够灵�z�d��可以用来描述你的问题域。DSLs包含的XML元素(Element)和属�?Attribute)代表了问题域中各�U�要素�?br>
(原文开�?
�q?�D�|��间企业��Java��直能让你睡着。有多少J2EE-EJB应用�E�序只是从网��|��取数据�ƈ把它们存入到数据库中?但开发者真正应该开发和�l�护的却是他�?应用�E�序中复杂的商业逻辑。这个问题不仅仅适用于将要新应用�Q�而且渐渐圎ͼ�也适用于那些长期运行的商业核心应用�Q�它们的内部逻辑也需要经常改变，而且往往要求在一个非常短的时间内�?br>
在以前的文章中，“用Drools让你的商业逻辑使用框架”,我介�l�了Drools框架�Q�展�C�Z��它如何用来组 �l�复杂的商业逻辑。Drool用一�l�简单的�Q�众所周知的事物替换了许多�~�杂的if…then表达式。如果你�l�历�q�和商业客户的会议，�q��ؓ他们提出的想要实现的东西的复杂程度搞得头痛，或许你应该考虑一下像Drools�q�样的规则引擎了。这��文章将向你展示如何在企业��Java应用中��用Drools.

一路到底的框架

�?多数开发者都有自己喜��q��框架。无特定��序�Q�它们包括表现层框架�Q�Struts, JSF, Cocoon和Spring�Q?持久化框�Ӟ��JDO, Hibernate, Cayenne and Entity Beans�Q�以及结构框�?EJB, 又是Spring, Pico和Excalibur), �q�有其它很多。每�U�框枉��各有所长，�l�开发者提供子许多“卛_��即用”的功能。��用框架来部��v应用意味着你避免了许多让�h厌烦的细节，让你集中注意力到关键之处�?br>到目前�ؓ��_��在框架所能做的事中仍然有一个缺口，那就是商业逻辑没有框架。像EJB和Spring�q�样的工兯��好，但它们却几乎没有提及�?么组�l�你的那些if …then语句。把Drools加到你的开发工��L��中意味着现在你可�?#8220;一路到�?#8221;的��用框架来构徏你的应用�E�序。图1昄��了这��L��一个应�?br>

�?. 用于Java应用的框�?br>
�q�篇文章��基于我们已�l�了解的Drools框架的功能，�q�些功能可以让我们构��L��一个应用。]

我什么时候应该��用规则引擎？
“如果你有一把锤子，那所有的东西都看��h��都像钉子”�Q�这句话在��Y件工�E�领域几乎成了陈词滥调了。虽然规则引擎能解决我们的许多问题，但确实值得认真考虑一下规则引擎对我们的企业��Java应用是否合适。需要问的问题有�Q?br>
�?我的应用�E�序有多复杂?对于那些只是把数据从数据库中传入传出�Q��ƈ不做更多事情的应用程序，最好不要��用规则引擎。但是，当在Java中有一定量的商业逻辑处理的话�Q�可以考虑Drools的��用。这是因为很多应用随着旉��的推�U�越来越复杂�Q�而Drools可以让你��L��应对�q�一切�?br>
�?我的应用的生命周期有多久�Q?/strong>�q�个问题的正��答案往往�?#8220;令�h惊讶的长”――还记得那些认�ؓ他们的程序不会苟�z�d��2000�q�的大型机的�E�序员吗�Q��用规则引擎将会在中长期得到好处。像�q�篇文章所展示的那��P��甚至原型都能从Drools与灵�z�L��法的�l�合中获益，�?#8220;原型�pȝ��”转化成生产系�l��?br>
�?我的应用需要改变吗�Q?/strong>唯一能确定的是你的需求将会改变，无论是在开发过�E�中或是在开发完成以后。Drools使用一个或多个��单易配的XML文�g帮你来应对这一切�?br>
那么性能呢？
�?果你正在写一个企业��应用�Q�很有可能它会扩展到成百�Q�如果不是成千）的用戗��你已经知道现有的Java和J2EE应用能做到这一点，但一个��用了 Drools的应用对�q�一压力的表现如何？�{�案是：“令�h吃惊的好”。大多数开发者只是因��Z��?#8220;失控”而依赖于他�h的代码（比如�Q�某�U�框�Ӟ��Q�想惌�� 个：Drools不仅可以让你的应用和“传统”的编�E�方法一样快�Q�甚臛_��以更�?看下面：

�?避免�p�糕的代�?/strong>�Q�Drools引导开发者去�?#8220;正确的事”。你可以��定你正在写的代码是好的�Q�但你的开发伙伴呢�Q�你可以同样�q�样说吗�Q��用框架可以让你更��L��地写出更快，更好的代码�?br>
�?优化�q�的框架�Q�你有多��次看见商业逻辑重复��C��数据库中提取相同的信息，从而降低了整个应用的速度�Q�如果正��用的话，Drools不仅仅能够记住信息，而且�q�能��C��以往使用该信息进行测试的�l�果�Q�从而大�q�提升应用的速度�?br>
�?Rete��法�Q?很多�ơ我们�ƈ不是真正需要��?#8220;if”条�g。被Drools实现的Rete��法�Q�可以用一个优化的�Ҏ��替换掉所有的“if…then”表达式。需要重�Ҏ�� 及的是：Rete��法在��用更多的内存来降低运行时延迟斚w��作了折衷。当然这在现代的应用服务器中�q�不是一个问题，我们也�ƈ不推荐你在移动手��Z��使用 Drools!

我们到哪里了�Q?/span>

�?我们上一��文章中�Q�我们写了一个基于Drools引擎的简单的股票交易�E�序。我们实��C��不同的商业规则，展示了我们可以如何迅速地改变规则去适应商业需求，�q�且JUnit��试�l�了我们高度自信可以��认�pȝ��实是像我们设想的那栯��作的。但是这个应用几乎没有用户介面，而且用硬�~�码代替了数据库。�ؓ了把�?们的�E�序提升��C��业��的水�q�I��我们需要增加两个主要的东西�?br>
�?某种用户介面�Q�最理想的是��Z��标准的Web表现层的框架�?br>�?一个数据存取对�?DAO)让Drools与数据库�Q�或其它后端�Q�交互�?br>
从现有表现框架中实现规则引擎

�?多数企业�U�Java应用是通过Web介面�q�行交互的，其中最被广泛��用的Web表现层框架是Apache的Struts。理想的�l�果是：我们写的应用可以从表现层知道它下面的应用�?而不是通过相反的方向。它的好处在于不仅仅可以使我们将来变换其它的表现层（比如Ajax或web service界面�Q�，而且意味着�C�Z��代码可以非常�Ҏ��地应用于其它像Spring的框架�?br>
下面的代码片断演�C�Z��始何从Web表现层调�?商业逻辑�Q�通过规则引擎�Q�，�q�根据返回结果显�C�Z��同的��面。这一例子中，我们使用了一个Struts行�ؓ�Q�但其代码是和��用其它表现层框架甚至一�?Servlet或一个Jsp��面是很�c�M��的。这个片断��用了struts-config.xml配置文�g�Q�JSP��面来上�?昄��数据�Q��ƈ且生成WAR�?件来�q�行布��v。片断展�C�Z��怎样把规则引擎和web框架集成使用�?br>

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import BusinessLayer;
/**
* Sample Struts action with Pseudocode
* 使用伪代码的Struts行�ؓ�C�Z��
*/
public class SampleStrutsAction extends Action{

  /**
   * Standard Struts doPerfom method
   * 标准的Struts doPerform�Ҏ��
   */
  public ActionForward doPerform(
                ActionMapping mapping,
                    ActionForm form,
                    HttpServletRequest request,
                    HttpServletResponse response)
        throws InvalidEntryPointException {
//Local Variables
//本地变量
    StockOffer userOffer =null;

//Get any previous values from the session
//从session取得以前的数�?br>    userOffer=(StockOffer)request.getSession()
           .getAttribute("PREVIOUS_STOCK_OFFER");

//create this object if it is null
//如�ؓnull则创建新对象
    if (null==userOffer){
      userOffer = new StockOffer();
    }
//Update with the incoming values
//用上送的数据更新
//These values match those on the form
//�q�些数据是与form中的数据相对应的
    userOffer.setStockName(request.
                getParameterValue("STOCK_NAME"));
    userOffer.setStockPrice(request
               .getParameterValue("STOCK_PRICE"));
    userOffer.setStockQuantity(request
               .getParameterValue("STOCK_QTY"));

//Reset the output value
//重置输出数据
    userOffer.setRecommendPurchase(null);
//Call the Business Layer
//调用商业�?br>    BusinessLayer
              .evaluateStockPurchase(userOffer);

//Forward to the appropriate page
//转向合适的��面
    if ("YES".equals(
      testOffer.getRecommendPurchase()){
        return mapping.findForward("YES_WEB_PAGE");
    }
//otherwise default to the no page
//否则指向无此��面
          return mapping.findForward("NO_WEB_PAGE");
  }
}

�q�个例子包含了几个东�ѝ��经常，我们需要的数据是用户通过好几个网��传来的�Q�因此在�q�一例子中展�C�Z��通过session中的StockOffer对象来保存过��M��来的数据�?br>
下一步，如果用户改变了一些��|��我们更新StockOffer对象。然后我们重�|�了rcommendPurchase标志用以在调用商业逻辑层之前清除以前的�l�果。最后我们��用商业逻辑层的�q�回来决定让用户转向哪一��面�?br>
�?�q�一例子中，需要注意我们将商业逻辑�Q�买或不��C��支股��）与表现层逻辑�Q�决定�{向哪一��面�Q�分��d��来。这��我们可以在不同的应用中重用我们的商业规则�?另外�Q�看一下状态信息（用户已经告知我们的东西）是存储在Session中的StockOffer对象中的�Q��ƈ没有在商业层中。这样就保证了商业层的无�?态性，�q�将使整个应用更��h��展性和性能�?br>
集成规则引擎与数据库�?/span>

�?目前为止�Q�我们的应用已经有一个web表现层和一个商业层的规则引擎，但还没有�Ҏ��与数据库�q�行交互。这一节的例子��展�C�如何实现。我们的例子是基于数�?讉K��对象�Q�DAO�Q�模式的�Q�它把所有与数据库（或后端数据源�Q�交互的代码包装在了一个可插入�Q�可配置的类中。同��L��Q�这一例子一样适用于其它持久性框　 �Ӟ��比如Hibernate和Cayenne�?br>关于如何�l�织数据导有几个要点�Q?br>
�?应该只有商业层与数据层交互。如果表现层�Q�前端）需要一些数据，它首先应通过商业层。这��我们的代码更�Ҏ��l�织和阅诅R�?br>�?��可能地�Q�我们应让我们的数据层无状态－我们应该在其它的地方存放客户端数据（比如�Q�web前端的session�Q�就像前面的例子�Q�。这不同于我们可以在 �q�一层做的数据缓存。两者的区别在于状态信息经常是用户定义的，而我们在数据层缓存的数据应该是整个应用共享的。这��L��层次提升了性能�?br>�?我们应该让商业逻辑军_��数据是否需要――如不需要，提取数据的调用就不应该执行�?br>
��Z��实现我们��单的数据讉K��对象�Q�我们创��Z��个新对象�Q�StockNameDao, DaoImplementation,�?DaoFactory

StockNameDao是一个定义了两个�Ҏ��的接口：getStockName()�q�回一个我们可以处理的股票名称的列�?isOnStockList()��查一个给定的股票是否在处理列表中。我们的商业层在需要这些信息时会调用这些方法�?br>
DaoImplementation是StockNameDao的一个实现。这里的数据是硬�~�码的，但我们可以通过查询数据库或通过像Bloomberg�q�样的web service提取信息�?br>
DaoFactory 我们用来生成合适的StockNameDao实例。不直接创徏对象而��用这一��骤的好处在于，它充许我们在�q�行时刻军_��使用哪一个DAO实现�Q�这是像 Spring�q�样的框架特别擅长的�Q?一个factory�Q�工厂）可以�q�回多种�c�d��的DAO(比如�Q�StockNameDao, StockPriceDao, StockHistoryDao),�q�意味着我们可以通过我们的DaoFactory,让规则自己决定需要什么数据和DAO.

�q�是StockNameDao接口�Q?br>

/**
* Defines a Data Access Object - a non data
* source specific way of obtaining data.
* 定义一个数据存取对象－一�U�非数据源获取数据的�Ҏ��
*/
public interface StockNameDao {
  /**
   * Get a list of stock names for the application
   * @return String[] array of stock names
   * 得到一个股��名字的列表
   * �q�回股票名称的String[]数组
   */
  public String [] getStockNames();

  /**
   * Check if our stock is on the list
   * ��查股��是否在列表�?br>   * @param stockName
   * @return
   */
  public boolean isOnStockList(String stockName);
}
And here's the DaoImplementation:
�q�是DaoImplementation:

/**
* Concrete Definition of a Data Access Object
* 数据存取对象的具体定�?br> */
public class DaoImplementation
                        implements StockNameDao {
  /**
   * Constructor with package level access only
   * to encourage use of factory method
   * �q�里的构造器只是让你使用工厂(factory)�Ҏ��
   */
  DaoImplementation(){}
  /**
   * Get a list of stock names for the app.
   * This is a hard coded sample
   * normally we would get this from
   * a database or other datasource.
   * 得到一个股��名字的列表�Q�这只是一个硬�~�码的例子，一般来
　 * 说我们应该从数据库或其它数据源取得数�?br>   * @return String[] array of stock names
   */
  public String[] getStockNames() {
    String[] stockNames=
      {"XYZ","ABC","MEGACORP","SOMEOTHERCOMPANY"};

    return stockNames;
  }

  /**
   * Check if our stock is on the list
   * ��查我们的股票是否在列表中
   * @param stockName
   * @return true / false as appropriate
   */
  public boolean isOnStockList(String stockName){

//Get our list of stocks
//获取股票列表
    String stockList[] = getStockNames();

    //Loop and see if our stock is on it
// done this way for clarity . not speed!
//循环看股��是否存在，�q�样做是��Z��清晰不是速度!
    for (int a=0; a        if(stockList[a].equals(stockName)){
          return true;
        }
    }

    //Default return value
    return false;
  }
}

��单的DaoFactory,只是�q�回DaoImplementation�Q?br>

package net.firstpartners.rp;
/**
* Factory Method to get the Data Access Object.
* Normally we could replace this with a
* framework like Spring or Hibernate
* 得到数据存取对象的工厂方法，通常我们可以��它替换为像Spring�?br>*  Hibernatte�q�样的框�?br> */
public class DaoFactory {
  /**
   * Get the stock name Dao
   * This sample is hardcoded - in reality
   * we would make this configurable / cache
   * instances of the Dao as appropriate
   * 得到股票名字的Dao,�q�个例子是硬�~�码的－实际上我们可以让它成�?br>　 * 可配的，�~�存的合适的Dao对象�?br>   * @return an instance of StockNameDao
   */
  public static StockNameDao getStockDao(){
        return new DaoImplementation();
  }
}

现在我们有了��单的DAO实现来作为我们的数据库层�Q�那如何��它与Drools商业层集成在一起呢�Q�最新的商业规则文�g�Q�BusinessLayer.xml��会向我们展�C�：

  xmlns="http://drools.org/rules"
  xmlns:java="http://drools.org/semantics/java"
  xmlns:xs="
        http://www.w3.org/2001/XMLSchema-instance"
  xs:schemaLocation="
        http://drools.org/rules rules.xsd
  http://drools.org/semantics/java java.xsd">



    java.lang.Object


    java.lang.String


    net.firstpartners.rp.StockOffer


    net.firstpartners.rp.DaoFactory


    net.firstpartners.rp.StockNameDao










      identifier="daoFactory">DaoFactory






    public void printStock(
      net.firstpartners.rp.StockOffer stock)
      {
          System.out.println(
          "Name:"+stock.getStockName()
          +" Price: "+stock.getStockPrice()
          +" BUY:"+stock.getRecommendPurchase());
      }







      StockOffer





      stockOffer.getStockName().equals("XYZ")


      stockOffer.getRecommendPurchase() == null


      stockOffer.getStockPrice() > 10





        stockOffer.setRecommendPurchase(
        StockOffer.NO);
        printStock(stockOffer);










      StockOffer




      stockOffer.getStockPrice() < 0




      stockOffer.setRecommendPurchase
        (StockOffer.NO);
      printStock(stockOffer);








      StockOffer




      daoFactory.getStockDao().isOnStockList(
        stockOffer.getStockName())



      stockOffer.getRecommendPurchase() == null


      stockOffer.getStockPrice() < 100



        stockOffer.setRecommendPurchase(
          StockOffer.YES);
          printStock(stockOffer);



��Z��与数据访问层集成�Q�该文�g(相对于上一��文�?有几处改变：
�?在最上面�Q�我们有几个新的来把StockNameDao, DaoImplementation, �?DaoFactory�c�d��入系�l��?br>�?我们有一个新的标�?lt;application-data>,它把DaoFactory的实例赋�l�一个变量�?lt;application-data>标记�c�M��于参敎ͼ�只不�q�它是运用于所有商业规则，而不只是一个�?br>�?“股�h��_��?#8221;的规则有一个新条�g�Q�它用DaoFactory和StockNameDao来检查股��是否在处理列表中�?br>
�?们又一�ơ运行BusinessRulesTest(模拟�?。模拟单元测试没有问题，既��我们改变了程序的�l�构�Q�我们仍然没有改变它在做什么。从输出的日志来看，我们可以看到我们的商业规则��用StockNameDao作�ؓ他们评估的一部䆾�Q��ƈ�?DaoImplementation.isOnStockList()被调用了�?br>虽然�q�个例子展示的是从数据源��d��信息�Q�其实写信息也是一��L��?理。如果某个规则决定应该做的话。区别在于我们的DAO��会有一些setSomeInformation()的方法，一旦条件满��I��q�个�Ҏ��会在商业规则的部分被调用�?br>
�ȝ��
�q?��文章中�Q�我们展�C�Z��大多数Java服务器端的应用有的三层：表现层，商业逻辑层和数据持久化层。当框架被广泛地使用在表现层和持久层中，直到目前为止�q?没有框架可以包装低��的商业逻辑。就像我们在�q�些例子中看的，Drools和JSR-94是降低java应用复杂度，提高开发速度的理惛_��选者。我希望�q?些例�E�能鼓励你去�q�一步接�q�规则引擎，他们��会��Z��的应用的开发和�l�护节省不少旉��?br>资源
�?本文的范例代�?/font>
�?Drools��目主页
�?[ur=http://www.jroller.com/page/eu/20040810]Drools规则的信息[/url]
�?"Introduction to Drools and Rule Engines," Drools��目�l�提�?/font>
�?Drools规则的schema文�g
�?JSR-94: Java规则引擎概述
�?Struts框架主页
�?Spring框架主页
�?Hibernate主页
�?JUnit��试框架
�?
�?[url=http://herzberg.ca.sandia.gov/jess/index.shtml]Jena语义与规则引�?/font>
�?JSR-94主页
�?Jess in Action主页
�?"Business Rule Thinking" (��Z��Jess)
�?a target=_new>规则�pȝ��的概�q?/font>
�?"Jess implementation of the Rete algorithm"

Paul Browne 已经�?FirstPartners.net在企业��Java应用斚w��作了差不�?�q�的��N��

junky 2007-06-27 18:09 发表评论