关于后端:Java规则引擎easyrules详细介绍

最近在思考一个基于规定进行筛选的技术重构，想通过规定引擎进行实现，借着这个机会正好能够具体理解一下规定引擎。本篇文章将会具体介绍规定引擎easy-rules的应用。我的项目地址：github.com/j-easy/easy…
简介
Easy Rules是一个简略但功能强大的Java规定引擎，提供以下个性:

轻量级框架和易于学习的API
基于POJO的开发
反对从原始规定创立组合规定
反对通过表达式（如MVEL，SPEL和JEXL）定义规定

开始应用
引入依赖
<dependency>

<groupId>org.jeasy</groupId><artifactId>easy-rules-core</artifactId><version>4.1.0</version>

</dependency>
复制代码
下面只引入了core模块依赖，如须要其它模块内容，再引入对应依赖即可。
定义规定
介绍
大多数业务规定能够用以下定义示意:

name：规定命名空间中的惟一规定名称
description：规定的简要形容
priority：规定的优先级
facts：触发规定时的一组已知事实
conditions：在给定一些事实的状况下，为了利用该规定，须要满足的一组条件
actions：满足条件时要执行的一组操作(可能会增加/删除/批改事实)

Easy Rules为定义业务规定的每个关键点提供了形象。Easy Rules中的规定由Rule接口示意:
public interface Rule extends Comparable<Rule> {

/*** 此办法封装了规定的条件。* @return 如果依据提供的事实能够利用规定，则为true，否则为false*/boolean evaluate(Facts facts);/*** 此办法封装了规定的操作。* @throws 如果在执行操作期间产生谬误，则抛出异样*/void execute(Facts facts) throws Exception;//Getters and setters for rule name, description and priority omitted.

}
复制代码
evaluate()办法封装了必须为true能力触发规定的条件。execute()办法封装了在满足规定条件时应该执行的操作。条件和操作由Condition和Action接口示意。
规定能够用两种不同的形式定义:

通过在POJO上增加注解来申明
通过RuleBuilder API编程

这些是定义规定的最罕用办法，然而如果须要，您也能够实现Rule接口或扩大BasicRule类。
应用注解定义规定
Easy Rules提供了@Rule注解，能够将POJO转换为规定。
@Rule(name = "my rule", description = "my rule description", priority = 1)
public class MyRule {

@Conditionpublic boolean when(@Fact("fact") fact) {    // 规定条件    return true;}@Action(order = 1)public void then(Facts facts) throws Exception {    // 规定为true时的操作1}@Action(order = 2)public void finally() throws Exception {    // 规定为true时的操作2}

}
复制代码
@Condition注解用来标记评估规定条件的办法，这个办法必须是public，能够有一个或多个带@Fact注解的参数，并返回一个boolean类型。只有一个办法能够用@Condition注解标记。
@Action注解用来标记执行操作的办法，规定能够有多个操作。能够应用order属性以指定的程序执行操作。
应用RuleBuilder定义规定
RuleBuilder容许你用流式API定义规定。
Rule rule = new RuleBuilder()

