1. 认识Kie

1.1 KieService

KieServices作为 KIE 项目中的核心接口之一，KieService 充当了集线器的角色，为其他服务提供线程安全的单例。它简化了与 Kie 组件的交互，使得开发者可以更方便地管理和使用业务规则、流程等。

主要功能

访问 Kie 构建设施：KieService 提供了构建 Kie 组件（如 KieModule、KieBase、KieSession 等）的方法。通过这些方法，开发者可以动态地加载、编译和执行规则或流程。
管理 Kie 运行时环境：KieService 还负责管理 Kie 容器（KieContainer），它是存储和管理 KieBase 的环境。通过 KieContainer，开发者可以轻松地获取 KieBase，并在其中创建 KieSession 来执行规则或流程实例。
简化配置和使用：KieService 使用默认值来最小化配置量，同时提供了灵活的配置选项以满足不同场景的需求。这使得开发者可以更加专注于业务逻辑的实现，而不是繁琐的配置工作。

// 获取 KieServices 实例
KieServices kieServices = KieServices.Factory.get();

1.2 KieFileSystem

KieFileSystem是一个内存文件系统，它为Drools规则引擎提供了一个虚拟的文件系统环境，不会真实在磁盘上创建文件。在这个环境中，开发者可以像操作普通文件系统一样，添加、删除和修改规则文件和其他资源。这些资源将被Drools规则引擎用于后续的编译和执行过程。

工作原理

资源存储：KieFileSystem内部维护了一个内存数据结构，用于存储添加到其中的资源。这些资源可以是规则文件（如DRL文件）、决策表、流程定义等。
资源访问：开发者可以通过KieFileSystem提供的API来访问和操作这些资源。例如，可以读取规则文件的内容，或将其写入到内存文件系统中。
资源编译：在规则引擎启动或运行时，KieFileSystem中的资源可以被编译成可执行的形式。这些编译后的资源将被加载到规则引擎的执行环境中，以便进行规则匹配和执行。

// 创建 KieFileSystem 实例并配置规则引擎
KieFileSystem kieFileSystem = kieServices.newKieFileSystem();
// 添加规则文件到KieFileSystem
kieFileSystem.write("src/main/resources/rules/myRule.drl", ResourceFactory.newClassPathResource("rules/myRule.drl"));
//kieFileSystem.write("src/main/resources/rules/myRule.drl", ruleContent);

注意：

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

如果每次都创建一个新的KieFileSystem，当我们加载一个新的规则内容的时候，那么之前的规则内容可能会丢失。

可以看到，我们写入的路径是 src/main/resources/rules/myRule.drl，那么这是什么意思呢？

简单理解如下：

src/main/resources：这个是固定写法。

rules/rule01：加载的包路径。

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

1.3 KieBuilder

KieBuilder是Drools规则引擎中的一个编译器，它接收KieFileSystem中存储的规则文件和其他资源作为输入，然后执行编译过程，将这些资源转换成规则引擎可以执行的形式。编译过程中，KieBuilder会检查规则文件的语法和语义正确性，并生成相应的编译结果。

工作原理

输入处理：KieBuilder首先会读取KieFileSystem中存储的规则文件和其他资源。这些资源可以是DRL文件、决策表、流程定义等。
编译过程：在编译过程中，KieBuilder会执行以下操作。语法检查：验证规则文件的语法是否符合Drools规则语言的标准。语义检查：分析规则文件的语义，确保规则之间的逻辑关系和依赖关系正确无误。资源转换：将规则文件和其他资源转换成规则引擎可以执行的形式，如内存中的数据结构或字节码。
输出生成：编译完成后，KieBuilder会生成编译结果。这些结果包括编译成功的规则集、编译过程中发现的错误和警告信息等。

// 创建KieBuilder实例并执行编译操作
KieBuilder kieBuilder = kieServices.newKieBuilder(kieFileSystem);
kieBuilder.buildAll();
 
// 检查编译结果
Results results = kieBuilder.getResults();
if (results.hasMessages(Message.Level.ERROR)) {
    // 处理编译错误
    System.out.println("编译错误：" + results.getMessages());
} else {
    // 编译成功，获取KieModule
    KieModule kieModule = kieBuilder.getKieModule();
    // ... 使用kieModule进行后续操作 ...
}

1.4 KieModule

KieModule是一个逻辑上的模块，它封装了一组规则、流程、函数等，使得这些资源可以在Drools规则引擎中作为一个整体被管理和执行。KieModule通常通过kmodule.xml文件进行定义，该文件描述了KieModule的结构和内容。kmodule.xml 文件定义了 KieBase 的名字，配置，以及其他用来创建KieBases和KieSession的资源，是一个存放所有定义好的 KieBases 资源的容器。

