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

• mvel
• easy-rules
• RulesEngine
• 规则引擎选型及应用
• 规则引擎之EasyRules
• expression-language-support