SpringBoot整合Drools7.0

最新推荐文章于 2024-06-28 16:19:18 发布

关注我：程序猿之塞伯坦

最新推荐文章于 2024-06-28 16:19:18 发布

阅读量1.1w

点赞数 1

本文链接：https://blog.csdn.net/u013115157/article/details/88413946

版权

Drools规则引擎说明及应用专栏收录该内容

70 篇文章 16 订阅

订阅专栏

SpringBoot相信大家都很熟悉了，这里小编就再进行讲述了，由于现在用Springboot的人越来越多，当然小编也不会错过机会进行学习，这个章节里，小编就带领着大家，学习如何Springboot与Drools7.0整合。

小编在之前的章节中有讲过与Spring，与其说整合，还不如说只是将这两个不相关的工具放到一个项目里，SpringBoot只是处理本职工作，而Drools同样也是如此，这里小编要提出一个结论，这也是很多初学者很困惑的地方

规则内容是规则内容，规则文件是规则文件
规则流中流程是流程，规则是规则
与Spring、SpringMvc、Mybatis整合时SSM是SSM Drools是Drools，只不过提供了接口
与SpringBoot时，Boot是Boot，Drools是Drools，两者只是关系上的调用

得出上面的结论后，下面我们就正式带读者进行SpringBoot下的Drools，我们都知道SpringBoot提供服务器，通过main方法就可以启动，所有我们无需再引用tomcat进行启动。

第一步：创建一个maven项目，并引用相关jar包

  <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <!-- drools 规则引擎 版本 -->
        <drools.version>7.0.0.Final</drools.version>
        <log4j2.version>2.5</log4j2.version>
    </properties>

    <!-- Maven POM文件继承 spring-boot-starter-parent -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.7.RELEASE</version>
    </parent>

    <!-- 依赖项定义 -->
    <dependencies>
        <!-- start drools -->
        <dependency>
            <groupId>org.drools</groupId>
            <artifactId>drools-core</artifactId>
            <version>${drools.version}</version>
        </dependency>

        <dependency>
            <groupId>org.drools</groupId>
            <artifactId>drools-compiler</artifactId>
            <version>${drools.version}</version>
        </dependency>

        <dependency>
            <groupId>org.kie</groupId>
            <artifactId>kie-spring</artifactId>
            <version>${drools.version}</version>
        </dependency>

        <dependency>
            <groupId>org.kie</groupId>
            <artifactId>kie-internal</artifactId>
            <version>${drools.version}</version>
        </dependency>

        <dependency>
            <groupId>org.drools</groupId>
            <artifactId>drools-templates</artifactId>
            <version>${drools.version}</version>
        </dependency>
        <!-- end drools -->
        <!-- Spring boot start -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>



        <!-- mysql连接 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.30</version>
        </dependency>
        <!-- mybatis -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.1.1</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>RELEASE</version>
        </dependency>

        <!--Gson-->
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
        </dependency>

    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <fork>true</fork>
                </configuration>
            </plugin>
        </plugins>
    </build>

在上面的引用中，读者一定会发现，为什么会有Redis 和 Mybatis的引用，这个例子中，小编要对实际的应用场景做一个demo的说明

第二步：创建Mysql数据库

并创建表插入数据

分别创建dao包及接口

package com.dao;

import java.util.List;


public interface PersonDao {
    List  listAll();
}

分别创建mapper及配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.dao.PersonDao">
    <sql id="Base_Column_List">
       rule_name
    </sql>

    <select id="listAll" resultType="java.lang.String">
        select
           *
        from person
    </select>
</mapper>

创建SpringBoot配置文件

server.port=8888
#Mysql
spring.jpa.show-sql=true
spring.datasource.url=jdbc:mysql://locahost:3306/drools
spring.datasource.username=root
spring.datasource.password=Best_2017
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.max-active=10
spring.datasource.max-idle=5
spring.datasource.min-idle=0

#定义LOG输出级别
log4j.rootLogger=DEBUG,Console,File
#定义日志输出目的地为控制台
log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.Target=System.out
#可以灵活地指定日志输出格式，下面一行是指定具体的格式
log4j.appender.Console.layout = org.apache.log4j.PatternLayout
#log4j.appender.Console.layout.ConversionPattern=[%c] - %m%n
log4j.appender.Console.layout.ConversionPattern=%d %p [%c] - %m%n
#文件大小到达指定尺寸的时候产生一个新的文件
log4j.appender.File = org.apache.log4j.RollingFileAppender
#指定输出目录
log4j.appender.File.File = logs/promote.log
#定义文件最大大小
log4j.appender.File.MaxFileSize = 10MB
# 输出所以日志，如果换成DEBUG表示输出DEBUG以上级别日志
log4j.appender.File.Threshold = ALL
log4j.appender.File.layout = org.apache.log4j.PatternLayout
log4j.appender.File.layout.ConversionPattern =[%p] [%d{yyyy-MM-dd HH\:mm\:ss}][%c]%m%n
###显示mybatis的SQL语句部分，类似于hibernate在控制台打印sql语句那部分
log4j.logger.java.sql.ResultSet=INFO 
log4j.logger.org.apache=INFO 
log4j.logger.java.sql.Connection=DEBUG 
log4j.logger.java.sql.Statement=DEBUG 
log4j.logger.java.sql.PreparedStatement=DEBUG