            .name("myRule")            .description("myRuleDescription")            .priority(3)            .when(condition)            .then(action1)            .then(action2)            .build();

复制代码
在本例中，condition是Condition接口的实例，action1和action2是Action接口的实例。
组合规定
Easy Rules容许从原始规定创立简单的规定。一个CompositeRule由一组规定组成。组合规定是一个抽象概念，因为组合规定能够以不同的形式触发。Easy Rules提供了3种CompositeRule的实现。

UnitRuleGroup：单元规定组是作为一个单元应用的组合规定，要么利用所有规定，要么不利用任何规定。
ActivationRuleGroup：激活规定组触发第一个实用规定并疏忽组中的其余规定。规定首先依照其在组中的天然程序(默认状况下优先级)进行排序。
ConditionalRuleGroup：条件规定组将具备最高优先级的规定作为条件，如果具备最高优先级的规定的计算结果为true，那么将触发其余的规定。

组合规定能够从原始规定创立并像惯例规定一样注册。
// 从两个原始规定创立组合规定
UnitRuleGroup myUnitRuleGroup =

new UnitRuleGroup("myUnitRuleGroup", "unit of myRule1 and myRule2");

myUnitRuleGroup.addRule(myRule1);
myUnitRuleGroup.addRule(myRule2);

// 像惯例规定一样注册组合规定
Rules rules = new Rules();
rules.register(myUnitRuleGroup);

RulesEngine rulesEngine = new DefaultRulesEngine();
rulesEngine.fire(rules, someFacts);
复制代码
规定优先级
Easy Rules中的每个规定都有一个优先级。这示意触发注册规定的默认程序。默认状况下，值越低优先级越高。要笼罩此行为，您应该重写compareTo()办法以提供自定义优先级策略。

如果是继承BasicRule，能够在构造方法中指定优先级，或者重写getPriority()办法。
如果是应用POJO定义规定，能够通过@Rule注解的priority属性指定优先级，或者应用@Priority注解标记一个办法。这个办法必须是public，无参却返回类型为Integer。
如果应用RuleBuilder定义规定，能够应用RuleBuilder#priority()办法指定优先级。

Rules API
Easy rules中的一组规定由rules API示意。它的应用办法如下:
Rules rules = new Rules();
rules.register(myRule1);
rules.register(myRule2);
复制代码
Rules示意已注册规定的命名空间，因而，在同一命名空间下，每一个曾经注册的规定必须有惟一的名称。

Rules是通过Rule#compareTo()办法进行比拟的，因而，Rule的实现应该正确的实现compareTo()办法来确保繁多空间下领有惟一的规定名称。

定义事实
Easy Rules中的一个事实是由Fact示意的:
public class Fact<T> {
private final String name;
private final T value;
}
复制代码
一个事实有一个名称和一个值，两者都不能为null。另一方面，Facts API 示意一组事实并充当事实的命名空间。这意味着，在一个Facts实例中，事实必须有惟一的名称。
上面是一个如何定义事实的例子:
Fact<String> fact = new Fact("foo", "bar");
Facts facts = new Facts();
facts.add(fact);
复制代码
你也能够应用一个更短的版本，用put办法创立命名的事实，如下所示:
Facts facts = new Facts();
facts.put("foo", "bar");
复制代码
能够应用@Fact注解将事实注入到规定的条件和操作方法中。在以下规定中，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的参数将被注入所有已知的事实。
留神：

如果条件办法中短少注入的事实，引擎将记录一个正告，并认为条件被计算为false。
如果动作办法中短少注入的事实，则不会执行该动作，并且抛出org.jeasy.rules.core.NoSuchFactException异样。

定义规定引擎
Easy Rules提供了RulesEngine接口的两种实现:

DefaultRulesEngine：依据规定的天然程序(默认为优先级)利用规定。
InferenceRulesEngine：在已知的事实上一直地利用规定，直到没有更多的规定可用。

创立规定引擎
能够应用构造方法创立规定引擎。
RulesEngine rulesEngine = new DefaultRulesEngine();
// or
RulesEngine rulesEngine = new InferenceRulesEngine();
复制代码
能够按如下形式触发已注册的规定。
rulesEngine.fire(rules, facts);
复制代码
规定引擎参数
Easy Rules引擎能够配置以下参数:
https://zhuanlan.zhihu.com/p/...
https://zhuanlan.zhihu.com/p/...
https://zhuanlan.zhihu.com/p/...
https://zhuanlan.zhihu.com/p/...
https://zhuanlan.zhihu.com/p/...
https://zhuanlan.zhihu.com/p/...
https://zhuanlan.zhihu.com/p/...
https://zhuanlan.zhihu.com/p/...
https://zhuanlan.zhihu.com/p/...
https://zhuanlan.zhihu.com/p/...
https://zhuanlan.zhihu.com/p/...
参数类型默认值rulePriorityThresholdintMaxIntskipOnFirstAppliedRulebooleanfalserulePriorityThresholdintfalseskipOnFirstFailedRulebooleanfalseskipOnFirstNonTriggeredRulebooleanfalse

skipOnFirstAppliedRule：当一个规定胜利利用时，跳过余下的规定。
skipOnFirstFailedRule：当一个规定失败时，跳过余下的规定。
skipOnFirstNonTriggeredRule：当一个规定未触发时，跳过余下的规定。
rulePriorityThreshold：当优先级超过指定的阈值时，跳过余下的规定。

能够应用RulesEngineParameters API指定这些参数:
RulesEngineParameters parameters = new RulesEngineParameters()

.rulePriorityThreshold(10).skipOnFirstAppliedRule(true).skipOnFirstFailedRule(true).skipOnFirstNonTriggeredRule(true);

RulesEngine rulesEngine = new DefaultRulesEngine(parameters);
复制代码
如果你想从你的引擎中获取参数，你能够应用以下代码段:
RulesEngineParameters parameters = myEngine.getParameters();
复制代码
这容许在创立引擎参数后从新设置引擎参数。
定义规定监听器
能够通过RuleListener API来监听规定执行事件:
public interface RuleListener {

/** * 在评估规定之前触发。 * * @param rule 正在被评估的规定 * @param facts 评估规定之前的已知事实 * @return 如果规定应该评估，则返回true，否则返回false */default boolean beforeEvaluate(Rule rule, Facts facts) {    return true;}/** * 在评估规定之后触发 * * @param rule 评估之后的规定 * @param facts 评估规定之后的已知事实 * @param evaluationResult 评估后果 */default void afterEvaluate(Rule rule, Facts facts, boolean evaluationResult) { }/** * 运行时异样导致条件评估谬误时触发 * * @param rule 评估之后的规定 * @param facts 评估时的已知事实 * @param exception 条件评估时产生的异样 */default void onEvaluationError(Rule rule, Facts facts, Exception exception) { }/** * 在规定操作执行之前触发。 * * @param rule 以后的规定 * @param facts 执行规定操作时的已知事实 */default void beforeExecute(Rule rule, Facts facts) { }/** * 在规定操作胜利执行之后触发 * * @param rule t以后的规定 * @param facts 执行规定操作时的已知事实 */default void onSuccess(Rule rule, Facts facts) { }/** * 在规定操作执行失败时触发 * * @param rule 以后的规定 * @param facts 执行规定操作时的已知事实 * @param exception 执行规定操作时产生的异样 */default void onFailure(Rule rule, Facts facts, Exception exception) { }

}
复制代码
能够实现这个接口来提供自定义行为，以便在每个规定之前/之后执行。要注册监听器，请应用以下代码段：
DefaultRulesEngine rulesEngine = new DefaultRulesEngine();
rulesEngine.registerRuleListener(myRuleListener);
复制代码
能够注册任意数量的侦听器，它们将依照注册程序执行。
留神：当应用组合规定时，监听器是围绕组合规定调用的。
定义规定引擎监听器
能够通过RulesEngineListener API来监听规定引擎的执行事件:
public interface RulesEngineListener {

/** * 在执行规定集之前触发 * * @param rules 要触发的规定集 * @param facts 触发规定前的事实 */default void beforeEvaluate(Rules rules, Facts facts) { }/** * 在执行规定集之后触发 * * @param rules 要触发的规定集 * @param facts 触发规定前的事实 */default void afterExecute(Rules rules, Facts facts) { }

}
复制代码
RulesEngineListener容许咱们在触发整个规定集之前/之后提供自定义行为。能够应用如下形式注册监听器。
DefaultRulesEngine rulesEngine = new DefaultRulesEngine();
rulesEngine.registerRulesEngineListener(myRulesEngineListener);
复制代码
能够注册任意数量的监听器，它们将依照注册程序执行。
表达式语言(EL)反对
Easy Rules反对用MVEL、SpEL和JEXL定义规定。
EL提供者注意事项
EL提供者在行为上有一些区别。例如，当一个事实在条件中缺失时，MVEL抛出一个异样，而SpEL将疏忽它并返回false。因而，在抉择Easy Rules应用哪个EL之前，你应该理解这些差别。
通过编程的形式定义规定
条件、动作和规定别离由MVELCondition/SpELCondition/JexlCondition、MVELAction/SpELAction/JexlAction和MVELRule/SpELRule/JexlRule类示意。上面是一个应用MVEL定义规定的例子:
Rule ageRule = new MVELRule()

