springboot项目整合Drools实战问题

已于 2024-04-11 21:59:25 修改
阅读量634 收藏 3
点赞数 7
文章标签： spring boot 后端 java
于 2024-04-11 21:53:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shenyu0009csdn/article/details/137653554
版权

最近我们公司安排开发一个aps（排程平台），然后让我动态实现动态drl文件生成，将这个建模功能面向甲方，让甲方自己实现规则制定，我就负责这个排程功能的实现。于是就学着将drools整合到springboot项目中。然后自己摸着石头过河，尝试自己搞一下drools。

第1步:创建springboot项目：

第2步：导入drools的依赖

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.qiyan.Drools</groupId>
    <artifactId>Drools</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>Drools</name>
    <description>Drools</description>
    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.6.13</spring-boot.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.drools</groupId>
            <artifactId>drools-core</artifactId>
            <version>7.6.0.Final</version>
        </dependency>
        <dependency>
            <groupId>org.drools</groupId>
            <artifactId>drools-compiler</artifactId>
            <version>7.6.0.Final</version>
        </dependency>
        <dependency>
            <groupId>org.drools</groupId>
            <artifactId>drools-templates</artifactId>
            <version>7.6.0.Final</version>
        </dependency>
        <dependency>
            <groupId>org.kie</groupId>
            <artifactId>kie-api</artifactId>
            <version>7.6.0.Final</version>
        </dependency>
        <dependency>
            <groupId>org.kie</groupId>
            <artifactId>kie-spring</artifactId>
            <version>7.6.0.Final</version>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-tx</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-beans</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-core</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-context</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>${spring-boot.version}</version>
                <configuration>
                    <mainClass>com.qiyan.drools.DroolsApplication</mainClass>
                    <skip>true</skip>
                </configuration>
                <executions>
                    <execution>
                        <id>repackage</id>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

 第3步：创建src/main/resources/application.yaml

server:
  address: 127.0.0.1
  port: 8080
  servlet:
    context-path: /api
spring:
  config:
    name: drool_springboot

第4步：创建一个src/main/java/com/qiyan/drools/config/DroolsConfig.java文件（如果有了DroolsConfig文件就不用在src/main/resources/META-INF/kmodule.xml）创建kmodule.xml文件了，两种方式都是为了创建工厂对象，用来创建KieBase对象来执行drl文件的进行规则匹配。

package com.qiyan.drools.config;

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

import java.io.IOException;

@Configuration
public class DroolsConfig {
     //这个地址就是用来存放drl文件的地址
    private static final String RULES_PATH = "rules/";

    @Bean //注册对象交给spring容器管理
    @ConditionalOnMissingBean(KieFileSystem.class) //该注解作用看spring里面有没有这个对象，有的话直接拿出来用，没有的话才创建bean对象
    public KieFileSystem kieFileSystem() throws IOException {
        KieFileSystem kieFileSystem = getKieServices().newKieFileSystem();
        for (Resource file : getRuleFiles()) {
            kieFileSystem.write(ResourceFactory.newClassPathResource(RULES_PATH + file.getFilename(), "UTF-8"));
        }
        return kieFileSystem;
    }

    private Resource[] getRuleFiles() throws IOException {
        ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();
        return resourcePatternResolver.getResources("classpath*:" + RULES_PATH + "**/*.*");
    }

    @Bean
    @ConditionalOnMissingBean(KieContainer.class)
    public KieContainer kieContainer() throws IOException {
        final KieRepository kieRepository = getKieServices().getRepository();

        kieRepository.addKieModule(new KieModule() {
            @Override
            public ReleaseId getReleaseId() {
                return kieRepository.getDefaultReleaseId();
            }
        });

        KieBuilder kieBuilder = getKieServices().newKieBuilder(kieFileSystem());
        kieBuilder.buildAll();

        return getKieServices().newKieContainer(kieRepository.getDefaultReleaseId());
    }

    private KieServices getKieServices() {
        return KieServices.Factory.get();
    }

    @Bean
    @ConditionalOnMissingBean(KieBase.class)
    public KieBase kieBase() throws IOException {
        return kieContainer().getKieBase();
    }

    @Bean
    @ConditionalOnMissingBean(KieSession.class)
    public KieSession kieSession() throws IOException {
        return kieContainer().newKieSession();
    }

