1、背景

在之前的章节中，我们的drools规则文件都是在src/main/resources目录下写死的，这样不够灵活。假设我想在程序运行的过程中，动态去修改规则，这样就不好实现。此处我们将规则文件保存到数据库中，实现规则的动态加载、刷新。

2、前置知识

1、如何动态构建出一个`kmodule.xml`文件

2、kmodule.xml应该被谁加载

KieFileSystem kieFileSystem = kieServices.newKieFileSystem();

kieFileSystem.writeKModuleXML(kieModuleModel.toXML());

3、我们drl规则内容如何加载

kieFileSystem.write("src/main/resources/rules/rule01/1.drl","drl规则内容");

KieBuilder kieBuilder = kieServices.newKieBuilder(kieFileSystem);

kieBuilder.buildAll();

Results results = kieBuilder.getResults();

List<Message> messages = results.getMessages(Message.Level.ERROR);

if(null != messages && !messages.isEmpty()){

    for (Message message : messages) {

        System.out.println(message);

    }

}

注意：

从此处我们可以看到，drl 规则内容是被kieFileSystem加载的，后期如果我们要实现动态的更新规则内容，那么kieFileSystem是否应该是同一个，即我们需要缓存这个kieFileSystem。

如果不缓存有什么后果？

当我们加载一个新的规则内容的时候，那么之前的规则内容可能会丢失。

可以看到，我们写入的路径是 src/main/resources/rules/rule01/1.drl是这样的，那么这是什么意思呢？简单理解如下：

src/main/resources：这个可以理解成固定写法。

rules/rule01：这个需要看1、如何动态构建出一个kmodule.xml文件，这个里面动态构建了一个kieBase01，然后加入的package是rules/rule01。即需要对应起来。

1.drl：规则文件的名字。

KieFileSystem：这个是一个虚拟的文件系统，不会真实在磁盘上创建文件，是基于内存的。

4、动态构建KieContainer

if (null == kieContainer) {

  kieContainer = kieServices.newKieContainer(kieServices.getRepository().getDefaultReleaseId());

}

// 更新

((KieContainerImpl) kieContainer).updateToKieModule((InternalKieModule) kieBuilder.getKieModule());

此处的疑问？

1、kieContainer这个我们是否可以每次都创建一个，然后用新的覆盖旧的？

我个人觉得是不可以的，因为，覆盖，就意味着，我们需要销毁旧的KieContainer对象，调用kieContainer.dispose()，那么如果这个时候，我们系统中已经创建了KieSession，正在处理规则，那么是否就会出现问题。

2、kieServices.newKieContainer(ReleaseId)中的ReleaseId如何获取？

上图中说明了ReleaseId的获取方法，此处我们简单使用直接通过kieServices.getRepository().getDefaultReleaseId()获取即可。

3、updateToKieModule的作用

将新的KieModule应用到已经存在的KieContainer对象上，如果KieSession对应已经存在，那么新的规则对KieSession是可见的。

比如：我们修改了规则内容，那么KieSession是知道的。

3、需求

规则的内容需要从数据库中动态加载出来，例子中是保存在内存中。
需要创建多个KieBase，实现规则的隔离。
可以动态的更新或添加规则。
可以删除规则。

4、实现

1、引入jar包

<dependencyManagement>

   <dependencies>

        <dependency>

            <groupId>org.drools</groupId>

            <artifactId>drools-bom</artifactId>

            <type>pom</type>

            <version>7.69.0.Final</version>

            <scope>import</scope>

        </dependency>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-dependencies</artifactId>

            <version>2.6.7</version>

            <scope>import</scope>

            <type>pom</type>

        </dependency>

    </dependencies>

</dependencyManagement>

<dependencies>

    <dependency>

        <groupId>org.springframework.boot</groupId>

        <artifactId>spring-boot-starter-web</artifactId>

    </dependency>

    <dependency>

        <groupId>org.drools</groupId>

        <artifactId>drools-compiler</artifactId>

    </dependency>

    <dependency>

        <groupId>org.drools</groupId>

        <artifactId>drools-mvel</artifactId>

    </dependency>

    <dependency>

        <groupId>org.projectlombok</groupId>

        <artifactId>lombok</artifactId>

        <version>1.18.22</version>

    </dependency>