    .name("age rule")    .description("Check if person's age is > 18 and marks the person as adult")    .priority(1)    .when("person.age > 18")    .then("person.setAdult(true);");

复制代码
通过规定形容文件定义规定
能够应用规定形容文件定义规定，应用MVELRuleFactory/SpELRuleFactory/JexlRuleFactory来从描述符文件创建规定。上面是一个在alcohol-rule.yml中以YAML格局定义的MVEL规定示例:
name: "alcohol rule"
description: "children are not allowed to buy alcohol"
priority: 2
condition: "person.isAdult() == false"
actions:

• "System.out.println("Shop: Sorry, you are not allowed to buy alcohol");"

复制代码
MVELRuleFactory ruleFactory = new MVELRuleFactory(new YamlRuleDefinitionReader());
MVELRule alcoholRule = ruleFactory.createRule(new FileReader("alcohol-rule.yml"));
复制代码

还能够应用一个文件创建多个规定。

name: adult rule
description: when age is greater than 18, then mark as adult
priority: 1
condition: "person.age > 18"
actions:

• "person.setAdult(true);"

name: weather rule
description: when it rains, then take an umbrella
priority: 2
condition: "rain == true"
actions:

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

复制代码
能够应用如下形式将这些规定加载到rules对象中。
MVELRuleFactory ruleFactory = new MVELRuleFactory(new YamlRuleDefinitionReader());
Rules rules = ruleFactory.createRules(new FileReader("rules.yml"));
复制代码
Easy Rules还反对从JSON描述符加载规定。具体参考文档，这里不做开展。
规定定义中的错误处理
对于条件中不正确表达式的引擎行为
对于条件求值过程中可能产生的任何运行时异样(失落事实、表达式中输出谬误等)，引擎将记录一个正告，并认为条件求值为false。能够应用RuleListener#onEvaluationError来监听评估谬误。
对于操作中不正确表达式的引擎行为
对于任何在执行操作时可能产生的运行时异样(失落事实、表达式中输出谬误等)，该操作将不会执行，引擎将记录一个谬误。能够应用RuleListener#onFailure来监听操作执行异样。当一个规定失败时，引擎将挪动到下一个规定，除非设置了skipOnFirstFailedRule参数。
理论栗子
本栗子应用Easy Rules实现FizzBuzz应用程序。FizzBuzz是一个简略的应用程序，须要从1数到100，并且:

如果数字是5的倍数，则打印“fizz”
如果数字是7的倍数，请打印“buzz”
如果数字是5和7的倍数，请打印“fizzbuzz”
否则打印数字自身

public class FizzBuzz {
public static void main(String[] args) {

for(int i = 1; i <= 100; i++) {  if (((i % 5) == 0) && ((i % 7) == 0))    System.out.print("fizzbuzz");  else if ((i % 5) == 0) System.out.print("fizz");  else if ((i % 7) == 0) System.out.print("buzz");  else System.out.print(i);  System.out.println();}System.out.println();

}
}
复制代码
咱们将为每个需要编写一条规定:
@Rule
public class FizzRule {

@Conditionpublic boolean isFizz(@Fact("number") Integer number) {    return number % 5 == 0;}@Actionpublic void printFizz() {    System.out.print("fizz");}@Prioritypublic int getPriority() {    return 1;}

}
复制代码
@Rule
public class BuzzRule {

@Conditionpublic boolean isBuzz(@Fact("number") Integer number) {    return number % 7 == 0;}@Actionpublic void printBuzz() {    System.out.print("buzz");}@Prioritypublic int getPriority() {    return 2;}

}
复制代码
public class FizzBuzzRule extends UnitRuleGroup {

public FizzBuzzRule(Object... rules) {    for (Object rule : rules) {        addRule(rule);    }}@Overridepublic int getPriority() {    return 0;}

}
复制代码
@Rule
public class NonFizzBuzzRule {

@Conditionpublic boolean isNotFizzNorBuzz(@Fact("number") Integer number) {    return number % 5 != 0 || number % 7 != 0;}@Actionpublic void printInput(@Fact("number") Integer number) {    System.out.print(number);}@Prioritypublic int getPriority() {    return 3;}

}
复制代码
以下是对这些规定的一些解释:

FizzRule和BuzzRule很简略，它们会查看输出是5的倍数还是7的倍数，而后打印后果。
FizzBuzzRule是一个组合规定。通过FizzRule和BuzzRule创立。基类抉择为UnitRuleGroup，要么满足并利用这两个规定，要么什么都不利用。
NonFizzBuzzRule是既不是5的倍数也不是7的倍数时的规定。

请留神，咱们曾经设置了优先级，因而规定的触发程序与Java示例中的示例雷同。
而后，咱们必须将这些规定注册到一个规定集中，并应用一个规定引擎来触发它们:
public class FizzBuzzWithEasyRules {

public static void main(String[] args) {    // 创立规定引擎    RulesEngineParameters parameters = new RulesEngineParameters().skipOnFirstAppliedRule(true);    RulesEngine fizzBuzzEngine = new DefaultRulesEngine(parameters);    // 创立规定    Rules rules = new Rules();    rules.register(new FizzRule());    rules.register(new BuzzRule());    rules.register(new FizzBuzzRule(new FizzRule(), new BuzzRule()));    rules.register(new NonFizzBuzzRule());    // 触发规定    Facts facts = new Facts();    for (int i = 1; i <= 100; i++) {        facts.put("number", i);        fizzBuzzEngine.fire(rules, facts);        System.out.println();    }}

}