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行为示例
 */
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取得以前的数据
    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      
//这些数据是与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
//调用商业层
    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");
  }
}

/**
 * Defines a Data Access Object - a non data 
 * source specific way of obtaining data.
 * 定义一个数据存取对象－一种非数据源获取数据的方法
 */ 
public interface StockNameDao {
  /**
   * Get a list of stock names for the application 
   * @return String[] array of stock names
   * 得到一个股票名字的列表
   * 返回股票名称的String[]数组
   */
  public String [] getStockNames();
        
  /**
   * Check if our stock is on the list
   * 检查股票是否在列表中
   * @param stockName
   * @return
   */
  public boolean isOnStockList(String stockName);
}
And here's the DaoImplementation:
这是DaoImplementation:

/**
 * Concrete Definition of a Data Access Object 
 * 数据存取对象的具体定义
 */ 
public class DaoImplementation
                        implements StockNameDao {
  /**
   * Constructor with package level access only 
   * to encourage use of factory method
   * 这里的构造器只是让你使用工厂(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.
   * 得到一个股票名字的列表，这只是一个硬编码的例子，一般来
　 * 说我们应该从数据库或其它数据源取得数据
   * @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!
//循环看股票是否存在，这样做是为了清晰不是速度!
    for (int a=0; a<stockList.length;a++){
        if(stockList[a].equals(stockName)){
          return true;
        }
    }
                
    //Default return value
    return false;       
  }
}

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或
*  Hibernatte这样的框架
 */
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,这个例子是硬编码的－实际上我们可以让它成为
　 * 可配的，缓存的合适的Dao对象。
   * @return an instance of StockNameDao
   */
  public static StockNameDao getStockDao(){
        return new DaoImplementation();
  }
}

<?xml version="1.0"?>
<rule-set name="BusinessRulesSample"
  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">
  <!-- Import the Java Objects that 
                        we refer to in our rules --> 
<!-- 导入规则中使用的对象 -->
  <java:import>
    java.lang.Object
  </java:import>
  <java:import>
    java.lang.String
  </java:import>
  <java:import>
    net.firstpartners.rp.StockOffer
  </java:import>
  <java:import>
    net.firstpartners.rp.DaoFactory
  </java:import>
  <java:import>
    net.firstpartners.rp.StockNameDao
  </java:import>
  <!-- Application Data not associated -->
  <!-- with any particular rule -->
  <!-- In this case it's our factory -->
  <!-- object which gives us back -->
  <!-- a handle to whatever Dao (Data -->
  <!-- access object) that we need -->
  <!-- 没有和任何规则联系的应用数据，这里是我们的工厂对象，-->
  <!—它向我们提供向后的操作,告诉我们什么Dao 是我们需要的。-->

  <application-data 
    identifier="daoFactory">DaoFactory
  </application-data>
  <!-- A Java (Utility) function -->
 <!-- 一个Java方法 -->
  <!-- we reference in our rules -->   
  <!-- 在我们的规则中打印跟踪信息 -->    
  <java:functions>
    public void printStock(
      net.firstpartners.rp.StockOffer stock)
      {
          System.out.println(
          "Name:"+stock.getStockName()
          +" Price: "+stock.getStockPrice()     
          +" BUY:"+stock.getRecommendPurchase());
      } 
  </java:functions>
  <!-- Check for XYZ Corp-->   
<!-- 检查XYZ公司 -->    
  <rule name="XYZCorp" salience="-1">
    <!-- Parameters we can pass into--> 
<!-- the business rule -->
<!-- 可以传入规则中的参数 -->
    <parameter identifier="stockOffer">
      <class>StockOffer</class>
    </parameter">
    <!-- Conditions that must be met for -->
<!-- business rule to fire -->   
<!-- 激活规则必须满足的条件 -->      
    <java:condition>
      stockOffer.getStockName().equals("XYZ")
    </java:condition> 
    <java:condition>
      stockOffer.getRecommendPurchase() == null
    </java:condition>
    <java:condition>
      stockOffer.getStockPrice() > 10
    </java:condition>
        
    <!-- What happens when the business -->
<!-- rule is activated -->
<!-- 规则激活后执行的步骤 -->
    <java:consequence>
        stockOffer.setRecommendPurchase(
        StockOffer.NO); 
        printStock(stockOffer);
    </java:consequence>
  </rule>
  <!-- Ensure that negative prices -->
  <!-- are not accepted -->  
  <!-- 确定负数不被接受 -->     
  <rule name="Stock Price Not Negative">
    <!-- Parameters we can pass into the -->