</dependencies>

2、创建规则实体类

此实体类和数据库中的表是一一对应的。

package com.huan.drools.entity;

import lombok.Getter;

import lombok.Setter;

import java.util.Date;

/**

 * drools 规则实体类

 *

 * @author huan.fu

 * @date 2022/5/27 - 10:00

 */

@Getter

@Setter

public class DroolsRule {

    /**

     * 规则id

     */

    private Long ruleId;

    /**

     * kbase的名字

     */

    private String kieBaseName;

    /**

     * 设置该kbase需要从那个目录下加载文件，这个是一个虚拟的目录，相对于 `src/main/resources`

     * 比如：kiePackageName=rules/rule01 那么当前规则文件写入路径为： kieFileSystem.write("src/main/resources/rules/rule01/1.drl")

     */

    private String kiePackageName;

    /**

     * 规则内容

     */

    private String ruleContent;

    /**

     * 规则创建时间

     */

    private Date createdTime;

    /**

     * 规则更新时间

     */

    private Date updateTime;

    public void validate() {

        if (this.ruleId == null || isBlank(kieBaseName) || isBlank(kiePackageName) || isBlank(ruleContent)) {

            throw new RuntimeException("参数有问题");

        }

    }

    private boolean isBlank(String str) {

        return str == null || str.isEmpty();

    }

}

需要注意的属性：

kieBaseName: 创建的kbase的名字。

kiePackageName：该kbase的属性package的值。

3、实现drools动态规则

package com.huan.drools;

import com.huan.drools.entity.DroolsRule;

import lombok.extern.slf4j.Slf4j;

import org.drools.compiler.kie.builder.impl.InternalKieModule;

import org.drools.compiler.kie.builder.impl.KieContainerImpl;

import org.kie.api.KieBase;

import org.kie.api.KieServices;

import org.kie.api.builder.KieBuilder;

import org.kie.api.builder.KieFileSystem;

import org.kie.api.builder.Message;

import org.kie.api.builder.Results;

import org.kie.api.builder.model.KieBaseModel;

import org.kie.api.builder.model.KieModuleModel;

import org.kie.api.runtime.KieContainer;

import org.kie.api.runtime.KieSession;

import org.springframework.stereotype.Component;

import java.util.Collection;

import java.util.List;

/**

 * drools 管理

 *

 * @author huan.fu

 * @date 2022/5/27 - 14:42

 */

@Component

@Slf4j

public class DroolsManager {

    // 此类本身就是单例的

    private final KieServices kieServices = KieServices.get();

    // kie文件系统，需要缓存，如果每次添加规则都是重新new一个的话，则可能出现问题。即之前加到文件系统中的规则没有了

    private final KieFileSystem kieFileSystem = kieServices.newKieFileSystem();

    // 可以理解为构建 kmodule.xml

    private final KieModuleModel kieModuleModel = kieServices.newKieModuleModel();

    // 需要全局唯一一个，如果每次加个规则都新创建一个，那么旧需要销毁之前创建的kieContainer，如果此时有正在使用的KieSession，则可能有问题

    private KieContainer kieContainer;

    /**

     * 判断该kbase是否存在

     */

    public boolean existsKieBase(String kieBaseName) {

        if (null == kieContainer) {

            return false;

        }

        Collection<String> kieBaseNames = kieContainer.getKieBaseNames();

        if (kieBaseNames.contains(kieBaseName)) {

            return true;

        }

        log.info("需要创建KieBase:{}", kieBaseName);

        return false;

    }

    public void deleteDroolsRule(String kieBaseName, String packageName, String ruleName) {

        if (existsKieBase(kieBaseName)) {

            KieBase kieBase = kieContainer.getKieBase(kieBaseName);

            kieBase.removeRule(packageName, ruleName);

            log.info("删除kieBase:[{}]包:[{}]下的规则:[{}]", kieBaseName, packageName, ruleName);

        }

    }

    /**

     * 添加或更新 drools 规则

     */

