SpringBoot 之数据源配置
文章目录市面上的几种数据源比对SpringBoot自动装配DataSource原理Hikari 数据源配置Druid 数据源配置配置参数详解配置 Druid 数据源参数配置 Druid 后台管理 Servlet 和 监控 FilterSpringBoot集成Druid连接池数据源 c3p0 并集成 mybatisDruid 多数据源配置springboot2.0整合druid，以及springbo
·
文章目录
springboot2.0整合druid，以及springboot自动装配DataSource原理
市面上的几种数据源比对
常用的数据库连接池： C3P0、DBCP、Druid、HiKariCP
- C3P0： 在16-18年没有更新，19年更新了，但是更新很慢，且历史悠久，代码及其复杂，不利于维护，性能差，不推荐使用。
- DBCP： 更新速度很慢，基本处于不活跃状态，不推荐使用。
- Druid： 阿里开源，功能最为全面，sql拦截等功能，统计数据较为全面，具有良好的扩展性，需要监控sql性能，推荐使用。
- HiKariCP： SpringBoot2默认的数据源，优化力度大，功能简单，起源于boneCP，性能优越，推荐使用。
性能：HiKariCP > Druid > DBCP > C3P0
SpringBoot自动装配DataSource原理
SpringBoot 已经实现了自动加载 DataSource 的相关配置。只需要在项目中引用相关依赖，在配置文件 application.yml 中配置相关属性即可。
自动装配配置类：org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration。
@Configuration
// 自动配置条件，当给定的类名在类路径上存在，则实例化当前Bean
@ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class })
// 开启属性配置类生效，这里生效的是：DataSourceProperties 配置类
@EnableConfigurationProperties(DataSourceProperties.class)
// 引入两个配置类
@Import({ DataSourcePoolMetadataProvidersConfiguration.class,
DataSourceInitializationConfiguration.class })
public class DataSourceAutoConfiguration {
......
@Configuration
// 按照条件注册Bean，需实现Condition接口，matches方法返回true
@Conditional(PooledDataSourceCondition.class)
// 当BeanFactory中不存在 DataSource、XADataSource 类型的 bean
@ConditionalOnMissingBean({ DataSource.class, XADataSource.class })
// 导入数据源配置类
@Import({ DataSourceConfiguration.Hikari.class, DataSourceConfiguration.Tomcat.class,
DataSourceConfiguration.Dbcp2.class, DataSourceConfiguration.Generic.class,
DataSourceJmxConfiguration.class })
protected static class PooledDataSourceConfiguration {
}
在PooledDataSourceConfiguration内部类上有 Tomcat.class 、Hikari.class 、Dbcp2.class 、Generic.class 四个内部类。
每个内部类上都包含有 @ConditionalOnClass(XXX.class) 条件注解，即只有某些特定条件才会创建一个特定的 bean。
JDBC场景启动器中默认依赖了HikariCP，所以默认只有 HikariCP内部类满足了所有的限定条件。
abstract class DataSourceConfiguration {
......
// 判断当前 classpath 下是否存在指定类
@ConditionalOnClass(HikariDataSource.class)
// beanFactory中不存在 DataSource 类型的 bean
@ConditionalOnMissingBean(DataSource.class)
// spring.datasource.type 属性值默认为 com.zaxxer.hikari.HikariDataSource
@ConditionalOnProperty(name = "spring.datasource.type", havingValue = "com.zaxxer.hikari.HikariDataSource", matchIfMissing = true)
static class Hikari {
@Bean
@ConfigurationProperties(prefix = "spring.datasource.hikari")
public HikariDataSource dataSource(DataSourceProperties properties) {
HikariDataSource dataSource = createDataSource(properties,
HikariDataSource.class);
if (StringUtils.hasText(properties.getName())) {
dataSource.setPoolName(properties.getName());
}
return dataSource;
}
}
属性绑定：
通过上面的@EnableConfigurationProperties(DataSourceProperties.class)注解来生效的。
@ConfigurationProperties(prefix = "spring.datasource") 表示通过绑定配置文件中以 spring.datasource 开头的属性到配置类中。
@ConfigurationProperties(prefix = "spring.datasource")
public class DataSourceProperties implements BeanClassLoaderAware, InitializingBean {
......
}
总结：
通过上面的分析，最终 DataSourceAutoConfiguration 数据源自动配置将 DataSource 对象注册到 IOC 容器中的，默认的数据源类型 com.zaxxer.hikari.HikariDataSource 。
Spring Boot 2 中已经将默认数据源更改为 Hikari 数据源，之前版本中的默认数据源为 org.apache.tomcat.jdbc.pool.DataSource，主要是因为 Hikari 数据源优异的性能。
HiKariCP 数据源配置
导入依赖：
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<!-- 如果数据库服务器是5.7以下版本，驱动建议使用这个版本，如果使用高版本会导致时间问题-->
<version>5.1.42</version>
<scope>runtime</scope>
</dependency>
<!-- JDBC场景启动器 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
在全局配置文件中配置 spring.datasource 相关值：
spring.datasource.url=jdbc:mysql://localhost:3306/test?useUnicode=true&useSSL=false&characterEncoding=utf8
spring.datasource.username=root
spring.datasource.password=123456
# JDBC驱动程序的完全限定名称，默认情况下，基于URL自动检测。
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
# 数据源类型，SpringBoot2以后默认HikariDataSource
spring.datasource.type=com.zaxxer.hikari.HikariDataSource
#连接池名称，默认HikariPool-1
spring.datasource.hikari.pool-name=YqHikariPool
#最大连接数，小于等于0会被重置为默认值10；大于零小于1会被重置为minimum-idle的值
spring.datasource.hikari.maximum-pool-size=12
#连接超时时间:毫秒，小于250毫秒，否则被重置为默认值30秒
spring.datasource.hikari.connection-timeout=60000
#最小空闲连接，默认值10，小于0或大于maximum-pool-size，都会重置为maximum-pool-size
spring.datasource.hikari.minimum-idle=10
#空闲连接超时时间：毫秒，默认值600000（10分钟），大于等于max-lifetime且max-lifetime>0，会被重置为0；不等于0且小于10秒，会被重置为10秒。
# 只有空闲连接数大于最大连接数且空闲时间超过该值，才会被释放
spring.datasource.hikari.idle-timeout=540000
#连接最大存活时间：毫秒.不等于0且小于30秒，会被重置为默认值30分钟.设置应该比mysql设置的超时时间短
spring.datasource.hikari.max-lifetime=540000
#连接测试查询
spring.datasource.hikari.connection-test-query=SELECT 1
SpringBoot通过org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration来实现自动装配数据源。
SpringBoot通过org.springframework.boot.autoconfigure.jdbc.DataSourceProperties定义了数据源相关配置。
SpringBoot2.0以后默认使用的是 class com.zaxxer.hikari.HikariDataSource 数据源。
如果想自定义数据源，比如 DruidDataSource，则可以使用 type 指定：
spring:
datasource:
type: com.alibaba.druid.pool.DruidDataSource
打印数据源信息：
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
import javax.sql.DataSource;
@Component
// 实现 Spring Bean 生命周期接口 ApplicationContextAware
public class DataSourceShow implements ApplicationContextAware{
private ApplicationContext applicationContext = null;
// Spring 容器会自动调用这个方法 , 注入 Spring IoC 容器
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
this.applicationContext = applicationContext;
// Spring Boot 默认已经配置好了数据源，程序员可以直接 DI 注入然后使用即可
DataSource dataSource = this.applicationContext.getBean(DataSource.class);
System.out.println("--------------------------------");
System.out.println(dataSource.getClass().getName());
System.out.println("--------------------------------");
}
}
Druid 数据源配置
官方文档：https://github.com/alibaba/druid
1、Druid 是阿里巴巴开源平台上一个数据库连接池实现，结合了 C3P0、DBCP、PROXOOL 等 DB 池的优点，同时加入了日志监控。
2、Druid 可以很好的监控 DB 池连接和 SQL 的执行情况，天生就是针对监控而生的 DB 连接池。
3、druid依赖：
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.11</version>
</dependency>
配置参数详解：
com.alibaba.druid.pool.DruidDataSource 基本配置参数如下：
| 配置 | 缺省值 | 说明 |
|---|---|---|
| name | 配置这个属性的意义在于，如果存在多个数据源，监控的时候可以通过名字来区分开来。如果没有配置，将会生成一个名字，格式是：“DataSource-” + System.identityHashCode(this) | |
| jdbcUrl | 连接数据库的url，不同数据库不一样。例如： mysql : jdbc:mysql://10.20.153.104:3306/druid2 oracle : jdbc:oracle:thin:@10.20.149.85:1521:ocnauto | |
| username | 连接数据库的用户名 | |
| password | 连接数据库的密码。如果你不希望密码直接写在配置文件中，可以使用ConfigFilter。详细看这里：https://github.com/alibaba/druid/wiki/%E4%BD%BF%E7%94%A8ConfigFilterhttps://github.com/alibaba/druid/wiki/%E4%BD%BF%E7%94%A8ConfigFilter | |
| driverClassName | 根据url自动识别 这一项可配可不配，如果不配置druid会根据url自动识别dbType，然后选择相应的driverClassName(建议配置下) | |
| initialSize | 0 | 初始化时建立物理连接的个数。初始化发生在显示调用init方法，或者第一次getConnection时 |
| maxActive | 8 | 最大连接池数量 |
| maxIdle | 8 | 已经不再使用，配置了也没效果 |
| minIdle | 最小连接池数量 | |
| maxWait | 获取连接时最大等待时间，单位毫秒。配置了maxWait之后，缺省启用公平锁，并发效率会有所下降，如果需要可以通过配置useUnfairLock属性为true使用非公平锁。 | |
| poolPreparedStatements | false | 是否缓存preparedStatement，也就是PSCache。PSCache对支持游标的数据库性能提升巨大，比如说oracle。在mysql下建议关闭。 |
| maxOpenPreparedStatements | -1 | 要启用PSCache，必须配置大于0，当大于0时，poolPreparedStatements自动触发修改为true。在Druid中，不会存在Oracle下PSCache占用内存过多的问题，可以把这个数值配置大一些，比如说100 |
| validationQuery | 用来检测连接是否有效的sql，要求是一个查询语句。如果validationQuery为null，testOnBorrow、testOnReturn、testWhileIdle都不会其作用。 | |
| testOnBorrow | true | 申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。 |
| testOnReturn | false | 归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能 |
| testWhileIdle | false | 建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。 |
| timeBetweenEvictionRunsMillis | 有两个含义： 1) Destroy线程会检测连接的间隔时间2) testWhileIdle的判断依据，详细看testWhileIdle属性的说明 | |
| numTestsPerEvictionRun | 不再使用，一个DruidDataSource只支持一个EvictionRun | |
| minEvictableIdleTimeMillis | ||
| connectionInitSqls | 物理连接初始化的时候执行的sql | |
| exceptionSorter | 根据dbType自动识别 | 当数据库抛出一些不可恢复的异常时，抛弃连接 |
| filters | 属性类型是字符串，通过别名的方式配置扩展插件，常用的插件有： 监控统计用的filter:stat日志用的filter:log4j防御sql注入的filter:wall | |
| proxyFilters | 类型是List<com.alibaba.druid.filter.Filter>，如果同时配置了filters和proxyFilters，是组合关系，并非替换关系！ |
配置 Druid 数据源参数：
1、如同以前 c3p0、dbcp 数据源可以设置数据源连接初始化大小、最大连接数、等待时间、最小连接数 等一样，Druid 数据源同理可以进行设置。
2、Druid 数据源参数配置在全局配置文件中即可：
spring:
datasource:
# 公共部分对应的是 org.springframework.boot.autoconfigure.jdbc.DataSourceProperties 中的属性
url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8&characterSetResults=utf8
username: root
password: 123456
# 可以不配置，根据url自动识别，建议配置
driver-class-name: com.mysql.jdbc.Driver
type: com.alibaba.druid.pool.DruidDataSource
# druid 数据源专有配置
# 属性对应的是 com.alibaba.druid.pool.DruidDataSource 中的属性，Spring Boot 默认是不注入不了这些属性值的，需要自己绑定
# 初始化连接池个数
initialSize: 5
# 最小连接池个数——》已经不再使用，配置了也没效果
minIdle: 2
# 最大连接池个数
maxActive: 20
# 配置获取连接等待超时的时间，单位毫秒，缺省启用公平锁，并发效率会有所下降
maxWait: 60000
# 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
timeBetweenEvictionRunsMillis: 60000
# 配置一个连接在池中最小生存的时间，单位是毫秒
minEvictableIdleTimeMillis: 300000
# 用来检测连接是否有效的sql，要求是一个查询语句。
# 如果validationQuery为null，testOnBorrow、testOnReturn、testWhileIdle都不会起作用
validationQuery: SELECT 1 FROM DUAL
# 建议配置为true，不影响性能，并且保证安全性。
# 申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。
testWhileIdle: true
# 申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能
testOnBorrow: false
# 归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能
testOnReturn: false
# 打开PSCache，并且指定每个连接上PSCache的大小
poolPreparedStatements: true
# 配置监控统计拦截的filters,通过别名的方式配置扩展插件，多个英文逗号分隔，常用的插件有：
# 监控统计；filter:stat
# 日志记录；filter:log4j（需导入 log4j 依赖，Maven 地址： https://mvnrepository.com/artifact/log4j/log4j）
# 防御sql注入；filter:wall
filters: stat,wall,log4j
# 通过connectProperties属性来打开mergeSql功能；慢SQL记录
connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
# 合并多个DruidDataSource的监控数据
useGlobalDataSourceStat: true
maxPoolPreparedStatementPerConnectionSize: 20
3、Druid 数据源的专有属性对应的是 com.alibaba.druid.pool.DruidDataSource 中的属性，虽然切换为 Druid 数据源之后，Spring Boot 会自动生成 DruidDataSource 并放入容器中供程序员使用，但是它并不会自动绑定配置文件的参数。
4、所以需要程序员自己为 com.alibaba.druid.pool.DruidDataSource 绑定全局配置文件中的参数，再添加到容器中，而不再使用 Spring Boot 的自动生成了。
配置 Druid 后台管理 Servlet 和 监控 Filter：
1、Druid 数据源具有监控的功能，并提供了一个 web 界面方便用户查看，类似安装 路由器 时，人家也提供了一个默认的 web 页面。
所以需要设置 Druid 的后台管理页面，比如 登录账号、密码 等。
DruidConfig配置类案例：
import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.sql.DataSource;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
@Configuration
public class DruidConfig {
/**
* 添加 DruidDataSource 组件到容器中，并绑定属性：
* 将自定义的 Druid 数据源添加到容器中，不再让 Spring Boot 自动创建
* 这样做的目的是：绑定全局配置文件中的 druid 数据源属性到 com.alibaba.druid.pool.DruidDataSource
* 从而让它们生效
* @ConfigurationProperties(prefix = "spring.datasource")：作用就是将 全局配置文件中 前缀为 spring.datasource
* 的属性值注入到 com.alibaba.druid.pool.DruidDataSource 的同名参数中
*/
@ConfigurationProperties(prefix = "spring.datasource")
@Bean
public DataSource druidDataSource() {
return new DruidDataSource();
}
/**
* 注册 Druid 监控之管理后台的 Servlet
*/
@Bean
public ServletRegistrationBean servletRegistrationBean() {
ServletRegistrationBean bean = new ServletRegistrationBean(
new StatViewServlet(), "/druid/*");
/**
* 这些参数可以在 com.alibaba.druid.support.http.StatViewServlet 的父类 com.alibaba.druid.support.http.ResourceServlet 中找到
* loginUsername：Druid 后台管理界面的登录账号
* loginPassword：Druid 后台管理界面的登录密码
* allow：Druid 白名单，后台允许谁可以访问,多个用逗号分割， 如果allow没有配置或者为空，则允许所有访问
* initParams.put("allow", "localhost")：表示只有本机可以访问
* initParams.put("allow", "")：为空或者为null时，表示允许所有访问
* deny：Druid 黑名单，后台拒绝谁访问，多个用逗号分割 (共同存在时，deny优先于allow)
* initParams.put("deny", "192.168.1.20");表示禁止此ip访问
*/
Map<String, String> initParams = new HashMap<>();
initParams.put("loginUsername", "admin");
initParams.put("loginPassword", "123456");
initParams.put("allow", "");
/*initParams.put("deny", "192.168.1.20");*/
/** 设置初始化参数*/
bean.setInitParameters(initParams);
return bean;
}
/**
* 配置 Druid 监控之 web 监控的 filter
* 这个过滤器的作用就是统计 web 应用请求中所有的数据库信息，
* 比如 发出的 sql 语句，sql 执行的时间、请求次数、请求的 url 地址、以及seesion 监控、数据库表的访问次数 等等。
*/
@Bean
public FilterRegistrationBean filterRegistrationBean() {
FilterRegistrationBean bean = new FilterRegistrationBean();
bean.setFilter(new WebStatFilter());
/** exclusions：设置哪些请求进行过滤排除掉，从而不进行统计*/
Map<String, String> initParams = new HashMap<>();
initParams.put("exclusions", "*.js,*.gif,*.jpg,*,png,*.css,/druid/*");
bean.setInitParameters(initParams);
/** "/*" 表示过滤所有请求*/
bean.setUrlPatterns(Arrays.asList("/*"));
return bean;
}
}
访问：http://127.0.0.1:8080/druid/login.html
SpringBoot集成Druid连接池
1、在 Spring Boot 项目中加入druid-spring-boot-starter依赖 (点击查询最新版本)
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
<version>1.1.17</version>
</dependency>
2、添加配置
spring:
datasource:
# 可以不配置，根据url自动识别，建议配置
driver-class-name: com.mysql.jdbc.Driver
url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8&characterSetResults=utf8
username: root
password: 123456
druid:
# 初始化连接池个数
initial-size: 5
# 最大连接池个数
max-active: 20
# 最小连接池个数
min-idle: 5
# 配置获取连接等待超时的时间，单位毫秒，缺省启用公平锁，并发效率会有所下降
max-wait: 60000
# 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
time-between-eviction-runs-millis: 60000
# 配置一个连接在池中最小生存的时间，单位是毫秒
min-evictable-idle-time-millis: 300000
# 如果validationQuery为null，testOnBorrow、testOnReturn、testWhileIdle都不会起作用
validation-query: SELECT 1 FROM DUAL
# 建议配置为true，不影响性能，并且保证安全性。
# 申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。
test-while-idle: true
# 申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能
test-on-borrow: false
# 归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能
test-on-return: false
# 打开PSCache，并且指定每个连接上PSCache的大小
pool-prepared-statements: true
Druid 多数据源配置（不同Mapper操作不同数据源）
1、pom 依赖
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
<version>1.1.17</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.28</version>
<scope>runtime</scope>
</dependency>
2、yml 配置
spring:
datasource:
type: com.alibaba.druid.pool.DruidDataSource
driver-class-name: com.mysql.jdbc.Driver
druid:
# 初始化连接池个数
initial-size: 5
# 最大连接池个数
max-active: 20
# 最小连接池个数
min-idle: 5
# 配置获取连接等待超时的时间，单位毫秒，缺省启用公平锁，并发效率会有所下降
max-wait: 60000
# 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
time-between-eviction-runs-millis: 60000
# 配置一个连接在池中最小生存的时间，单位是毫秒
min-evictable-idle-time-millis: 300000
# 如果validationQuery为null，testOnBorrow、testOnReturn、testWhileIdle都不会起作用
validation-query: SELECT 1 FROM DUAL
# 建议配置为true，不影响性能，并且保证安全性。
# 申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。
test-while-idle: true
# 申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能
test-on-borrow: false
# 归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能
test-on-return: false
# 打开PSCache，并且指定每个连接上PSCache的大小
pool-prepared-statements: true
one:
jdbc-url: jdbc:mysql://47.103.82.100:3306/chargepile-v2.0?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
username: root
password: GT2021!
two:
jdbc-url: jdbc:mysql://139.196.127.156:3306/chargepile-v2.0?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
username: root
password: GT2021!
3、数据源配置，提供两个 DataSource
import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.sql.DataSource;
@Configuration
public class DataSourceConfig {
@Bean
@ConfigurationProperties(prefix = "spring.datasource.one")
DataSource dsOne() {
return DruidDataSourceBuilder.create().build();
}
@Bean
@ConfigurationProperties(prefix = "spring.datasource.two")
DataSource dsTwo() {
return DruidDataSourceBuilder.create().build();
}
}
4、MyBatis配置（两个数据源在两个类中分开来配置）
第一个数据源配置
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import javax.annotation.Resource;
import javax.sql.DataSource;
@Configuration
@MapperScan(basePackages = "com.demo.mapper1",
sqlSessionFactoryRef = "sqlSessionFactory1",
sqlSessionTemplateRef = "sqlSessionTemplate1")
public class MyBatisConfigOne {
@Resource(name = "dsOne")
DataSource dsOne;
@Bean
SqlSessionFactory sqlSessionFactory1() {
SqlSessionFactory sessionFactory = null;
try {
SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
bean.setDataSource(dsOne);
// 每张表对应的xml文件
bean.setMapperLocations(resolver.getResources(("classpath:mapper/*Mapper.xml")));
// 每一张表对应的实体类
bean.setTypeAliasesPackage("com.demo.entity");
sessionFactory = bean.getObject();
} catch (Exception e) {
e.printStackTrace();
}
return sessionFactory;
}
@Bean
SqlSessionTemplate sqlSessionTemplate1() {
return new SqlSessionTemplate(sqlSessionFactory1());
}
}
第二个数据源配置
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import javax.annotation.Resource;
import javax.sql.DataSource;
@Configuration
@MapperScan(basePackages = "com.demo.mapper2",
sqlSessionFactoryRef = "sqlSessionFactory2",
sqlSessionTemplateRef = "sqlSessionTemplate2")
public class MyBatisConfigTwo {
@Resource(name = "dsTwo")
DataSource dsTwo;
@Bean
SqlSessionFactory sqlSessionFactory2() {
SqlSessionFactory sessionFactory = null;
try {
SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
bean.setDataSource(dsTwo);
// 每张表对应的xml文件
bean.setMapperLocations(resolver.getResources(("classpath:mapper/*Mapper.xml")));
// 每一张表对应的实体类
bean.setTypeAliasesPackage("com.demo.entity");
sessionFactory = bean.getObject();
} catch (Exception e) {
e.printStackTrace();
}
return sessionFactory;
}
@Bean
SqlSessionTemplate sqlSessionTemplate2() {
return new SqlSessionTemplate(sqlSessionFactory2());
}
}
5、mapper 和实体类创建
@Data
public class User {
private int id;
private String name;
}
public interface UserMapperOne {
List<User> getAllUser();
}
public interface UserMapperTwo {
List<User> getAllUser();
}
6、mapper 对应的 XML 配置
<?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.demo.mapper1.UserMapperOne">
<select id="getAllUser" resultType="com.demo.entity.User">
select * from user;
</select>
</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.demo.mapper2.UserMapperTwo">
<select id="getAllUser" resultType="com.demo.entity.User">
select * from user;
</select>
</mapper>
最后，在Service中注入两个不同的Mapper，不同的Mapper将操作不同的数据源。
HikariCP 多数据源动态配置
1、pom 依赖
<dependencies>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.4.2</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<!-- 如果数据库服务器是5.7以下版本，驱动建议使用这个版本，如果使用高版本会导致时间问题-->
<version>5.1.42</version>
<scope>runtime</scope>
</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.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
</dependencies>
2、yml 配置
spring:
datasource:
type: com.zaxxer.hikari.util.DriverDataSource
hikari:
minimum-idle: 5
maximum-pool-size: 20
auto-commit: true
idle-timeout: 540000
max-lifetime: 540000
connection-timeout: 60000
connection-test-query: SELECT 1
master:
driver-class-name: com.mysql.jdbc.Driver
jdbc-url: jdbc:mysql://47.103.82.100:3306/chargepile-v2.0?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
username: root
password: GT2021!
slave:
driver-class-name: com.mysql.jdbc.Driver
jdbc-url: jdbc:mysql://139.196.127.156:3306/chargepile-v2.0?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
username: root
password: GT2021!
3、创建类MybatisPlusConfig，配置注入数据源
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.type.JdbcType;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;
@Configuration
public class MybatisPlusConfig {
/**
* 创建 master 数据源
*
* @return dataSource
*/
@Bean(name = "master")
@ConfigurationProperties(prefix = "spring.datasource.master")
public DataSource masterDataSource() {
return DataSourceBuilder.create().build();
}
/**
* 创建 slave 数据源
*
* @return dataSource
*/
@Bean(name = "slave")
@ConfigurationProperties(prefix = "spring.datasource.slave")
public DataSource slaveDataSource() {
return DataSourceBuilder.create().build();
}
/**
* 动态数据源配置
*
* @return dataSource
*/
@Bean
@Primary
public DataSource multipleDataSource(@Qualifier("master") DataSource master,
@Qualifier("slave") DataSource slave) {
DynamicDataSource dynamicDataSource = new DynamicDataSource();
Map<Object, Object> dataSources = new HashMap<>();
dataSources.put(DBTypeEnum.MASTER.getValue(), master);
dataSources.put(DBTypeEnum.SLAVE.getValue(), slave);
dynamicDataSource.setTargetDataSources(dataSources);
dynamicDataSource.setDefaultTargetDataSource(master);
return dynamicDataSource;
}
@Bean("sqlSessionFactory")
public SqlSessionFactory sqlSessionFactory() throws Exception {
// 导入 MybatisSqlSession 配置
MybatisSqlSessionFactoryBean sessionFactory = new MybatisSqlSessionFactoryBean();
PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
// 设置数据源
sessionFactory.setDataSource(multipleDataSource(masterDataSource(), slaveDataSource()));
// 实体类别名扫描，多个 package 用逗号或者分号隔开
sessionFactory.setTypeAliasesPackage("com.yq.demo.entity");
// xml 配置文件位置
sessionFactory.setMapperLocations(resolver.getResources(("classpath:/mapper/**.xml")));
// 导入 mybatis 配置
MybatisConfiguration configuration = new MybatisConfiguration();
configuration.setJdbcTypeForNull(JdbcType.NULL);
configuration.setMapUnderscoreToCamelCase(true);
configuration.setCacheEnabled(false);
sessionFactory.setConfiguration(configuration);
return sessionFactory.getObject();
}
}
4、创建动态数据源的获取类 DynamicDataSource 继承 AbstractRoutingDataSource：
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
/**
* 扩展 Spring 的 AbstractRoutingDataSource 抽象类，实现动态数据源（他的作用就是动态切换数据源）。
* AbstractRoutingDataSource 中的抽象方法 determineCurrentLookupKey 是实现数据源的route的核心。
* 上下文DbContextHolder为一线程安全的ThreadLocal
*/
public class DynamicDataSource extends AbstractRoutingDataSource {
/**
* 取得当前使用哪个数据源
* @return
*/
@Override
protected Object determineCurrentLookupKey() {
return DbContextHolder.getDbType();
}
}
5、创建获取，设置数据源的类 DbContextHolder，为了线程安全使用了 ThreadLocal：
/**
* 设置，获取，清空 当前线程内的数据源变量。
*/
public class DbContextHolder {
private static final ThreadLocal CONTEXT_HOLDER = new ThreadLocal();
/**
* 设置数据源
*
* @param dbTypeEnum 数据库类型
*/
public static void setDbType(DBTypeEnum dbTypeEnum) {
CONTEXT_HOLDER.set(dbTypeEnum.getValue());
}
/**
* 取得当前数据源
*
* @return dbType
*/
public static String getDbType() {
return (String) CONTEXT_HOLDER.get();
}
/**
* 清除上下文数据
*/
public static void clearDbType() {
CONTEXT_HOLDER.remove();
}
}
/**
* 设置数据源
*/
public enum DBTypeEnum {
/**
* 主库
*/
MASTER("master"),
/**
* 从库
*/
SLAVE("slave");
private final String value;
DBTypeEnum(String value) {
this.value = value;
}
public String getValue() {
return value;
}
}
6、添加一个 aop 切面类 DataSourceSwitchAspect，这样就可以动态切换数据源了：
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import java.util.Objects;
/**
* AOP方式动态切换数据源 (为了保证AOP在事务注解之前生效,Order的值越小,优先级越高)
*/
@Slf4j
@Component
@Aspect
@Order(-100)
public class DataSourceSwitchAspect {
@Pointcut("execution(* com.yq.demo.service..*.*(..))")
private void dbAspect() {
}
@Before("dbAspect()")
public void db(JoinPoint joinPoint) {
MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
DataSourceSwitch dataSourceSwitch = methodSignature.getMethod().getAnnotation(DataSourceSwitch.class);
if (Objects.isNull(dataSourceSwitch)) {
DbContextHolder.setDbType(DBTypeEnum.MASTER);
} else {
dataSourceSwitch.value();
switch (dataSourceSwitch.value().getValue()) {
case "master":
DbContextHolder.setDbType(DBTypeEnum.MASTER);
break;
case "slave":
DbContextHolder.setDbType(DBTypeEnum.SLAVE);
break;
default:
DbContextHolder.setDbType(DBTypeEnum.MASTER);
}
}
}
}
7、添加一个可以供我们用注解形式的调用方式的接口：
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* 多数据源切换
*/
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface DataSourceSwitch {
/**
* 指定数据源，默认主数据源
*/
DBTypeEnum value() default DBTypeEnum.MASTER;
}
最后测试：
@Service
@AllArgsConstructor
public class TestServiceImpl implements TestService {
private TestMapper testMapper;
@DataSourceSwitch(DBTypeEnum.SLAVE) // 指定数据源，默认 master
@Override
public void demo() {
}
}
为开发者提供学习成长、分享交流、生态实践、资源工具等服务，帮助开发者快速成长。
更多推荐
15
0- 0
已为社区贡献2条内容
所有评论(0)