试用JBoss Rules

前言

这两天研究了一下JBoss Rules，最大的感觉是JBoss Rules的文档写得不错，而且Eclipse IDE插件的功能也挺不错，相比JBoss JBPM好多了。

个人觉得规则引擎就是把一堆if/else逻辑从业务代码转移到配置文件中，这样如果业务规则发生变化就不用更改代码，而且如果描述这种规则的语言 足够清晰明白，更改业务规则的任务就可以由业务人员来完成了，Domain Specific Language就是来干这事的。

JBoss Rules的内部机制，这里就不再详细介绍了，已经有先行者对JBoss Rules的参考手册进行了整理，参见www.blogjava.net/guangnian0412/category/11762.html 。

我针对一个实际的业务场景写了一个例子，应用场景是这样的，一个汽车网的销售人员的提成有一定的规则，大致的规则根据售出价格的折扣来决定提成比例，比如如果10000元的广告服务，最后售出价格是4500，销售人员的提成是0.3%。

创建工程

假定已经安装了Eclipse JBoss Rules插件，新建一个Rules工程。

创建规则文件

创建一个规则文件如下：

ruby 代码

1. #描述如何计算销售人员提成比例的规则    
2. package org.gaofubing.commision   
3.   
4. import org.gaofubing.discount.CommisionComputer;   
5.   
6.   
7. #折扣小于5折   
8. rule   "lessThanFive"   
9.        
10.      when   
11.         computer:CommisionComputer(discount < 5)   
12.      then     
13.         computer.setDeduct(0.03);                  
14. end   
15.   
16. #折扣等于5折   
17. rule   "equalsFive"   
18.        
19.      when   
20.         computer:CommisionComputer(discount == 5)   
21.      then     
22.         computer.setDeduct(0.1);       
23. end   
24.   
25. #折扣大于5折小于等于6折   
26. rule   "betweenFiveAndSix"   
27.        
28.      when   
29.         computer:  CommisionComputer(discount :discount ,discount > 5,discount <= 6)   
30.      then     
31.         computer.setDeduct(((discount.doubleValue() -5) * 0.5 + 6 * 0.1 ) / discount.doubleValue());           
32. end   
33.   
34. #折扣大于6折小于等于7折   
35. rule   "betweenSixAndSeven"   
36.        
37.      when   
38.         computer: CommisionComputer(discount :discount ,discount > 6,discount <= 7)   
39.      then     
40.         computer.setDeduct(((discount.doubleValue() -6) * 0.6 + (6 - 5) * 0.5 + 5 * 0.1 ) / discount.doubleValue());       
41. end   
42.   
43. #折扣大于7折小于等于8折   
44. rule   "betweenSevenAndEight"   
45.        
46.      when   
47.         computer:CommisionComputer(discount :discount ,discount > 7,discount <= 8)   
48.      then     
49.         computer.setDeduct(((discount.doubleValue() -7) * 0.65 + (7-6) * 0.6 + (6 - 5) * 0.5 + 5 * 0.1 ) / discount.doubleValue());    
50. end   
51.   
52. #折扣大于8折小于等于9折   
53. rule   "betweenEightAndNine"   
54.        
55.      when   
56.         computer:CommisionComputer(discount :discount ,discount > 8,discount <= 9)   
57.      then     
58.         computer.setDeduct(((discount.doubleValue() -8) * 0.7 + (8-7) * 0.65 + (7-6) * 0.6 + (6 - 5) * 0.5 + 5 * 0.1 ) / discount.doubleValue());      
59. end   
60.   
61. #折扣大于9折   
62. rule   "greaterThanNine"   
63.        
64.      when   
65.         computer:CommisionComputer(discount :discount ,discount > 9)    
66.      then     
67.         computer.setDeduct(((discount.doubleValue() -9) * 0.85 + (9-8) * 0.7 + (8-7) * 0.65 + (7-6) * 0.6 + (6 - 5) * 0.5 + 5 * 0.1 ) / discount.doubleValue());   
68. end   

在测试的时候发生过一些问题，如果要描述折扣大于8小于9的条件，使用如下代码就不行

java 代码

1. computer: CommisionComputer(discount:discount,discount >  6 ) && CommisionComputer(discount <=  7 )  

另外CommisionComputer的discount属性是double类型，Rules的then部分会将其自动封箱，但是不会自动拆箱，所以如果then部分使用discount就会报错，必须使用discount.doubleValue();

创建Java类

CommisionComputer类的主要方法是computeCommision方法接受一个合同价格和售出价格，返回销售人员的提成数额。

java 代码

