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

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>