总体：

使用方面除了官网的wiki外，推荐阅读

作者：夜尽天明_
链接：https://juejin.cn/post/7048917724126248967
来源：稀土掘金

非annotation 方式，执行不是jdk proxy模式
annotation 方式，和rulebook 类似使用jdk
proxy模式，但由于本质居于pojo和继承模式，proxy调用比较简单，采用return class类指定方法
每个rule 只有一个action方法，这点与rulebook不同
支持CompositeRule，默认有3种，但不支持rulebook chain式按order执行
两种执行引擎，DefaultRulesEngine 只执行一次，InferenceRulesEngine 会循环执行，直到所有rule的evaluation 返回false
evaluation 相当于rulebook的condition，action相当于rulebook 的then

核心类及代码

public final class DefaultRulesEngine extends AbstractRulesEngine 的执行函数

void doFire(Rules rules, Facts facts) {
    if (rules.isEmpty()) {
        LOGGER.warn("No rules registered! Nothing to apply");
        return;
    }
    logEngineParameters();
    log(rules);
    log(facts);
    LOGGER.debug("Rules evaluation started");
    for (Rule rule : rules) {
        final String name = rule.getName();
        final int priority = rule.getPriority();
        if (priority > parameters.getPriorityThreshold()) {
            LOGGER.debug("Rule priority threshold ({}) exceeded at rule '{}' with priority={}, next rules will be skipped",
                    parameters.getPriorityThreshold(), name, priority);
            break;
        }
        //执行listener ，如果有返回false ，那么就不执行当前rule
        if (!shouldBeEvaluated(rule, facts)) {
            LOGGER.debug("Rule '{}' has been skipped before being evaluated", name);
            continue;
        }
        boolean evaluationResult = false;
        try {
            evaluationResult = rule.evaluate(facts);
        } catch (RuntimeException exception) {
            LOGGER.error("Rule '" + name + "' evaluated with error", exception);
            triggerListenersOnEvaluationError(rule, facts, exception);
            // give the option to either skip next rules on evaluation error or continue by considering the evaluation error as false
            if (parameters.isSkipOnFirstNonTriggeredRule()) {
                LOGGER.debug("Next rules will be skipped since parameter skipOnFirstNonTriggeredRule is set");
                break;
            }
        }
        if (evaluationResult) {
            LOGGER.debug("Rule '{}' triggered", name);
            triggerListenersAfterEvaluate(rule, facts, true);
            try {
                triggerListenersBeforeExecute(rule, facts);
                rule.execute(facts);
                LOGGER.debug("Rule '{}' performed successfully", name);
                triggerListenersOnSuccess(rule, facts);
                if (parameters.isSkipOnFirstAppliedRule()) {
                    LOGGER.debug("Next rules will be skipped since parameter skipOnFirstAppliedRule is set");
                    break;
                }
            } catch (Exception exception) {
                LOGGER.error("Rule '" + name + "' performed with error", exception);
                triggerListenersOnFailure(rule, exception, facts);
                if (parameters.isSkipOnFirstFailedRule()) {
                    LOGGER.debug("Next rules will be skipped since parameter skipOnFirstFailedRule is set");
                    break;
                }
            }
        } else {
            LOGGER.debug("Rule '{}' has been evaluated to false, it has not been executed", name);
            triggerListenersAfterEvaluate(rule, facts, false);
            if (parameters.isSkipOnFirstNonTriggeredRule()) {
                LOGGER.debug("Next rules will be skipped since parameter skipOnFirstNonTriggeredRule is set");
                break;
            }
        }
    }
}

private boolean shouldBeEvaluated(Rule rule, Facts facts) {
    return triggerListenersBeforeEvaluate(rule, facts);
}
private boolean triggerListenersBeforeEvaluate(Rule rule, Facts facts) {
    return ruleListeners.stream().allMatch(ruleListener -> ruleListener.beforeEvaluate(rule, facts));
}