创建POJO

package com.model;

public class Person {
    String name;
    String age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }
}

创建Service

package com.service;

import com.dao.PersonDao;
import com.model.Person;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;

@Service
public class PersonService {

    @Resource
    private PersonDao personDao;



    public List<Person> listPerson(){
        List<Person> list=personDao.listAll();
        return list;
    }
}

创建controller

第三步：创建Springboot启动类

package com;

import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.tomcat.jdbc.pool.DataSource;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;


@SpringBootApplication
@MapperScan("com.dao")
public class Application {
	
	protected static Logger logger=LoggerFactory.getLogger(Application.class);

	@Bean
    @ConfigurationProperties(prefix="spring.datasource")
    public DataSource dataSource() {
        return new DataSource();
    }

    @Bean
    public SqlSessionFactory sqlSessionFactoryBean() throws Exception {

        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dataSource());

        PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();

        sqlSessionFactoryBean.setMapperLocations(resolver.getResources("classpath*:mapper/*.xml"));

        return sqlSessionFactoryBean.getObject();
    }

    @Bean
    public PlatformTransactionManager transactionManager() {
        return new DataSourceTransactionManager(dataSource());
    }


	public static void main(String[] args) {
		SpringApplication.run(Application.class, args);
		logger.info("SpringBoot Start Success");
	}
}

运行启动类

访问请求地址

完成以上步骤，我们就就完成了一大部分，将SpringBoot与Mybatis进行了整合，下面我们将规则进行整合：这里小编教读者一种很简单的创建规则库的方法

创建规则库的方法

package com.rule;

import org.kie.api.KieBase;
import org.kie.api.io.ResourceType;
import org.kie.internal.utils.KieHelper;

public class NewKieBase {
    //将业务规则写到规则库中
    public static KieBase rulekieBase(String rule) {//rule值就是我们动态传入的规则内容
        KieHelper helper = new KieHelper();
        KieBase kieBase = null;
        try {
            helper.addContent(rule,ResourceType.DRL);
//为了省事，小编直接将rule写成activityRule()
            kieBase = helper.build();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return kieBase;
    }
}

编写规则内容

package com.rule;

public class RuleExecute {
    public static String activityRule() {
        StringBuffer ruleDrl = new StringBuffer();
        ruleDrl.append("package rules \n ");
        ruleDrl.append("import   com.model.Person; \n");
        ruleDrl.append(" rule    \'person_1\' \n");
        ruleDrl.append(" no-loop true \n");
        ruleDrl.append(" salience  10 \n");
        ruleDrl.append(" when \n");
        ruleDrl.append("  $p:Person(name==\'张三\',age==\'22\' )\n ");
        ruleDrl.append(" then \n");
        ruleDrl.append("  modify($p){ setName(\'张小三\' )} \n");
        ruleDrl.append("end \n");
        return ruleDrl.toString();
    }
}

Drools实现类，这里小编主要用到的是创建kieBase的方式。我们创建kieBase，而并非直接创建Session，不管是有状态的还是无状态的，这是为了更有余地的去进行创建和完成编辑规则。

package com.service;


import org.kie.api.KieBase;
import org.springframework.stereotype.Service;

import static com.rule.NewKieBase.rulekieBase;

@Service
public class DroolsService {
    /**
     * 创建KieSession
     * @return
     */
    public KieBase newKieBase() {
        KieBase kieBase = rulekieBase();
        return kieBase;
    }
}

重新编辑PersonService实现代码

package com.service;

import com.dao.PersonDao;
import com.model.Person;
import org.kie.api.KieBase;
import org.kie.api.runtime.KieSession;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;

@Service
public class PersonService {
    @Resource
    private PersonDao personDao;
    @Resource
    private DroolsService droolsService;

    public List<Person> listPerson(){
        KieBase kieBase=droolsService.newKieBase();
        List<Person> list=personDao.listAll();
        for(Person person:list){
            KieSession kieSession= kieBase.newKieSession();
            kieSession.insert(person);
            int i=kieSession.fireAllRules();
            kieSession.dispose();
        }
        return list;
    }
}

重新启动服务

我们发现，之前的张三已经成功改成了张小三，证明我们成功利用规则进行了修改，业务判断。但这里小编要说的，上面只是测试的例子，与SpringBoot方式很多，但结论就那些，规则是规则，只是接口提供应用，重点小编要说的是，如果读者喜欢用有状态的Session要注意迭代的问题，并且对于规则库来说，规则只创建一次就好，是可以通过一些方式进行封装保存的，可并非是redis哦，因为我们都知道，kiesession是无法共享的，也就是规则库是无法共享的。

关注我：程序猿之塞伯坦

关注

1
点赞
踩
16

收藏

觉得还不错? 一键收藏
10
评论
SpringBoot整合Drools7.0

SpringBoot相信大家都很熟悉了，这里小编就再进行讲述了，由于现在用Springboot的人越来越多，当然小编也不会错过机会进行学习，这个章节里，小编就带领着大家，学习如何Springboot与Drools7.0整合。小编在之前的章节中有讲过与Spring，与其说整合，还不如说只是将这两个不相关的工具放到一个项目里，SpringBoot只是处理本职工作，而Drools同样也是如此，这里小...
复制链接

扫一扫

专栏目录