官網源碼：https://github.com/j-easy/easy-rules
官網案例：https://github.com/j-easy/easy-rules/wiki/fizz-buzz
介紹：
規則引擎是為了解決業務代碼和業務規則分離的引擎，是一種嵌入在應用程序中的組件，實現了將業務決策從應用程序代碼中分離，其實就是將一大堆if/else進行處理，Easy Rules 所做的，它提供了Rule創建具有條件和操作的規則的抽象，以及RulesEngine通過一組規則運行以評估條件和執行操作的API

核心功能：

輕量級庫和易于學習的 API

帶有注解編程模型的基于 POJO 的開發

用于定義業務規則并通過 Java 輕松應用它們的有用抽象

從原始規則創建復合規則的能力

使用表達式語言（如 MVEL、SpEL 和 JEXL）定義規則的能力

一個規則由名稱、描述、優先級三個屬性和判斷、執行兩個方法組成，實現Rule接口，
和使用@Rule,@Condition,@Action,@Priority,@Fact注解的效果是一樣的。

它主要包括幾個主要的類或接口：Rule,RulesEngine,RuleListener,Facts
還有幾個主要的注解：@Action,@Condition,@Fact,@Priority,@Rule

Rule

public interface Rule extends Comparable<Rule> {/*** 默認的規則名稱*/String DEFAULT_NAME = "rule";/*** 默認的規則描述*/String DEFAULT_DESCRIPTION = "description";/*** 默認的規則優先級*/int DEFAULT_PRIORITY = Integer.MAX_VALUE - 1;getter and setter.../*** 規則引擎判斷條件* 如果提供的facts被應用到規則上返回true，否則返回false*/boolean evaluate(Facts facts);/*** 規則引擎判斷條件返回true后，執行此方法*/void execute(Facts facts) throws Exception;}

RulesEngine負責檢查和開啟規則，同時可以得到規則引擎的參數和規則監聽器列表

public interface RulesEngine {/*** 返回規則引擎的參數*/RulesEngineParameters getParameters();/*** 返回已注冊的規則監聽器的列表*/List<RuleListener> getRuleListeners();/*** 在給定的因素上開啟所有已注冊的規則*/void fire(Rules rules, Facts facts);/*** 檢查規則和因素是否符合*/Map<Rule, Boolean> check(Rules rules, Facts facts); }

RuleListener在規則執行的4個階段加上了觸發器，可以靈活地控制規則執行結果
(定義規則監聽器通過實現RuleListener接口)

public interface RuleListener {/*** 規則條件判斷之前的觸發器*/boolean beforeEvaluate(Rule rule, Facts facts);/*** 規則條件判斷之后的觸發器*/void afterEvaluate(Rule rule, Facts facts, boolean evaluationResult);/*** 規則執行之前的觸發器*/void beforeExecute(Rule rule, Facts facts);/*** 規則執行成功之后的觸發器*/void onSuccess(Rule rule, Facts facts);/*** 規則執行失敗之后的觸發器*/void onFailure(Rule rule, Facts facts, Exception exception);}

Facts就是一個hashmap，通過注解@Fact(String value)，其中的value是map的key，可以拿到Facts中的value

public class Facts implements Iterable<Map.Entry<String, Object>> {private Map<String, Object> facts = new HashMap<>();/*** 在工作空間放置一個因素*/public Object put(String name, Object fact) {Objects.requireNonNull(name);return facts.put(name, fact);}/*** 刪除因素*/public Object remove(String name) {Objects.requireNonNull(name);return facts.remove(name);}/*** 通過name得到因素*/public Object get(String name) {Objects.requireNonNull(name);return facts.get(name);}/*** 以map形式返回因素*/public Map<String, Object> asMap() {return facts;}... }

一. pom.xml中引入maven依賴

<!--easy rules核心庫--> <dependency><groupId>org.jeasy</groupId><artifactId>easy-rules-core</artifactId><version>4.0.0</version> </dependency><!--規則定義文件格式，支持json,yaml等--> <dependency><groupId>org.jeasy</groupId><artifactId>easy-rules-support</artifactId><version>4.0.0</version> </dependency><!--支持mvel規則語法庫--> <dependency><groupId>org.jeasy</groupId><artifactId>easy-rules-mvel</artifactId><version>4.0.0</version> </dependency>

