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是无法共享的,也就是规则库是无法共享的。