Drools规则引擎

// 定义入口点
EntryPoint entryPoint = kieSession.getEntryPoint("Fire");

// 向入口点中插入对象
entryPoint.insert(new Fire());

// 规则中使用 from entry-point 匹配对象
rule "Example Rule"
when
    $fire: Fire() from entry-point "Fire"
then
    // 规则的条件满足时执行的动作
    System.out.println("Fire detected!");
end

KIE Api

#KieServices

// 通过单例创建KieServices
KieServices kieServices = KieServices.Factory.get();
// 获取KieContainer
KieContainer kieContainer = kieServices.getKieClasspathContainer();
// 获取KieRepository
KieRepository kieRepository = kieServices.getRepository();

#KieContainer

// 通过单例创建KieServices
KieServices kieServices = KieServices.Factory.get();
// 获取KieContainer
KieContainer kieContainer = kieServices.getKieClasspathContainer();

// 获取KieBase
KieBase kieBase = kieContainer.getKieBase();
// 创建KieSession
KieSession kieSession = kieContainer.newKieSession("session-name");

#KieBase

// 获取KieBase
KieBase kieBase = kieContainer.getKieBase();
KieSession kieSession = kieBase.newKieSession();
StatelessKieSession statelessKieSession = kieBase.newStatelessKieSession();

#KieSession

#KieRepository

// 通过单例创建KieServices
KieServices kieServices = KieServices.Factory.get();
// 获取KieRepository
KieRepository kieRepository = kieServices.getRepository();

#KieProject

#ClasspathKieProject

#kmodule.xml

#kbase的属性：

#ksession的属性：

// 在类路径下加载所有的规则文件

KieServices kieServices = KieServices.Factory.get();

KieContainer kContainer = kieServices.getKieClasspathContainer();

Drools思维导图

Drools核心| ProcessOn免费在线作图,在线流程图,在线思维导图

ProcessOn是一个在线协作绘图平台，为用户提供强大、易用的作图工具！支持在线创作流程图、思维导图、组织结构图、网络拓扑图、BPMN、UML图、UI界面原型设计、iOS界面原型设计等。同时依托于互联网实现了人与人之间的实时协作和共享。

https://www.processon.com/view/link/64929593a81ac041c9486fe2

<kmodule>
  ...
  <kbase>
    ...
    <ksession name="KSession2_1" type="stateless" default="true" clockType="realtime">
    ...
  </kbase>
  ...
</kmodule>

<kmodule>
  ...
  <kbase name="KBase2" default="false" eventProcessingMode="stream" equalsBehavior="equality" declarativeAgenda="enabled" packages="org.domain.pkg2, org.domain.pkg3" includes="KBase1">
    ...
  </kbase>
  ...
</kmodule>

无状态KIE Session

StatelessKieSession kSession = kContainer.newStatelessKieSession();

Applicant applicant = new Applicant("Mr John Smith", 16);

assertTrue(applicant.isValid());

ksession.execute(applicant);

assertFalse(applicant.isValid());

无状态KIE会话中的全局变量

kieSession.setGlobal("orderDiscount", orderDiscount);

kieSession.execute(orderRequest);

System.out.println(kieSession.getGlobals().get("orderDiscount"));




// Set up a list of commands.
List cmds = new ArrayList();
cmds.add(CommandFactory.newSetGlobal("list1", new ArrayList(), true));
cmds.add(CommandFactory.newInsert(new Person("jon", 102), "person"));
cmds.add(CommandFactory.newQuery("Get People" "getPeople"));

// Execute the list.
ExecutionResults results = ksession.execute(CommandFactory.newBatchExecution(cmds));

// Retrieve the `ArrayList`.
results.getValue("list1");
// Retrieve the inserted `Person` fact.
results.getValue("person");
// Retrieve the query as a `QueryResults` instance.
results.getValue("Get People");

规则引擎：通过匹配规则库和事实库，挑选出对应的规则到日程，最后执行对应的action。

rate算法简介
Rete匹配算法是一种进行大量模式集合和大量对象集合间比较的高效方法，通过这种方法找出所有匹配各个模式的对象。

Rete算法以牺牲内存换取高速的策略
Rete算法分为两个部分：规则编译（rule compilation）、运行时执行（runtime execution）.

有状态KIE sessions

import org.drools.core.DroolsExecutor;
import org.drools.core.model.Fire;
import org.drools.core.model.Room;
import org.drools.core.model.Sprinkler;
import org.junit.Test;
import org.kie.api.KieServices;
import org.kie.api.runtime.KieContainer;
import org.kie.api.runtime.KieSession;
import org.kie.api.runtime.rule.FactHandle;

import java.util.HashMap;
import java.util.Map;

/**
 * @author : kenny
 * @since : 2023/6/21
 **/
public class DroolsStatefulExecutorTest {

