【Java】规则引擎 Drools

已于 2025-02-18 13:43:53 修改
阅读量1k 收藏 22
点赞数 25
分类专栏： java JavaWeb 文章标签： java
于 2025-02-14 18:00:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_55675216/article/details/145638017
版权

https://www.bilibili.com/video/BV1nW421R7qJ 来自尚硅谷

背景

在这里插入图片描述

/**
 * 设置订单积分
 */
public void setOrderPoint(Order order){
    if (order.getAmout() <= 100){
        order.setScore(0);
    }else if(order.getAmout() > 100 && order.getAmout() <= 500){
        order.setScore(100);
    }else if(order.getAmout() > 500 && order.getAmout() <= 1000){
        order.setScore(500);
    }else{
        order.setScore(1000);
    }
}

对于不经常变化的业务，我们通常是将规则硬编码到程序中。但是经常变化的业务，我们就得把业务流程从代码中剥离出来。

1、硬编码实现业务规则难以维护
2、硬编码实现业务规则难以应对变化
3、业务规则发生变化需要修改代码，重启服务后才能生效

那么面对上面的业务场景，还有什么好的实现方式吗？

此时我们需要引入规则引擎来帮助我们将规则从代码中分离出去，让开发人员从规则的代码逻辑中解放出来，把规则的维护和设置交由业务人员去管理。

规则引擎概述

规则引擎，全称为业务规则管理系统，规则引擎的主要思想是将应用程序中的业务决策部分分离出来，并使用预定义的语义模块编写业务决策（业务规则），由用户或开发者在需要时进行配置、管理。

需要注意的是规则引擎并不是一个具体的技术框架，而是指的一类系统。目前市面上具体的规则引擎产品有：drools、VisualRules、iLog等。

规则引擎实现了将业务决策从应用程序代码中分离出来，接收数据输入，解释业务规则，并根据业务规则做出业务决策。规则引擎其实就是一个输入输出平台。

系统中引入规则引擎后，业务规则不再以程序代码的形式驻留在系统中，取而代之的是处理规则的规则引擎，业务规则存储在规则库中，完全独立于程序。业务人员可以像管理数据一样对业务规则进行管理，比如查询、添加、更新、统计、提交业务规则等。业务规则被加载到规则引擎中供应用系统调用。

对于一些存在比较复杂的业务规则并且业务规则会频繁变动的系统比较适合使用规则引擎，如下：
1、风险控制系统----风险贷款、风险评估
2、反欺诈项目----银行贷款、征信验证
3、决策平台系统----财务计算
4、促销平台系统----满减、打折、加价购

Drools

drools是一款由JBoss组织提供的基于Java语言开发的开源规则引擎，可以将复杂且多变的业务规则从硬编码中解放出来，以规则脚本的形式存放在文件或特定的存储介质中(例如存放在数据库中)，使得业务规则的变更不需要修改项目代码、重启服务器就可以在线上环境立即生效。

入门案例

引入依赖

   <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.0.5</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <java.version>17</java.version>
        <drools.version>8.41.0.Final</drools.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.drools</groupId>
            <artifactId>drools-core</artifactId>
            <version>${drools.version}</version>
        </dependency>
        <dependency>
            <groupId>org.drools</groupId>
            <artifactId>drools-compiler</artifactId>
            <version>${drools.version}</version>
        </dependency>
        <dependency>
            <groupId>org.drools</groupId>
            <artifactId>drools-decisiontables</artifactId>
            <version>${drools.version}</version>
        </dependency>
        <dependency>
            <groupId>org.drools</groupId>
            <artifactId>drools-mvel</artifactId>
            <version>${drools.version}</version>
        </dependency>
    </dependencies>

添加Drools配置类 (固定的)，规则文件所在路径一定要指定对

import org.kie.api.KieServices;
import org.kie.api.builder.*;
import org.kie.api.runtime.KieContainer;
import org.kie.api.runtime.KieSession;
import org.kie.internal.io.ResourceFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 规则引擎配置类
 */
@Configuration
public class DroolsConfig {

