easy-rules小试牛刀

本文主要研究下easy-rules。

easy-rules是一款轻量级的规则引擎。

maven

		<dependency>
			<groupId>org.jeasy</groupId>
			<artifactId>easy-rules-core</artifactId>
			<version>3.1.0</version>
		</dependency>
        <dependency>
            <groupId>org.jeasy</groupId>
            <artifactId>easy-rules-mvel</artifactId>
            <version>3.1.0</version>
        </dependency>
复制代码

Rule创建方式

基于mvel表达式

easy-rules首先集成了mvel表达式,后续可能集成SpEL

  • 配置文件
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\");"
复制代码
  • 加载运行
		//create a person instance (fact)
		Person tom = new Person("Tom", 14);
		Facts facts = new Facts();
		facts.put("person", tom);

		MVELRule alcoholRule = MVELRuleFactory.createRuleFrom(new File(getClass().getClassLoader().getResource("alcohol-rule.yml").getFile()));

		// create a rule set
		Rules rules = new Rules();
		rules.register(alcoholRule);

		//create a default rules engine and fire rules on known facts
		RulesEngine rulesEngine = new DefaultRulesEngine();

		System.out.println("Tom: Hi! can I have some Vodka please?");
		rulesEngine.fire(rules, facts);
复制代码

注解方式

@Rule
public class BuzzRule {

    @Condition
    public boolean isBuzz(@Fact("number") Integer number) {
        return number % 7 == 0;
    }

    @Action
    public void printBuzz() {
        System.out.println("buzz");
    }

    @Priority
    public int getPriority() {
        return 2;
    }
}
复制代码
  • @Rule可以标注name和description属性,每个rule的name要唯一,如果没有指定,则RuleProxy则默认取类名
  • @Condition是条件判断,要求返回boolean值,表示是否满足条件
  • @Action标注条件成立之后触发的方法
  • @Priority标注该rule的优先级,默认是Integer.MAX_VALUE - 1,值越小越优先

实现Rule接口

easy-rules-core-3.1.0-sources.jar!/org/jeasy/rules/api/Rule.java

/**
 * Abstraction for a rule that can be fired by the rules engine.
 *
 * Rules are registered in a rule set of type <code>Rules</code> in which they must have a <strong>unique</strong> name.
 *
 * @author Mahmoud Ben Hassine (mahmoud.benhassine@icloud.com)
 */
public interface Rule extends Comparable<Rule> {

    /**
     * Default rule name.
     */
    String DEFAULT_NAME = "rule";

    /**
     * Default rule description.
     */
    String DEFAULT_DESCRIPTION = "description";

    /**
     * Default rule priority.
     */
    int DEFAULT_PRIORITY = Integer.MAX_VALUE - 1;

    /**
     * Getter for rule name.
     * @return the rule name
     */
    String getName();

    /**
     * Getter for rule description.
     * @return rule description
     */
    String getDescription();

    /**
     * Getter for rule priority.
     * @return rule priority
     */
    int getPriority();

    /**
     * Rule conditions abstraction : this method encapsulates the rule's conditions.
     * <strong>Implementations should handle any runtime exception and return true/false accordingly</strong>
     *
     * @return true if the rule should be applied given the provided facts, false otherwise
     */
    boolean evaluate(Facts facts);

    /**
     * Rule actions abstraction : this method encapsulates the rule's actions.
     * @throws Exception thrown if an exception occurs during actions performing
     */
    void execute(Facts facts) throws Exception;

}
复制代码

实现这个接口,也是创建rule的一种形式。

源码解析

  • register easy-rules-core-3.1.0-sources.jar!/org/jeasy/rules/api/Rules.java
    /**
     * Register a new rule.
     *
     * @param rule to register
     */
    public void register(Object rule) {
        Objects.requireNonNull(rule);
        rules.add(RuleProxy.asRule(rule));
    }
复制代码

这里使用RuleProxy.asRule方法

  • RuleProxy easy-rules-core-3.1.0-sources.jar!/org/jeasy/rules/core/RuleProxy.java
    /**
     * Makes the rule object implement the {@link Rule} interface.
     *
     * @param rule the annotated rule object.
     * @return a proxy that implements the {@link Rule} interface.
     */
    public static Rule asRule(final Object rule) {
        Rule result;
        if (rule instanceof Rule) {
            result = (Rule) rule;
        } else {
            ruleDefinitionValidator.validateRuleDefinition(rule);
            result = (Rule) Proxy.newProxyInstance(
                    Rule.class.getClassLoader(),
                    new Class[]{Rule.class, Comparable.class},
                    new RuleProxy(rule));
        }
        return result;
    }
复制代码

可以看到,如果有实现Rule接口,则直接返回,没有的话(即基于注解的形式),则利用JDK的动态代理进行包装。

  • invoke
   @Override
    public Object invoke(final Object proxy, final Method method, final Object[] args) throws Throwable {
        String methodName = method.getName();
        switch (methodName) {
            case "getName":
                return getRuleName();
            case "getDescription":
                return getRuleDescription();
            case "getPriority":
                return getRulePriority();
            case "compareTo":
                return compareToMethod(args);
            case "evaluate":
                return evaluateMethod(args);
            case "execute":
                return executeMethod(args);
            case "equals":
                return equalsMethod(args);
            case "hashCode":
                return hashCodeMethod();
            case "toString":
                return toStringMethod();
            default:
                return null;
        }
    }
复制代码

可以看到这里invoke对方法进行了适配

下面以getName为例看下如何根据注解来返回

    private String getRuleName() {
        org.jeasy.rules.annotation.Rule rule = getRuleAnnotation();
        return rule.name().equals(Rule.DEFAULT_NAME) ? getTargetClass().getSimpleName() : rule.name();
    }
复制代码

可以看到这里对注解进行了解析

小结

从本质上看,规则引擎的目的就是要以松散灵活的方式来替代硬编码式的if else判断,来达到解耦的目的,不过实际场景要额外注意规则表达式的安全问题。

doc

©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页