SpringBoot整合Mybatis使用Druid数据库连接池

2023-09-15 22:33:04 58

本文实例为大家分享了SpringBoot整合Mybatis使用Druid数据库连接池的方法，具体内容如下

在SpringBoot项目中,增加如下依赖



org.mybatis.spring.boot
mybatis-spring-boot-starter
1.1.1




mysql
mysql-connector-java
runtime




com.alibaba
druid
1.0.26

在resource目录下,创建jdbc.properties配置文件,加入以下配置

#数据库配置
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf8&useSSL=false
spring.datasource.username=admin
spring.datasource.password=admin
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
#连接池配置
#初始化大小，最小，最大
spring.datasource.initialSize=5
spring.datasource.minIdle=5
spring.datasource.maxActive=20
#配置获取连接等待超时的时间
spring.datasource.maxWait=60000
#配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
spring.datasource.timeBetweenEvictionRunsMillis=60000
#配置一个连接在池中最小生存的时间，单位是毫秒
spring.datasource.minEvictableIdleTimeMillis=300000
#测试连接是否有效的sql
spring.datasource.validationQuery=select'x'
#建议配置为true，不影响性能，并且保证安全性
#申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效
spring.datasource.testWhileIdle=true
#申请连接时执行validationQuery检测连接是否有效
spring.datasource.testOnBorrow=false
#归还连接时执行validationQuery检测连接是否有效
spring.datasource.testOnReturn=false
#要启用PSCache，必须配置大于0，当大于0时，poolPreparedStatements自动触发修改为true
spring.datasource.maxPoolPreparedStatementPerConnectionSize=20
#属性类型是字符串，通过别名的方式配置扩展插件，常用的插件有：
#监控统计用的filter:stat
#日志用的filter:log4j
#防御sql注入的filter:wall
spring.datasource.filters=stat,log4j,wall

创建数据源配置类DataSourceConfig.java,代码如下

packagecom.liao.mybatis;

importcom.alibaba.druid.pool.DruidDataSource;
importorg.mybatis.spring.annotation.MapperScan;
importorg.slf4j.Logger;
importorg.slf4j.LoggerFactory;
importorg.springframework.beans.factory.annotation.Autowired;
importorg.springframework.beans.factory.annotation.Value;
importorg.springframework.context.annotation.Bean;
importorg.springframework.context.annotation.Configuration;
importorg.springframework.context.annotation.PropertySource;
importorg.springframework.stereotype.Component;

importjavax.sql.DataSource;
importjava.sql.SQLException;