    private static final KieServices kieServices = KieServices.Factory.get();
    //制定规则文件的路径
    private static final String RULES_CUSTOMER_RULES_DRL = "rules/order.drl";

    @Bean
    public KieContainer kieContainer() {
        //获得Kie容器对象
        KieFileSystem kieFileSystem = kieServices.newKieFileSystem();
        kieFileSystem.write(ResourceFactory.newClassPathResource(RULES_CUSTOMER_RULES_DRL));

        KieBuilder kieBuilder = kieServices.newKieBuilder(kieFileSystem);
        kieBuilder.buildAll();

        KieModule kieModule = kieBuilder.getKieModule();
        KieContainer kieContainer = kieServices.newKieContainer(kieModule.getReleaseId());

        return kieContainer;
    }

}

创建实体类Order

import lombok.Data;

@Data
public class Order {
    private double amout;
    private double score;
}

lombok指定好版本很重要

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.10</version>
        </dependency>

创建规则文件resources/rules/order.drl

//订单积分规则
package com.order

//规则一：100元以下 不加分
rule "order_rule_1"
    when
        $order:Order(amout < 100)
    then
        $order.setScore(0);
        System.out.println("成功匹配到规则一：100元以下 不加分");
end

//规则二：100元 - 500元 加100分
rule "order_rule_2"
    when
        $order:Order(amout >= 100 && amout < 500)
    then
         $order.setScore(100);
         System.out.println("成功匹配到规则二：100元 - 500元 加100分");
end

//规则三：500元 - 1000元 加500分
rule "order_rule_3"
    when
        $order:Order(amout >= 500 && amout < 1000)
    then
         $order.setScore(500);
         System.out.println("成功匹配到规则三：500元 - 1000元 加500分");
end

//规则四：1000元以上 加1000分
rule "order_rule_4"
    when
        $order:Order(amout >= 1000)
    then
         $order.setScore(1000);
         System.out.println("成功匹配到规则四：1000元以上 加1000分");
end

编写测试类

package com.atguigu.drools;

import org.junit.jupiter.api.Test;
import com.atguigu.drools.model.Order;
import org.kie.api.runtime.KieContainer;
import org.kie.api.runtime.KieSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class DroolsDemosApplicationTests {

    @Autowired
    private KieContainer kieContainer;

    @Test
    public void test(){
        //从Kie容器对象中获取会话对象
        KieSession session = kieContainer.newKieSession();

        //Fact对象，事实对象
        Order order = new Order();
        order.setAmout(1300);

        //将Order对象插入到工作内存中
        session.insert(order);

        //激活规则，由Drools框架自动进行规则匹配，如果规则匹配成功，则执行当前规则
        session.fireAllRules();
        //关闭会话
        session.dispose();

        System.out.println("订单金额：" + order.getAmout() +
                "，添加积分：" + order.getScore());
    }

}

问：我们虽然没有在代码中编写规则的判断逻辑，但是我们还是在规则文件中编写了业务规则，这跟在代码中编写规则有什么本质的区别呢？
答案：使用规则引擎时业务规则可以做到动态管理。业务人员可以像管理数据一样对业务规则进行管理，比如查询、添加、更新、统计、提交业务规则等。这样就可以做到在不重启服务的情况下调整业务规则。

封装输入输出对象

  • 输入对象
    在这里插入图片描述
  • 输出对象
    在这里插入图片描述

费用规则文件

package  com.atguigu.daijia

import com.atguigu.daijia.model.form.rules.FeeRuleRequest;
import java.math.BigDecimal;
import java.math.RoundingMode;

global com.atguigu.daijia.model.vo.rules.FeeRuleResponse feeRuleResponse;

