规则引擎-Easy-Rules_easyrules规则引擎

一、什么是规则引擎

规则引擎（Rule Engine）是一种软件组件或应用程序，它允许用户或开发者以业务规则的形式定义复杂的业务逻辑，而无需编写硬编码的代码。这些业务规则可以被动态地管理（添加、删除、修改）和执行，从而允许系统更加灵活和可配置地处理各种业务场景。

二、Easy Rules是什么样的

• 当谈到轻量级框架与易于学习的API时，这些特性通常与灵活性、低学习曲线以及快速开发周期相关联。在规则引擎领域，这样的框架允许开发者以简单而直观的方式构建、维护和扩展业务规则。以下是对这些特性的详细阐述，以及如何与基于POJO的开发、组合规则创建以及表达式语言（如MVEL、SPEL和JEXL）支持相结合：

  轻量级框架

  轻量级框架通常意味着它们具有较小的内存占用、简单的架构和快速的启动时间。这样的框架易于集成到现有项目中，不会引入过多的依赖或复杂性。对于规则引擎而言，轻量级框架能够迅速响应业务规则的变化，同时保持系统的轻量和高性能。

  易于学习的API

  易于学习的API是用户友好的，其设计旨在减少学习曲线，使新手和经验丰富的开发者都能快速上手。一个好的API应该具有清晰的文档、直观的命名约定和一致的接口。在规则引擎的上下文中，这意味着开发者可以轻松地定义、查询和修改业务规则，而无需深入了解底层实现的复杂性。

  基于POJO的开发

  Plain Old Java Objects（POJOs）是一种简单的Java对象，不包含任何特定框架的类或接口继承。基于POJO的开发意味着开发者可以使用普通的Java类来定义业务逻辑和数据模型，而无需依赖于任何外部库或框架的特定功能。在规则引擎中，这允许开发者使用标准的Java对象来表示业务规则的条件和动作，从而简化了代码的编写和维护。

  支持从原始规则创建组合规则

  组合规则是将多个原始规则组合成一个更复杂的规则的逻辑结构。这种能力对于处理复杂的业务场景非常有用，因为它允许开发者将小的、可管理的规则片段组合成更强大、更灵活的规则集。支持组合规则的规则引擎应该提供清晰的语法和API来定义这些组合关系，如顺序执行、并行执行、逻辑与（AND）、逻辑或（OR）等。

  支持通过表达式（如MVEL，SPEL和JEXL）定义规则

  表达式语言（如MVEL、Spring Expression Language - SPEL、和Java Expression Language - JEXL）提供了一种强大的方式来在代码中嵌入动态表达式。这些表达式可以引用Java对象、执行方法调用、进行算术和逻辑运算等。在规则引擎中，支持这些表达式语言允许开发者以更灵活和强大的方式定义业务规则的条件和动作。例如，他们可以使用表达式来检查特定对象的属性值、调用对象的方法或根据输入数据计算新值。

三、规则定义

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

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.
 
}

valuate()方法封装了必须为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 {
 
    @Condition
    public 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表示已注册规则的命名空间，因此，在同一命名空间下，每一个已经注册的规则必须有唯一的名称。

定义事实

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 {
 
    @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
    }
 
}

类型为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引擎可以配置以下参数:

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定义规则。

通过编程的方式定义规则
条件、动作和规则分别由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");"

还可以使用一个文件创建多个规则。

---
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"));

总的来说，对于日常工作还是很有帮助的