学步园

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");
  }
}

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

/**
 * 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;       
  }
}

简单的DaoFactory,只是返回DaoImplementation：

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();
  }
}

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

<?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>

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

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