    @Test
    public void test(){
        System.err.println("Before factory init....");
        KieServices kieServices = KieServices.Factory.get();
        System.err.println("After factory init....");
        KieContainer kContainer = kieServices.getKieClasspathContainer();
        KieSession ksession = kContainer.newKieSession();

        String[] names = new String[]{"kitchen", "bedroom", "office", "livingroom"};
        Map<String,Room> name2room = new HashMap<>();
        for( String name: names ){
            Room room = new Room( name );
            name2room.put( name, room );
            ksession.insert( room );
            Sprinkler sprinkler = new Sprinkler( room );
            ksession.insert( sprinkler );
        }

        ksession.fireAllRules();

        Fire kitchenFire = new Fire( name2room.get( "kitchen" ) );
        Fire officeFire = new Fire( name2room.get( "office" ) );
        FactHandle kitchenFireHandle = ksession.insert( kitchenFire );
        FactHandle officeFireHandle = ksession.insert( officeFire );

        ksession.fireAllRules();

        ksession.delete( kitchenFireHandle );
        ksession.delete( officeFireHandle );

        ksession.fireAllRules();

        ksession.dispose(); // 在完成规则执行后，记得释放会话资源
    }
}





public class Room {
  private String name;
  // Getter and setter methods
}

public class Sprinkler {
  private Room room;
  private boolean on;
  // Getter and setter methods
}

public class Fire {
  private Room room;
  // Getter and setter methods
}

public class Alarm { }



import org.drools.core.model.Fire
import org.drools.core.model.Sprinkler
import org.drools.core.model.Alarm
rule "When there is a fire turn on the sprinkler"
when
  Fire($room : room)
  $sprinkler : Sprinkler(room == $room, on == false)
then
  modify($sprinkler) { setOn(true) }; // 有状态 KIE 会话则依赖modify规则中的语句来通知 Drools 规则引擎更改
  System.out.println("Turn on the sprinkler for room "+$room.getName());
end

rule "Raise the alarm when we have one or more fires"
when
    exists Fire()
then
    insert( new Alarm() );
    System.out.println( "Raise the alarm" );
end

rule "Cancel the alarm when all the fires have gone"
when
    not Fire()
    $alarm : Alarm()
then
    delete( $alarm );
    System.out.println( "Cancel the alarm" );
end


rule "Status output when things are ok"
when
    not Alarm()
    not Sprinkler( on == true )
then
    System.out.println( "Everything is ok" );
end

// Obtain a KIE session pool from the KIE container
KieContainerSessionsPool pool = kContainer.newKieSessionsPool(10);

// Create KIE sessions from the KIE session pool
KieSession kSession = pool.newKieSession();

// 从drools中获取new出来的对象
List<ChildBusPass> childBusPassList = new ArrayList<>();
for (Object object : ksession.getObjects()) {
    if (object instanceof ChildBusPass) {
        childBusPassList.add((ChildBusPass) object);
    }
}

• identity：（默认）Drools 规则引擎使用 来IdentityHashMap存储所有插入的事实。对于每个新事实插入，Drools 规则引擎都会返回一个新FactHandle对象。如果再次插入事实，Drools 规则引擎将返回原始FactHandle对象，忽略同一事实的重复插入。在此模式下，只有当两个事实是具有相同身份的完全相同的对象时，对于 Drools 规则引擎来说它们才是相同的。

• equality：Drools规则引擎使用aHashMap来存储所有插入的事实。FactHandle仅当插入事实不等于现有事实时，Drools 规则引擎才会根据equals()插入事实的方法返回新对象。在此模式下，如果两个事实以相同的方式组成，则对于 Drools 规则引擎而言，这两个事实是相同的，无论身份如何。当您希望基于特征相等而不是显式标识来评估对象时，请使用此模式。

1. 规则优先级（Rule Salience）：
• 规则优先级通过为规则设置一个数值来定义其执行顺序。数值越高的规则优先级越高，即会先执行。
• 通过设置规则的 salience 属性来指定规则的优先级。例如，salience 10 表示比 salience 5 的规则具有更高的优先级。

2. 议程分组（Agenda Groups）：
• 议程分组可以将规则分成不同的组，每个组具有独立的执行顺序。默认情况下，所有规则属于默认分组。
• 通过将规则的 agenda-group 属性设置为特定分组名称，可以将规则分配给该分组。
• 在执行规则时，你可以选择只执行特定分组的规则，从而控制规则的执行顺序。

3. internalMatch 分组：
• internalMatch 是规则匹配的实例，可以通过对规则设置 activation-group 属性来将其分组。
• 当一个规则的 internalMatch 被激活时，只有同一组中的其他规则中的 internalMatch 才会被激活。
• 这样可以确保同一组中的规则按照特定顺序执行，而不会被其他组中的规则干扰。

