java轻量级规则引擎easy-rules使用介绍

轻量级规则引擎easy-rules--参考

我们在写业务代码经常遇到需要一大堆if/else,会导致代码可读性大大降低,有没有一种方法可以避免代码中出现大量的判断语句呢?答案是用规则引擎,但是传统的规则引擎都比较重,比如开源的Drools,不适合在小需求中应用。最近在github上面看到一个傻瓜式的Java规则引擎Easy-Rules,这里结合自己写的demo介绍如何使用这个规则引擎,希望对大家有所帮助。

easy-rules的特点

  • 轻量级类库和容易上手
  • 基于POJO的开发与注解的编程模型
  • 基于MVEL表达式的编程模型(适用于极简单的规则,一般不推荐)
  • 支持根据简单的规则创建组合规则
  • 方便且适用于java的抽象的业务模型规则

它主要包括几个主要的类或接口:Rule,RulesEngine,RuleListener,Facts还有几个主要的注解:@Action,@Condition,@Fact,@Priority,@Rule

例1:基于POJO开发与注解的编程模型:判断1-50中,被3或者8整除的数

首先maven 引入easy-rules

   <dependency>
      <groupId>org.jeasy</groupId>
      <artifactId>easy-rules-core</artifactId>
      <version>3.3.0</version>
    </dependency>
    <dependency>
      <groupId>org.jeasy</groupId>
      <artifactId>easy-rules-mvel</artifactId>
      <version>3.3.0</version>
    </dependency>

编写规则POJO:

规则1

@Rule(name = "被3整除", description = "number如果被3整除,打印:number is three")
public class ThreeRule {
  /**
   * Condition:条件判断注解:如果return true, 执行Action
   *
   * @param number
   * @return
   */
  @Condition
  public boolean isThree(@Fact("number") int number) {
    return number % 3 == 0;
  }

  /**
   * Action 执行方法注解
   *
   * @param number
   */
  @Action
  public void threeAction(@Fact("number") int number) {
    System.out.println(number + " is three");
  }

  /**
   * Priority:优先级注解:return 数值越小,优先级越高
   *
   * @return
   */
  @Priority
  public int getPriority() {
    return 1;
  }
}

规则2

@Rule(name = "被8整除")
public class EightRule {

  /**
   * 条件
   *
   * @param number
   * @return
   */
  @Condition
  public boolean isEight(@Fact("number") int number) {
    return number % 8 == 0;
  }

  /**
   * 满足条件的动作
   *
   * @param number
   */
  @Action
  public void eightAction(@Fact("number") int number) {
    System.out.println(number + " is eight");
  }

  /**
   * 条件判断的优先级
   *
   * @return
   */
  @Priority
  public int getPriority() {
    return 2;
  }
}

规则3(组合规则-同时执行)

@Rule(name = "被3和8同时整除", description = "这是一个组合规则")
public class ThreeEightRuleUnitGroup extends UnitRuleGroup {

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

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

规则4

@Rule(name = "既不被3整除也不被8整除", description = "打印number自己")
public class OtherRule {
  @Condition
  public boolean isOther(@Fact("number") int number){
    return number % 3 != 0 || number % 8 != 0;
  }

  @Action
  public void printSelf(@Fact("number") int number){
    System.out.print(number);
  }

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

执行规则

public class ThreeEightRuleLauncher {

  public static void main(String[] args) {
    /**
     * 创建规则执行引擎
     * 注意: skipOnFirstAppliedRule意思是,只要匹配到第一条规则就跳过后面规则匹配
     */
    RulesEngineParameters parameters = new
    RulesEngineParameters().skipOnFirstAppliedRule(true);
    RulesEngine rulesEngine = new DefaultRulesEngine(parameters);
    //创建规则
    Rules rules = new Rules();
    rules.register(new EightRule());
    rules.register(new ThreeRule());
    rules.register(new ThreeEightRuleUnitGroup(new EightRule(), new ThreeRule()));
    rules.register(new OtherRule());
    Facts facts = new Facts();
    for (int i=1 ; i<=50 ; i++){
      //规则因素,对应的name,要和规则里面的@Fact 一致
      facts.put("number", i);
      //执行规则
      rulesEngine.fire(rules, facts);
      System.out.println();
    }
  }
}

例2:基于MVEL表达式的编程模型

本例演示如何使用MVEL表达式定义规则,MVEL通过Easy-Rules MVEL模块提供。此模块包含使用MVEL定义规则的API。我们将在这里使用这些API,其目标是实现一个简单的商店应用程序,要求如下:禁止儿童购买酒精,成年人的最低法定年龄为18岁。 商店顾客由Person类定义:

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Person {
  private String name;

  private boolean adult;

  private int age;
  //getter, setter 省略

  public Person(String name, int age) {
    this.name = name;
    this.age = age;
  }
}

我们定义两个规则:

