如何删除jar包(drools动态增加、修改、删除规则)

1、背景

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

2、前置知识

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


如何删除jar包(drools动态增加、修改、删除规则)

动态构建出一个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,然后加入的packagerules/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如何获取?


如何删除jar包(drools动态增加、修改、删除规则)

ReleaseId的获取


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

3、updateToKieModule的作用
将新的
KieModule应用到已经存在的KieContainer对象上,如果KieSession对应已经存在,那么新的规则对KieSession是可见的。
比如:我们修改了规则内容,那么KieSession是知道的。

3、需求

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

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 (thisleId == 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.droolspiler.kie.builder.impl.InternalKieModule;
import org.droolspiler.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.apintime.KieContainer;
import org.kie.apintime.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("需要创建KieBase:{}", kieBaseName);
        return false;
    }

    public void deleteDroolsRule(String kieBaseName, String packageName, String ruleName) {
        if (existsKieBase(kieBaseName)) {
            KieBase kieBase = kieContainer.getKieBase(kieBaseName);
            kieBasemoveRule(packageName, ruleName);
            log("删除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("kieBase:{}添加一个新的包:{}", kieBaseName, droolsRule.getKiePackageName());
            } else {
                kieBaseModel = null;
            }
        }
        String file = "src/main/resources/"   droolsRule.getKiePackageName()   "/"   droolsRule.getRuleId()   ".drl";
        log("加载虚拟规则文件:{}", file);
        kieFileSystem.write(file, droolsRule.getRuleContent());

        if (kieBaseModel != null) {
            String kmoduleXml = kieModuleModel.toXML();
            log("加载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();
    }
}

需要注意的是:

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

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

package com.huan.drools.service;

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) {
            droolsRuleMapmove(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)' \
--header 'Content-Type: application/json' \
--data-raw '{
    "ruleId": 1,
    "kieBaseName": "kieBase01",
    "kiePackageName": "rulesle01",
    "ruleContent": "package rulesle01 \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 rulesle01

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\¶m\=1
rulesle01le-01执行了,前端传递的参数:1%
➜  ~

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

7、修改规则

需求:6、测试规则的动态添加的基础上,修改规则。

之前的规则

package rulesle01

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 rulesle01

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)' \
--header 'Content-Type: application/json' \
--data-raw '{
    "ruleId": 1,
    "kieBaseName": "kieBase01",
    "kiePackageName": "rulesle01",
    "ruleContent": "package rulesle01 \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\¶m\=1
➜  ~ curl http://localhost:8080/drools/rule/fireRule\?kieBaseName\=kieBase01\¶m\=6
rulesle01le-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\¶m\=6
➜  ~ curl http://localhost:8080/drools/rule/fireRule\?kieBaseName\=kieBase01\¶m\=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": "rulesle01",
    "ruleContent": "package rulesle01 \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": "rulesle02",
    "ruleContent": "package rulesle02 \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\¶m\=1
rulesle01le-01执行了,前端传递的参数:1%
➜  ~ curl http://localhost:8080/drools/rule/fireRule\?kieBaseName\=kieBase02\¶m\=1
rulesle02le-01执行了,前端传递的参数:1%
➜  ~

2、执行


如何删除jar包(drools动态增加、修改、删除规则)

测试多kbase

在这里插入图片描述

5、完整代码

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

6、参考文档

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