// 获取KieModule
KieModule kieModule = kieBuilder.getKieModule();

1.5 KieContainer

KieContainer是Drools规则引擎的容器，它用于加载和管理规则文件。通过KieContainer，可以获取到规则文件中定义的规则和规则集，并创建相应的KieSession对象。KieContainer通常在应用程序启动时创建，并在整个应用程序的生命周期中重复使用。

工作原理

加载规则文件：KieContainer通过读取和解析kmodule.xml文件，加载指定的规则文件。这些规则文件通常以DRL（Drools Rule Language）格式编写，定义了业务规则。
管理KieBase：KieContainer内部维护了一个或多个KieBase实例。KieBase是一个知识仓库，包含了若干的规则、流程、方法等。KieContainer通过KieBase来组织和管理这些规则。
创建KieSession：当需要执行规则时，KieContainer可以根据需求创建KieSession对象。KieSession是Drools规则引擎的执行环境，它包含了运行时数据（即“事实”），并对这些数据进行规则运算。

// 创建 KieContainer
KieContainer kieContainer = kieServices.newKieClasspathContainer();

动态构建KieContainer

if (null == kieContainer) {
  kieContainer = kieServices.newKieContainer(kieServices.getRepository().getDefaultReleaseId());
}
// 更新
// 将新的KieModule应用到已经存在的KieContainer对象上，如果KieSession对应已经存在，那么新的规则对KieSession是可见的
((KieContainerImpl) kieContainer).updateToKieModule((InternalKieModule) kieBuilder.getKieModule());

1.6 KieBase

KieBase包含了规则（Rule）和规则相关的数据（Fact）以及规则之间的关系。在Drools中，规则通常以DRL文件的形式存在，而Fact则是与规则进行匹配的实际数据对象。

KieBase的主要功能是存储和管理规则，以及提供规则执行的环境。当规则引擎接收到一个Fact对象时，它会在KieBase中查找与之匹配的规则，并执行这些规则所定义的操作。

// 方式一：从 KieContainer 中获取 KieBase
KieBase kieBase = kieContainer.getKieBase();

// 方式二：使用KieHelper来构建KieBase
KieHelper kieHelper = new KieHelper();
kieHelper = kieHelper.addContent(ruleContent, ResourceType.DRL);
KieBase kieBase = kieHelper.build();

1.7 KieSession

KieSession是Drools中用于执行规则和管理事实的会话对象。它基于KieBase创建，包含运行时数据，并对这些数据实时进行规则运算。

KieSession有两种类型：有状态（Stateful）和无状态（Stateless）。有状态KieSession可以保持会话状态，允许多次与规则引擎进行交互；而无状态KieSession则不保持会话状态，每次交互都是独立的。

主要功能

执行规则：KieSession可以将事实（Fact）对象传递给规则引擎，并执行与之匹配的规则。规则执行的结果可以影响Fact对象的状态或产生新的Fact对象。
管理事实：KieSession提供了插入（insert）、更新（update）、删除（delete）事实对象的方法，允许开发人员动态地管理事实集合。
会话控制：对于有状态KieSession，开发人员可以控制会话的开始、结束以及会话期间的事实插入和规则执行。无状态KieSession则通过单次调用执行所有操作，无需显式控制会话状态。

// 从 KieBase 中创建 KieSession 并执行规则
KieSession kieSession = kieBase.newKieSession();
kieSession.insert(new OrderRequest(...)); // 插入事实
kieSession.fireAllRules(); // 执行所有匹配的规则
kieSession.dispose(); // 关闭 KieSession

注意：KieContainer是线程安全的，而KieContainer.newStatelessKieSession()和KieContainer.newKieSession()方法是线程不安全的。

1.8 有状态 KieSession 和无状态 KieSession 区别

Drools 的 Session 分为有状态和无状态。

有状态KieSession可以保持会话状态，允许多次与规则引擎进行交互；而无状态KieSession则不保持会话状态，每次交互都是独立的。

KieSession

与规则引擎持久交互
推理过程多次触发同一个数据集。推理解释：有两个规则，规则一里面修改discount，规则二的条件是discount>50。那么，插入一个discount为30的对象，当你在规则一中用modify把discount设置为80时，规则引擎会意识到这个值变了，会触发规则二的执行。
使用完后，要调用 dispose() 方法
有状态会话可以随时添加事实（Fact）

StatelessKieSession

