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);
联系客服