1. package  org.gaofubing.discount;   
2.   
3. import  java.io.InputStreamReader;   
4. import  java.io.Reader;   
5.   
6. import  org.apache.commons.logging.Log;   
7. import  org.apache.commons.logging.LogFactory;   
8. import  org.drools.RuleBase;   
9. import  org.drools.RuleBaseFactory;   
10. import  org.drools.WorkingMemory;   
11. import  org.drools.compiler.PackageBuilder;   
12. import  org.drools.rule .Package;   
13.   
14. public   class  CommisionComputer   
15. {   
16.      private   static   final  String RULE_FILE =  "discount.drl" ;   
17.        
18.      protected   static  Log log = LogFactory.getLog(CommisionComputer. class );   
19.        
20.      //折扣   
21.      private   double  discount;   
22.        
23.      //提成比例   
24.      private   double  deduct;   
25.        
26.      /**  
27.      * 根据合同价格和销售价格计算销售人员提成  
28.      * @param contractPrice 合同价格  
29.      * @param saledPrice 销售价格  
30.      * @return 提成  
31.      */   
32.      public   double  computeCommision( double  contractPrice, double  saledPrice)   
33.     {   
34.          try  {               
35.              //读取规则集,创建工作内存区   
36.             RuleBase ruleBase = readRule(RULE_FILE);   
37.             WorkingMemory workingMemory = ruleBase.newWorkingMemory();   
38.                
39.             log.debug( "执行规则前的提成比例值为："  + getDeduct());   
40.                
41.              //激活规则   
42.             setDiscount(saledPrice * 10d /contractPrice);             
43.             workingMemory.assertObject( this );   
44.             workingMemory.fireAllRules();    
45.                
46.             log.debug( "执行规则后的提成比例值为："  + getDeduct());               
47.                
48.         }  catch  (Throwable t) {   
49.             t.printStackTrace();   
50.             log.debug( "不能成功执行规则" ,t);   
51.         }   
52.          return  contractPrice * getDeduct();   
53.     }   
54.        
55.      /**  
56.      * 读取规则文件  
57.      * @param ruleFile 规则文件名称，相对于类路径  
58.      */   
59.      private  RuleBase readRule(String ruleFile)  throws  Exception   
60.     {   
61.          //读取规则文件   
62.         Reader source =  new  InputStreamReader(CommisionComputer. class .getClassLoader().getResourceAsStream(ruleFile));   
63.            
64.          //创建包   
65.         PackageBuilder builder =  new  PackageBuilder();   
66.         builder.addPackageFromDrl( source );   
67.         Package pkg = builder.getPackage();   
68.            
69.          //构建规则集   
70.         RuleBase ruleBase = RuleBaseFactory.newRuleBase();   
71.         ruleBase.addPackage( pkg );   
72.          return  ruleBase;   
73.     }   
74.   
75.      public   double  getDiscount()   
76.     {   
77.          return  discount;   
78.     }   
79.   
80.      public   void  setDiscount(  double  discount)   
81.     {   
82.          this .discount = discount;   
83.     }   
84.   
85.      public   double  getDeduct()   
86.     {   
87.          return  deduct;   
88.     }   
89.   
90.      public   void  setDeduct(  double  deduct)   
91.     {   
92.          this .deduct = deduct;   
93.     }   
94.   
95. }   

创建测试

测试代码如下：

java 代码

1. public   void  testDiscountLessThanFive()   
2. {   
3.      double  commision = computer.computeCommision( 10000 , 4500 );   
4.     assertEquals(commision, 10000 * 0.03 );   
5. }   
6.   
7. public   void  testDiscountEqualsFive()   
8. {   
9.      double  commision = computer.computeCommision( 10000 , 5000 );   
10.     assertEquals(commision, 10000 * 0.1 );   
11. }   
12.   
13. public   void  testDiscountBetweenFiveAndSix()   
14. {   
15.      double  commision = computer.computeCommision( 10000 , 5500 );   
16.      double  discount =  5500  * 10d / 10000 ;   
17.      double  deduct = ((discount - 5 ) *  0.5  +  6  *  0.1  ) /discount;   
18.     assertEquals(commision, 10000 *deduct);   
19. }   
20.   
21. public   void  testDiscountBetweenSixAndSeven()   
22. {   
23.      double  commision = computer.computeCommision( 10000 , 6500 );   
24.      double  discount =  6500  * 10d / 10000 ;   
25.      double  deduct = ((discount - 6 ) *  0.6  + ( 6  -  5 ) *  0.5  +  5  *  0.1  ) /discount;   
26.     assertEquals(commision, 10000 *deduct);   
27. }   
28.   
29. public   void  testDiscountBetweenSevenAndEight()   
30. {   
31.      double  commision = computer.computeCommision( 10000 , 7500 );   
32.      double  discount =  7500  * 10d / 10000 ;   
33.      double  deduct = ((discount - 7 ) *  0.65  + ( 7 - 6 ) *  0.6  + ( 6  -  5 ) *  0.5  +  5  *  0.1  ) /discount;   
34.     assertEquals(commision, 10000 *deduct);   
35. }   
36.   
37. public   void  testDiscountBetweenEightAndNine()   
38. {   
39.      double  commision = computer.computeCommision( 10000 , 8500 );   
40.      double  discount =  8500  * 10d / 10000 ;   
41.      double  deduct = ((discount - 8 ) *  0.7  + ( 8 - 7 ) *  0.65  + ( 7 - 6 ) *  0.6  + ( 6  -  5 ) *  0.5  +  5  *  0.1  ) /discount;   
42.     assertEquals(commision, 10000 *deduct);   
43. }   
44.   
45. public   void  testDiscountGreaterThanNine()   
46. {   
47.      double  commision = computer.computeCommision( 10000 , 9500 );   
48.      double  discount =  9500  * 10d / 10000 ;   
49.      double  deduct = ((discount - 9 ) *  0.85  + ( 9 - 8 ) *  0.7  + ( 8 - 7 ) *  0.65  + ( 7 - 6 ) *  0.6  + ( 6  -  5 ) *  0.5  +  5  *  0.1  ) /discount;   
50.     assertEquals(commision, 10000 *deduct);   
51. }