溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
關于Java規則引擎Easy Rules的用法，其實不難理解，下面讓小編帶著大家一起分析分析，希望大家閱讀完這篇文章后大所收獲。
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. 定義規則
大多數業務規則可以用以下定義表示：
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類上添加@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實現：
復合規則可以從基本規則創建并注冊為常規規則：
//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接口實現：
創建規則引擎：
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規則引擎Easy Rules的用法內容對大家有幫助，同時也希望大家多多支持億速云，關注億速云行業資訊頻道，遇到問題就找億速云，詳細的解決方法等著你來學習!
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
