java drl_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 classWeatherRule {

@Conditionpublic boolean itRains(@Fact("rain") booleanrain) {returnrain;

}

@Actionpublic voidtakeAnUmbrella() {

System.out.println("It rains, take an umbrella!");

}

}

方式二：链式编程

Rule weatherRule = newRuleBuilder()

.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 = newMVELRule()

.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(newYamlRuleDefinitionReader());

Rule weatherRule= ruleFactory.createRule(new FileReader("weather-rule.yml"));

接下来，应用规则

public classTest {public static voidmain(String[] args) {//define facts

Facts facts = newFacts();

facts.put("rain", true);//define rules

Rule weatherRule =...

Rules rules= newRules();

rules.register(weatherRule);//fire rules on known facts

RulesEngine rulesEngine = newDefaultRulesEngine();

rulesEngine.fire(rules, facts);

}

}

入门案例：Hello Easy Rules

org.jeasy

easy-rules-core

4.0.0

通过骨架创建maven项目：

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

默认给我们生成了一个HelloWorldRule规则，如下：

packagecom.cjs.example.rules;importorg.jeasy.rules.annotation.Action;importorg.jeasy.rules.annotation.Condition;importorg.jeasy.rules.annotation.Rule;

@Rule(name= "Hello World rule", description = "Always say hello world")public classHelloWorldRule {

@Conditionpublic booleanwhen() {return true;

}

@Actionpublic void then() throwsException {

System.out.println("hello world");

}

}

2.  规则定义

2.1.  定义规则

大多数业务规则可以用以下定义表示：

Name : 一个命名空间下的唯一的规则名称

Description : 规则的简要描述

Priority : 相对于其他规则的优先级

Facts : 事实，可立即为要处理的数据

Conditions : 为了应用规则而必须满足的一组条件

Actions : 当条件满足时执行的一组动作

Easy Rules为每个关键点提供了一个抽象来定义业务规则。

在Easy Rules中，Rule接口代表规则

public interfaceRule {/*** This method encapsulates the rule's conditions.

*@returntrue if the rule should be applied given the provided facts, false otherwise*/

booleanevaluate(Facts facts);/*** This method encapsulates the rule's actions.

*@throwsException if an error occurs during actions performing*/

void execute(Facts facts) throwsException;//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 classMyRule {

@Conditionpublic boolean when(@Fact("fact") fact) {//my rule conditions

return true;

}

@Action(order= 1)public void then(Facts facts) throwsException {//my actions

}

@Action(order= 2)public void finally() throwsException {//my final actions

}

}

@Condition注解指定规则条件

@Fact注解指定参数

@Action注解指定规则执行的动作

RuleBuilder支持链式风格定义规则，例如：

Rule rule = newRuleBuilder()

.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 = newRules();

rules.register(myUnitRuleGroup);

RulesEngine rulesEngine= newDefaultRulesEngine();

rulesEngine.fire(rules, someFacts);

每个规则都有优先级。它代表触发注册规则的默认顺序。默认情况下，较低的值表示较高的优先级。可以重写compareTo方法以提供自定义优先级策略。

2.2.  定义事实

在Easy Rules中，Fact API代表事实

public class Fact{private finalString name;private finalT value;

}

举个栗子：

Fact fact = new Fact("foo", "bar");

Facts facts= newFacts();

facts.add(fact);

或者，也可以用这样简写形式

Facts facts = newFacts();

facts.put("foo", "bar");

用@Fact注解可以将Facts注入到condition和action方法中

@RuleclassWeatherRule {

@Conditionpublic boolean itRains(@Fact("rain") booleanrain) {returnrain;

}

@Actionpublic voidtakeAnUmbrella(Facts facts) {

System.out.println("It rains, take an umbrella!");//can add/remove/modify facts

}

}

2.3.  定义规则引擎

Easy Rules提供两种RulesEngine接口实现：

DefaultRulesEngine : 根据规则的自然顺序应用规则

InferenceRulesEngine : 持续对已知事实应用规则，直到不再适用任何规则为止

创建规则引擎：

RulesEngine rulesEngine = newDefaultRulesEngine();//or

RulesEngine rulesEngine= new InferenceRulesEngine();

然后，注册规则

rulesEngine.fire(rules, facts);

规则引擎有一些可配置的参数，如下图所示：

举个栗子：

RulesEngineParameters parameters = newRulesEngineParameters()

.rulePriorityThreshold(10)

.skipOnFirstAppliedRule(true)

.skipOnFirstFailedRule(true)

.skipOnFirstNonTriggeredRule(true);

RulesEngine rulesEngine= new DefaultRulesEngine(parameters);

2.4. 定义规则监听器

通过实现RuleListener接口

public interfaceRuleListener {/*** Triggered before the evaluation of a rule.

*

*@paramrule being evaluated

*@paramfacts known before evaluating the rule

*@returntrue if the rule should be evaluated, false otherwise*/

default booleanbeforeEvaluate(Rule rule, Facts facts) {return true;

}/*** Triggered after the evaluation of a rule.

*

*@paramrule that has been evaluated

*@paramfacts known after evaluating the rule

*@paramevaluationResult true if the rule evaluated to true, false otherwise*/

default void afterEvaluate(Rule rule, Facts facts, booleanevaluationResult) { }/*** Triggered on condition evaluation error due to any runtime exception.

*

*@paramrule that has been evaluated

*@paramfacts known while evaluating the rule

*@paramexception that happened while attempting to evaluate the condition.*/

default voidonEvaluationError(Rule rule, Facts facts, Exception exception) { }/*** Triggered before the execution of a rule.

*

*@paramrule the current rule

*@paramfacts known facts before executing the rule*/

default voidbeforeExecute(Rule rule, Facts facts) { }/*** Triggered after a rule has been executed successfully.

*

*@paramrule the current rule

*@paramfacts known facts after executing the rule*/

default voidonSuccess(Rule rule, Facts facts) { }/*** Triggered after a rule has failed.

*

*@paramrule the current rule

*@paramfacts known facts after executing the rule

*@paramexception the exception thrown when attempting to execute the rule*/

default voidonFailure(Rule rule, Facts facts, Exception exception) { }

}

3.  示例

4.0.0

com.cjs.example

easy-rules-quickstart

1.0.0-SNAPSHOT

jar

org.jeasy

easy-rules-core

4.0.0

org.jeasy

easy-rules-support

4.0.0

org.jeasy

easy-rules-mvel

4.0.0

org.slf4j

slf4j-simple

1.7.30

4.  扩展

规则本质上是一个函数，如y=f(x1,x2,..,xn)

规则引擎就是为了解决业务代码和业务规则分离的引擎，是一种嵌入在应用程序中的组件，实现了将业务决策从应用程序代码中分离。

还有一种常见的方式是Java+Groovy来实现，Java内嵌Groovy脚本引擎进行业务规则剥离。