    public void addOrUpdateRule(DroolsRule droolsRule) {

        // 获取kbase的名称

        String kieBaseName = droolsRule.getKieBaseName();

        // 判断该kbase是否存在

        boolean existsKieBase = existsKieBase(kieBaseName);

        // 该对象对应kmodule.xml中的kbase标签

        KieBaseModel kieBaseModel = null;

        if (!existsKieBase) {

            // 创建一个kbase

            kieBaseModel = kieModuleModel.newKieBaseModel(kieBaseName);

            // 不是默认的kieBase

            kieBaseModel.setDefault(false);

            // 设置该KieBase需要加载的包路径

            kieBaseModel.addPackage(droolsRule.getKiePackageName());

            // 设置kieSession

            kieBaseModel.newKieSessionModel(kieBaseName + "-session")

                    // 不是默认session

                    .setDefault(false);

        } else {

            // 获取到已经存在的kbase对象

            kieBaseModel = kieModuleModel.getKieBaseModels().get(kieBaseName);

            // 获取到packages

            List<String> packages = kieBaseModel.getPackages();

            if (!packages.contains(droolsRule.getKiePackageName())) {

                kieBaseModel.addPackage(droolsRule.getKiePackageName());

                log.info("kieBase:{}添加一个新的包:{}", kieBaseName, droolsRule.getKiePackageName());

            } else {

                kieBaseModel = null;

            }

        }

        String file = "src/main/resources/" + droolsRule.getKiePackageName() + "/" + droolsRule.getRuleId() + ".drl";

        log.info("加载虚拟规则文件:{}", file);

        kieFileSystem.write(file, droolsRule.getRuleContent());

        if (kieBaseModel != null) {

            String kmoduleXml = kieModuleModel.toXML();

            log.info("加载kmodule.xml:[\n{}]", kmoduleXml);

            kieFileSystem.writeKModuleXML(kmoduleXml);

        }

        KieBuilder kieBuilder = kieServices.newKieBuilder(kieFileSystem);

        // 通过KieBuilder构建KieModule下所有的KieBase

        kieBuilder.buildAll();

        // 获取构建过程中的结果

        Results results = kieBuilder.getResults();

        // 获取错误信息

        List<Message> messages = results.getMessages(Message.Level.ERROR);

        if (null != messages && !messages.isEmpty()) {

            for (Message message : messages) {

                log.error(message.getText());

            }

            throw new RuntimeException("加载规则出现异常");

        }

        // KieContainer只有第一次时才需要创建，之后就是使用这个

        if (null == kieContainer) {

            kieContainer = kieServices.newKieContainer(kieServices.getRepository().getDefaultReleaseId());

        } else {

            // 实现动态更新

            ((KieContainerImpl) kieContainer).updateToKieModule((InternalKieModule) kieBuilder.getKieModule());

        }

    }

    /**

     * 触发规则，此处简单模拟，会向规则中插入一个Integer类型的值

     */

    public String fireRule(String kieBaseName, Integer param) {

        // 创建kieSession

        KieSession kieSession = kieContainer.newKieSession(kieBaseName + "-session");

        StringBuilder resultInfo = new StringBuilder();

        kieSession.setGlobal("resultInfo", resultInfo);

        kieSession.insert(param);

        kieSession.fireAllRules();

        kieSession.dispose();

        return resultInfo.toString();

    }

}

需要注意的是：

KieFileSystem 需要是单例的，即使用的是同一个。
KieContainer需要是单例的，即使用的是同一个。
通过updateToKieModule方法动态更新。

4、模拟数据库，实现规则的CRUD

package com.huan.drools.service.com;

import com.huan.drools.DroolsManager;

import com.huan.drools.entity.DroolsRule;

import com.huan.drools.service.DroolsRuleService;

import org.springframework.stereotype.Service;

import javax.annotation.Resource;

import java.util.*;

/**

 * @author huan.fu

 * @date 2022/5/27 - 14:34

 */

@Service

public class DroolsRuleServiceImpl implements DroolsRuleService {

    @Resource

    private DroolsManager droolsManager;

    /**

     * 模拟数据库

     */

    private Map<Long, DroolsRule> droolsRuleMap = new HashMap<>(16);

    @Override

    public List<DroolsRule> findAll() {

        return new ArrayList<>(droolsRuleMap.values());

    }

    @Override

    public void addDroolsRule(DroolsRule droolsRule) {

        droolsRule.validate();

        droolsRule.setCreatedTime(new Date());

        droolsRuleMap.put(droolsRule.getRuleId(), droolsRule);

        droolsManager.addOrUpdateRule(droolsRule);

    }

