EasyRules

最新推荐文章于 2025-03-07 18:36:00 发布
最新推荐文章于 2025-03-07 18:36:00 发布
阅读量1.4k 收藏 14
点赞数 3
分类专栏： 规则引擎 文章标签： java drools
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_41896365/article/details/122253126
版权

规则引擎使用简介(easyRules)

github地址：https://github.com/j-easy/easy-rules

参考文章：https://www.jianshu.com/p/9b67ab434795
https://my.oschina.net/crosschen/blog/4803180
http://t.zoukankan.com/rongfengliang-p-12693489.html

文章目录

为什么要用规则引擎替代if-else?

世界上最遥远的距离，是我在if里你在else里

为什么会使用到if-else?

  • 刚开始自己写的代码很简洁，逻辑清晰，函数精简，没有一个if-else
    但是需求发展却不以人的意志为转移
  • 业务逻辑千奇百怪
  • 需求无限叠加
  • 项目进度约束
  • …

由于以上诸多原因，最终代码中会出现很多的if-else，而且更有甚者有很多嵌套的if-else，着会给接锅者头越来越秃

使用if-else的场景主要有

  • 异常逻辑处理
  • 特殊case处理
  • 不同状态处理

过多的繁琐的if-else不但会降低程序的性能，还不利于后期维护，有可能出现昨天写的代码，今天来看“我靠！这是啥呀！！”

现在有一个相对较好的工具可以帮助我们进行复杂逻辑处理，那就是规则引擎。

什么是规则引擎

如果是简单的逻辑判断可以通过if-else轻松解决，但是，现实中的业务逻辑不允许我们轻松解决，一旦业务逻辑复杂了，if-else接那么香了，规则引擎就不同，你可以根据业务场景来编写不同的规则，即使业务变更了，只需要修改或添加相关的规则就可，然后引用不同的规则进行逻辑处理，这样做可以极大的降低开发成本和运维的难度，也变相保护了大伙的头发，何乐而不为呢？！

规则引擎应用场景

  • 流程分支非常复杂，规则变量庞大，常规编码（if-else）难以实现
  • 有不确定性的需求，变更频率较高
  • 需要快速做出响应和决策
  • 规则变更期望脱离于开发人员，脱离coding

规则引擎流程

在这里插入图片描述

业务规则发展历程

在这里插入图片描述

相关工具

Drools, easy-rules，Rule Book(未了解过)

Droolseasy-rulesRule Book
简介可以执行复杂事件处理的规则引擎简单轻量级的规则引擎支持Lambda的轻量级规则引擎
流行度8.7 ★★★★★8.0 ★★★★5.1 ★★★
活跃度9.4 ❤❤❤❤❤7.5 ❤❤❤❤4.4 ❤❤❤
代码质量L1（Lumnify统计）L5（Lumnify统计）
当前版本7.47.0.FinalV 4.1V 0.12
版本支持7.x 版本已持续多年仅支持 4.1.x，老版本不支持更新2018年5月发布V 0.11，V 0.12发布时间不详
编程语言JavaJavaJava
算法RETE算法--

在这里插入图片描述

easy-rules使用简介

相关依赖：

<dependencies>
        <dependency>
            <groupId>org.jeasy</groupId>
            <artifactId>easy-rules-core</artifactId>
            <version>4.1.0</version>
        </dependency>

        <dependency>
            <groupId>org.jeasy</groupId>
            <artifactId>easy-rules-support</artifactId>
            <version>4.1.0</version>
        </dependency>

        <dependency>
            <groupId>org.jeasy</groupId>
            <artifactId>easy-rules-mvel</artifactId>
            <version>4.1.0</version>
        </dependency>
</dependencies>
规则定义

  1. 基于注解的javaBean定义

    使用@Rule来定义一个规则，@Condition 申明规则条件判断（只能有一个），@Action 申明规则执行内容（可有多个，并且可以通过order指定优先级）

    @Rule(name = "weather rule", description = "if it rains then take an umbrella")
class WeatherRule {

    @Condition
    public boolean itRains(@Fact("rain") boolean rain) {
        return rain;
    }
    
    @Action(order = 0)
    public void takeAnUmbrella() {
        System.out.println("It rains, take an umbrella!");
    }
    