/**
*数据源
*
*@authorhongyangliao
*@ClassName:DataSourceConfig
*@Date18-1-2下午8:56
*/
@Configuration
@MapperScan("com.liao.**.dao")
publicclassDataSourceConfig{
privatestaticfinalLoggerlogger=LoggerFactory.getLogger(DataSourceConfig.class);

@Autowired
privateJdbcConfigjdbcConfig;

@Bean
@Primary//在同样的DataSource中，首先使用被标注的DataSource
publicDataSourcedataSource(){
DruidDataSourcedruidDataSource=newDruidDataSource();
druidDataSource.setUrl(jdbcConfig.getUrl());
druidDataSource.setUsername(jdbcConfig.getUserName());
druidDataSource.setPassword(jdbcConfig.getPassword());
druidDataSource.setInitialSize(jdbcConfig.getInitialSize());
druidDataSource.setMinIdle(jdbcConfig.getMinIdle());
druidDataSource.setMaxActive(jdbcConfig.getMaxActive());
druidDataSource.setTimeBetweenEvictionRunsMillis(jdbcConfig.getTimeBetweenEvictionRunsMillis());
druidDataSource.setMinEvictableIdleTimeMillis(jdbcConfig.getMinEvictableIdleTimeMillis());
druidDataSource.setValidationQuery(jdbcConfig.getValidationQuery());
druidDataSource.setTestWhileIdle(jdbcConfig.isTestWhileIdle());
druidDataSource.setTestOnBorrow(jdbcConfig.isTestOnBorrow());
druidDataSource.setTestOnReturn(jdbcConfig.isTestOnReturn());
druidDataSource.setMaxPoolPreparedStatementPerConnectionSize(jdbcConfig.getMaxPoolPreparedStatementPerConnectionSize());
try{
druidDataSource.setFilters(jdbcConfig.getFilters());
}catch(SQLExceptione){
if(logger.isInfoEnabled()){
logger.info(e.getMessage(),e);
}
}
returndruidDataSource;
}


/**
*Jdbc配置类
*
*@authorhongyangliao
*@ClassName:JdbcConfig
*@Date18-1-2下午9:00
*/
@PropertySource(value="classpath:jdbc.properties")
@Component
publicstaticclassJdbcConfig{
/**
*数据库用户名
*/
@Value("${spring.datasource.username}")
privateStringuserName;
/**
*驱动名称
*/
@Value("${spring.datasource.driver-class-name}")
privateStringdriverClass;
/**
*数据库连接url
*/
@Value("${spring.datasource.url}")
privateStringurl;
/**
*数据库密码
*/
@Value("${spring.datasource.password}")
privateStringpassword;

/**
*数据库连接池初始化大小
*/
@Value("${spring.datasource.initialSize}")
privateintinitialSize;

/**
*数据库连接池最小最小连接数
*/
@Value("${spring.datasource.minIdle}")
privateintminIdle;

/**
*数据库连接池最大连接数
*/
@Value("${spring.datasource.maxActive}")
privateintmaxActive;

/**
*获取连接等待超时的时间
*/
@Value("${spring.datasource.maxWait}")
privatelongmaxWait;

/**
*多久检测一次
*/
@Value("${spring.datasource.timeBetweenEvictionRunsMillis}")
privatelongtimeBetweenEvictionRunsMillis;

/**
*连接在池中最小生存的时间
*/
@Value("${spring.datasource.minEvictableIdleTimeMillis}")
privatelongminEvictableIdleTimeMillis;

/**
*测试连接是否有效的sql
*/
@Value("${spring.datasource.validationQuery}")
privateStringvalidationQuery;

/**
*申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，检测连接是否有效
*/
@Value("${spring.datasource.testWhileIdle}")
privatebooleantestWhileIdle;

/**
*申请连接时,检测连接是否有效
*/
@Value("${spring.datasource.testOnBorrow}")
privatebooleantestOnBorrow;

/**
*归还连接时,检测连接是否有效
*/
@Value("${spring.datasource.testOnReturn}")
privatebooleantestOnReturn;

/**
*PSCache大小
*/
@Value("${spring.datasource.maxPoolPreparedStatementPerConnectionSize}")
privateintmaxPoolPreparedStatementPerConnectionSize;

/**
*通过别名的方式配置扩展插件
*/
@Value("${spring.datasource.filters}")
privateStringfilters;

publicStringgetUserName(){
returnuserName;
}

publicvoidsetUserName(StringuserName){
this.userName=userName;
}

publicStringgetDriverClass(){
returndriverClass;
}

publicvoidsetDriverClass(StringdriverClass){
this.driverClass=driverClass;
}

publicStringgetUrl(){
returnurl;
}

publicvoidsetUrl(Stringurl){
this.url=url;
}

publicStringgetPassword(){
returnpassword;
}

publicvoidsetPassword(Stringpassword){
this.password=password;
}

publicintgetInitialSize(){
returninitialSize;
}

publicvoidsetInitialSize(intinitialSize){
this.initialSize=initialSize;
}

publicintgetMinIdle(){
returnminIdle;
}

publicvoidsetMinIdle(intminIdle){
this.minIdle=minIdle;
}

publicintgetMaxActive(){
returnmaxActive;
}

publicvoidsetMaxActive(intmaxActive){
this.maxActive=maxActive;
}

publiclonggetMaxWait(){
returnmaxWait;
}

publicvoidsetMaxWait(longmaxWait){
this.maxWait=maxWait;
}

publiclonggetTimeBetweenEvictionRunsMillis(){
returntimeBetweenEvictionRunsMillis;
}

publicvoidsetTimeBetweenEvictionRunsMillis(longtimeBetweenEvictionRunsMillis){
this.timeBetweenEvictionRunsMillis=timeBetweenEvictionRunsMillis;
}

publiclonggetMinEvictableIdleTimeMillis(){
returnminEvictableIdleTimeMillis;
}

publicvoidsetMinEvictableIdleTimeMillis(longminEvictableIdleTimeMillis){
this.minEvictableIdleTimeMillis=minEvictableIdleTimeMillis;
}

publicStringgetValidationQuery(){
returnvalidationQuery;
}

publicvoidsetValidationQuery(StringvalidationQuery){
this.validationQuery=validationQuery;
}

publicbooleanisTestWhileIdle(){
returntestWhileIdle;
}

publicvoidsetTestWhileIdle(booleantestWhileIdle){
this.testWhileIdle=testWhileIdle;
}

publicbooleanisTestOnBorrow(){
returntestOnBorrow;
}

publicvoidsetTestOnBorrow(booleantestOnBorrow){
this.testOnBorrow=testOnBorrow;
}

publicbooleanisTestOnReturn(){
returntestOnReturn;
}

publicvoidsetTestOnReturn(booleantestOnReturn){
this.testOnReturn=testOnReturn;
}

publicintgetMaxPoolPreparedStatementPerConnectionSize(){
returnmaxPoolPreparedStatementPerConnectionSize;
}

publicvoidsetMaxPoolPreparedStatementPerConnectionSize(intmaxPoolPreparedStatementPerConnectionSize){
this.maxPoolPreparedStatementPerConnectionSize=maxPoolPreparedStatementPerConnectionSize;
}

publicStringgetFilters(){
returnfilters;
}

publicvoidsetFilters(Stringfilters){
this.filters=filters;
}
}
}