    @Override

    public void updateDroolsRule(DroolsRule droolsRule) {

        droolsRule.validate();

        droolsRule.setUpdateTime(new Date());

        droolsRuleMap.put(droolsRule.getRuleId(), droolsRule);

        droolsManager.addOrUpdateRule(droolsRule);

    }

    @Override

    public void deleteDroolsRule(Long ruleId, String ruleName) {

        DroolsRule droolsRule = droolsRuleMap.get(ruleId);

        if (null != droolsRule) {

            droolsRuleMap.remove(ruleId);

            droolsManager.deleteDroolsRule(droolsRule.getKieBaseName(), droolsRule.getKiePackageName(), ruleName);

        }

    }

}

此处是使用内存保存规则，也可以保存到数据库中。

5、创建控制层

@RestController

@RequestMapping("/drools/rule")

public class DroolsRuleController {

    @Resource

    private DroolsRuleService droolsRuleService;

    @Resource

    private DroolsManager droolsManager;

    @GetMapping("findAll")

    public List<DroolsRule> findAll() {

        return droolsRuleService.findAll();

    }

    @PostMapping("add")

    public String addRule(@RequestBody DroolsRule droolsRule) {

        droolsRuleService.addDroolsRule(droolsRule);

        return "添加成功";

    }

    @PostMapping("update")

    public String updateRule(@RequestBody DroolsRule droolsRule) {

        droolsRuleService.updateDroolsRule(droolsRule);

        return "修改成功";

    }

    @PostMapping("deleteRule")

    public String deleteRule(Long ruleId, String ruleName) {

        droolsRuleService.deleteDroolsRule(ruleId, ruleName);

        return "删除成功";

    }

    @GetMapping("fireRule")

    public String fireRule(String kieBaseName, Integer param) {

        return droolsManager.fireRule(kieBaseName, param);

    }

}

6、测试规则的动态添加

1、添加规则

curl --location --request POST 'http://localhost:8080/drools/rule/add' \

--header 'User-Agent: apifox/1.0.0 (https://www.apifox.cn)' \

--header 'Content-Type: application/json' \

--data-raw '{

    "ruleId": 1,

    "kieBaseName": "kieBase01",

    "kiePackageName": "rules.rule01",

    "ruleContent": "package rules.rule01 \n global java.lang.StringBuilder resultInfo \n rule \"rule-01\" when $i: Integer() then resultInfo.append(drools.getRule().getPackageName()).append(\".\").append(drools.getRule().getName()).append(\"执行了，前端传递的参数:\").append($i); end"

}'

package rules.rule01

global java.lang.StringBuilder resultInfo

rule "rule-01"

    when

        $i: Integer()

    then

        resultInfo.append(drools.getRule().getPackageName()).append(".").append(drools.getRule().getName()).append("执行了，前端传递的参数:").append($i);

end

2、运行

➜  ~ curl http://localhost:8080/drools/rule/fireRule\?kieBaseName\=kieBase01\&param\=1

rules.rule01.rule-01执行了，前端传递的参数:1%

➜  ~

可以看到我们动态加载的规则执行了。

7、修改规则

需求： 在 6、测试规则的动态添加的基础上，修改规则。

之前的规则

package rules.rule01

global java.lang.StringBuilder resultInfo

rule "rule-01"

    when

        $i: Integer()

    then

        resultInfo.append(drools.getRule().getPackageName()).append(".").append(drools.getRule().getName()).append("执行了，前端传递的参数:").append($i);

end

修改后的规则

package rules.rule01

global java.lang.StringBuilder resultInfo

rule "rule-01"

    when

        $i: Integer(intValue() > 3) // 注意此处修改了

    then

        resultInfo.append(drools.getRule().getPackageName()).append(".").append(drools.getRule().getName()).append("执行了，前端传递的参数:").append($i);

end

可以看到修改的地方为$i: Integer(intValue() > 3)，即增加了一个条件判断。

1、修改规则

➜  ~ curl --location --request POST 'http://localhost:8080/drools/rule/update' \

--header 'User-Agent: apifox/1.0.0 (https://www.apifox.cn)' \

--header 'Content-Type: application/json' \