/**
1.起步价
    00:00:00-06:59:59  19元(含3公里)
    07:00:00-23:59:59  19元(含5公里)
*/
rule "起步价 00:00:00-07:00:00  19元(含3公里)"
    salience 10          //指定优先级，数值越大优先级越高，不指定的情况下由上到下执行
    no-loop true         //防止陷入死循环
    when
        $rule:FeeRuleRequest(startTime >= "00:00:00" && startTime < "07:00:00")
    then
        //基础里程 3公里
        feeRuleResponse.setBaseDistance(new BigDecimal("3.0"));
        //收费19元 础里程费
        feeRuleResponse.setBaseDistanceFee(new BigDecimal("19.0"));
        //超出里程  超出基础里程的里程
        feeRuleResponse.setExceedDistance(new BigDecimal("0.0"));
        feeRuleResponse.setExceedDistancePrice(new BigDecimal("4.0"));
        System.out.println("00:00:00-07:00:00 " + feeRuleResponse.getBaseDistance() + "公里，起步价:" + feeRuleResponse.getBaseDistanceFee() + "元");
end

rule "起步价 07:00:00-23:59:59  19元(含5公里)"
    salience 10          //指定优先级，数值越大优先级越高，不指定的情况下由上到下执行
    no-loop true         //防止陷入死循环
    when
        /*规则条件，到工作内存中查找FeeRuleRequest对象
        里面出来的结果只能是ture或者false
        $rule是绑定变量名，可以任意命名，官方推荐$符号，定义了绑定变量名，可以在then部分操作fact对象*/
        $rule:FeeRuleRequest(startTime >= "07:00:00" && startTime <= "23:59:59")
    then
        feeRuleResponse.setBaseDistance(new BigDecimal("5.0"));
        feeRuleResponse.setBaseDistanceFee(new BigDecimal("19.0"));

        //5公里内里程费为0
        feeRuleResponse.setExceedDistance(new BigDecimal("0.0"));
        feeRuleResponse.setExceedDistancePrice(new BigDecimal("3.0"));
        System.out.println("07:00:00-23:59:59 " + feeRuleResponse.getBaseDistance() + "公里，起步价:" + feeRuleResponse.getBaseDistanceFee() + "元");
end

/**
2.里程费
    超出起步里程后开始计算
    00:00:00-06:59:59   4元/1公里
    07:00:00-23:59:59   3元/1公里
*/
rule "里程费 00:00:00-06:59:59 4元/1公里"
    salience 10          //指定优先级，数值越大优先级越高，不指定的情况下由上到下执行
    no-loop true         //防止陷入死循环
    when
        /*规则条件，到工作内存中查找FeeRuleRequest对象
        里面出来的结果只能是ture或者false
        $rule是绑定变量名，可以任意命名，官方推荐$符号，定义了绑定变量名，可以在then部分操作fact对象*/
        $rule:FeeRuleRequest(startTime >= "00:00:00"
            && startTime <= "06:59:59"
            && distance > 3.0)
    then
        BigDecimal exceedDistance = $rule.getDistance().subtract(new BigDecimal("3.0"));
        feeRuleResponse.setExceedDistance(exceedDistance);
        feeRuleResponse.setExceedDistancePrice(new BigDecimal("4.0"));
        System.out.println("里程费，超出里程:" + feeRuleResponse.getExceedDistance() + "公里，单价：" + feeRuleResponse.getExceedDistancePrice());
end
rule "里程费 07:00:00-23:59:59 3元/1公里"
    salience 10          //指定优先级，数值越大优先级越高，不指定的情况下由上到下执行
    no-loop true         //防止陷入死循环
    when
        /*规则条件，到工作内存中查找FeeRuleRequest对象
        里面出来的结果只能是ture或者false
        $rule是绑定变量名，可以任意命名，官方推荐$符号，定义了绑定变量名，可以在then部分操作fact对象*/
        $rule:FeeRuleRequest(startTime >= "07:00:00"
            && startTime <= "23:59:59"
            && distance > 5.0)
    then
        BigDecimal exceedDistance = $rule.getDistance().subtract(new BigDecimal("5.0"));
        feeRuleResponse.setExceedDistance(exceedDistance);
        feeRuleResponse.setExceedDistancePrice(new BigDecimal("3.0"));
        System.out.println("里程费，超出里程:" + feeRuleResponse.getExceedDistance() + "公里，单价：" + feeRuleResponse.getExceedDistancePrice());