    @Bean
    @ConditionalOnMissingBean(KModuleBeanFactoryPostProcessor.class)
    public KModuleBeanFactoryPostProcessor kiePostProcessor() {
        return new KModuleBeanFactoryPostProcessor();
    }

}

第5步：创建一个对应的任务的实体类(这个就是用规则文件里面需要导入的用来进行规则匹配的对象)

package com.qiyan.drools.entity;

import lombok.Data;

/**
 * 贷款额度对象
 */
@Data
public class Loans {


    /**
     * 征信等级：等级0：额度0，等级1:额度10w，等级2:额度5w，等级3:额度3w。其余：额度1.5w
     */
    private Integer creditGrade;


    /**
     * 额度
     */
    private Integer amount;
}

第6步：在resources目录下的创建一个rules文件夹，用来放drl文件（config文件地址就是这个文件的地址）src/main/resources/rules/testRules.drl

package rules;


import com.qiyan.drools.entity.Loans;

//征信等级：等级0：额度0，等级1:额度10w，等级2:额度5w，等级3:额度3w。其余：额度1.5w

  //征信等级0
  rule "credit_0" //名称需唯一
  when
  $loans:Loans(creditGrade == 0)
  then
  $loans.setAmount(0);
     System.out.println("触发规则，征信等级为0，额度0");
  end


  //征信等级1
  rule "credit_1" //名称需唯一
  when
  $loans:Loans(creditGrade == 1)
  then
  $loans.setAmount(100000);
  System.out.println("触发规则，征信等级为1，额度100000");
  end

  //征信等级2
  rule "credit_2" //名称需唯一
  when
  $loans:Loans(creditGrade == 2)
  then
  $loans.setAmount(50000);
       System.out.println("触发规则，征信等级为2，额度50000");
  end

      //征信等级3
   rule "credit_3" //名称需唯一
   when
   $loans:Loans(creditGrade == 3)
   then
   $loans.setAmount(30000);
           System.out.println("触发规则，征信等级为1，额度30000");
   end

  //征信等级 其他
  rule "credit_4" //名称需唯一
  when
  $loans:Loans(creditGrade>3)
  then
  $loans.setAmount(15000);
  System.out.println("触发规则，征信等级为:其他，额度15000");
  end

第7步：写一个测试类测试代码

  @Test
    public void test() {
        //获取kieserver
        KieSession kieSession = kieBase.newKieSession();
        //事实对象
        Loans loans = new Loans();
        //设置征信登记为1
        loans.setCreditGrade(1);
        //插入事实对象到session中
        kieSession.insert(loans);
        //执行规则引擎
        kieSession.fireAllRules();
        System.out.println("对象信息：" + loans.toString());
        kieSession.dispose();
        System.out.println("规则执行完成，关闭规则");


    }

代码执行结果：

在这过程中遇到的问题：

问题一：这个问题，就是jdk版本问题，好像是和jdk17不兼容，但是修改jdk版本为jdk1.8就没有问题了。

  1. 根本异常 (java.lang.ExceptionInInitializerError)：通常这个异常表明在执行静态初始化代码块或者初始化静态变量时发生了异常。在你这个情况下，是因为后面的反射访问异常。

  2. 反射访问异常 (java.lang.reflect.InaccessibleObjectException)：这个异常是因为你的代码尝试通过反射去访问一个Java模块中的类或成员，但是该模块没有"开放（opens）"这个包给你的模块使用。从错误信息来看，是因为尝试访问java.util.TreeMap的comparator字段，但是java.base模块没有对你的代码模块开放java.util包。

  3. 原因：从Java 9开始引入了模块系统，对于反射的访问会有更加严格的控制。如果你的代码运行在Java 9或更高版本上，而你尝试访问某些JDK内部api，就可能会遇到这个问题。