二. 定義規則

大多數業務規則可以由以下定義表示：

名稱：規則命名空間中的唯一規則名稱

說明：規則的簡要說明

優先級：相對于其他規則的規則優先級

事實：去匹配規則時的一組已知事實

條件：為了匹配該規則，在給定某些事實的情況下應滿足的一組條件

動作：當條件滿足時要執行的一組動作（可以添加/刪除/修改事實）

Easy Rules為定義業務規則的每個關鍵點提供了抽象。

public interface Rule {/*** 改方法封裝規則的條件（conditions）* @return 如果提供的事實適用于該規則返回true, 否則，返回false*/boolean evaluate(Facts facts);/*** 改方法封裝規則的操作（actions）* @throws 如果在執行過程中發生錯誤將拋出Exception*/void execute(Facts facts) throws Exception;//Getters and setters for rule name, description and priority omitted.}

evaluate方法封裝了必須求值為TRUE才能觸發規則的條件。
execute方法封裝了在滿足規則條件時應執行的操作。條件和動作ConditionandAction接口表示。

首先，定義規則，方式有多種

方式一：注解

@Condition注解指定規則條件

@Fact注解指定參數

@Action注解指定規則執行的動作

@Rule(name = "weather rule", description = "if it rains then take an umbrella") public class WeatherRule {@Conditionpublic boolean itRains(@Fact("rain") boolean rain) {return rain;}@Actionpublic void takeAnUmbrella() {System.out.println("It rains, take an umbrella!");} }

@Condition注解標記計算規則條件的方法。此方法必須是公共的，可以有一個或多個用@Fact注解的參數，并返回布爾類型。只有一個方法能用@Condition注解。

@Action注解標記要執行規則操作的方法。規則可以有多個操作。可以使用order屬性按指定的順序執行操作。默認情況下，操作的順序為0。

方式二：鏈式編程

Rule rule = new RuleBuilder().name("myRule").description("myRuleDescription").priority(3).when(condition).then(action1).then(action2).build();

在這個例子中, Condition實例condition，Action實例是action1和action2。

方式三：表達式

Rule weatherRule = new MVELRule().name("weather rule").description("if it rains then take an umbrella").when("rain == true").then("System.out.println(\"It rains, take an umbrella!\");");

方式四：yml配置文件
例如：weather-rule.yml

name: "weather rule" description: "if it rains then take an umbrella" condition: "rain == true" actions:- "System.out.println(\"It rains, take an umbrella!\");" MVELRuleFactory ruleFactory = new MVELRuleFactory(new YamlRuleDefinitionReader()); Rule weatherRule = ruleFactory.createRule(new FileReader("weather-rule.yml"));

組合規則

CompositeRule由一組規則組成。這是一個典型地組合設計模式的實現。

組合規則是一個抽象概念，因為可以以不同方式觸發組合規則。

Easy Rules自帶三種CompositeRule實現：

UnitRuleGroup : 要么應用所有規則，要么不應用任何規則（AND邏輯）
ActivationRuleGroup : 它觸發第一個適用規則，并忽略組中的其他規則（XOR邏輯）
ConditionalRuleGroup : 如果具有最高優先級的規則計算結果為true，則觸發其余規則
復合規則可以從基本規則創建并注冊為常規規則：

//Create a composite rule from two primitive rules UnitRuleGroup myUnitRuleGroup = new UnitRuleGroup("myUnitRuleGroup", "unit of myRule1 and myRule2"); myUnitRuleGroup.addRule(myRule1); myUnitRuleGroup.addRule(myRule2);//Register the composite rule as a regular rule Rules rules = new Rules(); rules.register(myUnitRuleGroup);RulesEngine rulesEngine = new DefaultRulesEngine(); rulesEngine.fire(rules, someFacts);

每個規則都有優先級。它代表觸發注冊規則的默認順序。默認情況下，較低的值表示較高的優先級。可以重寫compareTo方法以提供自定義優先級策略。

定義事實
Facts API是一組事實的抽象，在這些事實上檢查規則。
在內部，Facts實例持有HashMap<String，Object>，這意味著：
事實需要命名，應該有一個唯一的名稱，且不能為空
任何Java對象都可以充當事實
這里有一個實例定義事實:

// define facts Facts facts = new Facts(); facts.add("rain", true);

用@Fact注解可以將Facts注入到condition和action方法中
在下面的規則中，rain 事實被注入itRains方法的rain參數:

@Rule class WeatherRule {@Conditionpublic boolean itRains(@Fact("rain") boolean rain) {return rain;}@Actionpublic void takeAnUmbrella(Facts facts) {System.out.println("It rains, take an umbrella!");// can add/remove/modify facts}}

Facts類型參數 被注入已知的 facts中 (像action方法takeAnUmbrella一樣).

如果缺少注入的fact, 這個引擎會拋出 RuntimeException異常.
定義規則引擎
從版本3.1開始，Easy Rules提供了RulesEngine接口的兩種實現：

DefaultRulesEngine：根據規則的自然順序（默認為優先級）應用規則。

InferenceRulesEngine：持續對已知事實應用規則，直到不再應用規則為止。

創建一個規則引擎
要創建規則引擎，可以使用每個實現的構造函數：

RulesEngine rulesEngine = new DefaultRulesEngine(); // or RulesEngine rulesEngine = new InferenceRulesEngine();

然后，您可以按以下方式觸發注冊規則：

rulesEngine.fire(rules, facts);

規則引擎參數

Easy Rules 引擎可以配置以下參數：

Parameter Type Required Default rulePriorityThreshold int no MaxInt skipOnFirstAppliedRule boolean no false skipOnFirstFailedRule boolean no false skipOnFirstNonTriggeredRule boolean no false

skipOnFirstAppliedRule：告訴引擎規則被觸發時跳過后面的規則。
skipOnFirstFailedRule：告訴引擎在規則失敗時跳過后面的規則。
skipOnFirstNonTriggeredRule：告訴引擎一個規則不會被觸發跳過后面的規則。
rulePriorityThreshold：告訴引擎如果優先級超過定義的閾值，則跳過下一個規則。版本3.3已經不支持更改，默認MaxInt。
可以使用RulesEngineParameters API指定這些參數：

RulesEngineParameters parameters = new RulesEngineParameters().rulePriorityThreshold(10).skipOnFirstAppliedRule(true).skipOnFirstFailedRule(true).skipOnFirstNonTriggeredRule(true);RulesEngine rulesEngine = new DefaultRulesEngine(parameters);

如果要從引擎獲取參數，可以使用以下代碼段：

RulesEngineParameters parameters = myEngine.getParameters();

這允許您在創建引擎后重置引擎參數。

開始測試案例
1.創建項目（通過maven骨架創建）

mvn archetype:generate \-DarchetypeGroupId=org.jeasy \-DarchetypeArtifactId=easy-rules-archetype \-DarchetypeVersion=4.0.0

創建完成后，會默認生成一個HelloWorldRule規則

入過啟動報錯 Error:(26, 34) java: 程序包org.jeasy.rules.annotation不存在

File -->settings —>maven —>Runner ,勾選：Dele… 然后保存

重寫啟動

依賴：

測試案例一：

1.用到的實體

package org.testRule.one;/*** @author: YXY* @date: 2021/6/23 15:22* @Version 1.0*/ public class User {private Integer age;public Integer getAge() {return age;}public void setAge(Integer age) {this.age = age;} }

2.測試類

package org.testRule.one;import org.jeasy.rules.annotation.Rule; import org.jeasy.rules.api.Facts; import org.jeasy.rules.api.Rules; import org.jeasy.rules.api.RulesEngine; import org.jeasy.rules.core.DefaultRulesEngine; import org.jeasy.rules.mvel.MVELRule;import java.util.HashMap; import java.util.Map;/*** @author: YXY* @date: 2021/6/23 15:21* @Version 1.0*/ public class MVELTestRule {public static void main(String[] args) {//規則引擎RulesEngine rulesEngine = new DefaultRulesEngine();//規則MVELRule ageRule = new MVELRule().name("my rule").description("test demo rule").priority(1).when("user.age > 18").then("map.put('code',200);map.put('msg','success');");Rules rules = new Rules();rules.register(ageRule);Facts facts = new Facts();User user = new User();user.setAge(19);facts.put("user",user);Map map = new HashMap();facts.put("map",map);rulesEngine.fire(rules,facts);System.out.println(map);} }

3.運行結果

測試案例二:


1.定義規則

package org.testRule.tow.rules;import org.jeasy.rules.annotation.*;/*** @author: YXY* @date: 2021/6/23 15:19* @Version 1.0*/ @Rule(name = "被2整除") public class TwoRule {@Conditionpublic boolean isTwo(@Fact("num") int num){System.out.println("---isTwo----run----");return num % 2 == 0;}@Actionpublic void action(@Fact("num") int num){System.out.println(num + " 被2整除");}@Prioritypublic int getPriority(){return 1;}} package org.testRule.tow.rules;import org.jeasy.rules.annotation.*;/*** @author: YXY* @date: 2021/6/23 15:19* @Version 1.0*/ @Rule(name = "被3整除") public class ThreeRule {@Condition //條件判斷注解：如果return true， 執行Actionpublic boolean isThree(@Fact("num") int num){System.out.println("---isThree----run----");return num % 3 == 0;}@Actionpublic void action(@Fact("num") int num){System.out.println(num + " 被3整除");}@Priority //優先級注解：return 數值越小，優先級越高public int getPriority(){return 2;} } package org.testRule.tow.rules;import org.jeasy.rules.annotation.Rule; import org.jeasy.rules.support.composite.UnitRuleGroup;/*** @author: YXY* @date: 2021/6/23 15:19* @Version 1.0*/ @Rule(name = "被2和3同時整除") public class TwoThreeRuleUnitGroup extends UnitRuleGroup {public TwoThreeRuleUnitGroup(Object... rules) {for (Object rule : rules) {addRule(rule);}}@Overridepublic int getPriority() {return 0;} } package org.testRule.tow.rules;import org.jeasy.rules.annotation.*;/*** @author: YXY* @date: 2021/6/23 15:20* @Version 1.0*/ @Rule(name = "既不被2整除也不被3整除") public class OtherRule {@Conditionpublic boolean isOther(@Fact("num") int num){System.out.println("---isOther----run----");return num % 2 != 0 && num % 3 != 0;}@Actionpublic void action(@Fact("num") int num){System.out.print(num);}@Prioritypublic int getPriority(){return 3;} }

2.測試類

package org.testRule.tow;import org.jeasy.rules.api.Facts; import org.jeasy.rules.api.Rules; import org.jeasy.rules.api.RulesEngine; import org.jeasy.rules.core.DefaultRulesEngine; import org.testRule.tow.rules.OtherRule; import org.testRule.tow.rules.ThreeRule; import org.testRule.tow.rules.TwoRule; import org.testRule.tow.rules.TwoThreeRuleUnitGroup;/*** @author: YXY* @date: 2021/6/23 15:21* @Version 1.0*/public class RuleTest {public static void main(String[] args) {RulesEngine rulesEngine = new DefaultRulesEngine();//創建規則Rules rules = new Rules();rules.register(new TwoRule());rules.register(new ThreeRule());rules.register(new TwoThreeRuleUnitGroup(new TwoRule(), new ThreeRule()));rules.register(new OtherRule());//設置真實數據Facts facts = new Facts();for (int i=1 ; i<=10 ; i++){//規則因素，對應的name，要和規則里面的@Fact 一致facts.put("num", i);//執行規則rulesEngine.fire(rules, facts);System.out.println();}} }

3.運行結果

控制臺亂碼解決：

-Dfile.encoding=UTF-8

總結

以上是生活随笔為你收集整理的规则引擎Easy-rules的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。