end

/**
3.等候费
    等候10分钟后  1元/1分钟
*/
rule "等候费 等候10分钟后 1元/1分钟"
    salience 10          //指定优先级，数值越大优先级越高，不指定的情况下由上到下执行
    no-loop true         //防止陷入死循环
    when
        /*规则条件，到工作内存中查找FeeRuleRequest对象
        里面出来的结果只能是ture或者false
        $rule是绑定变量名，可以任意命名，官方推荐$符号，定义了绑定变量名，可以在then部分操作fact对象*/
        $rule:FeeRuleRequest(waitMinute > 10)
    then
        Integer exceedWaitMinute = $rule.getWaitMinute() - 10;
        feeRuleResponse.setBaseWaitMinute(10);
        feeRuleResponse.setExceedWaitMinute(exceedWaitMinute);
        feeRuleResponse.setExceedWaitMinutePrice(new BigDecimal("1.0"));
        System.out.println("等候费，超出分钟:" + feeRuleResponse.getExceedWaitMinute() + "分钟，单价：" + feeRuleResponse.getExceedWaitMinutePrice());
end
rule "无等候费"
    salience 10          //指定优先级，数值越大优先级越高，不指定的情况下由上到下执行
    no-loop true         //防止陷入死循环
    when
        /*规则条件，到工作内存中查找FeeRuleRequest对象
        里面出来的结果只能是ture或者false
        $rule是绑定变量名，可以任意命名，官方推荐$符号，定义了绑定变量名，可以在then部分操作fact对象*/
        $rule:FeeRuleRequest(waitMinute <= 10)
    then
        feeRuleResponse.setBaseWaitMinute(10);
        feeRuleResponse.setExceedWaitMinute(0);
        feeRuleResponse.setExceedWaitMinutePrice(new BigDecimal("1.0"));
        System.out.println("等候费：无");
end

/**
4.远途费
    订单行程超出12公里后每公里1元
*/
rule "远途费 订单行程超出12公里后每公里1元"
    salience 10          //指定优先级，数值越大优先级越高，不指定的情况下由上到下执行
    no-loop true         //防止陷入死循环
    when
        /*规则条件，到工作内存中查找FeeRuleRequest对象
        里面出来的结果只能是ture或者false
        $rule是绑定变量名，可以任意命名，官方推荐$符号，定义了绑定变量名，可以在then部分操作fact对象*/
        $rule:FeeRuleRequest(distance > 12.0)
    then
        BigDecimal exceedLongDistance = $rule.getDistance().subtract(new BigDecimal("12.0"));
        feeRuleResponse.setBaseLongDistance(new BigDecimal("12.0"));
        feeRuleResponse.setExceedLongDistance(exceedLongDistance);
        feeRuleResponse.setExceedLongDistancePrice(new BigDecimal("1.0"));
        System.out.println("远途费，超出公里:" + feeRuleResponse.getExceedLongDistance() + "公里，单价：" + feeRuleResponse.getExceedLongDistancePrice());
end
rule "无远途费"
    salience 10          //指定优先级，数值越大优先级越高，不指定的情况下由上到下执行
    no-loop true         //防止陷入死循环
    when
        /*规则条件，到工作内存中查找FeeRuleRequest对象
        里面出来的结果只能是ture或者false
        $rule是绑定变量名，可以任意命名，官方推荐$符号，定义了绑定变量名，可以在then部分操作fact对象*/
        $rule:FeeRuleRequest(distance <= 12.0)
    then
        feeRuleResponse.setBaseLongDistance(new BigDecimal("12.0"));
        feeRuleResponse.setExceedLongDistance(new BigDecimal("0"));
        feeRuleResponse.setExceedLongDistancePrice(new BigDecimal("0"));
        System.out.println("远途费：无");
end