  • 规则1:可以更新Person实例,判断年龄是否大于18岁,并设置成人标志。
  • 规则2:判断此人是否为成年人,并拒绝儿童(即非成年人)购买酒精。

显然,规则1的优先级要大于规则2,我们可以设置规则1的Priority为1,规则2的Priority为2,这样保证规则引擎在执行规则的时候,按优先级的顺序执行规则。

规则1的定义

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

规则2的定义,我们放到alcohol-rule.yml文件中

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

执行规则

public class ShopLauncher {
  public static void main(String[] args) throws Exception {
    //创建一个Person实例(Fact)
    Person tom = new Person("Tom", 19);
    Facts facts = new Facts();
    facts.put("person", tom);

    //创建规则1
    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);");
    //创建规则2
    Rule alcoholRule = new MVELRuleFactory(new YamlRuleDefinitionReader()).
        createRule(new FileReader(ResourceUtils.getFile("classpath:alcohol-rule.yml")));

    Rules rules = new Rules();
    rules.register(ageRule);
    rules.register(alcoholRule);

    //创建规则执行引擎,并执行规则
    RulesEngine rulesEngine = new DefaultRulesEngine();
    System.out.println("Tom: Hi! can I have some Vodka please?");
    rulesEngine.fire(rules, facts);
    System.out.println(JSON.toJSONString(tom));
  }
}

执行结果如下:

本篇主要介绍easy-rules的使用

深入了解原理,可以查看github源码:https://github.com/j-easy/easy-rules

到此这篇关于java轻量级规则引擎easy-rules使用介绍的文章就介绍到这了,更多相关java easy-rules内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Java规则引擎Easy Rules的使用介绍

    1. Easy Rules 概述 Easy Rules是一个Java规则引擎,灵感来自一篇名为<Should I use a Rules Engine?>的文章 规则引擎就是提供一种可选的计算模型.与通常的命令式模型(由带有条件和循环的命令依次组成)不同,规则引擎基于生产规则系统.这是一组生产规则,每条规则都有一个条件(condition)和一个动作(action)---- 简单地说,可以将其看作是一组if-then语句. 精妙之处在于规则可以按任何顺序编写,引擎会决定何时使用对顺序有意义的任

  • java轻量级规则引擎easy-rules使用介绍

    轻量级规则引擎easy-rules--参考 我们在写业务代码经常遇到需要一大堆if/else,会导致代码可读性大大降低,有没有一种方法可以避免代码中出现大量的判断语句呢?答案是用规则引擎,但是传统的规则引擎都比较重,比如开源的Drools,不适合在小需求中应用.最近在github上面看到一个傻瓜式的Java规则引擎Easy-Rules,这里结合自己写的demo介绍如何使用这个规则引擎,希望对大家有所帮助. easy-rules的特点 轻量级类库和容易上手 基于POJO的开发与注解的编程模型 基于

  • Java规则引擎easy-rules详细介绍

    目录 简介 开始使用 引入依赖 定义规则 使用注解定义规则 使用RuleBuilder定义规则 组合规则 规则优先级 Rules API 定义事实 定义规则引擎 创建规则引擎 规则引擎参数 定义规则监听器 定义规则引擎监听器 表达式语言(EL)支持 EL提供者注意事项 通过编程的方式定义规则 通过规则描述文件定义规则 规则定义中的错误处理 实际栗子 最近在思考一个基于规则进行挑选的技术重构,想通过规则引擎进行实现,借着这个机会正好可以详细了解一下规则引擎.本篇文章将会详细介绍规则引擎easy-r