--data-raw '{

    "ruleId": 1,

    "kieBaseName": "kieBase01",

    "kiePackageName": "rules.rule01",

    "ruleContent": "package rules.rule01 \n global java.lang.StringBuilder resultInfo \n rule \"rule-01\" when $i: Integer(intValue() > 3) then resultInfo.append(drools.getRule().getPackageName()).append(\".\").append(drools.getRule().getName()).append(\"执行了，前端传递的参数:\").append($i); end"

}'

此处修改了规则内存中Integer的值必须>3时才执行。

2、运行

➜  ~ curl http://localhost:8080/drools/rule/fireRule\?kieBaseName\=kieBase01\&param\=1

➜  ~ curl http://localhost:8080/drools/rule/fireRule\?kieBaseName\=kieBase01\&param\=6

rules.rule01.rule-01执行了，前端传递的参数:6%

➜  ~

从上面可以看到，当我们传递的param=1时，没有结果数据，当param=6时有结果输出。

8、删除

需求： 将上一步创建的规则删除

1、删除规则

➜  ~ curl --location --request POST 'http://localhost:8080/drools/rule/deleteRule?ruleId=1&ruleName=rule-01'

删除成功%

➜  ~

2、运行结果

➜  ~ curl http://localhost:8080/drools/rule/fireRule\?kieBaseName\=kieBase01\&param\=6

➜  ~ curl http://localhost:8080/drools/rule/fireRule\?kieBaseName\=kieBase01\&param\=1

➜  ~

可以看到删除成功了。

9、模拟2个kbase

1、添加规则并执行

➜  ~ curl --location --request POST 'http://localhost:8080/drools/rule/add' \

--header 'Content-Type: application/json' \

--data-raw '{

    "ruleId": 1,

    "kieBaseName": "kieBase01",

    "kiePackageName": "rules.rule01",

    "ruleContent": "package rules.rule01 \n global java.lang.StringBuilder resultInfo \n rule \"rule-01\" when $i: Integer() then resultInfo.append(drools.getRule().getPackageName()).append(\".\").append(drools.getRule().getName()).append(\"执行了，前端传递的参数:\").append($i); end"

}'

添加成功%

➜  ~ curl --location --request POST 'http://localhost:8080/drools/rule/add' \

--header 'Content-Type: application/json' \

--data-raw '{

    "ruleId": 2,

    "kieBaseName": "kieBase02",

    "kiePackageName": "rules.rule02",

    "ruleContent": "package rules.rule02 \n global java.lang.StringBuilder resultInfo \n rule \"rule-01\" when $i: Integer() then resultInfo.append(drools.getRule().getPackageName()).append(\".\").append(drools.getRule().getName()).append(\"执行了，前端传递的参数:\").append($i); end"

}'

添加成功%

➜  ~ curl http://localhost:8080/drools/rule/fireRule\?kieBaseName\=kieBase01\&param\=1

rules.rule01.rule-01执行了，前端传递的参数:1%

➜  ~ curl http://localhost:8080/drools/rule/fireRule\?kieBaseName\=kieBase02\&param\=1

rules.rule02.rule-01执行了，前端传递的参数:1%

➜  ~

2、执行

5、完整代码

https://gitee.com/huan1993/spring-cloud-parent/tree/master/drools/drools-dynamic-crud-rule

6、参考文档

1、https://docs.drools.org/7.69.0.Final/drools-docs/html_single/index.html#_definingakiemoduleprogrammatically

drools动态增加、修改、删除规则的更多相关文章

