在你的企業級java應用中使用Drools

什麼是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顯示了這樣的一個應用


圖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框架集成使用。

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對象來保存過去以來的數據。

下一步，如果用戶改變了一些值，我們更新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接口：

/**
 * 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來檢查股票是否在處理列表中。

我們又一次運行BusinessRulesTest(模擬器)。模擬單元測試沒有問題，既使我們改變了程序的結構，我們仍然沒有改變它在做什麼。從輸出的日誌來看，我們可以看到我們的商業規則使用StockNameDao作爲他們評估的一部份，並且DaoImplementation.isOnStockList()被調用了。
雖然這個例子展示的是從數據源讀取信息，其實寫信息也是一樣的原理。如果某個規則決定應該做的話。區別在於我們的DAO將會有一些setSomeInformation()的方法，一旦條件滿足，這個方法將會在商業規則的<java:consequence>部分被調用。

總結
這篇文章中，我們展示了大多數Java服務器端的應用有的三層：表現層，商業邏輯層和數據持久化層。當框架被廣泛地使用在表現層和持久層中，直到目前爲止還沒有框架可以包裝低級的商業邏輯。就像我們在這些例子中看的，Drools和JSR-94是降低java應用複雜度，提高開發速度的理想候選者。我希望這些例程能鼓勵你去進一步接近規則引擎，他們將會爲你的應用的開發和維護節省不少時間。
資源
● 本文的範例代碼
● Drools項目主頁
● [ur=http://www.jroller.com/page/eu/20040810]Drools規則的信息[/url]
● "Introduction to Drools and Rule Engines," Drools項目組提供
● Drools規則的schema文件
● JSR-94: Java規則引擎概述
● Struts框架主頁
● Spring框架主頁
● Hibernate主頁
● JUnit測試框架
●
● [url=http://herzberg.ca.sandia.gov/jess/index.shtml]Jena語義與規則引擎
● JSR-94主頁
● Jess in Action主頁
● "Business Rule Thinking" (基於Jess)
●規則系統的概述
● "Jess implementation of the Rete algorithm"

作者：Paul Browne 翻譯：simmone
原文地址:
http://www.onjava.com/pub/a/onjava/2005/08/24/drools.html


Paul Browne 已經爲 FirstPartners.net在企業級Java應用方面作了差不多7年的顧問