不能重复插入事实（Fact）
执行规则使用 execute() 方法，没有 insert(), fireAllRules() 和 dispose() 方法

2. SpringBoot的整合

2.1 添加Drools的相关依赖

在pom.xml文件中添加以下依赖：

<dependency>
    <groupId>org.drools</groupId>
    <artifactId>drools-compiler</artifactId>
</dependency>
<dependency>
    <groupId>org.drools</groupId>
    <artifactId>drools-mvel</artifactId>
</dependency>

2.2 实战

使用KieServices执行规则

// 获取 KieServices 实例
KieServices kieServices = KieServices.Factory.get();
 
// 创建 KieFileSystem 实例并配置规则引擎
KieFileSystem kieFileSystem = kieServices.newKieFileSystem();
kieFileSystem.write("src/main/resources/rule/rule0.drl", ruleContent);
        
// 创建 KieBuilder 实例并构建 Drools 模块
KieBuilder kieBuilder = kieServices.newKieBuilder(kieFileSystem);
kieBuilder.buildAll();
 
// 获取 KieModule 并创建 KieContainer
KieModule kieModule = kieBuilder.getKieModule();
KieContainer kieContainer = kieServices.newKieContainer(kieModule.getReleaseId());
 
// 从 KieContainer 中获取 KieBase
KieBase kieBase = kieContainer.getKieBase();
 
// 从 KieBase 中创建 KieSession 并执行规则
KieSession kieSession = kieBase.newKieSession();
kieSession.insert(new OrderRequest(...)); // 插入事实
kieSession.fireAllRules(); // 执行所有匹配的规则
kieSession.dispose(); // 关闭 KieSession

使用KieHelper执行规则

public void execKieBase(String kieBaseName, String ruleContent) {
	KieHelper kieHelper = new KieHelper();
	kieHelper = kieHelper.addContent(ruleContent, ResourceType.DRL);
	
	// 获取 KieServices 实例
	KieServices kieServices = KieServices.get();
	KieModuleModel kieModuleModel = kieServices.newKieModuleModel();
	
	KieBaseModel kieBaseModel = kieModuleModel.newKieBaseModel(kieBaseName);
	// 默认的kieBase
	kieBaseModel.setDefault(true);
    // 设置该KieBase需要加载的包路径
	kieBaseModel.addPackage("");
	// 设置kieSession
	kieBaseModel.newKieSessionModel(kieBaseName + "-session")
			// 默认session
			.setDefault(true);
			
	kieHelper = kieHelper.setKieModuleModel(kieModuleModel);
	ReleaseId releaseId = kieServices.newReleaseId("com.rule", kieBaseName, "1.0.0");
	kieHelper = kieHelper.setReleaseId(releaseId);
	
	KieBase kieBase = kieHelper.build(MultithreadEvaluationOption.YES, MaxThreadsOption.get(20));
	KieSession kieSession = kieBase.newKieSession();
    try {
        // 匹配规则
        kieSession.fireAllRules();
    } catch (Exception e) {
        logger.error("规则调用失败" + e.getMessage());
    }
    // 关闭会话
    kieSession.dispose();
}

动态生成并加载Drools规则文件。

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 管理
 *
 */
@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(String ruleId, String ruleContent, String kieBaseName, String kiePackageName) {
        // 判断该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(kiePackageName);
            // 设置kieSession
            kieBaseModel.newKieSessionModel(kieBaseName + "-session")
                    // 不是默认session
                    .setDefault(false);
        } else {
            // 获取到已经存在的kbase对象
            kieBaseModel = kieModuleModel.getKieBaseModels().get(kieBaseName);
            // 获取到packages
            List<String> packages = kieBaseModel.getPackages();
            if (!packages.contains(kiePackageName)) {
                kieBaseModel.addPackage(kiePackageName);
                log.info("kieBase:{}添加一个新的包:{}", kieBaseName, kiePackageName);
            } else {
                kieBaseModel = null;
            }
        }
        String file = "src/main/resources/" + kiePackageName + "/" + ruleId + ".drl";
        log.info("加载虚拟规则文件:{}", file);
        kieFileSystem.write(file, ruleContent);

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

    /**
     * 模拟触发规则
     */
    public String fireRule(String kieBaseName, Integer param) {
        // 创建kieSession
        KieSession kieSession = kieContainer.newKieSession(kieBaseName + "-session");
        StringBuilder result = new StringBuilder();
        kieSession.setGlobal("result", result);
        // 向规则中插入一个Integer类型的值
        kieSession.insert(param);
        kieSession.fireAllRules();
        kieSession.dispose();
        return result.toString();
    }
}