技術文章 » drools動態增加、修改、刪除規則

drools動態增加、修改、刪除規則

2022-05-28 12:03:31

目錄

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