/**
5.计算总金额
    订单总金额 = 基础里程费 + 超出基础里程的费 + 等候费 + 远程费
*/
rule "计算总金额"
    salience 10          //指定优先级，数值越大优先级越高，不指定的情况下由上到下执行
    no-loop true         //防止陷入死循环
    when
        /*规则条件，到工作内存中查找FeeRuleRequest对象
        里面出来的结果只能是ture或者false
        $rule是绑定变量名，可以任意命名，官方推荐$符号，定义了绑定变量名，可以在then部分操作fact对象*/
        $rule:FeeRuleRequest(distance > 0.0)
    then
        //订单总金额 = 基础里程费 + 超出基础里程的费 + 等候费 + 远程费
        BigDecimal distanceFee = feeRuleResponse.getBaseDistanceFee().add(feeRuleResponse.getExceedDistance().multiply(feeRuleResponse.getExceedDistancePrice()));
        BigDecimal waitFee = new BigDecimal(feeRuleResponse.getExceedWaitMinute()).multiply(feeRuleResponse.getExceedWaitMinutePrice());
        BigDecimal longDistanceFee = feeRuleResponse.getExceedLongDistance().multiply(feeRuleResponse.getExceedLongDistancePrice());
        
        BigDecimal totalAmount = distanceFee.add(waitFee).add(longDistanceFee);
        feeRuleResponse.setDistanceFee(distanceFee);
        feeRuleResponse.setWaitFee(waitFee);
        feeRuleResponse.setLongDistanceFee(longDistanceFee);
        feeRuleResponse.setTotalAmount(totalAmount);
        System.out.println("计算总金额:" + feeRuleResponse.getTotalAmount() + "元");
end
  • 测试类
/*
 *  1 00:00:00-06:59:59  19元(含3公里)   == 超出12公里
 *  2 00:00:00-06:59:59   4元/1公里      == 增加一公里，单价4元
 *  3 等候10分钟后  1元/1分钟             == 超过10分钟，单价1元
 *  4 订单行程超出12公里后每公里1元        == 超出3公里 ，单价 1元
 * 代驾总金额：19 + 12*4 + 10 + 3 = 80
 */
@Test
void test1() {
    FeeRuleRequest feeRuleRequest = new FeeRuleRequest();
    feeRuleRequest.setDistance(new BigDecimal(15.0));
    feeRuleRequest.setStartTime("01:59:59");
    feeRuleRequest.setWaitMinute(20);

    // 开启会话
    KieSession kieSession = kieContainer.newKieSession();

    FeeRuleResponse feeRuleResponse = new FeeRuleResponse();
    kieSession.setGlobal("feeRuleResponse", feeRuleResponse);
    // 设置订单对象
    kieSession.insert(feeRuleRequest);
    // 触发规则
    kieSession.fireAllRules();
    // 中止会话
    kieSession.dispose();
    System.out.println("后："+JSON.toJSONString(feeRuleResponse));
}

drools规则引擎原理

drools规则引擎由以下三部分构成：

  • Working Memory（工作内存）
  • Rule Base（规则库）
  • Inference Engine（推理引擎）

其中Inference Engine（推理引擎）又包括：

  • Pattern Matcher（匹配器） 具体匹配哪一个规则，由这个完成
  • Agenda(议程)
  • Execution Engine（执行引擎）

相关概念：

  • Working Memory：工作内存，drools规则引擎会从Working Memory中获取数据并和规则文件中定义的规则进行模式匹配，所以我们开发的应用程序只需要将我们的数据插入到Working Memory中即可，例如本案例中我们调用kieSession.insert(order)就是将order对象插入到了工作内存中。

  • Fact：事实，是指在drools 规则应用当中，将一个普通的JavaBean插入到Working Memory后的对象就是Fact对象，例如本案例中的Order对象就属于Fact对象。Fact对象是我们的应用和规则引擎进行数据交互的桥梁或通道。

  • Rule Base：规则库，我们在规则文件中定义的规则都会被加载到规则库中。

  • Pattern Matcher：匹配器，将Rule Base中的所有规则与Working Memory中的Fact对象进行模式匹配，匹配成功的规则将被激活并放入Agenda（议程）中。

  • Agenda：议程，用于存放通过匹配器进行模式匹配后被激活的规则。

  • Execution Engine：执行引擎，执行Agenda中被激活的规则。