  • SpringBoot2整合Drools规则引擎及案例详解

    一.Drools引擎简介 1.基础简介 Drools是一个基于java的规则引擎,开源的,可以将复杂多变的规则从硬编码中解放出来,以规则脚本的形式存放在文件中,使得规则的变更不需要修正代码重启机器就可以立即在线上环境生效.具有易于访问企业策略.易于调整以及易于管理的特点,作为开源业务规则引擎,符合业内标准,速度快.效率高. 2.规则语法 (1).演示drl文件格式 package droolRule ; import org.slf4j.Logger import org.slf4j.Logge

  • Spring Boot+Drools规则引擎整合详解

    目的 官方的Drools范例大都是基于纯Java项目或Maven项目,而基于Spring Boot项目的很少. 本文介绍如何在Spring Boot项目上加上Drools规则引擎. POM依赖 POM文件如下: <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=&q

  • SpringBoot整合Drools规则引擎动态生成业务规则的实现

          最近的项目中,使用的是flowable工作流来处理业务流程,但是在业务规则的配置中,是在代码中直接固定写死的,领导说这样不好,需要规则可以动态变化,可以通过页面去动态配置改变,所以就花了几天时间去研究了一下Drools规则引擎框架.然后应用到了项目中. 首先在项目中引入规则引擎相关依赖 <properties> <java.version>1.8</java.version> <drools.version>7.20.0.Final</dr

  • 一文带你学会规则引擎Drools的应用

    目录 前言 引入依赖 Drools配置类 添加业务Model 定义drools 规则 添加Service层 添加Controller 测试一下 总结 前言 现在有这么个需求,网上购物,需要根据不同的规则计算商品折扣,比如VIP客户增加5%的折扣,购买金额超过1000元的增加10%的折扣等,而且这些规则可能随时发生变化,甚至增加新的规则.面对这个需求,你该怎么实现呢?难道是计算规则一变,就要修改业务代码,重新测试,上线吗. 其实,我们可以通过规则引擎来实现,Drools 就是一个开源的业务规则引擎

  • Java虚拟机执行引擎知识总结

    执行引擎 也只有几个概念, JVM方法调用和执行的基础数据结构是 栈帧, 是内存区域中 虚拟机栈中的栈元素, 每一个方法的执行就对应着一个栈帧在虚拟机栈中出栈入栈的过程. 栈帧:则是包含有局部变量表, 操作数栈, 动态连接, 方法返回地址, 附加信息. 1 局部变量表: 存储单位是 slot, 一个slot占据32位, 对于64位的数据类型, 则是分配连续两个slot空间. 而对于一个非静态方法而言, 有一个隐藏参数, 为 this, 而在局部变量表中的变量存储顺序则是 this -> 方法参数

  • Java中批处理框架spring batch详细介绍

    spring batch简介 spring batch是spring提供的一个数据处理框架.企业域中的许多应用程序需要批量处理才能在关键任务环境中执行业务操作. 这些业务运营包括: 无需用户交互即可最有效地处理大量信息的自动化,复杂处理. 这些操作通常包括基于时间的事件(例如月末计算,通知或通信). 在非常大的数据集中重复处理复杂业务规则的定期应用(例如,保险利益确定或费率调整). 集成从内部和外部系统接收的信息,这些信息通常需要以事务方式格式化,验证和处理到记录系统中. 批处理用于每天为企业处

  • C#规则引擎RulesEngine的具体使用

    当编写应用程序时,经常性需要花费大量的时间与精力处理业务逻辑,往往业务逻辑的变化需要重构或者增加大量代码,对开发测试人员很不友好. 之前在这篇文章说过,可以使用脚本引擎来将我们需要经常变化的代码进行动态编译执行,自由度非常大,不过对应的需要资源也多.如果只是针对非常具体业务逻辑的变化,可以尝试使用RulesEngine对程序进行操作. 下文使用了官方示例且部分内容翻译自说明文档 简介 RulesEngine是微软推出的规则引擎,规则引擎在很多企业开发中有所应用,是处理经常变动需求的一种优雅的方法

随机推荐