java.lang.IllegalStateException: Failed to load ApplicationContext

    at org.springframework.test.context.cache.DefaultCacheAwareContextLoaderDelegate.loadContext(DefaultCacheAwareContextLoaderDelegate.java:98)
    at org.springframework.test.context.support.DefaultTestContext.getApplicationContext(DefaultTestContext.java:124)
    at org.springframework.test.context.web.ServletTestExecutionListener.setUpRequestContextIfNecessary(ServletTestExecutionListener.java:190)
    at org.springframework.test.context.web.ServletTestExecutionListener.prepareTestInstance(ServletTestExecutionListener.java:132)
    at org.springframework.test.context.TestContextManager.prepareTestInstance(TestContextManager.java:248)
    at org.springframework.test.context.junit.jupiter.SpringExtension.postProcessTestInstance(SpringExtension.java:138)
    at org.junit.jupiter.engine.descriptor.ClassBasedTestDescriptor.lambda$invokeTestInstancePostProcessors$8(ClassBasedTestDescriptor.java:363)
    at org.junit.jupiter.engine.descriptor.ClassBasedTestDescriptor.executeAndMaskThrowable(ClassBasedTestDescriptor.java:368)
    at org.junit.jupiter.engine.descriptor.ClassBasedTestDescriptor.lambda$invokeTestInstancePostProcessors$9(ClassBasedTestDescriptor.java:363)
    at java.base/java.util.stream.ReferencePipeline$3$1.accept(ReferencePipeline.java:197)
    at java.base/java.util.stream.ReferencePipeline$2$1.accept(ReferencePipeline.java:179)
    at java.base/java.util.ArrayList$ArrayListSpliterator.forEachRemaining(ArrayList.java:1625)
    at java.base/java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:509)
    at java.base/java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:499)
    at java.base/java.util.stream.StreamSpliterators$WrappingSpliterator.forEachRemaining(StreamSpliterators.java:310)
    at java.base/java.util.stream.Streams$ConcatSpliterator.forEachRemaining(Streams.java:735)
    at java.base/java.util.stream.Streams$ConcatSpliterator.forEachRemaining(Streams.java:734)
    at java.base/java.util.stream.ReferencePipeline$Head.forEach(ReferencePipeline.java:762)
    at org.junit.jupiter.engine.descriptor.ClassBasedTestDescriptor.invokeTestInstancePostProcessors(ClassBasedTestDescriptor.java:362)
    at org.junit.jupiter.engine.descriptor.ClassBasedTestDescriptor.lambda$instantiateAndPostProcessTestInstance$6(ClassBasedTestDescriptor.java:283)
    at org.junit.platform.engine.support.hierarchical.ThrowableCollector.execute(ThrowableCollector.java:73)
    at org.junit.jupiter.engine.descriptor.ClassBasedTestDescriptor.instantiateAndPostProcessTestInstance(ClassBasedTestDescriptor.java:282)
    at org.junit.jupiter.engine.descriptor.ClassBasedTestDescriptor.lambda$testInstancesProvider$4(ClassBasedTestDescriptor.java:272)
    at java.base/java.util.Optional.orElseGet(Optional.java:364)
    at org.junit.jupiter.engine.descriptor.ClassBasedTestDescriptor.lambda$testInstancesProvider$5(ClassBasedTestDescriptor.java:271)
    at org.junit.jupiter.engine.execution.TestInstancesProvider.getTestInstances(TestInstancesProvider.java:31)
    at org.junit.jupiter.engine.descriptor.TestMethodTestDescriptor.lambda$prepare$0(TestMethodTestDescriptor.java:102)
    at org.junit.platform.engine.support.hierarchical.ThrowableCollector.execute(ThrowableCollector.java:73)
    at org.junit.jupiter.engine.descriptor.TestMethodTestDescriptor.prepare(TestMethodTestDescriptor.java:101)
    at org.junit.jupiter.engine.descriptor.TestMethodTestDescriptor.prepare(TestMethodTestDescriptor.java:66)
    at org.junit.platform.engine.support.hierarchical.NodeTestTask.lambda$prepare$2(NodeTestTask.java:123)
    at org.junit.platform.engine.support.hierarchical.ThrowableCollector.execute(ThrowableCollector.java:73)
    at org.junit.platform.engine.support.hierarchical.NodeTestTask.prepare(NodeTestTask.java:123)
    at org.junit.platform.engine.support.hierarchical.NodeTestTask.execute(NodeTestTask.java:90)
    at java.base/java.util.ArrayList.forEach(ArrayList.java:1511)
    at org.junit.platform.engine.support.hierarchical.SameThreadHierarchicalTestExecutorService.invokeAll(SameThreadHierarchicalTestExecutorService.java:41)
    at org.junit.platform.engine.support.hierarchical.NodeTestTask.lambda$executeRecursively$6(NodeTestTask.java:155)
    at org.junit.platform.engine.support.hierarchical.ThrowableCollector.execute(ThrowableCollector.java:73)
    at org.junit.platform.engine.support.hierarchical.NodeTestTask.lambda$executeRecursively$8(NodeTestTask.java:141)
    at org.junit.platform.engine.support.hierarchical.Node.around(Node.java:137)
    at org.junit.platform.engine.support.hierarchical.NodeTestTask.lambda$executeRecursively$9(NodeTestTask.java:139)
    at org.junit.platform.engine.support.hierarchical.ThrowableCollector.execute(ThrowableCollector.java:73)
    at org.junit.platform.engine.support.hierarchical.NodeTestTask.executeRecursively(NodeTestTask.java:138)
    at org.junit.platform.engine.support.hierarchical.NodeTestTask.execute(NodeTestTask.java:95)
    at java.base/java.util.ArrayList.forEach(ArrayList.java:1511)
    at org.junit.platform.engine.support.hierarchical.SameThreadHierarchicalTestExecutorService.invokeAll(SameThreadHierarchicalTestExecutorService.java:41)
    at org.junit.platform.engine.support.hierarchical.NodeTestTask.lambda$executeRecursively$6(NodeTestTask.java:155)
    at org.junit.platform.engine.support.hierarchical.ThrowableCollector.execute(ThrowableCollector.java:73)
    at org.junit.platform.engine.support.hierarchical.NodeTestTask.lambda$executeRecursively$8(NodeTestTask.java:141)
    at org.junit.platform.engine.support.hierarchical.Node.around(Node.java:137)
    at org.junit.platform.engine.support.hierarchical.NodeTestTask.lambda$executeRecursively$9(NodeTestTask.java:139)
    at org.junit.platform.engine.support.hierarchical.ThrowableCollector.execute(ThrowableCollector.java:73)
    at org.junit.platform.engine.support.hierarchical.NodeTestTask.executeRecursively(NodeTestTask.java:138)
    at org.junit.platform.engine.support.hierarchical.NodeTestTask.execute(NodeTestTask.java:95)
    at org.junit.platform.engine.support.hierarchical.SameThreadHierarchicalTestExecutorService.submit(SameThreadHierarchicalTestExecutorService.java:35)
    at org.junit.platform.engine.support.hierarchical.HierarchicalTestExecutor.execute(HierarchicalTestExecutor.java:57)
    at org.junit.platform.engine.support.hierarchical.HierarchicalTestEngine.execute(HierarchicalTestEngine.java:54)
    at org.junit.platform.launcher.core.EngineExecutionOrchestrator.execute(EngineExecutionOrchestrator.java:107)
    at org.junit.platform.launcher.core.EngineExecutionOrchestrator.execute(EngineExecutionOrchestrator.java:88)
    at org.junit.platform.launcher.core.EngineExecutionOrchestrator.lambda$execute$0(EngineExecutionOrchestrator.java:54)
    at org.junit.platform.launcher.core.EngineExecutionOrchestrator.withInterceptedStreams(EngineExecutionOrchestrator.java:67)
    at org.junit.platform.launcher.core.EngineExecutionOrchestrator.execute(EngineExecutionOrchestrator.java:52)
    at org.junit.platform.launcher.core.DefaultLauncher.execute(DefaultLauncher.java:114)
    at org.junit.platform.launcher.core.DefaultLauncher.execute(DefaultLauncher.java:86)
    at org.junit.platform.launcher.core.DefaultLauncherSession$DelegatingLauncher.execute(DefaultLauncherSession.java:86)
    at org.junit.platform.launcher.core.SessionPerRequestLauncher.execute(SessionPerRequestLauncher.java:53)
    at com.intellij.junit5.JUnit5IdeaTestRunner.startRunnerWithArgs(JUnit5IdeaTestRunner.java:57)
    at com.intellij.rt.junit.IdeaTestRunner$Repeater$1.execute(IdeaTestRunner.java:38)
    at com.intellij.rt.execution.junit.TestsRepeater.repeat(TestsRepeater.java:11)
    at com.intellij.rt.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:35)
    at com.intellij.rt.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:232)
    at com.intellij.rt.junit.JUnitStarter.main(JUnitStarter.java:55)