创建Session工厂配置类SessionFactoryConfig.java,代码如下

packagecom.liao.mybatis;

importjava.io.IOException;

importjavax.sql.DataSource;

importorg.mybatis.spring.SqlSessionFactoryBean;
importorg.springframework.beans.factory.annotation.Autowired;
importorg.springframework.context.annotation.Bean;
importorg.springframework.context.annotation.Configuration;
importorg.springframework.core.io.ClassPathResource;
importorg.springframework.transaction.annotation.EnableTransactionManagement;

@Configuration
@EnableTransactionManagement//启注解事务管理，等同于xml配置方式的
publicclassSessionFactoryConfig{

/**
*mybatis配置路径
*/
privatestaticStringMYBATIS_CONFIG="mybatis-config.xml";

@Autowired
privateDataSourcedataSource;


/***
*创建sqlSessionFactoryBean
*并且设置configtion如驼峰命名.等等
*设置mapper映射路径
*设置datasource数据源
*
*@Title:createSqlSessionFactoryBean
*@author:hongyangliao
*@Date:18-1-3上午9:52
*@param
*@returnorg.mybatis.spring.SqlSessionFactoryBeansqlSessionFactoryBean实例
*@throws
*/
@Bean(name="sqlSessionFactory")
publicSqlSessionFactoryBeancreateSqlSessionFactoryBean()throwsIOException{
SqlSessionFactoryBeansqlSessionFactory=newSqlSessionFactoryBean();
//设置mybatisconfiguration扫描路径
sqlSessionFactory.setConfigLocation(newClassPathResource(MYBATIS_CONFIG));
//设置datasource
sqlSessionFactory.setDataSource(dataSource);
returnsqlSessionFactory;
}
}

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持毛票票。

声明：本文内容来源于网络，版权归原作者所有，内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：czq8825#qq.com（发邮件时，请将#更换为@）进行举报，并提供相关证据，一经查实，本站将立刻删除涉嫌侵权内容。

SpringBoot整合Mybatis使用Druid数据库连接池

热门推荐

随机推荐