<!-- business rule -->
<!-- 可以传入规则中的参数 -->   
    <parameter identifier="stockOffer">
      <class>StockOffer</class>
    </parameter>
<!-- Conditions for rule to fire -->
<!-- 激活规则必须满足的条件 -->    
    <java:condition>
      stockOffer.getStockPrice() < 0
    </java:condition>
  
<!--When rule is activated then ... -->
<!-- 规则激活后执行的步骤 -->
    <java:consequence>
      stockOffer.setRecommendPurchase
        (StockOffer.NO);        
      printStock(stockOffer);
    </java:consequence>
  </rule>
  <!-- Check for Negative Prices-->   
<!-- 寻找低价 -->     
  <rule name="Stock Price Low Enough">
  <!-- Parameters for the rule -->
<!-- 可以传入规则中的参数 -->
    <parameter identifier="stockOffer">
      <class>StockOffer</class>
    </parameter>
    
<!-- Now uses Dao to get stock list -->
<!-- 现在使用Dao获取股票列表 -->
    <java:condition>
      daoFactory.getStockDao().isOnStockList(
        stockOffer.getStockName())
    </java:condition>
        
    <java:condition>
      stockOffer.getRecommendPurchase() == null
    </java:condition>
    <java:condition>
      stockOffer.getStockPrice() < 100
    </java:condition>
<!-- When rule is activated do this -->
<!-- 规则激活后执行的步骤 -->
    <java:consequence>
        stockOffer.setRecommendPurchase(
          StockOffer.YES);      
          printStock(stockOffer);
    </java:consequence>
  </rule>
</rule-set>