剁椒酸菜鱼
关注
  • 7
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
Drools（6）：Spring Boot整合Drools
u013938578的博客
07-28 748
代码】Drools（6）SpringBoot整合Drools。
springboot整合Drools规则引擎，实现高效的业务规则
06-25
Drools引擎简介 1、基础简介 Drools是一个基于java的规则引擎，开源的，可以将复杂多变的规则从硬编码中解放出来，以规则脚本的形式存放在文件中，使得规则的变更不需要修正代码重启机器就可以立即在线上环境生效。...
springboot集成规则引擎drools
qq_14946371的博客
05-23 1825
规则引擎的主要思想是将应用程序中的业务决策部分分离出来，并使用预定义的语义模板编写业务决策（业务规则），由用户或开发者在需要时进行配置、管理。欢迎关注个人公众号【好好学技术】交流学习drools是一款由JBoss组织提供的基于java语言开发的开源规则引擎，可以将复杂且多变的业务规则从硬编码中解放出来，以规则脚本的形式存放在文件或特定的存储介质中（如存放在数据库中），使得业务规则的变更不需要修改项目代码、重启服务器就可以在线上环境立即生效。Drools中文网 | 基于java的功能强大的开源规则引擎。
Spring Boot集成drools
最新发布
kiingking的博客
07-11 380
在Spring Boot中集成Drools规则引擎涉及几个步骤，包括添加依赖、配置规则引擎、创建规则文件、编写控制器触发规则等。
从零开始：Spring Boot 中使用 Drools 规则引擎的完整指南
weixin_48278764的博客
06-28 1117
从零开始：Spring Boot 中使用 Drools 规则引擎的完整指南
SpringBoot整合Drools
高朗的博客
10-23 6816
文章目录关于Drools一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 关于Drools 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： import numpy a
SpringBoot整合规则引擎Drools
上善若泪
05-11 4775
假如有这么个需求，网上购物，需要根据不同的规则计算商品折扣，比如VIP客户增加5%的折扣，购买金额超过1000元的增加10%的折扣等，而且这些规则可能随时发生变化，甚至增加新的规则。面对这个需求，你该怎么实现呢？难道是计算规则一变，就要修改业务代码，重新测试，上线吗。其实，我们可以通过规则引擎来实现，Drools就是一个开源的业务规则引擎，可以很容易地与springboot应用程序集成，那本文就用Drools来实现一下上面说的需求吧。前面的类中指定drools规则的目录，现在我们在目录下添加。
SpringBoot2整合Drools规则引擎及案例详解
08-25
主要介绍了SpringBoot2整合Drools规则引擎及案例详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
springboot集成drools实现重新加载规则
10-21
这通常通过在`pom.xml`文件中引入Maven依赖完成，确保包含Drools的核心库和相关的Spring整合模块： ```xml <groupId>org.kie <artifactId>kie-spring ${drools.version} <groupId>org.kie <artifactId>kie-...
springboot整合activiti和drools #资源达人分享计划#
08-08
将SpringBoot、Activiti和Drools整合在一起，我们可以创建一个灵活且高效的工作流程系统，其中Activiti负责流程的流转，Drools则负责处理流程中的决策逻辑。例如，在金融行业的风控场景中，当一笔交易触发时，...
drools集成springboot demo
07-18
drools集成springboot demo
SpringBoot集成drools
huan的学习记录
05-26 1643
在之前的文章中，我们学习了drools的一些基本语法，在这篇文章中，我们实现在SpringBoot中集成drools。
Drools实战
Java硬件工程师的博客
05-28 635
Drools实战 1 个人所得税计算器 本小节我们需要通过Drools规则引擎来根据规则计算个人所得税，最终页面效果如下： [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-M1HjKK8N-1653749251774)(…/media/pictures/Drools.assets/image-20200214132448956.png)] 1.1 名词解释 税前月收入：即税前工资，指交纳个人所得税之前的总工资 应纳税所得额：指按照税法规定确定纳税人在一定期间所获得的所有应税.
drools －规则语法
热门推荐
哎幽的成长
12-25 3万+
文章结构1. 基础api2. FACT对象3. 规则4. 函数1. 基础api在 Drools 当中，规则的编译与运行要通过Drools 提供的各种API 来实现，这些API 总体来讲可以分为三类：规则编译、规则收集和规则的执行。完成这些工作的API 主要有KnowledgeBuilder、KnowledgeBase、StatefulKnowledgeSession、StatelessKnowled
SpringBoot集成Drools
sn5diphone6的博客
12-19 704
System.out.println("-----税后工资：" + $cal.getActualwage());System.out.println("-----应纳税所得额："+$cal.getWagemore());System.out.println("-----税前工资："+$cal.getWage());System.out.println("-----税率：" + $cal.getCess());rule "个人所得税：设置税率-->>应纳税所得额<=1500"--drools 规则引擎-->
Java-springboot集成+drools规则引擎集成，动态化编程
lvyuanj的专栏
03-25 2294
Java-springboot集成+drools规则引擎集成，可以通过界面化大的方式动态化编程
SpringBoot入门系列（六）整合Drools
qq_39203889的博客
04-21 750
随着商业发展，业务上经常会发生快速变动。如果还按照以往的开发模式，业务逻辑的每次变动都需要程序员介入开发，那时间成本太高。 为了解决这个问题，Drools这一类可以通过外部配置调整业务逻辑的工具应运而生，本章就说一说如何用springboot集成Drools 第一步：pom.xml <properties> <!-- drools 规则引擎 版本 --&g...
springboot整合drools
06-28
### 回答1： Spring Boot是一个快速开发的框架，而Drools是一个规则引擎，可以用于业务规则的管理和执行。将两者整合可以实现更加灵活的业务逻辑控制。 具体实现步骤如下： 1. 引入Drools依赖 在pom.xml文件中添加Drools的依赖： ``` <dependency> <groupId>org.drools</groupId> <artifactId>drools-core</artifactId> <version>7.54..Final</version> </dependency> ``` 2. 创建Drools规则文件 在resources目录下创建一个名为rules的文件夹，用于存放Drools规则文件。例如，创建一个名为rule.drl的文件，内容如下： ``` package com.example.rule rule "rule1" when $p : Person(age > 18) then System.out.println("Hello, " + $p.getName() + "!"); end ``` 3. 创建Drools配置类 创建一个Drools配置类，用于加载Drools规则文件和创建Drools的KieSession。例如： ``` @Configuration public class DroolsConfig { @Autowired private KieFileSystem kieFileSystem; @Autowired private KieRepository kieRepository; @Autowired private KieBuilder kieBuilder; @Autowired private KieContainer kieContainer; @PostConstruct public void init() { try { kieFileSystem.write(ResourceFactory.newClassPathResource("rules/rule.drl")); kieBuilder.buildAll(); } catch (Exception e) { e.printStackTrace(); } } @Bean public KieFileSystem kieFileSystem() { return KieServices.Factory.get().newKieFileSystem(); } @Bean public KieRepository kieRepository() { return KieServices.Factory.get().getRepository(); } @Bean public KieBuilder kieBuilder() { return KieServices.Factory.get().newKieBuilder(kieFileSystem()); } @Bean public KieContainer kieContainer() { return KieServices.Factory.get().newKieContainer(kieRepository().getDefaultReleaseId()); } @Bean public KieSession kieSession() { return kieContainer().newKieSession(); } } ``` 4. 创建业务类 创建一个业务类，例如Person类，用于测试Drools规则的执行。例如： ``` public class Person { private String name; private int age; public Person(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } } ``` 5. 测试Drools规则的执行 在Controller中注入KieSession，然后创建一个Person对象，将其插入到KieSession中，最后执行KieSession的fireAllRules方法，即可执行Drools规则。例如： ``` @RestController public class TestController { @Autowired private KieSession kieSession; @GetMapping("/test") public String test() { Person person = new Person("Tom", 20); kieSession.insert(person); kieSession.fireAllRules(); return "success"; } } ``` 以上就是Spring Boot整合Drools的基本步骤。 ### 回答2： Spring Boot与Drools的整合是在实现业务规则引擎方面非常有用的一种方式。Spring Boot是一个基于Spring框架的快速开发应用程序的工具，而Drools则是一款常用的业务规则引擎，通过它可以轻松实现业务逻辑的灵活处理。 整合Spring Boot与Drools Spring Boot使用Java语言进行开发，而Drools使用DRL（Drools Rule Language）语言进行业务规则的编写。在整合的过程中，我们需要定义规则的模型，创建Drools的KieSession，将模型与规则引擎进行交互。具体步骤如下： 1. 引入依赖 在pom.xml文件中添加Drools的依赖，如下所示： ``` <dependency> <groupId>org.drools</groupId> <artifactId>drools-core</artifactId> <version>7.37.0.Final</version> </dependency> ``` 2. 定义规则模型 使用DRL语言定义业务规则的模型，如下所示： ``` package com.example.droolsdemo import com.example.droolsdemo.Person import com.example.droolsdemo.Result rule "Person age rule" when $p: Person(age > 18) then Result result = new Result(); result.setMessage("You are an adult now!"); insert(result); System.out.println(result.toString()); end ``` 3. 加载规则 在启动Spring Boot应用程序时，从DRL文件中加载规则并创建KieSession，以便后续与规则引擎进行交互。示例如下： ``` @Autowired private KieContainer kieContainer; public KieSession getKieSession () { KieSession kieSession = kieContainer.newKieSession(); kieSession.getAgenda().getAgendaGroup("person-group").setFocus(); return kieSession; } ``` 4. 执行规则 在业务逻辑中调用上述方法获取KieSession，使用Drools提供的API执行对应的规则。示例代码如下： ``` KieSession kieSession = getKieSession(); Person person = new Person(); person.setAge(20); kieSession.insert(person); kieSession.fireAllRules(); ``` 总结 Spring Boot和Drools是两个非常强大的工具，在进行业务规则引擎整合时，可以让规则引擎的开发更加快速和灵活。通过上述方法，可以使用Spring Boot轻松实现Drools的加载和规则执行，提高产品质量、业务效率和效益。 ### 回答3： Drools是一个规则引擎，用于逻辑推理和复杂的事件处理。而Spring Boot是现代化的Java开发框架，它提供了快速开发应用程序所需的所有组件，包括自动配置、依赖注入等。将这两个框架整合起来可以帮助我们快速开发具有复杂业务逻辑的应用程序。 Spring Boot和Drools的整合需要以下步骤： 1. 添加Drools的依赖项到Spring Boot项目中。 2. 创建一个Drools配置文件，Drools的规则定义在该文件中。 3. 在Spring Boot应用程序中创建一个Drools的会话，用于执行规则。 4. 将对象（Fact）插入到Drools会话中，并执行规则。 下面是一个Spring Boot程序整合Drools的简单例子： 首先，在Spring Boot项目中添加Drools的Maven依赖项，可以在pom.xml文件中添加以下内容： ``` <dependency> <groupId>org.kie</groupId> <artifactId>kie-ci</artifactId> <version>7.0.0.Final</version> </dependency> ``` 接下来，在项目中创建一个Drools的配置文件，例如rules.drl文件，用于定义规则。在该文件中，可以定义所有需要执行的规则。例如： ``` rule "discount rule" when $order : Order(discount == 0) then $order.setDiscount(10); update($order); end ``` 然后，在Spring Boot应用程序中创建一个Drools会话，用于执行规则。示例代码如下： ``` @Service public class DroolsService { KieSession kieSession; @Autowired public DroolsService(KieContainer kieContainer) { kieSession = kieContainer.newKieSession(); } public void execute(Order order) { kieSession.insert(order); kieSession.fireAllRules(); } } ``` 如上所述，我们在DroolsService类中创建了一个Drools会话对象，并将要执行的对象（Fact）插入到该会话中。然后，我们执行规则（fireAllRules()）来处理订单对象并更新它。 最后，在Spring Boot应用程序中调用DroolsService对象的execute方法，传递要执行规则的对象。例如： ``` @RestController @RequestMapping("/order") public class OrderController { @Autowired private DroolsService droolsService; @PostMapping("/discount") public Order applyDiscount(@RequestBody Order order) { droolsService.execute(order); return order; } } ``` 如上所述，我们在OrderController类中定义了一个applyDiscount方法，用于接收订单对象并调用DroolsService对象的execute方法，来处理订单并更新它。最后返回处理后的订单对象。 总而言之，使用Spring Boot整合Drools，可以让我们快速开发具有复杂业务逻辑的应用程序。将Drools的规则引擎和Spring Boot的自动配置、依赖注入等特性结合起来，可以有效地提高代码的可维护性和可扩展性。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值