在这里插入图片描述

规则文件的编写什么的没有放，可以去看一看

[Drools]JAVA规则引擎 -- Drools
quzishen的专栏
01-25 21万+
Drools是一个基于java的规则引擎，开源的，可以将复杂多变的规则从硬编码中解放出来，以规则脚本的形式存放在文件中，使得规则的变更不需要修正代码重启机器就可以立即在线上环境生效。 1、Drools语法开始语法之前首先要了解一下drools的基本工作过程，通常而言我们使用一个接口来做事情，首先要穿进去参数，其次要获取到接口的实现执行完毕后的结果，而drools也是一样的，我们需要传递进去数据，用于规则的检查，调用外部接口，同时还可能需要获取到规则执行完毕后得到的结果。在drools中，这个传递数据进去的对
[Drools]JAVA规则引擎2 -- Drools实例
热门推荐
quzishen的专栏
01-26 2万+
上一篇文章 http://blog.youkuaiyun.com/quzishen/archive/2011/01/25/6163012.aspx 描述了一些常用的drools的语法标签和一个模拟实例即发送积分的场景，这一片优化了一下代码，在此贴一下，希望有这方面使用经验的朋友多多交流沟通，指正不足。通常而言，习惯上我们将规则放到文件系统中，比如以drl结尾的规则文件，现在我们要扩充一下，使其放到数据库中，以供多台服务器同时使用，同时依然保留文件系统的支持。先看下一个接口：/** * 规则接口 * @autho
Java规则引擎Drools急速入门
llg3189609554的博客
03-24 1055
（1）什么是规则引擎全称为业务规则管理系统，英⽂名为BRMS(即 Business Rule Management System)。规则引擎的主要思想是将应用程序中的业务决策部分分离出来，并使用预定义的语义模块编写业务决策（业务规则），由用户或开发者在需要时进行配置、管理。需要注意的是规则引擎并不是一个具体的技术框架，而是指的⼀类系统，即业务规则管理系统。目前市面上具体的规则引擎产品有：drools、VisualRules、iLog等，使用最为广泛并且开源的是Drools。
java规则引擎 -- Drools
08-11
NULL 博文链接：https://gwh-08.iteye.com/blog/2241020
Java规则引擎-Drools
web开发自学
06-20 218
InfoQ发布了一个关于规则引擎的介绍Real-World Rule Engines，原文 http://www.infoq.com/articles/Rule-Engines ONJava上也有两篇文章： Give Your Business Logic a Framework with Drools http://www.onjava.com/lpt/a/6093 Using Drool...
Drools规则引擎
BadBoyxiaolin的博客
05-30 1万+
Drools（Drools Rule Engine）是一个开源的规则引擎，它主要用于在Java应用程序中实现规则管理。Drools规则引擎将规则定义和管理从应用程序代码中分离出来，使得规则可以独立于应用程序运行。这样可以提高规则的可靠性和可维护性，同时也可以使得规则的更新和管理更加方便。将规则定义和管理从应用程序代码中分离出来，使得规则可以独立于应用程序运行。提供基于规则的访问和操作数据的功能，例如过滤、排序、检索等。支持动态规则扩展和维护，可以根据需要添加、删除或修改规则。
新一代Java规则引擎Drools实战.pdf
最新发布
04-24
文档支持目录章节跳转同时还支持阅读器左侧大纲显示和...作为一种广泛应用于企业级开发、移动应用、大数据等众多领域的编程语言，Java 以其跨平台性、高性能和丰富的类库，为开发者提供了一个稳定而高效的开发环境。
新一代Java规则引擎Drools9.0特性解析.pdf
04-23
文档支持目录章节跳转同时还支持阅读器左侧大纲显示和...作为一种广泛应用于企业级开发、移动应用、大数据等众多领域的编程语言，Java 以其跨平台性、高性能和丰富的类库，为开发者提供了一个稳定而高效的开发环境。
使用java规则引擎Drools自动排班前言.doc
06-11
在本文中，我们将探讨如何使用Java规则引擎Drools进行自动排班。Drools是一个强大的、基于规则的系统，它允许开发者以声明式的方式表达复杂的业务逻辑，类似于专家系统。本文以一个简化的运输车队排班需求为例，展示...
Drools示例，纯java工程，直接运行
03-26
学习drools下载的项目，诸多问题已经解决，特适合新手，直接run as applicaiton！引用的那个人的博客找不到了，很尴尬。
JAVA规则引擎[Drools]--实例篇
01-27
随着互联网应用的飞速发展，各种业务需求也应运而生，对于不断变更和革新的业务规则而言，项目的开发就很有必要把规则部分独立提取出来，此时Drools的价值就得到了体现。废话不多说，看一个简单的例子。这里举一个手机话费的例子。首先要分析自己的业务逻辑，根据业务而制定出不同的规则，这里我们假设有3个规则。1、对于新开户的手机用户送20元话费。2、在2014年10月到12期间充值的用户，不论金额多少充值满3次就赠送5元话费。3、当月充值金额达到100以上，每达到一次赠送话费10元。分析这些规则，并把他们抽象成一个Fact对象。业务和规则都整理清楚了我们就可以开始规则引擎的核心部分啦，这里我定义的是接口和
java营销活动动态引擎规则_JAVA规则引擎 Drools 教程
weixin_39847728的博客
03-01 1394
我们的日常生活是由规则驱动的。每次我们在开车的时候停在红灯处，之所以这样做，因为我们遵循一条规则，灯变红时我们应该停下来。如果你跳起来，最终会落到地面，这是由地球引力所决定的，它可以被表示成简单的数学方程。然而，对于我们生活日常中的规则，我们使用更加简单的结构来表示：当 XXX 的时候，做 XXX 的事。1 2when 满足什么样的条件 then 最终结果在程序中普遍的存在一些业务逻辑规则...
Java规则引擎Drools：概念、应用与实践
"Java规则引擎-Drools的介绍及应用-...Java规则引擎Drools为处理动态和复杂的业务逻辑提供了一种强大而灵活的工具。通过理解和掌握Drools，开发人员可以更好地实现业务规则的管理，提高软件系统的可扩展性和适应性。
Drools规则引擎 Java
湖人•总冠军
01-22 7053
前言： Drools是一款基于Java的开源规则引擎 　　实现了将业务决策从应用程序中分离出来。 　　优点： 　　　　1、简化系统架构，优化应用 　　　　2、提高系统的可维护性和维护成本 　　　　3、方便系统的整合 　　　　4、减少编写“硬代码”业务规则的成本和风险 不多说，直接low代码，此例是使用springboot项目为基础： 1.需添加maven依赖 使用7.x： ...
JAVA中Drools规则引擎
爱软件-从懂得生活开始。
05-11 946
在系统建设阶段，有些功能是通过drools规则引擎来实现的，通过规则引擎，我们可以实现很多可以动态变更及函数过滤的功能，但是我们在处理字符串处理的时候，不可避免的会遇到特殊字符的处理，所以我们针对特殊字符需要进行该转义的转义。主要的几个字符如下：switch (sign) { case "||":sign="\\|\\|";break; case "|...
Java中的基于规则的引擎（如Drools）
weixin_53840353的博客
08-29 1006
Drools是一个基于规则的引擎，使用一种声明性语言来定义复杂的业务规则。Drools提供了一种规则文件（.drl），用于编写业务规则，并且这些规则可以在运行时动态加载和执行。Drools作为一个开源的基于规则的引擎，提供了强大的规则管理和执行能力。通过使用Drools，可以将业务规则从应用逻辑中分离出来，使得系统更具灵活性和可维护性。在本文中，我们介绍了Drools的基本概念和优势，详细讲解了如何安装和配置Drools，并通过一个示例展示了如何在Java应用中集成Drools。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

开心星人

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值