drools的简单入门案例场景分析

<dependencyManagement>

     <dependencies>

         <dependency>

             <groupId>org.drools</groupId>

             <artifactId>drools-bom</artifactId>

             <type>pom</type>

             <version>7.69.0.Final</version>

             <scope>import</scope>

         </dependency>

     </dependencies>

</dependencyManagement>

<dependencies>

     <dependency>

        <groupId>org.drools</groupId>

         <artifactId>drools-compiler</artifactId>

     </dependency>

     <dependency>

         <groupId>org.drools</groupId>

         <artifactId>drools-mvel</artifactId>

     </dependency>

     <dependency>

         <groupId>ch.qos.logback</groupId>

         <artifactId>logback-classic</artifactId>

         <version>1.2.11</version>

     </dependency>

</dependencies>

<kmodule xmlns="http://www.drools.org/xsd/kmodule">

     <!--

         kbase 可以存在多个

         name: 指定kbase的名字，需要是唯一的

         packages: 包名，可以理解为到src/main/resources目录下查找这个包名下的规则文件,多个包使用逗号分割

         default: 当前kbase是否是默认的kbase

     -->

     <kbase name="shop-kabse" packages="com.huan.shop" default="false">

         <!--

             ksession 可以存在多个

             name: 指定ksession 的名字，需要唯一

             defalut: 当前ksession在这个kbase下是否是默认的

             type: 指定当前ksession是否是有状态的 stateless表示是无状态的

         -->

         <ksession name="shop-ksession" default="false" type="stateless"/>

         <ksession name="shop-ksession-stateful" default="false" type="stateful"/>

     </kbase>

</kmodule>

包名，必须放置在第一行

package

// 引入Java中的类，需要些全限定名

import

// 定义function ，可选

function  // Optional

// 定义 query ，可选

query  // Optional

declare   // Optional

global   // Optional

// rule 关键字 "rule name" 规则的名字

rule "rule name"

     // Attributes 属性可选

     when  // 关键字

         // Conditions  条件，可为空

     then

         // Actions // 匹配后执行的结果

end // 关键字

// 包名，必须防止到第一行，这个名字需要和 kbase中package属性的值一致

package com.huan.shop

/**

  * 倒入类

  */

import com.huan.drools.CustomerOrder

// 定义规则

rule "shop-rule-01"

     when

         // 模式匹配：到工作内存中查找CustomerOrder，并且这个对象的purchaseQuantity值需要是1，

         // 如果条件成立，$order是绑定变量名，一般以$开头，和fact对象区分开

         $order:CustomerOrder(purchaseQuantity == 1)

     then

         System.out.println("匹配规则 shop-rule-01");

         // 赋值，此处赋值后，在Java代码中获取获取到赋值后的值

         $order.setDiscount(1D);

end

rule "shop-rule-02"

     when

         $order:CustomerOrder(purchaseQuantity == 2)

     then

         System.out.println("匹配规则 shop-rule-02");

         $order.setDiscount(0.98);

end

rule "shop-rule-03"

     when

         $order:CustomerOrder(purchaseQuantity >= 3)

     then

         System.out.println("匹配规则 shop-rule-03");

         $order.setDiscount(0.85);

end

/**

  * 客户购买衣服的订单，省略 getter 和 setter 方法

  *

  * @author huan.fu

  * @date 2022/5/12 - 11:27

  */

public class CustomerOrder {

     /**

      * 购买了几件衣服

      */

     private Integer purchaseQuantity;

     /**

      * 最终打多少折

      */

     private Double discount;

     public CustomerOrder(Integer purchaseQuantity) {

         this .purchaseQuantity = purchaseQuantity;

     }

}

package com.huan.drools;

import org.kie.api.KieServices;

import org.kie.api.event.rule.DebugRuleRuntimeEventListener;

import org.kie.api.runtime.KieContainer;

import org.kie.api.runtime.KieSession;

import org.kie.api.runtime.StatelessKieSession;

/**

  * drools 测试类

  */

public class DroolsApplication {

     public static void main(String[] args) throws InterruptedException {

         // 无状态session测试

         statelessSessionTest();

         // 有状态session测试

         statefulSessionTest();

     }

     private static void statelessSessionTest() {

         // 获取kie services

         KieServices kieServices = KieServices.get();

         // 获取kie容器对象

         KieContainer kieContainer = kieServices.getKieClasspathContainer();

         // 获取kie session , 此处获取的是无状态的session，因为 <ksession name="shop-ksession" default="false" type="stateless"/>

         // 中type="stateless"就是无状态的session

         StatelessKieSession kieSession = kieContainer.newStatelessKieSession( "shop-ksession" );

         // 创建一个对象，可以理解为 Fact对象，即事实对象

         CustomerOrder customerOrder = new CustomerOrder( 2 );

         // 添加监听器，便于观察日志

         kieSession.addEventListener( new DebugRuleRuntimeEventListener());

         // 无状态的session只需要执行 execute 方法即可。

         kieSession.execute(customerOrder);

         System.err.println( "通过规则后，获取到的折扣为:" + customerOrder.getDiscount());

     }

     private static void statefulSessionTest() {

         // 获取kie services

         KieServices kieServices = KieServices.get();

         // 获取kie容器对象

         KieContainer kieContainer = kieServices.getKieClasspathContainer();

         // 获取kie session , 此处获取的是有状态的session

         KieSession kieSession = kieContainer.newKieSession( "shop-ksession-stateful" );

         // 创建一个对象，可以理解为 Fact对象，即事实对象

         CustomerOrder customerOrder = new CustomerOrder( 3 );

         // 添加监听器，便于观察日志

         kieSession.addEventListener( new DebugRuleRuntimeEventListener());

         // 将customerOrder对象加入到工作内存中

         kieSession.insert(customerOrder);

         // 触发所有的规则，如果只想触发指定的规则，则使用fireAllRules(AgendaFilter agendaFilter)方法

         kieSession.fireAllRules();

         // 有状态的session一定需要调用dispose方法

         kieSession.dispose();

         System.err.println( "通过规则后，获取到的折扣为:" + customerOrder.getDiscount());

     }

}