Drools规则引擎快速入门

drools是一款由JBoss组织提供的基于Java语言开发的开源规则引擎，可以将复杂且多变的业务规则从硬编码中解放出来，以规则脚本的形式存放在文件或特定的存储介质中(例如存放在数据库中)，使得业务规则的变更不需要修改项目代码、重启服务器就可以在线上环境立即生效。

drools官网地址,drools源码下载地址

1.规则引擎应用场景

对于一些存在比较复杂的业务规则并且业务规则会频繁变动的系统比较适合使用规则引擎，如下：

风险控制系统—-风险贷款、风险评估
反欺诈项目—-银行贷款、征信验证
决策平台系统—-财务计算
促销平台系统—-满减、打折、加价购在项目中使用drools时，如果单独使用只需要导入如下maven坐标即可：

<dependency>
    <groupId>org.drools</groupId>
    <artifactId>drools-compiler</artifactId>
     <version>7.62.0.Final</version> 
</dependency>

如果整合spring使用

<dependency>
    <groupId>org.kie</groupId>
    <artifactId>kie-spring</artifactId>
    <version>7.62.0.Final</version> 
</dependency>

如果我们使用IDEA开发drools应用，IDEA中已经集成了drools插件drools API开发步骤如下：

2. Drools快速入门案例

2.1. 业务场景说明

业务场景：消费者在图书商城购买图书，下单后需要在支付页面显示订单优惠后的价格。具体优惠规则如下：假设需求：订单满减

规则编号	规则名称	描述
1	规则一	所购图书总价在100元以下的优惠5元
2	规则二	所购图书总价在100到200元的优惠25元
3	规则三	所购图书总价在200到300元的优惠60元
4	规则四	所购图书总价在300元以上的优惠110元

3.开发实现

【步骤一】:创建maven工程drools-demo并导入drools相关maven坐标

这里springboot版本使用的2.7.17

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <artifactId>spring-boot-starter-parent</artifactId>
        <groupId>org.springframework.boot</groupId>
        <version>2.7.17</version>
    </parent>


    <groupId>com.zbbmeta</groupId>
    <artifactId>drools-demo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>

    <dependencies>
        <!--        wbe-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- Drools dependency -->
        <dependency>
            <groupId>org.kie</groupId>
            <artifactId>kie-spring</artifactId>
            <version>7.62.0.Final</version> <!-- 或者适用于你的Spring Boot版本的其他Drools版本 -->
        </dependency>
        <!--        lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <!--        test-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>

        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.8.22</version>
        </dependency>
    </dependencies>
</project>

【步骤二】:创建实体类Order

package com.zbbmeta.entity;

import lombok.Data;

/**
 * @Author: springboot葵花宝典
 * @description: TODO
 */
@Data
public class Order {
    private Double originalPrice;//订单原始价格，即优惠前价格
    private Double realPrice;//订单真实价格，即优惠后价格
}

【步骤三】:创建规则文件resources/rules/bookDiscount.drl

//图书优惠规则
import com.zbbmeta.entity.Order

//规则一：所购图书总价在100元以下优惠5元
rule "book_discount_1"
    when
        $order:Order(originalPrice < 100)
    then
        $order.setRealPrice($order.getOriginalPrice()-5);
        System.out.println("成功匹配到规则一：所购图书总价在100元以下优惠5元");
end

//规则二：所购图书总价在100到200元的优惠25元
rule "book_discount_2"
    when
        $order:Order(originalPrice < 200 && originalPrice >= 100)
    then
        $order.setRealPrice($order.getOriginalPrice() - 250);
        System.out.println("成功匹配到规则二：所购图书总价在100到200元的优惠25元");
end

//规则三：所购图书总价在200到300元的优惠60元
rule "book_discount_3"
    when
        $order:Order(originalPrice <= 300 && originalPrice >= 200)
    then
        $order.setRealPrice($order.getOriginalPrice() - 60);
        System.out.println("成功匹配到规则三：所购图书总价在200到300元的优惠60元");
end

//规则四：所购图书总价在300元以上的优惠110元
rule "book_discount_4"
    when
        $order:Order(originalPrice >= 300)
    then
        $order.setRealPrice($order.getOriginalPrice() - 110);
        System.out.println("成功匹配到规则四：所购图书总价在300元以上的优惠110元");
end

【步骤四】:配置Drools引擎

创建一个Drools引擎的配置类，通常命名为DroolsConfig

package com.zbbmeta.config;

import org.kie.api.KieBase;
import org.kie.api.KieServices;
import org.kie.api.builder.*;


import org.kie.spring.KModuleBeanFactoryPostProcessor;
import org.springframework.core.io.Resource;
import org.kie.api.runtime.KieContainer;
import org.kie.api.runtime.KieSession;
import org.kie.internal.io.ResourceFactory;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;


import java.io.IOException;

/**
 * @Author: springboot葵花宝典
 * @description: TODO
 */
@Configuration
public class DroolsConfig {
    private static final String RULES_PATH = "rules/";

    @Bean
    public KieFileSystem kieFileSystem() throws IOException {

        KieFileSystem kieFileSystem = getKieServices().newKieFileSystem();
        for (Resource file : getRuleFiles()) {
            // 写入规则文件到 KieFileSystem
            kieFileSystem.write(ResourceFactory.newClassPathResource(RULES_PATH + file.getFilename(), "UTF-8"));
        }
        return kieFileSystem;
    }
    // 获取规则文件资源
    private Resource[] getRuleFiles() throws IOException {
        // 创建 ResourcePatternResolver 实例
        ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
        // 获取规则文件资源
        return resourcePatternResolver.getResources("classpath*:" + RULES_PATH + "**/*.drl");
    }
    // 获取 KieServices 实例
    private KieServices getKieServices() {
        // 获取 KieServices 实例
        return KieServices.Factory.get();
    }


    // 配置Drools容器，用于加载规则文件
    @Bean
    public KieContainer kieContainer() throws IOException {
        final KieRepository kieRepository = getKieServices().getRepository();

        kieRepository.addKieModule(kieRepository::getDefaultReleaseId);
        // 添加 KieModule 到 KieRepository
        KieBuilder kieBuilder = getKieServices().newKieBuilder(kieFileSystem());
        // 构建所有规则
        kieBuilder.buildAll();
        // 返回 KieContainer 实例
        return getKieServices().newKieContainer(kieRepository.getDefaultReleaseId());
    }

    // 创建KieBase，用于构建KieSession
    @Bean
    public KieBase kieBase(KieContainer kieContainer) {
        return kieContainer.getKieBase();
    }
    // 创建KieSession，用于执行规则
    @Bean
    public KieSession kieSession(KieContainer kieContainer) {
        return kieContainer.newKieSession();
    }
    // 配置 KModuleBeanFactoryPostProcessor，用于自动注册 KieBase 和 KieSession
    @Bean
    public KModuleBeanFactoryPostProcessor kiePostProcessor() {
        return new KModuleBeanFactoryPostProcessor();
    }
}

【步骤五】:创建Service

@Service
public class DroolsService {
    @Autowired
    KieSession kieSession;


    public Order executeOrderRule(Order order) {
        // 将事实插入到Drools会话中
        kieSession.insert(order);
        // 激活所有规则
        kieSession.fireAllRules();
        return order;
    }
}

【步骤六】:创建DroolsController

@RestController
public class DroolsController {

    @Autowired
     DroolsService droolsService;
     
    @PostMapping("/executeOrderRule")
    public Order executeOrderRule(@RequestBody Order order) {
        return droolsService.executeOrderRule(order);
    }
}