1. Easy Rules 概述
Easy Rules是一個Java規則引擎，靈感來自一篇名為《Should I use a Rules Engine?》的文章
規則引擎就是提供一種可選的計算模型。與通常的命令式模型（由帶有條件和迴圈的命令依次組成）不同，規則引擎基於生產規則系統。這是一組生產規則，每條規則都有一個條件（condition）和一個動作（action）———— 簡單地說，可以將其看作是一組if-then語句。
精妙之處在於規則可以按任何順序編寫，引擎會決定何時使用對順序有意義的任何方式來計算它們。考慮它的一個好方法是系統執行所有規則，選擇條件成立的規則，然後執行相應的操作。這樣做的好處是，很多問題都很自然地符合這個模型：
if car.owner.hasCellPhone then premium += 100; if car.model.theftRating > 4 then premium += 200; if car.owner.livesInDodgyArea && car.model.theftRating > 2 then premium += 300;規則引擎是一種工具，它使得這種計算模型程式設計變得更容易。它可能是一個完整的開發環境，或者一個可以在傳統平臺上工作的框架。生產規則計算模型最適合僅解決一部分計算問題，因此規則引擎可以更好地嵌入到較大的系統中。
你可以自己構建一個簡單的規則引擎。你所需要做的就是建立一組帶有條件和動作的物件，將它們儲存在一個集合中，然後遍歷它們以評估條件並執行這些動作。
Easy Rules它提供Rule抽象以建立具有條件和動作的規則，並提供RuleEngine API，該API通過一組規則執行以評估條件並執行動作。
Easy Rules簡單易用，只需兩步：
首先，定義規則，方式有很多種
方式一：註解
@Rule(name = "weather rule", description = "if it rains then take an umbrella") public class WeatherRule { @Condition public boolean itRains(@Fact("rain") boolean rain) { return rain; } @Action public void takeAnUmbrella() { System.out.println("It rains, take an umbrella!"); } }
方式二：鏈式程式設計
Rule weatherRule = new RuleBuilder() .name("weather rule") .description("if it rains then take an umbrella") .when(facts -> facts.get("rain").equals(true)) .then(facts -> System.out.println("It rains, take an umbrella!")) .build();
方式三：表示式
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"));
接下來，應用規則
public class Test { public static void main(String[] args) { // define facts Facts facts = new Facts(); facts.put("rain", true); // define rules Rule weatherRule = ... Rules rules = new Rules(); rules.register(weatherRule); // fire rules on known facts RulesEngine rulesEngine = new DefaultRulesEngine(); rulesEngine.fire(rules, facts); } }
入門案例：Hello Easy Rules
<dependency> <groupId>org.jeasy</groupId> <artifactId>easy-rules-core</artifactId> <version>4.0.0</version> </dependency>
通過骨架建立maven專案：
mvn archetype:generate \ -DarchetypeGroupId=org.jeasy \ -DarchetypeArtifactId=easy-rules-archetype \ -DarchetypeVersion=4.0.0
預設給我們生成了一個HelloWorldRule規則，如下：
package com.cjs.example.rules; import org.jeasy.rules.annotation.Action; import org.jeasy.rules.annotation.Condition; import org.jeasy.rules.annotation.Rule; @Rule(name = "Hello World rule", description = "Always say hello world") public class HelloWorldRule { @Condition public boolean when() { return true; } @Action public void then() throws Exception { System.out.println("hello world"); } }
2. 規則定義
2.1. 定義規則
大多數業務規則可以用以下定義表示：
- Name : 一個名稱空間下的唯一的規則名稱
- Description : 規則的簡要描述
- Priority : 相對於其他規則的優先順序
- Facts : 事實，可立即為要處理的資料
- Conditions : 為了應用規則而必須滿足的一組條件
- Actions : 當條件滿足時執行的一組動作
Easy Rules為每個關鍵點提供了一個抽象來定義業務規則。
在Easy Rules中，Rule介面代表規則
public interface Rule { /** * This method encapsulates the rule's conditions. * @return true if the rule should be applied given the provided facts, false otherwise */ boolean evaluate(Facts facts); /** * This method encapsulates the rule's actions. * @throws Exception if an error occurs during actions performing */ void execute(Facts facts) throws Exception; //Getters and setters for rule name, description and priority omitted. }
evaluate方法封裝了必須計算結果為TRUE才能觸發規則的條件。execute方法封裝了在滿足規則條件時應該執行的動作。條件和操作由Condition和Action介面表示。
定義規則有兩種方式：
- 通過在POJO類上新增註解
- 通過RuleBuilder API程式設計
可以在一個POJO類上新增@Rule註解，例如：
@Rule(name = "my rule", description = "my rule description", priority = 1) public class MyRule { @Condition public boolean when(@Fact("fact") fact) { //my rule conditions return true; } @Action(order = 1) public void then(Facts facts) throws Exception { //my actions } @Action(order = 2) public void finally() throws Exception { //my final actions } }
@Condition註解指定規則條件
@Fact註解指定引數
@Action註解指定規則執行的動作
RuleBuilder支援鏈式風格定義規則，例如：
Rule rule = new RuleBuilder() .name("myRule") .description("myRuleDescription") .priority(3) .when(condition) .then(action1) .then(action2) .build();
組合規則
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方法以提供自定義優先順序策略。
2.2. 定義事實
在Easy Rules中，Fact API代表事實
public class Fact<T> { private final String name; private final T value; }
舉個例子：
Fact<String> fact = new Fact("foo", "bar"); Facts facts = new Facts(); facts.add(fact);
或者，也可以用這樣簡寫形式
Facts facts = new Facts(); facts.put("foo", "bar");
用@Fact註解可以將Facts注入到condition和action方法中
@Rule class WeatherRule { @Condition public boolean itRains(@Fact("rain") boolean rain) { return rain; } @Action public void takeAnUmbrella(Facts facts) { System.out.println("It rains, take an umbrella!"); // can add/remove/modify facts } }
2.3. 定義規則引擎
Easy Rules提供兩種RulesEngine介面實現：
- DefaultRulesEngine : 根據規則的自然順序應用規則
- InferenceRulesEngine : 持續對已知事實應用規則，直到不再適用任何規則為止
建立規則引擎：
RulesEngine rulesEngine = new DefaultRulesEngine(); // or RulesEngine rulesEngine = new InferenceRulesEngine();
然後，註冊規則
rulesEngine.fire(rules, facts);
規則引擎有一些可配置的引數，如下圖所示：
舉個例子：
RulesEngineParameters parameters = new RulesEngineParameters() .rulePriorityThreshold(10) .skipOnFirstAppliedRule(true) .skipOnFirstFailedRule(true) .skipOnFirstNonTriggeredRule(true); RulesEngine rulesEngine = new DefaultRulesEngine(parameters);
2.4. 定義規則監聽器
通過實現RuleListener介面
public interface RuleListener { /** * Triggered before the evaluation of a rule. * * @param rule being evaluated * @param facts known before evaluating the rule * @return true if the rule should be evaluated, false otherwise */ default boolean beforeEvaluate(Rule rule, Facts facts) { return true; } /** * Triggered after the evaluation of a rule. * * @param rule that has been evaluated * @param facts known after evaluating the rule * @param evaluationResult true if the rule evaluated to true, false otherwise */ default void afterEvaluate(Rule rule, Facts facts, boolean evaluationResult) { } /** * Triggered on condition evaluation error due to any runtime exception. * * @param rule that has been evaluated * @param facts known while evaluating the rule * @param exception that happened while attempting to evaluate the condition. */ default void onEvaluationError(Rule rule, Facts facts, Exception exception) { } /** * Triggered before the execution of a rule. * * @param rule the current rule * @param facts known facts before executing the rule */ default void beforeExecute(Rule rule, Facts facts) { } /** * Triggered after a rule has been executed successfully. * * @param rule the current rule * @param facts known facts after executing the rule */ default void onSuccess(Rule rule, Facts facts) { } /** * Triggered after a rule has failed. * * @param rule the current rule * @param facts known facts after executing the rule * @param exception the exception thrown when attempting to execute the rule */ default void onFailure(Rule rule, Facts facts, Exception exception) { } }
3. 示例
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.cjs.example</groupId> <artifactId>easy-rules-quickstart</artifactId> <version>1.0.0-SNAPSHOT</version> <packaging>jar</packaging> <dependencies> <dependency> <groupId>org.jeasy</groupId> <artifactId>easy-rules-core</artifactId> <version>4.0.0</version> </dependency> <dependency> <groupId>org.jeasy</groupId> <artifactId>easy-rules-support</artifactId> <version>4.0.0</version> </dependency> <dependency> <groupId>org.jeasy</groupId> <artifactId>easy-rules-mvel</artifactId> <version>4.0.0</version> </dependency> <dependency> <groupId>org.slf4j</groupId> <artifactId>slf4j-simple</artifactId> <version>1.7.30</version> </dependency> </dependencies> </project>
4. 擴充套件
規則本質上是一個函式，如y=f(x1,x2,..,xn)
規則引擎就是為了解決業務程式碼和業務規則分離的引擎，是一種嵌入在應用程式中的元件，實現了將業務決策從應用程式程式碼中分離。
還有一種常見的方式是Java+Groovy來實現，Java內嵌Groovy指令碼引擎進行業務規則剝離。
https://github.com/j-easy/easy-rules/wiki