EasyRules

最新推荐文章于 2024-03-29 15:30:18 发布
最新推荐文章于 2024-03-29 15:30:18 发布
阅读量1.1k 收藏 12
点赞数 3
分类专栏： 规则引擎 文章标签： java drools
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/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.csdn.net/qq_41896365/article/details/122233006?spm=1001.2014.3001.5501

莫 须 有
关注
  • 3
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java规则引擎easy-rules详细介绍
weixin_64314555的博客
01-04 1万+
最近在思考一个基于规则进行挑选的技术重构，想通过规则引擎进行实现，借着这个机会正好可以详细了解一下规则引擎。本篇文章将会详细介绍规则引擎easy-rules的使用。 Easy Rules是一个简单但功能强大的Java规则引擎，提供以下特性: 轻量级框架和易于学习的API 基于POJO的开发 支持从原始规则创建组合规则 支持通过表达式（如MVEL，SPEL和JEXL）定义规则 开始使用 引入依赖 <dependency> <groupId>org.jeasy&l
Java规则引擎Easy Rules的使用介绍
08-19
Java规则引擎Easy Rules的使用介绍 Easy Rules是一个Java规则引擎，灵感来自一篇名为《Should I use a Rules Engine?》的文章。规则引擎是一种工具，它使得计算模型编程变得更容易。它可以是一个完整的开发环境，...
Java规则引擎-Easy Rules使用
HQ DevJ的专栏
01-18 2295
Java规则引擎-Easy Rules使用Easy Rules 介绍Easy Rules特性Easy Rules的使用使用注解的方式进行申明规则和使用使用MVL表达式进行规则的定义使用fluent进行创建使用规则加载yml进行配置规则 规则引擎由推理引擎发展而来，是一种嵌入在应用程序中的组件，实现了将业务决策从应用程序代码中分离出来，并使用预定义的语义模块编写业务决策。接受数据输入，解释业务规则，并根据业务规则做出业务决策。 开源的规则引擎有很多，像Drools，本文中用到的Easy Rules，Apach
Java规则引擎easy-rules详细介绍，java高级程序员面试
最新发布
2401_83621541的博客
03-29 1514
name：规则命名空间中的唯一规则名称：规则的简要描述priority：规则的优先级facts：触发规则时的一组已知事实conditions：在给定一些事实的情况下，为了应用该规则，需要满足的一组条件actions：满足条件时要执行的一组操作(可能会添加/删除/修改事实)Easy Rules为定义业务规则的每个关键点提供了抽象。Easy Rules中的规则由Rule接口表示:/**此方法封装了规则的条件。@return 如果根据提供的事实可以应用规则，则为true，否则为false*//**
Easy-Rules引擎
asdfasaa的博客
11-29 1731
Easy-Rules规则引擎的快速使用，从Rule，Fact，Listener三个方面教会你Easy-rules的使用。提高你的代码可读性，减少硬编码。
EasyRules动态规则实现
莫须有的博客
01-13 3877
EasyRules动态规则实现
规则引擎easy-rule快速入门及整合SpEL使用
qq_43472612的博客
01-12 3341
执行引擎easy-rule具有强大的解决分支问题的能力，在有多个判断条件时能够使代码的复用性和扩展性提高，同时支持spel等多种表达式，本文主要介绍了简单使用，希望能帮到你～
easyrulesplusmvel:一个结合 Easy Rules 和 MVEL 的 Java 项目
06-05
简单规则 结合和Java 项目演示了如何在 Java 中实现轻量级规则引擎并使决策能够表示为字符串，从而在属性文件或数据库中外部化，或通过 JMX 使用和。
利用Java的动态编译、动态加载结合EasyRules实现业务规则的动态性的项目源码
12-19
利用Java的动态编译、动态加载结合EasyRules实现业务规则的动态性的项目源码，具体详情请查看相关博客https://blog.csdn.net/qq_31142553/article/details/85013989
easyrulesgo:Go中的Easy Rules端口
05-05
EasyRulesGO EasyRules到Golang的端口 请阅读EasyRules链接，以快速了解概念和工作流程。 实现默认规则引擎允许复合规则（全部或全部）作者/贡献者作者/维护者package easyrulesgo_testimport ("fmt"core "github....
java轻量级规则引擎easy-rules使用介绍
08-19
java轻量级规则引擎Easy-Rules使用介绍 Easy-Rules是一个java轻量级规则引擎，它的特点是轻量级、容易上手、基于POJO的开发与注解的编程模型、基于MVEL表达式的编程模型等。 Easy-Rules主要包括几个主要的类或接口...
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规则引擎（2-细节篇）
lingbomanbu_lyl的博客
08-23 1741
语义就是先判断数字是否能被5和7同时整除，再判断是否能被5整除，再判断是否能被7整除，最后判断是否不能被5或7整除。，这是一个组合规则，也就是说当满足该组合规则的条件，且规则行为执行成功后，就会跳过后面低优先级的所有规则。该组合规则的源代码如下，可以看到只有最高优先级的规则可以被触发，才会继续应用其它规则中的规则。该组合规则判断规则是否触发的代码如下，可以看到，所有的规则如果被触发，相应的行为都会被执行。从该组合规则的源代码可以看到，该规则组中只有第一条可以被触发的规则才会执行相应的规则行为。
java开源引擎easyrule_java轻量级规则引擎easy-rules使用介绍
weixin_39709194的博客
02-13 618
轻量级规则引擎easy-rules--参考我们在写业务代码经常遇到需要一大堆if/else，会导致代码可读性大大降低，有没有一种方法可以避免代码中出现大量的判断语句呢？答案是用规则引擎，但是传统的规则引擎都比较重，比如开源的Drools，不适合在小需求中应用。最近在github上面看到一个傻瓜式的Java规则引擎Easy-Rules，这里结合自己写的demo介绍如何使用这个规则引擎，希望对大家有所...
java规则引擎之easy rules源码阅读
u013817349的专栏
09-25 9951
简介easy rules是一个简单而强大的java规则引擎，它有以下特性： 轻量级框架，学习成本低 基于POJO 为定义业务引擎提供有用的抽象和简便的应用 从原始的规则组合成复杂的规则
规则引擎EasyRules介绍，应用及示例
爱是与世界平行
09-14 6124
浅析Easy Rules规则引擎 轻量级规则引擎EasyRules Java规则引擎 Easy Rules 一、EasyRules介绍 1.1 概述 Easy Rules是一个简单而强大的Java规则引擎，提供以下功能： 轻量级框架和易于学习的API 基于POJO的开发与注解的编程模型 定义抽象的业务规则并轻松应用它们 支持从简单规则创建组合规则的能力 支持使用表达式语言（如MVEL和SpEL）定义规则的能力 在一篇非常有趣的规则引擎的文章中，Martin Fowler说： 您可以自己构建一个简单.
Java规则引擎easy rules
12-21 4682
场景 简单点描述，easy rules就是为了干掉if…else…语句。Easy Rules可以把业务逻辑抽象出来，使得业务开发更加顺畅、维护迭代更加快捷，代码更加清晰；有点策略模式的味道。 功能 轻量级框架，基于API方式 支持基于POJO和注解方式开发 支持创建组合规则 支持使用表达式语言（MVEL/SpEL） 名词描述 name：规则名称，唯一性 description：说明描述 priority：优先级 Facts：事实 Conditions：条件 Actions：执行动作 案例 背景 定义
快速使用easy rule
InvisibleMouse的博客
01-19 1354
Easy Rule的使用 Easy Rule介绍 对于Easy Rule是什么，本人无法给出具体的定义。只是说一下自己的理解，它是一个简单而强大的规则引擎，你可以自定义condition与action来组合实现一个自己的rule。 如果各位想要更详细的了解Easy Rule可以查阅Easy Rule的GitHub网址，和他人对Easy Rule的解释。具体的网址放在下方。 参考文章： EasyRule – GitHub地址 浅析Easy Rules规则引擎 万物Hello Word 一种技术开始于hello
easy rules 使用
06-10
可以创建一个规则类，实现`org.easyrules.core.BasicRule`接口，重写`getName()`方法和`getPriority()`方法，并在`evaluate()`方法中实现规则的逻辑。 2. 创建规则引擎 可以通过`org.easyrules.core....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值