package com.drools.core.model;

import org.kie.api.KieServices;
import org.kie.api.runtime.KieContainer;
import org.kie.api.runtime.KieSession;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author : kenny
 * @since : 2023/7/3
 **/
public class Order {
    private int orderId;
    private double amount;
    private double discount;

    public Order(int orderId, double amount, double discount) {
        this.orderId = orderId;
        this.amount = amount;
        this.discount = discount;
    }

    public int getOrderId() {
        return orderId;
    }

    public void setOrderId(int orderId) {
        this.orderId = orderId;
    }

    public double getAmount() {
        return amount;
    }

    public void setAmount(double amount) {
        this.amount = amount;
    }

    public double getDiscount() {
        return discount;
    }

    public void setDiscount(double discount) {
        this.discount = discount;
    }


    public static void main(String[] args) {
        KieServices kieServices = KieServices.get();

        KieContainer kieContainer = kieServices.getKieClasspathContainer();

        // 创建KieSession
        KieSession kieSession = kieContainer.newKieSession();

        // 创建订单对象
        Order order = new Order(1, 1200, 100);

        // 将订单对象插入到KieSession中
        kieSession.insert(order);

        // 设置当前的AgendaGroup为"ValidationGroup"
        kieSession.getAgenda().getAgendaGroup("ValidationGroup").setFocus();

        // 执行规则
        kieSession.fireAllRules();

        // 设置当前的AgendaGroup为"DiscountGroup"
        kieSession.getAgenda().getAgendaGroup("DiscountGroup").setFocus();

        // 执行规则
        kieSession.fireAllRules();

        // 关闭KieSession
        kieSession.dispose();

    }
}



import com.drools.core.model.Order;

agenda-group "ValidationGroup"
rule "CheckAmountRule"
    when
        $order: Order(amount > 1000)
    then
        System.out.println("Order amount exceeds the limit: " + $order.getAmount());
end

agenda-group "DiscountGroup"
rule "CalculateDiscountRule"
    when
        $order: Order()
    then
        $order.setDiscount($order.getAmount() * 0.1);
        System.out.println("Discount calculated: " + $order.getDiscount());
end

1. fireAllRules()方法：
• fireAllRules()方法是规则引擎的一次性执行方法。
• 当调用fireAllRules()方法时，规则引擎会按照当前规则流程（Agenda）中的规则顺序，依次执行匹配的规则。
• 该方法会一直执行，直到所有匹配的规则都被执行完毕或没有可执行的规则。
• 在执行期间，规则引擎会根据规则条件的匹配情况和规则的操作，对事实（Facts）进行处理，可能会产生新的事实并触发其他规则的执行。
• fireAllRules()方法通常用于在规则引擎中执行一次规则匹配和执行的操作。

2. fireUntilHalt()方法：
• fireUntilHalt()方法是规则引擎的持续执行方法。
• 当调用fireUntilHalt()方法时，规则引擎会按照当前规则流程（Agenda）中的规则顺序，依次执行匹配的规则。
• 该方法会一直执行，直到手动调用halt()方法停止执行或中断程序。
• 在执行期间，规则引擎会不断地进行规则匹配和执行，响应新的事实并触发其他规则的执行。
• fireUntilHalt()方法通常用于需要持续监听和处理规则引擎的情况，例如实时数据流处理、事件驱动的系统等。

• fireAllRules()方法用于一次性执行规则引擎中的规则，执行完毕后结束。

• fireUntilHalt()方法用于持续执行规则引擎中的规则，需要手动调用halt()方法停止执行。

1. Immediate Mode（立即模式）：
• 在立即模式下，当规则引擎插入一个新的事实后，会立即对新事实进行匹配和执行。
• 插入的事实将立即参与规则的匹配，可能触发其他规则的执行，可能导致新的事实产生。
• 立即模式适用于需要即时响应和处理新事实的场景。

2. Eager Mode（急切模式）：
• 在急切模式下，当规则引擎插入一个新的事实后，会暂停当前规则的执行，重新匹配所有规则并执行匹配的规则。
• 插入的事实会导致规则引擎重新执行规则流程，重新匹配所有的规则条件，可能触发其他规则的执行，可能导致新的事实产生。
• 急切模式适用于需要重新评估所有规则并执行全局计算的场景。

3. Semi-Eager Mode（半急切模式）：
• 半急切模式是立即模式和急切模式的折中方案。
• 在半急切模式下，当规则引擎插入一个新的事实后，会先完成当前规则的执行，然后重新匹配其他规则并执行匹配的规则。
• 插入的事实会等待当前规则的执行完成，然后才会重新匹配其他规则条件，并执行匹配的规则。
• 半急切模式适用于需要在规则执行过程中处理新事实，但又希望先完成当前规则执行的场景。