public final class InferenceRulesEngine extends AbstractRulesEngine 循环执行，指定facts结果满足了所有condition都不符合，才停止执行相关rules的核心代码如下：

@Override
public void fire(Rules rules, Facts facts) {
    Set<Rule> selectedRules;
    //默认只要有selectCandidates(rules, facts) 就会执行,如果facts 没有变化那么selectCandidates返回rules就会一直一样，即不断循环执行
    do {
        LOGGER.debug("Selecting candidate rules based on the following facts: {}", facts);
        selectedRules = selectCandidates(rules, facts);
        if (!selectedRules.isEmpty()) {
            delegate.fire(new Rules(selectedRules), facts);
        } else {
            LOGGER.debug("No candidate rules found for facts: {}", facts);
        }
    } while (!selectedRules.isEmpty());
}

private Set<Rule> selectCandidates(Rules rules, Facts facts) {
    Set<Rule> candidates = new TreeSet<>();
    //如果facts 没有变化
    for (Rule rule : rules) {
        if (rule.evaluate(facts)) {
            candidates.add(rule);
        }
    }
    return candidates;
}

使用InferenceRulesEngine 一定要修改fact。

UnitRuleGroup 所有rule作为一个整体判断是否执行

@Override
public boolean evaluate(Facts facts) {
    if (!rules.isEmpty()) {
        for (Rule rule : rules) {
            if (!rule.evaluate(facts)) {
                return false;
            }
        }
        return true;
    }
    return false;
}

public class ActivationRuleGroup extends CompositeRule
通过selectedRule来（随机）选择了第一个condition符合的rule

@Override
public boolean evaluate(Facts facts) {
    for (Rule rule : rules) {
        if (rule.evaluate(facts)) {
            selectedRule = rule;
            return true;
        }
    }
    return false;
}

public class ConditionalRuleGroup extends CompositeRule 首先判断RuleWithHighestPriority的condition是否满足，如果满足再选择重所有condition符合的rule进行fire

@Override
public boolean evaluate(Facts facts) {
    successfulEvaluations = new HashSet<>();
    conditionalRule = getRuleWithHighestPriority();
    if (conditionalRule.evaluate(facts)) {
        for (Rule rule : rules) {
            if (rule != conditionalRule && rule.evaluate(facts)) {
                successfulEvaluations.add(rule);
            }
        }
        return true;
    }
    return false;
}


private Rule getRuleWithHighestPriority() {
    List<Rule> copy = sort(rules);
    // make sure we only have one rule with the highest priority
    Rule highest = copy.get(0);
    if (copy.size() > 1 && copy.get(1).getPriority() == highest.getPriority()) {
       throw new IllegalArgumentException("Only one rule can have highest priority");
    }
    return highest;
}

RuleGroup支持从yml自动创建，或者手工创建，yml自动创建代码

switch (ruleDefinition.getCompositeRuleType()) {
    case "UnitRuleGroup":
        compositeRule = new UnitRuleGroup(name);
        break;
    case "ActivationRuleGroup":
        compositeRule = new ActivationRuleGroup(name);
        break;
    case "ConditionalRuleGroup":
        compositeRule = new ConditionalRuleGroup(name);
        break;
    default:
        throw new IllegalArgumentException("Invalid composite rule type, must be one of " + ALLOWED_COMPOSITE_RULE_TYPES);
}

代码创建

public void setUp() {
conditionalRule = new TestRule("conditionalRule", "description0", 0, true);
rule1 = new TestRule("rule1", "description1", 1, true);
rule2 = new TestRule("rule2", "description2", 2, true);
conditionalRuleGroup = new ConditionalRuleGroup();
conditionalRuleGroup.addRule(rule1);
conditionalRuleGroup.addRule(rule2);
conditionalRuleGroup.addRule(conditionalRule);
rules.register(conditionalRuleGroup);
}