关于后端:drools动态增加修改删除规则

@[TOC]

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、需要

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 (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();}
}

须要留神的是：

1. KieFileSystem 须要是单例的，即应用的是同一个。
2. KieContainer须要是单例的，即应用的是同一个。
3. 通过 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