jquery动态增加或删除tr和td【实际项目】
难点: (1)动态增加.删除tr和td (2)每天tr和td都有下标,且下标要动态变化, (3)tr和td为什么下标不能随便写,原因是此处需要把所有tr中的数据以list的形式发送到后台对象中,所有每 ...
Oracle 增加修改删除字段
Oracle 增加修改删除字段添加字段的语法:alter table tablename add (column datatype [default value][null/not null],…. ...
jQuery实现表格行的动态增加与删除(改进版)
之前写过一个简单的利用jQuery实现表格行的动态增加与删除的例子,有些人评论说"如果表格中是input元素,那么删除后的东西都将自动替换,这样应该是有问题的,建议楼主改进!",故 ...
SpringBoot定时任务升级篇（动态添加修改删除定时任务）
需求缘起:在发布了<Spring Boot定时任务升级篇>之后得到不少反馈,其中有一个反馈就是如何动态添加修改删除定时任务?那么我们一起看看具体怎么实现,先看下本节大纲: (1)思路说明: ...
hdfs以及hbase动态增加和删除节点
一个知乎上的问题:Hbase的Region server和hadoop的datanode是否可以部署在一台服务器上?如果是的话,二者是否是一对一的关系?部署在同一台服务器上,可以减少数据跨网络传输的流 ...
Oracle 增加修改删除字段与添加注释
添加字段的语法:alter table tablename add (column datatype [default value][null/not null],….); 修改字段的语法:alter ...
hibernate 批量增加修改删除
4.2 Hibernate的批量处理 Hibernate完全以面向对象的方式来操作数据库,当程序里以面向对象的方式操作持久化对象时,将被自动转换为对数据库的操作.例如调用Session的delete ...
Oracle-表的字段增加修改删除操作
表结构修改 ALTER TABLE SCOTT.TEST RENAME TO TEST1--修改表名 ALTER TABLE SCOTT.TEST RENAME COLUMN NAME TO NAME ...
js jquery select 操作获取值,选中选项,增加,修改,删除
select示例: <select id="sel"> <option value="1">one</option> < ...

随机推荐

javaweb之浏览功能
今天我们来写浏览功能,浏览主要是通过sql语句将数据库里的数据查出来,并显示在页面上. 一.dao层在上一篇文章的基础上dao层加入浏览方法. public List<Course> l ...
安卓性能测试之Lint测试
pre { direction: ltr; color: rgba(0, 0, 10, 1); text-align: left } pre.western { font-family: " ...
【每日日报】第三十八天---java与时间相关
1 今天看了网上的课程学习了java的关于时间的代码获取时间 import java.util.Date; public class DateDemo { public static void m ...
mysql各个集群方案的优劣
集群的好处高可用性:故障检测及迁移,多节点备份. 可伸缩性:新增数据库节点便利,方便扩容. 负载均衡:切换某服务访问某节点,分摊单个节点的数据库压力. 集群要考虑的风险网络分裂:群集还可能由于网络 ...
小程序安卓端播放不了音频解决方法wx.createInnerAudioContext()
在小程序播放音频时,使用组件wx.createInnerAudioContext(),安卓端无法播放音频. 我的情况:播放服务器上传来的音频,格式为mp3.首先查看你的格式是否符合文档要求在安卓端进 ...
c++对c的拓展_常量引用
常量引用:不能通过引用去修改引用所指向的内容 const int &ref =val; // const int *const ref =&val; 注意:可引用常量 (普通引用无法 ...
Typora基本使用语法(超好用的代码编辑工具)
Typora代码编辑软件,一款适合新手小白的做笔记工具,操作简单,大家可以去试试......
Java学习day36
元注解:负责注解其他注解,Java定义了4个标准的meta-annotation类型,用来提供对其它annotation类型作说明 1.@Target:用于描述注解的使用范围(即被描述的注解可以用在什 ...
控制Python浮点数输出位数
技术背景在Python的一些长效任务中,不可避免的需要向文本文件.二进制文件或者数据库中写入一些数据,或者是在屏幕上输出一些文本,此时如何控制输出数据的长度是需要我们注意的一个问题.比如对于一个二进 ...
基于Vue的v-charts导出图片并下载
依赖 npm install file-saver 页面 <ve-chart ref="chart"></ve-chart> <el-button t ...

drools动态增加、修改、删除规则

1、背景

2、前置知识

1、如何动态构建出一个kmodule.xml文件

2、kmodule.xml应该被谁加载

3、我们drl规则内容如何加载

4、动态构建KieContainer

3、需求

4、实现

1、引入jar包

2、创建规则实体类

3、实现drools动态规则

4、模拟数据库，实现规则的CRUD

5、创建控制层

6、测试规则的动态添加

1、添加规则

2、运行

7、修改规则

1、修改规则

2、运行

8、删除

1、删除规则

2、运行结果

9、模拟2个kbase

1、添加规则并执行

2、执行

5、完整代码

6、参考文档

drools动态增加、修改、删除规则的更多相关文章

随机推荐

热门专题

1、如何动态构建出一个`kmodule.xml`文件