    @Action(order = 1)
    public void takeAnUmbrella() {
        System.out.println("It rains, take an umbrella2!");
    }
}

    测试样例：

        public static void main(String[] args) {
        Facts facts = new Facts();
        facts.put("rain", true);

        // define rules
        Rules rules = new Rules();
        rules.register(new WeatherRules());

        // fire rules on known facts
        RulesEngine rulesEngine = new DefaultRulesEngine();
        rulesEngine.fire(rules, facts);
    }

  2. 流式编程方式实现

    通过RuleBuilder来定义一个规则，并在规则上直接定义规则内容

    Rule weatherRule = new RuleBuilder()
        .name("weather rule")
        .description("if it rains then take an umbrella")
        .when(facts -> facts.get("rain").equals(true))
        .then(facts -> System.out.println("It rains, take an umbrella!"))
        .build();

    测试代码：

    public class FluentTest {

    public static void main(String[] args) {
        Rule weatherRule = new MVELRule()
                .name("weather rule")
                .description("if it rains then take an umbrella")
                .when("rain == true")
                .then("System.out.println(\"It rains, take an umbrella! \nThat's fluentTest!\");");

        Rules rules = new Rules();
        rules.register(weatherRule);

        Facts facts = new Facts();
        facts.put("rain", true);

        RulesEngine engine = new DefaultRulesEngine();
        engine.fire(rules, facts);
    }
}

  3. 表达式定义

    通过MVELRule类来定义一个规则，通过表达是的方式在规则类上定义规则内容

    Rule weatherRule = new MVELRule()
        .name("weather rule")
        .description("if it rains then take an umbrella")
        .when("rain == true")
        .then("System.out.println(\"It rains, take an umbrella!\");");

    测试代码：

    public class ExpressionTest {

    public static void main(String[] args) {
        Rule weatherRule = new MVELRule()
                .name("weather rule")
                .description("if it rains then take an umbrella")
                .when("rain == true")
                .then("System.out.println(\"It rains, take an umbrella! \nThat's ExpressionTest\");");

        Rules rules = new Rules();
        rules.register(weatherRule);

        Facts facts = new Facts();
        facts.put("rain", true);

        RulesEngine engine = new DefaultRulesEngine();
        engine.fire(rules, facts);
    }
}

  4. yml文件定义

    通过定义一个yml规则文件，在通过读取文件来获取规则

    通过MVELRuleFactory类来获取yml文件定义的规则

    需要添加依赖

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

    yml文件：

    文件路径：resource/rules/rain.yml

    在这里插入图片描述

    name: "weather rule"
description: "if it rains then take an umbrella"
condition: "rain == true"
actions:
  - "System.out.println(\"It rains, take an umbrella!\");"

    文件读取：

    MVELRuleFactory ruleFactory = new MVELRuleFactory(new YamlRuleDefinitionReader());
