规则引擎--Easy-Rules2

没有是使用规则引擎

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

使用规则引擎

注意分析上面的判断条件

第一级是进行判断是否整除5和7，输出的内容和符合整除5和整除7的输出结果的拼接
第二级是整除5进行输出
第三级是整除7进行输出
第四级是不符合整除5和7，输出输入值

分析一下的代码

@rule注解为规则
@condition类似为if判断条件，返回值为boolean
@action类型输出的执行语句，返回值为void
setInput方法进行输出参数，对类的属性进行赋值
@Priority定义执行的级别

优先级别最高是0，
组合规则是继承CompositeRule，构造方法赋值其他的规则
CompositeRule是混合规则、ActivationRuleGroup、UnitRuleGroup、ConditionalRuleGroup

创建一个规则引擎，创建所需要的规则，规则引擎初始化所需要的规则。
执行的时候，对创建的规则进行赋值，此时组合规则是不需要赋值的，最后规则引擎发射规则（按照优先级>别开始执行规则，类似于线程的start）

第一规则

@Rule(name = "第一个规则",description = "整除3")
public class FirstRule {
    private int value;

    public void setValue(int value){
        this.value = value;
    }

    @Priority
    public int getPriority(){
        return 1;
    }

    @Condition
    public boolean judge(){
        return value%3==0;
    }

    @Action
    public void act(){
        System.out.print("<first rule : "+value+">");
    }
}

第二规则
与第一规则雷同，这里省略

组合规则

@Rule(name = "第一第二组合规则",description = "整除3和5")
public class ZeroRule extends CompositeRule {

    @Priority
    @Override
    public int getPriority(){
        return 0;
    }

    public ZeroRule(Object...rules){
        for (Object rule : rules) {
            addRule(rule);
        }
    }
}

test

    @Test
    void contextLoads() {
        RulesEngine engine = RulesEngineBuilder.aNewRulesEngine()
                .withSkipOnFirstAppliedRule(true)
                .withSilentMode(true)
                .build();
        FirstRule firstRule = new FirstRule();
        SecondRule secondRule = new SecondRule();
        engine.registerRule(firstRule);
        engine.registerRule(secondRule);
        engine.registerRule(new ZeroRule(firstRule,secondRule));

        for (int i = 0; i <= 30; i++) {
            firstRule.setValue(i);
            secondRule.setValue(i);
            engine.fireRules();
            System.out.println();
        }
    }

相对比第一种采用jeasy的依赖，整体操作上相对简便，而且在规则入参上灵活性比较强。