if ((user.isMemberOf(AdministratorGroup)
      && user.isMemberOf(teleworkerGroup))
     || user.isSuperUser(){      
         // 更多对特殊案例的检查
         if((expenseRequest.code().equals("B203")
           ||(expenseRequest.code().equals("A903")
                        &&(totalExpenses<200)
                &&(bossSignOff> totalExpenses))
           &&(deptBudget.notExceeded)) {
               //付款
           } else if {
               //检查许多其他的条件
           }
} else {
     //更多商务逻辑
}

import junit.framework.TestCase;
/*
 * 应用中商务规则的JUnit测试
        * 这也扮演商务规则的“模拟器“-让我们说明输入，检验输出；并在代码发*布前看看是否达到我的期望值。
*/
public class BusinessRuleTest extends TestCase {
/**
*股票购买测试
*/
  public void testStockBuy() throws Exception{
                
//用模拟值创建股票
    StockOffer testOffer = new StockOffer();
    testOffer.setStockName("MEGACORP");
    testOffer.setStockPrice(22);
    testOffer.setStockQuantity(1000);
                
//运行规则
    BusinessLayer.evaluateStockPurchase(testOffer);
                
        //达到我们的期望吗？
    assertTrue(
      testOffer.getRecommendPurchase()!=null);
    
    assertTrue("YES".equals(
      testOffer.getRecommendPurchase()));               
   }
}

/**
*示例商务逻辑的正面
*这个简单示例里，所有的商务逻辑都包含在一个类中。
*但在现实中，按需要代理给其他的类。
*/
public class BusinessLayer {

        /**
   *评价购买这支股票是否是个好主意
   *@参数 stockToBuy
   *@return 如果推荐购买股票返回真，否则返回假
   */
  public static void evaluateStockPurchase
    (StockOffer stockToBuy){
                return false;
  }
}
StockOffer类如下所示：
/**
* 简单的JavaBean保存StockOffer值。
* 一个’股票出价’就是别人卖出股票（公司股份）所给出的价格。
*/
public class StockOffer {
        
  //常量
  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;

/**
   * @返回股票名称
   */

  public String getStockName() {
        return stockName;
  }
/**
   * @参数 stockName 设置股票名称.
   */
  public void setStockName(String stockName) {
        this.stockName = stockName;
  }
/**
   * @return 返回股票价格.
   */

  public int getStockPrice() {
        return stockPrice;
  }
/**
   * @参数 stockPrice设置股票价格.
   */

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

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

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

  public String getRecommendPurchase() {
        return recommendPurchase;
  }
}

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;
/**
*示例商务逻辑的正面
*这个简单示例里，所有的商务逻辑都包含在一个类中。
*但在现实中，按需要代理给其他的类。
*@作者 缺省
*/
public class BusinessLayer {
//包含规则文件的名字
  private static final String BUSINESS_RULE_FILE=
                              "BusinessRules.drl";
        //内部处理的规则基础
  private static RuleBase businessRules = null;
/**
* 如果还没有装载商务规则的话就装载它。
*@抛出异常 -通常从这里恢复
*/
  private static void loadRules()
                       throws Exception{
    if (businessRules==null){
      businessRules = RuleBaseLoader.loadFromUrl(
          BusinessLayer.class.getResource(
          BUSINESS_RULE_FILE ) );
    }
  }     
        
/**
   *评价是否购买这支股票
   *@参数 stockToBuy
   *@return 如果推荐购买股票返回真，否则返回假
   *@抛出异常
   */
  public static void evaluateStockPurchase
       (StockOffer stockToBuy) throws Exception{
                
//确保商务规则被装载
    loadRules();
//一些程序进行的日志
    System.out.println( "FIRE RULES" );
    System.out.println( "----------" );
        //了解以前运行的状态
    WorkingMemory workingMemory 
            = businessRules.newWorkingMemory();
//小规则集可以添加调试侦听器
    workingMemory.addEventListener(
      new DebugWorkingMemoryEventListener());
        //让规则引擎了解实情
    workingMemory.assertObject(stockToBuy);
        //让规则引擎工作
    workingMemory.fireAllRules();
  }
}

<?xml version="1.0"?>
<rule-set name="BusinessRulesSample"
  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">
  <!-- Import the Java Objects that we refer 
                          to in our rules -->        
  <java:import>
    java.lang.Object
  </java:import>
  <java:import>
    java.lang.String
  </java:import>
  <java:import>
    net.firstpartners.rp.StockOffer
  </java:import>
  <!-- A Java (Utility) function we reference 
    in our rules-->  
  <java:functions>
    public void printStock(
      net.firstpartners.rp.StockOffer stock)
        {
        System.out.println("Name:"
          +stock.getStockName()
          +" Price: "+stock.getStockPrice()     
          +" BUY:"
          +stock.getRecommendPurchase());
        }
  </java:functions>
<rule-set>
  <!-- Ensure stock price is not too high-->      
  <rule name="Stock Price Low Enough">
    <!-- Params to pass to business rule -->
    <parameter identifier="stockOffer">
      <class>StockOffer</class>
    </parameter>
    <!-- Conditions or 'Left Hand Side' 
        (LHS) that must be met for 
         business rule to fire -->
    <!-- note markup -->
    <java:condition>
      stockOffer.getRecommendPurchase() == null
    </java:condition>
    <java:condition>
      stockOffer.getStockPrice() < 100
    </java:condition>
    <!-- What happens when the business 
                      rule is activated -->
    <java:consequence>
        stockOffer.setRecommendPurchase(
                              StockOffer.YES);  
          printStock(stockOffer);
    </java:consequence>
  </rule>
</rule-set>

/**
*测试买股票确保系统不接受负值
*/
  public void testNegativeStockBuy() 
                                throws Exception{
//用模拟值创建股票
      StockOffer testOffer = new StockOffer();
        testOffer.setStockName("MEGACORP");
        testOffer.setStockPrice(-22);
        testOffer.setStockQuantity(1000);
//运行规则
        BusinessLayer
              .evaluateStockPurchase(testOffer);
//是否达到我们的期望？
        assertTrue("NO".equals(
          testOffer.getRecommendPurchase()));
}

<!-- Ensure that negative prices 
                            are not accepted-->      
  <rule name="Stock Price Not Negative">
    <!-- Parameters we can pass into 
                          the business rule -->
    <parameter identifier="stockOffer">
      <class>StockOffer</class>
    </parameter>
    <!-- Conditions or 'Left Hand Side' (LHS) 
       that must be met for rule to fire -->
    <java:condition>
      stockOffer.getStockPrice() < 0
    </java:condition>
    <!-- What happens when the business rule 
                              is activated -->
    <java:consequence>
      stockOffer.setRecommendPurchase(
                                  StockOffer.NO);       
      printStock(stockOffer);
    </java:consequence>
  </rule>

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

/**
*确保系统系统在XYZ公司股价便宜时就购买他们的股票
*/
public void testXYZStockBuy() throws Exception{
//用模拟值创建股票
  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);
//运行规则
  BusinessLayer.evaluateStockPurchase(
    testOfferLow);
  assertTrue("YES".equals(
    testOfferLow.getRecommendPurchase()));
                
  BusinessLayer.evaluateStockPurchase(
    testOfferHigh);
  assertTrue("NO".equals(
    testOfferHigh.getRecommendPurchase()));             
}

<rule name="XYZCorp" salience="-1">
   <!-- Parameters we pass to rule -->
   <parameter identifier="stockOffer">
     <class>StockOffer</class>
   </parameter>
    
   <java:condition>
     stockOffer.getStockName().equals("XYZ")
   </java:condition> 
   <java:condition>
     stockOffer.getRecommendPurchase() == null
   </java:condition>
   <java:condition>
     stockOffer.getStockPrice() > 10
   </java:condition>
        
   <!-- What happens when the business 
                                rule is activated -->
   <java:consequence> 
     stockOffer.setRecommendPurchase(
       StockOffer.NO);  
     printStock(stockOffer);
   </java:consequence>
  </rule>

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

　　复杂企业级项目的开发以及其中随外部条件不断变化的业务规则(business logic),迫切需要分离商业决策者的商业决策逻辑和应用开发者的技术决策，并把这些商业决策放在中心数据库或其他统一的地方，让它们能在运行时（即商务时间）可以动态地管理和修改从而提供软件系统的柔性和适应性。规则引擎正是应用于上述动态环境中的一种解决方法。

　　本文第一部分简要介绍了规则引擎的产生背景和基于规则的专家系统，第二部分介绍了什么是规则引擎及其架构和算法，第三部分介绍了商业产品和开源项目实现等各种Java规则引擎，第四部分对Java规则引擎API（JSR-94）作了详细介绍，讲解了其体系结构，管理API和运行时API及相关安全问题，第五部分则对规则语言及其标准化作了探讨，第六部分给出了一个使用Java规则引擎API的简单示例，第七部分给予小结和展望。

　　1、 介绍

　　1.1 规则引擎产生背景

　　企业管理者对企业级IT系统的开发有着如下的要求：(1)为提高效率，管理流程必须自动化，即使现代商业规则异常复杂(2)市场要求业务规则经常变化，IT系统必须依据业务规则的变化快速、低成本的更新(3)为了快速、低成本的更新，业务人员应能直接管理IT系统中的规则，不需要程序开发人员参与。

　　而项目开发人员则碰到了以下问题:(1)程序=算法+数据结构，有些复杂的商业规则很难推导出算法和抽象出数据模型(2)软件工程要求从需求->设计->编码，然而业务规则常常在需求阶段可能还没有明确，在设计和编码后还在变化，业务规则往往嵌在系统各处代码中(3)对程序员来说，系统已经维护、更新困难，更不可能让业务人员来管理。

　　基于规则的专家系统的出现给开发人员以解决问题的契机。规则引擎由基于规则的专家系统中的推理引擎发展而来。下面简要介绍一下基于规则的专家系统。

　　1.2 基于规则的专家系统(RBES)

　　专家系统是人工智能的一个分支，它模仿人类的推理方式，使用试探性的方法进行推理，并使用人类能理解的术语解释和证明它的推理结论。专家系统有很多分类：神经网络、基于案例推理和基于规则系统等。

　　RBES包括三部分：Rule Base（knowledge base）、Working Memory（fact base）和Inference Engine（推理引擎）。它们的结构如下所示：

　　图1.基于规则的专家系统组成

　　如上图所示，推理引擎包括三部分：Pattern Matcher、Agenda和Execution Engine。Pattern Matcher何时执行哪个规则；Agenda管理PatternMatcher挑选出来的规则的执行次序；Execution Engine负责执行规则和其他动作。

　　推理引擎通过决定哪些规则满足事实或目标，并授予规则优先级，满足事实或目标的规则被加入议程。存在两者推理方式：演绎法（Forward-Chaining正向链）和归纳法（Backward-Chaining反向链）。演绎法从一个初始的事实出发，不断地应用规则得出结论（或执行指定的动作）。而归纳法则是从假设出发，不断地寻找符合假设的事实。

　　2、 规则引擎

　　2.1 业务规则
　
　　一个业务规则包含一组条件和在此条件下执行的操作，它们表示业务规则应用程序的一段业务逻辑。业务规则通常应该由业务分析人员和策略管理者开发和修改，但有些复杂的业务规则也可以由技术人员使用面向对象的技术语言或脚本来定制。业务规则的理论基础是:设置一个或多个条件，当满足这些条件时会触发一个或多个操作。

　　2.2 规则引擎

　　什么是规则引擎？规则引擎是如何执行规则的？这可以称之为"什么"与"如何"的问题。到底规则引擎是什么还是目前业界一个比较有争议的问题，在JSR-94种也几乎没有定义。可以这样认为充分定义和解决了"如何"的问题，"什么"问题本质上也迎刃而解。也许这又是一种"先有蛋还是先有鸡"哲学争论。今后标准规则语言的定义和推出及相关标准的制定应该可以给这样的问题和争论划上一个句号。本文中，暂且这样述说什么是规则引擎：规则引擎由推理引擎发展而来，是一种嵌入在应用程序中的组件，实现了将业务决策从应用程序代码中分离出来，并使用预定义的语义模块编写业务决策。接受数据输入，解释业务规则，并根据规则做出业务决策。

　　2.3 规则引擎的使用方式

　　由于规则引擎是软件组件，所以只有开发人员才能够通过程序接口的方式来使用和控制它，规则引擎的程序接口至少包含以下几种API：加载和卸载规则集的API；数据操作的API；引擎执行的API。开发人员在程序中使用规则引擎基本遵循以下5个典型的步骤：创建规则引擎对象；向引擎中加载规则集或更换规则集；向引擎提交需要被规则集处理的数据对象集合；命令引擎执行;导出引擎执行结果，从引擎中撤出处理过的数据。使用了规则引擎之后，许多涉及业务逻辑的程序代码基本被这五个典型步骤所取代。

　　一个开放的业务规则引擎应该可以"嵌入"在应用程序的任何位置，不同位置的规则引擎可以使用不同的规则集，用于处理不同的数据对象。此外，对使用引擎的数量没有限制。

　　2.4 规则引擎架构与推理

　　规则引擎的架构如下图所示：

　　图2. 业务规则引擎架构

　　规则引擎的推理步骤如下：a. 将初始数据（fact）输入至工作内存(Working Memory)。b. 使用Pattern Matcher将规则库(Rules repository)中的规则（rule）和数据（fact）比较。c. 如果执行规则存在冲突（conflict），即同时激活了多个规则，将冲突的规则放入冲突集合。d. 解决冲突，将激活的规则按顺序放入Agenda。e. 执行Agenda中的规则。重复步骤b至e，直到执行完毕Agenda中的所有规则。

　　任何一个规则引擎都需要很好地解决规则的推理机制和规则条件匹配的效率问题。

　　当引擎执行时，会根据规则执行队列中的优先顺序逐条执行规则执行实例，由于规则的执行部分可能会改变工作区的数据对象，从而会使队列中的某些规则执行实例因为条件改变而失效，必须从队列中撤销，也可能会激活原来不满足条件的规则，生成新的规则执行实例进入队列。于是就产生了一种"动态"的规则执行链，形成规则的推理机制。这种规则的"链式"反应完全是由工作区中的数据驱动的。

　　规则条件匹配的效率决定了引擎的性能，引擎需要迅速测试工作区中的数据对象，从加载的规则集中发现符合条件的规则，生成规则执行实例。1982年美国卡耐基·梅隆大学的Charles L. Forgy发明了一种叫Rete算法，很好地解决了这方面的问题。目前世界顶尖的商用业务规则引擎产品基本上都使用Rete算法。

　　2.5 规则引擎的算法
　
　　大部分规则引擎产品的算法，基本上都来自于Dr. Charles Forgy在1979年提出的RETE算法及其变体，Rete算法是目前效率最高的一个Forward-Chaining推理算法，Drools项目是Rete算法的一个面向对象的Java实现，Rete算法其核心思想是将分离的匹配项根据内容动态构造匹配树，以达到显著降低计算量的效果。

　　3、 Java规则引擎
　
　　目前主流的规则引擎组件多是基于Java和C++程序语言环境，已经有多种Java规则引擎商业产品与开源项目的实现，其中有的已经支持JSR94，有的正朝这个方向做出努力，列出如下：

　　3.1 Java规则引擎商业产品

　　Java规则引擎商业产品主要有（Jess不是开源项目，它可以免费用于学术研究，但用于商业用途则要收费）：

　　3.2 Java规则引擎开源项目

　　开源项目的实现主要包括：

　　Drools - Drools规则引擎应用Rete算法的改进形式Rete-II算法。从内部机制上讲，它使用了和Forgy的算法相同的概念和方法，但是增加了可与面向对象语言无缝连接的节点类型。

　　Mandarax 基于反向推理（归纳法）。能够较容易地实现多个数据源的集成。例如，数据库记录能方便地集成为事实集(facts sets)，reflection用来集成对象模型中的功能。目前不支持JSR 94

　　OFBiz Rule Engine - 支持归纳法(Backward chaining).最初代码基于Steven John Metsker的"Building Parsers in Java"，不支持JSR 94

　　JLisa - JLisa是用来构建业务规则的强大框架，它有着扩展了LISP优秀特色的优点,比Clips还要强大.这些特色对于多范例软件的开发是至关重要的.支持JSR 94

　　其它的开源项目实现有诸如Algernon, TyRuBa, JTP, JEOPS, InfoSapient, RDFExpert, Jena 2, Euler, JLog, Pellet OWL Reasoner, Prova, OpenRules, SweetRules, JShop2等等。

　　4、 Java规则引擎API(JSR-94)

　　4.1 简介

　　过去大部分的规则引擎开发并没有规范化，有其自有的API，这使得其与外部程序交互集成不够灵活。转而使用另外一种产品时往往意味需要重写应用程序逻辑和API调用，代价较大。规则引擎工业中标准的缺乏成为令人关注的重要方面。2003年11月定稿并于2004年8月最终发布的JSR 94（Java规则引擎API）使得Java规则引擎的实现得以标准化。

　　Java规则引擎API由javax.rules包定义，是访问规则引擎的标准企业级API。Java规则引擎API允许客户程序使用统一的方式和不同厂商的规则引擎产品交互，就像使用JDBC编写独立于厂商访问不同的数据库产品一样。Java规则引擎API包括创建和管理规则集合的机制，在Working Memory中添加，删除和修改对象的机制，以及初始化，重置和执行规则引擎的机制。

　　4.2 简介Java规则引擎API体系结构

　　Java规则引擎API分为两个主要部分:运行时客户API(the Runtime client API)和规则管理API(the rules administration API)。

　　4.2.1规则管理API

　　规则管理API在javax.rules.admin中定义,包括装载规则以及与规则对应的动作(执行集 execution sets)以及实例化规则引擎。规则可以从外部资源中装载,比如说URI,Input streams, XML streams和readers等等.同时管理API提供了注册和取消注册执行集以及对执行集进行维护的机制。使用admin包定义规则有助于对客户访问运行规则进行控制管理,它通过在执行集上定义许可权使得未经授权的用户无法访问受控规则。

　　管理API使用类RuleServiceProvider来获得规则管理(RuleAdministrator)接口的实例.规则管理接口提供方法注册和取消注册执行集.规则管理器(RuleAdministrator)提供了本地和远程的RuleExecutionSetProvider.在前面已提及,RuleExecutionSetProvider负责创建规则执行集.规则执行集可以从如XML streams, input streams等来源中创建.这些数据来源及其内容经汇集和序列化后传送到远程的运行规则引擎的服务器上.大多数应用程序中,远程规则引擎或远程规则数据来源的情况并不多见.为了避免这些情况中的网络开销,API规定了可以从运行在同一JVM中规则库中读取数据的本地RuleExecutionSetProvider.

　　规则执行集接口除了拥有能够获得有关规则执行集的方法,还有能够检索在规则执行集中定义的所有规则对象.这使得客户能够知道规则集中的规则对象并且按照自己需要来使用它们。

　　4.2.2 运行时API

　　运行时API定义在javax.rules包中,为规则引擎用户运行规则获得结果提供了类和方法。运行时客户只能访问那些使用规则管理API注册过的规则，运行时API帮助用户获得规则对话并且在这个对话中执行规则。

　　运行时API提供了对厂商规则引擎API实现的类似于JDBC的访问方法.规则引擎厂商通过类RuleServiceProvider(类RuleServiceProvider提供了对具体规则引擎实现的运行时和管理API的访问)将其规则引擎实现提供给客户,并获得RuleServiceProvider唯一标识规则引擎的URL.

　　URL推荐标准用法是使用类似"com.mycompany.myrulesengine.rules.RuleServiceProvider"这样的Internet域名空间,这将有助于访问URL的唯一性.类RuleServiceProvider内部实现了规则管理和运行时访问所需的接口.所有的RuleServiceProvider要想被客户所访问都必须用RuleServiceProviderManager进行注册。注册方式类似于JDBC API的DriverManager和Driver。

　　运行时接口是运行时API的关键部分.运行时接口提供了用于创建规则会话(RuleSession)的方法,规则会话如前所述是用来运行规则的.运行时API同时也提供了访问在service provider注册过的所有规则执行集(RuleExecutionSets).规则会话接口定义了客户使用的会话的类型,客户根据自己运行规则的方式可以选择使用有状态会话或者无状态会话。

　　无状态会话的工作方式就像一个无状态会话bean.客户可以发送单个输入对象或一列对象来获得输出对象.当客户需要一个与规则引擎间的专用会话时,有状态会话就很有用.输入的对象通过addObject() 方法可以加入到会话当中.同一个会话当中可以加入多个对象.对话中已有对象可以通过使用updateObject()方法得到更新.只要客户与规则引擎间的会话依然存在,会话中的对象就不会丢失。

　　RuleExecutionSetMetaData接口提供给客户让其查找规则执行集的元数据(metadata).元数据通过规则会话接口(RuleSession Interface)提供给用户。

　　使用运行时Runtime API的代码片断如下所示:

　　4.3 Java规则引擎API安全问题
　　
　　规则引擎API将管理API和运行时API加以分开,从而为这些包提供了较好粒度的安全控制.规则引擎API并没有提供明显的安全机制,它可以和J2EE规范中定义的标准安全API联合使用.安全可以由以下机制提供,如Java authentication and authorization service (JAAS),the Java cryptography extension (JCE),Java secure Socket Extension (JSSE),或者其它定制的安全API.JAAS能被用来定义规则执行集的许可权限,从而只有授权用户才能访问。

　　4.4 异常与日志

　　规则引擎API定义了javax.rules.RuleException作为规则引擎异常层次的根类.所有其它异常都继承于这个根类.规则引擎中定义的异常都是受控制的异常(checked exceptions),所以捕获异常的任务就交给了规则引擎。规则引擎API没有提供明确的日志机制,但是它建议将Java Logging API用于规则引擎API。

　　4.5 JSR 94 小结

　　JSR 94 为规则引擎提供了公用标准API,仅仅为实现规则管理API和运行时API提供了指导规范,并没有提供规则和动作该如何定义以及该用什么语言定义规则,也没有为规则引擎如何读和评价规则提供技术性指导.JSR 94规范将上述问题留给了规则引擎的厂商.在下一节我将简要介绍一下规则语言。

　　5、 规则语言

　　JSR 94中没有涉及用来创建规则和动作的语言.规则语言是规则引擎应用程序的重要组成部分,所有的业务规则都必须用某种语言定义并且存储于规则执行集中,从而规则引擎可以装载和处理他们。

　　由于没有关于规则如何定义的公用规范,市场上大多数流行的规则引擎都有其自己的规则语言，目前便有许多种规则语言正在应用，因此，当需要将应用移植到其他的Java规则引擎实现时，可能需要变换规则定义，如将Drools私有的DRL规则语言转换成标准的ruleML，Jess规则语言转换成ruleML等。这个工作一般由XSLT转换器来完成。

　　多种规则语言的使用使得不同规则引擎实现之间的兼容性成为问题.通用的规则引擎API或许可以减轻不同厂家API之间的问题,但公用规则语言的缺乏将仍然阻碍不同规则引擎实现之间的互操作性.尽管业界在提出公用规则语言上做出了一些努力, 比如说RuleML,SRML的出现,但距离获得绝大部分规则引擎厂商同意的公用标准还有很长的路要走。

　　6、 Java规则引擎API使用示例

　　6.1 设置规则引擎

　　Java规则引擎的管理活动阶段开始于查找一个合适的javax.rules.RuleServiceProvider对象，这个对象是应用程序访问规则引擎的入口。在J2EE环境中，你可能可以通过JNDI获得RuleServiceProvider。否则，你可以使用javax.rules.RuleServiceProviderManager类：

　　拥有了RuleServiceProvider对象，你就可以获得一个javax.rules.admin.RuleAdministrator类。从RuleAdministrator类中，你可以得到一个RuleExecutionSetProvider，从类名可以知道，它用于创建javax.rules.RuleExecutionSets对象。RuleExecutionSet基本上是一个装入内存的，准备好执行的规则集合。

　　包javax.rules.admin包括两个不同的RuleExecutionSetProvider类。RuleExecutionSetProvider类本身包括了从Serializable对象创建RuleExecutionSets的方法，因此在规则引擎位于远程服务器的情况下，仍然可以使用RuleExecutionSetProvider类，构造器的参数可以通过RMI来传递。另一个类是LocalRuleExecutionSetProvider，包含了其他方法，用于从非Serializable资源（如java.io.Reader－本地文件）创建RuleExectionSets。假设拥有了一个RuleServiceProvider对象，你可以从本地文件rules.xml文件创建一个RuleExectionSet对象。如以下的代码所示：

　　接下来，你可以使用RuleAdministrator注册获得的RuleExecutionSet，并给它分配一个名称。在运行时，你可以用同一个名称创建一个RuleSession；该RuleSession使用了这个命名的RuleExecutionSet。参见下面的用法：admin.registerRuleExecutionSet("rules", ruleSet, properties);

　　6.2 执行规则引擎

　　在运行时阶段，你可以参见一个RuleSession对象。RuleSession对象基本上是一个装载了特定规则集合的规则引擎实例。你从RuleServiceProvider得到一个RuleRuntime对象，接下来，从javax.rules.RuleRuntime得到RuleSession对象。

　　RuleSession分为两类：stateful和stateless。它们具有不同的功能。StatefulRuleSession的Working Memory能够在多个方法调用期间保存状态。你可以在多个方法调用期间在Working Memory中加入多个对象，然后执行引擎，接下来还可以加入更多的对象并再次执行引擎。相反，StatelessRuleSession类是不保存状态的，为了执行它的executeRules方法，你必须为Working Memory提供所有的初始数据，执行规则引擎，得到一个内容列表作为返回值。

　　下面的例子中，我们创建一个StatefulRuleSession实例，添加两个对象（一个Integer和一个String）到Working Memory，执行规则，然后得到Working Memory中所有的内容，作为java.util.List对象返回。最后，我们调用release方法清理RuleSession：

　　7、 结束语

　　Java规则引擎API(JSR-94)允许客户程序使用统一的方式和不同厂商的规则引擎产品交互，一定程度上给规则引擎厂商提供了标准化规范。但其几乎没有定义什么是规则引擎，当然也没有深入到规则是如何构建和操纵的，规则调用的效用，规则与Java语言的绑定等方面。并且JSR-94在对J2EE的支持上也不足。规则语言的标准化，JSR-94的进一步的充实深化都有待研究

当然我不知道他们公司是怎么想的，不过我想在中国想找真正3-4年工作经验的.Net开发人员恐怕基本上找不到，就是找到几个恐怕也有一大半是吹的。因为.Net从成型到现在估计也就3到4年时间（可能还不到）。更不要说大规模开始应用了。

以前还看过一个招聘高级J2EE工程师的广告，当然了，“高级”就是不一样，要求至少有5－6年J2EE开发经验。而大家当然都知道，6年前的1999年，J2EE才刚刚诞生。

我记得毕业时候看那些公司的招聘广告，都是牛得不得了，恨不得把所有的条件都列上。英语要n级，要懂这个懂那个，什么c++,c,rup,oracle,sql server,linux,unix之类，反正是能想到的东西都要懂，地球上存在地东西都要会。我当时看着那么多的招聘广告，觉得自己没有几个能够得上人家的标准的。问问身边认识的人，好像也没有几个能够得上这样的标准。

其实我们当然知道，这些都只是夸张而已。招聘的在招聘广告上掺水，应聘的在简历上掺水。等到大家真的互相了解了，对视嘿嘿一笑，什么n多的神技就如浮云般飘散。

只是我有时候真不知道，这样是好还是坏。