Rule weatherRule = ruleFactory.createRule(new FileReader("rain.yml"));

    测试代码：

    public class YmlTest {

    public static void main(String[] args) {
        MVELRuleFactory ruleFactory = new MVELRuleFactory(new YamlRuleDefinitionReader());
        
        // 读取规则文件
        String path = YmlTest.class.getResource("/rules/rain.yml").getPath();

        try {
            FileReader ymlReader = new FileReader(path);
            Rule rule = ruleFactory.createRule(ymlReader);

            Rules rules = new Rules();
            rules.register(rule);

            Facts facts = new Facts();
            facts.put("rain", true);

            RulesEngine engine = new DefaultRulesEngine();
            engine.fire(rules, facts);
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}

  5. json文件定义

    通过定义一个json规则文件，在通过读取文件来获取规则

    通过MVELRuleFactory类来获取json文件定义的规则

    需要添加依赖（若需要用到UnitRuleGroup相关类则需要添加第二个依赖）

    <dependency>
    <groupId>org.jeasy</groupId>
    <artifactId>easy-rules-mvel</artifactId>
    <version>4.1.0</version>
</dependency>
<dependency>
    <groupId>org.jeasy</groupId>
    <artifactId>easy-rules-support</artifactId>
    <version>4.1.0</version>
</dependency>

    json文件：

    //单个规则
[
    {
        "name": "3",
        "description": "if it rains then take an umbrella",
        "condition": "rain == true",
        "priority": 3,
        "actions": [
          "System.out.println(\"It rains, take an umbrella!\")"
        ]
	}
]
// 多个规则
[
  {
    "name": "1",
    "description": "1",
    "priority": 1,
    "compositeRuleType": "UnitRuleGroup",
    "composingRules": [
      {
        "name": "2",
        "description": "2",
        "condition": "user.getAge()<28",
        "priority": 2,
        "actions": [
          "System.out.println(\"UnitRuleGroup not ok rule2\")"
        ]
      },
      {
        "name": "3",
        "description": "3",
        "condition": "user.name.length<10",
        "priority": 3,
        "actions": [
          "System.out.println(\"UnitRuleGroup rule3\")"
        ]
      },
      {
        "name": "4",
        "description": "4",
        "condition": "user.name.length<10",
        "priority": 4,
        "actions": [
          "System.out.println(\"UnitRuleGrouprule4\")"
        ]
      },
      {
        "name": "5",
        "description": "5",
        "condition": "user.name.length<10",
        "priority": 5,
        "actions": [
          "System.out.println(\"UnitRuleGrouprule5\"), UserService.doAction4(user.userinfo)"
        ]
      }
    ]
  },
  {
    "name": "3",
    "description": "3",
    "condition": "user.name.length<50",
    "priority": 3,
    "actions": [
      "System.out.println(\"defaultrule3\")"
    ]
  }
]

    文件读取：

    MVELRuleFactory jsonFactory = new MVELRuleFactory(new JsonRuleDefinitionReader());
Rule weatherRule = ruleFactory.createRule(new FileReader("weather-rule.json"));

    测试代码：

    public static void main(String[] args) {
        MVELRuleFactory factory = new MVELRuleFactory(new JsonRuleDefinitionReader());

        // 读取json文件
        String path = JsonTest.class.getResource("/rules/rain.json").getPath();

        try {
            FileReader jsonFile = new FileReader(path);
            Rule rule = factory.createRule(jsonFile);

            Rules rules = new Rules();
            rules.register(rule);

            Facts facts = new Facts();
            facts.put("rain", true);

            RulesEngine engine = new DefaultRulesEngine();
            engine.fire(rules, facts);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    读取json文件时报了个错，我理解因该是要将json对象构造为数据结构，就算是单个规则也要已数据结构存放才行，我把json文件中的内容使用‘[ ]’ 框起来就好了。

    在这里插入图片描述

执行规则大致流程：

public class Test {
    public static void main(String[] args) {
        // define facts
        Facts facts = new Facts();
        facts.put("rain", true);

        // define rules 构造rule的形式有上面列举的几种
        Rule weatherRule = ...
        Rules rules = new Rules();
        rules.register(weatherRule);

        // fire rules on known facts
        RulesEngine rulesEngine = new DefaultRulesEngine();
        rulesEngine.fire(rules, facts);
    }
}
执行引擎（engine）

easyRules提供了两种引擎，分别是DefaultRulesEngine和InferenceRulesEngine

DefaultRulesEngine：根据设置的priority 来执行规则，若不设置priority则根据默认的顺序执行，每个规则只执行一次

InferenceRulesEngine：循环执行规则，只有当所有规则无法匹配成功才结束匹配（这里会出现死循环）

在对InferenceRulesEngine做测试时，我想每次在Condition中修改Face对象，但是并没有找到操作的方法，想了一下，condition中仅仅只是做判断的，好像不具备逻辑处理的能力，我觉得这是合理的，如果condition中做逻辑处理就违背了它的本职，最多也只能调用外部方法进行逻辑判断，而不是直接进行逻辑处理，逻辑处理应该要交到Action中进行。

引擎参数

参数类型是否必填默认值描述
rulePriorityThresholdintnoMaxInt当规则的priority超过设置的阈值，跳过规则
skipOnFirstAppliedRulebooleannofalse当第一个规则执行成功时，跳过下一个规则
skipOnFirstFailedRulebooleannofalse当第一个规则执行失败时，跳过下一个规则
skipOnFirstNonTriggeredRulebooleannofalse当第一个规则未触发时，跳过下一个规则

测试：

  • skipOnFirstAppliedRule参数

    @Rule(name = "fiveRules", description = "this is fiveRules")
public class FiveRules {

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

    @Action
    public void isFizz(@Fact("number") Integer number){
        System.out.println(number + "是5的倍数");
    }

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

    @Rule(name = "sevenRules", description = "this is sevenRules")
public class SevenRules {

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

    @Action
    public void then(@Fact("number") Integer number){
        System.out.println(number + "7的倍数！");
    }

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

    		Rules rules = new Rules();
        rules.register(new SevenRules());
        rules.register(new FiveRules());
//        rules.register(new FiveOrSevenRules(new FiveRules(), new SevenRules()));
//        rules.register(new NonFiveOrSevenRules());

        Facts facts = new Facts();

        facts.put("number", 35);

        RulesEngineParameters parameters = new RulesEngineParameters();
        parameters.setSkipOnFirstAppliedRule(true);

        RulesEngine engine = new DefaultRulesEngine(parameters);// 应用参数
        RulesEngine engine1 = new DefaultRulesEngine();// 不应用参数
        
        engine.fire(rules, facts);
        System.out.println("--------------------------");
        engine1.fire(rules, facts);
        System.out.println("--------------------------");

    运行结果：
35
35是5的倍数
--------------------------
35
35是5的倍数
357的倍数！
--------------------------

  • skipOnFirstFailedRule参数

    这个参数有点没整明白，失败跳过下一个规则，我理解的应该是返回false则不会执行下一个规则，但是即便第一个规则返回了false,下一个规则还是被执行了；也尝试了抛异常然后就不执行下一个规则，但是就算抛了异常，下一个规则还是被执行了，所以我有点不太懂了，代码就不贴了

  • skipOnFirstNonTriggeredRule参数
    这个和上面那个一样，没整明白！！！！

  • rulePriorityThreshold参数
    只有priority参数小于等于设置的值时规则才会被触发

    @Rule(name = "fiveRules", description = "this is fiveRules")
public class FiveRules {

    @Condition
    public boolean isFive(@Fact("number") Integer number){
    	System.out.println("触发规则isFive");
		return number % 5 == 0;
    }

    @Action
    public void isFizz(@Fact("number") Integer number){
        System.out.println(number + "是5的倍数");
    }

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

    @Rule(name = "sevenRules", description = "this is sevenRules")
public class SevenRules {

    @Condition
    public boolean isSeven(@Fact("number") Integer number){
        System.out.println("触发规则isSeven");
        return number % 7 == 0;
    }

    @Action
    public void then(@Fact("number") Integer number){
        System.out.println(number + "7的倍数！");
    }

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

}

    public static void main(String[] args) {
      RulesEngine engine = new DefaultRulesEngine(parameters);

        Rules rules = new Rules();
        rules.register(new SevenRules());
        rules.register(new FiveRules());

        Facts facts = new Facts();

        facts.put("number", 7);

        RulesEngineParameters parameters = new RulesEngineParameters();
//        parameters.setSkipOnFirstAppliedRule(true);
//        parameters.setSkipOnFirstFailedRule(true);
//        parameters.setSkipOnFirstNonTriggeredRule(true);
        parameters.setPriorityThreshold(5);

        RulesEngine engine = new DefaultRulesEngine(parameters);
        RulesEngine engine1 = new DefaultRulesEngine();
        
        engine.fire(rules, facts);
        System.out.println("--------------------------");
        engine1.fire(rules, facts);
        System.out.println("--------------------------");
    }

    运行结果：
触发规则isFive
--------------------------
触发规则isFive
触发规则isSeven
77的倍数！
--------------------------
规则监听
触发方法名触发时机
beforeEvaluate在执行规则Condition之前执行
afterEvaluate在执行完规则Condition之后执行
onEvaluationError在执行规则Condition中发生异常后执行
beforeExecute在执行规则Action之前执行
onSuccess在执行规则Action完成后执行
onFailure在执行规则Action发生异常之后执行

监听类：

public class MyRules implements RuleListener {
    @Override
    public boolean beforeEvaluate(Rule rule, Facts facts) {
        System.out.println("beforeEvaluate 触发");
        return true;
    }

    @Override
    public void afterEvaluate(Rule rule, Facts facts, boolean evaluationResult) {
        System.out.println("afterEvaluate 触发");
    }

    @Override
    public void onEvaluationError(Rule rule, Facts facts, Exception exception) {
        System.out.println("onEvaluationError 触发");
    }

    @Override
    public void beforeExecute(Rule rule, Facts facts) {
        System.out.println("beforeExecute 触发");
    }

    @Override
    public void onSuccess(Rule rule, Facts facts) {
        System.out.println("onSuccess 触发");
    }

    @Override
    public void onFailure(Rule rule, Facts facts, Exception exception) {
        System.out.println("onFailure 触发");
    }
}

规则类FiveRules：

@Rule(name = "fiveRules", description = "this is fiveRules")
public class FiveRules {

    @Condition
    public boolean isFive(@Fact("number") Integer number){
        System.out.println("触发规则isFive Condition");
//        System.out.println(1/0);
        return number % 5 == 0;
    }

    @Action
    public void isFizz(@Fact("number") Integer number){
        System.out.println(number + "是5的倍数 触发Action");
//        System.out.println(1/0);
    }

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

规则类SevenRules：

@Rule(name = "sevenRules", description = "this is sevenRules")
public class SevenRules {

    @Condition
    public boolean isSeven(@Fact("number") Integer number){
        System.out.println("触发规则isSeven Condition");
        System.out.println(1/0);
        return number % 7 == 0;
    }

    @Action
    public void then(@Fact("number") Integer number){
        System.out.println(number + " 是7的倍数！触发isSeven action");
    }

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

执行程序：

要使用监听需要使用DefaultRulesEngine 或 InferenceRulesEngine 规则引擎，使用一般的RulesEngine是没法使用监听功能的，监听器可以设置多个，若设置多个使用registerRuleListeners(List ruleListeners) 参数传入一组监听器即可。

public static void main(String[] args) {

        Rules rules = new Rules();
        rules.register(new SevenRules());
        rules.register(new FiveRules());

        Facts facts = new Facts();
        facts.put("number", 35);

        DefaultRulesEngine engine = new DefaultRulesEngine();
        engine.registerRuleListener(new MyRules());

        engine.fire(rules, facts);
    }

当监听的规则是一组复合规则的时候，监听程序只会作用在这一组规则上，而不是作用于组内的每一个规则，也就是说一组股则所有成功了，才算成功，只要有一个失败过异常，都不会触发成功（onSuccess）,有点类似数据库的事务。

符合规则类：

public class FiveOrSevenRules extends UnitRuleGroup{

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

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

执行程序：

public static void main(String[] args) {

        Rules rules = new Rules();
        rules.register(new FiveOrSevenRules(new FiveRules(), new SevenRules()));

        Facts facts = new Facts();

        facts.put("number", 35);

        DefaultRulesEngine engine = new DefaultRulesEngine();

        engine.fire(rules, facts);

    }
引擎监听
监听方法名触发时机
beforeEvaluate规则引擎触发之前执行，即在第一个规则的condition之前，先于规则监听的beforeEvaluate方法
afterExecute所有规则执行完成之后，后于规则监听的所有方法

引擎监听类:

引擎监听类需要实现 RulesEngineListener 类，通过重写beforeEvaluate方法和afterExecute方法实现

public class MyEngineListener implements RulesEngineListener {
    @Override
    public void beforeEvaluate(Rules rules, Facts facts) {
        System.out.println("engine beforeEvaluate 触发");
    }

    @Override
    public void afterExecute(Rules rules, Facts facts) {
        System.out.println("engine afterExecute 触发");
    }
}

规则类和上面规则监听的一样就不重复了

执行程序：

通过向规则引擎注册引擎监听类来进行监听，引擎监听也可以传多个，使用registerRulesEngineListeners(List rulesEngineListeners)方法，参数传入一组监听类即可。

    public static void main(String[] args) {

        Rules rules = new Rules();
        rules.register(new FiveOrSevenRules(new FiveRules(), new SevenRules()));

        Facts facts = new Facts();
        facts.put("number", 35);
        
        DefaultRulesEngine engine = new DefaultRulesEngine();
        engine.registerRulesEngineListener(new MyEngineListener());
        engine.registerRuleListener(new MyRules());

        engine.fire(rules, facts);
    }
表达式语言支持

这个在上面的规则定义已经有了，请移步规则定义

写了点测试代码，有兴趣的可以看一下，点这里查看

Drools

参考另一篇文章：https://blog.youkuaiyun.com/qq_41896365/article/details/122233006?spm=1001.2014.3001.5501

java 规则引擎 easyRules使用教程和示例
luolearn的博客
07-25 3299
规则引擎是一种软件系统，它使用定义好的业务规则来评估和执行相应的行为。它通常用于实现动态决策过程，使得规则可以在不更改应用程序代码的情况下进行修改和扩展。Easy Rules 是一个用Java编写的简单而强大的规则引擎，旨在简化规则引擎的使用。它的设计目标是使得开发者能够轻松上手，并能够快速实施业务逻辑。注解链式编程表达式yml配置文件方式一：注解@Rule注解可以把规则理解为if语句和满足条件后的执行体，当 @Condition注解的方法返回真的时候则执行@Action注解的 方法@Rule。
规则引擎-Drools-EasyRules教程
07-03
### 规则引擎-Drools-EasyRules教程 #### 规则引擎介绍 **规则引擎**是一种软件系统，用于执行一系列基于预定义规则的决策。它通常被设计为灵活且可扩展的，允许非技术人员通过定义规则来改变系统的决策逻辑而无需...
easy-rules：Java的简单愚蠢规则引擎
02-03
简单规则Java:trade_mark:的简单愚蠢规则引擎 项目状态 截至2020年12月，Easy Rules处于维护模式。 这意味着从现在开始将仅解决错误修复。 版本4.1.x是唯一受支持的版本。 请考虑尽早升级到此版本。 最新消息 月12日：版本4.1推出了一个新模块，以支持作为其他受支持的表达语言！ 您可以在找到有关其他更改的所有详细信息。 什么是简易规则？ Easy Rules是Java规则引擎，其灵感来自的一篇文章“ ” ，其中Martin说： 您可以自己构建一个简单的规则引擎。 您所需要做的就是创建一堆带有条件和动作的对象，将它们存储在一个集合中，然后遍历它们以评估条件并执行这些动作。 这正是E
规则引擎----easy rules
progammer10086的博客
05-06 1830
将复杂的if else判断剥离出来。
【中间件】一文搞懂规则引擎 - Easy Rules
最新发布
之杭
03-07 1356
Easy Rules 是一个 Java 规则引擎。Easy Rules 它提供 Rule 抽象以创建具有条件和动作的规则，并提供 RuleEngine API，该 API 通过一组规则运行以评估条件并执行动作。无论以那种方式进行代码的编写，最终实现的都是需要定义如下几个参数，通过不同的参数对规则进行描述。一个命名空间下的唯一的规则名称【对应代码中的 then() 与 @Rule 中 name 属性】
推荐：Easy Rules —— 简单易用的Java规则引擎
gitblog_00063的博客
05-10 615
推荐：Easy Rules —— 简单易用的Java规则引擎 easy-rulesThe simple, stupid rules engine for Java项目地址:https://gitcode.com/gh_mirrors/ea/easy-rules 简介 Easy Rules 是一个轻量级且易于学习的Java规则引擎，它提供了一个简单的方式来定义业务规则，并在Java应用中轻松应用这...
EasyRules 简单版规则引擎
琪琪的博客
03-03 4837
接触过Drools的同学都会被复杂的Api给难住，简直就是入门到放弃的一个过程，而EasyRule就是Drools的简化版，裁剪了部分使用场景非常少的复杂功能，也简化了很多Drools中的组件，这样我们在使用EasyRule的时候对于API理解就非常容易了 什么是Easy Rules？ Easy Rules是一个简单的JAVA开源规则引擎，它提供了规则抽象来创建带有评估条件和执行操作的规则，规则引擎API通过运行一组规则以评估条件和执行操作。 框架特点 轻量级类库 容易学习的API 基于POJO
Easy-Rules引擎
asdfasaa的博客
11-29 2356
Easy-Rules规则引擎的快速使用，从Rule，Fact，Listener三个方面教会你Easy-rules的使用。提高你的代码可读性，减少硬编码。
Java规则引擎easy-rules
客官你来啦，姑娘任你挑
01-18 6405
Java规则引擎easy-rules 首先以通俗的语言表达何为规则引擎： 一段代码： public class FizzBuzz { public static void main(String[] args) { for(int i = 1; i <= 100; i++) { if (((i % 5) == 0) && ((i % 7) == 0)){ System.out.print("能被5和7同时整除的数字"); }
Java规则引擎Easy Rules的使用介绍
08-19
Java规则引擎Easy Rules的使用介绍 Easy Rules是一个Java规则引擎，灵感来自一篇名为《Should I use a Rules Engine?》的文章。规则引擎是一种工具，它使得计算模型编程变得更容易。它可以是一个完整的开发环境，...
easyrulesplusmvel:一个结合 Easy Rules 和 MVEL 的 Java 项目
06-05
标题 "easyrulesplusmvel:一个结合 Easy Rules 和 MVEL 的 Java 项目" 提到的是一种基于 Java 的规则引擎实现，它整合了 Easy Rules 和 MVEL 这两个库。Easy Rules 是一个简单、灵活的 Java 规则引擎，旨在简化业务...
利用Java的动态编译、动态加载结合EasyRules实现业务规则的动态性的项目源码
12-19
利用Java的动态编译、动态加载结合EasyRules实现业务规则的动态性的项目源码，具体详情请查看相关博客https://blog.youkuaiyun.com/qq_31142553/article/details/85013989
规则引擎-Easy-Rules
myITShow的博客
07-19 5825
规则引擎（Rule Engine）是一种软件组件或应用程序，它允许用户或开发者以业务规则的形式定义复杂的业务逻辑，而无需编写硬编码的代码。这些业务规则可以被动态地管理（添加、删除、修改）和执行，从而允许系统更加灵活和可配置地处理各种业务场景。大多数业务规则可以用以下定义表示:name：规则命名空间中的唯一规则名称description：规则的简要描述priority：规则的优先级facts：触发规则时的一组已知事实。
Easy Rules规则引擎（1-基础篇）
lingbomanbu_lyl的博客
08-09 1958
Easy Rules是一个Java规则引擎，它提供了规则抽象，通过触发条件和触发后的行为去创建规则。还提供了规则引擎API，通过这些API可以基于一系列的规则去判断规则是否触发，以及触发后执行什么动作。轻量级Java库，易于学习的API。注解式编程模型实现基于POJO开发。通过抽象定义业务规则并且轻松应用规则。支持通过简单规则可以创建组合规则。支持通过表达式语言(MVEL、SPEL和JEXL)定义规则。--核心库-->--组合规则支持-->--SPEL表达式语言支持-->
规则引擎之 Easy Rules 详解
weixin_44594317的博客
11-22 2216
Easy Rules 非常适合需要快速实现业务规则引擎的场景。对于中小型项目，Easy Rules 的简单性和灵活性是一大优势。如果项目规则复杂或者性能要求较高，可以考虑结合 Drools 等更强大的规则引擎使用。
EasyRules动态规则实现
莫须有的博客
01-13 4662
EasyRules动态规则实现
【规则引擎】之easy-rules入门
JustryDeng
06-22 3907
https://github.com/j-easy/easy-rules 简介   在写业务逻辑时，我们不可避免的会使用到if这样的语法；对于特别复杂的业务场景，那么就可能会写很多"并联"或"串联"的if，冗余又不好管理；此时，我们不妨引入规则引擎。在我看来，规则引擎中的"规则即对应if"，规则引擎中的"引擎则是统筹管理这些if"的大脑。   当下规则引擎有很多，如DROOLS、OPENL TABLETS、EASY RULES、RULEBOOK等等，其中DROOLS的功能强大且完善，社区也非常活跃，但.
规则引擎-Easy rule
weixin_42454225的博客
06-04 1180
如其名，定义规则的执行引擎，是一套解决业务代码与执行其业务规则分离的解决方案或组件；举个例子：有一个功能为，当用户输入A时，将用户的信息更新为B//更新System.out.println("更新B");可以直观的感受到，怎么使用了规则引擎之后代码变多了而且变复杂了？且慢，让我们认真缕一缕；现在我们需要添加一个新逻辑，当用户输入B时，将信息更新为C；继续往后叠If-else或者使用switch使用策略模式，将输入的内容作为策略key；
Java之规则引擎 Easy Rules
psy1286479613的博客
11-19 1861
1. Easy Rules 概述 Easy Rules是一个Java规则引擎，灵感来自一篇名为《Should I use a Rules Engine?》的文章 规则引擎就是提供一种可选的计算模型。与通常的命令式模型（由带有条件和循环的命令依次组成）不同，规则引擎基于生产规则系统。这是一组生产规则，每条规则都有一个条件（condition）和一个动作（action）———— 简单地说，可以将其看作是一组if-then语句。 精妙之处在于规则可以按任何顺序编写，引擎会决定何时使用对顺序有意义的任何方式来计算它
Easy Rules
02-19
### Easy Rules Java 规则引擎框架文档和示例 #### 简介 Easy Rules 是一个轻量级的Java规则引擎框架，旨在简化业务逻辑与应用程序代码之间的分离。通过定义一组规则并将这些规则应用于特定的事实对象集合，可以...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值