文章目录

  • 市面上的几种数据源比对
  • SpringBoot自动装配DataSource原理
  • HiKariCP 数据源配置
  • Druid 数据源配置
  • SpringBoot集成Druid连接池
  • Druid 多数据源配置（不同Mapper操作不同数据源）
  • HikariCP 多数据源动态配置

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 容器@Overridepublic 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=utf8username: rootpassword: 123456# 可以不配置，根据url自动识别，建议配置driver-class-name: com.mysql.jdbc.Drivertype: 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:wallfilters: stat,wall,log4j# 通过connectProperties属性来打开mergeSql功能；慢SQL记录connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000# 合并多个DruidDataSource的监控数据useGlobalDataSourceStat: truemaxPoolPreparedStatementPerConnectionSize: 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")@Beanpublic DataSource druidDataSource() {return new DruidDataSource();}/*** 注册 Druid 监控之管理后台的 Servlet*/@Beanpublic 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 监控、数据库表的访问次数 等等。*/@Beanpublic 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.Driverurl: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8&characterSetResults=utf8username: rootpassword: 123456druid:# 初始化连接池个数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.DruidDataSourcedriver-class-name: com.mysql.jdbc.Driverdruid:# 初始化连接池个数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: trueone:jdbc-url: jdbc:mysql://47.103.82.100:3306/chargepile-v2.0?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8username: rootpassword: GT2021!two:jdbc-url: jdbc:mysql://139.196.127.156:3306/chargepile-v2.0?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8username: rootpassword: 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;@BeanSqlSessionFactory 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;}@BeanSqlSessionTemplate 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;@BeanSqlSessionFactory 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;}@BeanSqlSessionTemplate 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 mapperPUBLIC "-//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 mapperPUBLIC "-//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.DriverDataSourcehikari:minimum-idle: 5maximum-pool-size: 20auto-commit: trueidle-timeout: 540000max-lifetime: 540000connection-timeout: 60000connection-test-query: SELECT 1master:driver-class-name: com.mysql.jdbc.Driverjdbc-url: jdbc:mysql://47.103.82.100:3306/chargepile-v2.0?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8username: rootpassword: GT2021!slave:driver-class-name: com.mysql.jdbc.Driverjdbc-url: jdbc:mysql://139.196.127.156:3306/chargepile-v2.0?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8username: rootpassword: 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@Primarypublic 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*/@Overrideprotected 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@Overridepublic void demo() {}
}

SpringBoot 之数据源配置相关推荐

  1. Springboot多数据源配置详解

    Springboot多数据源配置详解 概念 配置 多数据源使用 概念 一般来说,我们正常的业务只涉及一个数据源,在特定的业务场景中需要使用多个数据源的情况,就需要配置多个数据源来满足特定的业务需求.本 ...

  2. springboot 多数据源配置的几种方式

    springboot多数据源配置的三种方式 application.yml配置 1.@Ds("配置数据源名称") 引入依赖 <dependency> <group ...

  3. java spring多数据源配置文件_基于注解实现SpringBoot多数据源配置

    1.功能介绍 在实际的开发中,同一个项目中使用多个数据源是很常见的场景.最近在学习的过程中使用注解的方式实现了一个Springboot项目多数据源的功能.具体实现方式如下. 2.在applicatio ...

  4. SpringBoot排除数据源配置，配置决定行为

    项目场景: 最近接到一个需求,大概意思呢就是数据库连接不够用了,部分服务(分服务)就不需要配置数据源了,需要跟db打交道的地方全部改成rpc去调用具备db能力的服务(总服务) 问题描述: 其实需要改的 ...

  5. SpringBoot多数据源配置

    作者平台: | CSDN:blog.csdn.net/qq_41153943 | 掘金:juejin.cn/user/651387- | 知乎:www.zhihu.com/people/1024- | ...

  6. springboot 多数据源配置，postgresql+mysql为例

    由于项目需要,利用springboot配置多数据源,postgresql+mysql: 1.首先导入需要的依赖包,包的版本根据需要选择,本项目是spring-boot-starter-parent 2 ...

  7. springBoot 双数据源配置 （Oracle+ SQL sever）主数据源配置setMapperLocations多个路径

    1.添加pom依赖 (部分) <!--添加 阿里连接池 支持--><dependency><groupId>com.alibaba</groupId>& ...

  8. springboot 多数据源配置与使用

    多数据源配置 这个是springboot1版本的 spingboot2移步 > springboot2.x jpa接入多数据源 application.properties 配置两个数据库 #数 ...

  9. springboot多数据源配置_SpringBoot-配置多数据源

    1.4.springboot整合多数据源 你们在项目中有使用到多数据源吗? 4.4.1配置文件中新增两个数据源 spring.datasource.test1.driverClassName = co ...

最新文章

  1. Android 解析imei
  2. python练习笔记——面试题 F(n) = F(n-1)+F(n-2)
  3. 黄斑区隆起原因诊断过程+黄斑反复水肿问题
  4. Pytorch(一) --线性模型
  5. Android之在Java socket作为服务器里面返回数据头部怎么写入浏览器需要下载文件的文件名
  6. 位，字，字节之间关系及关联知识普及
  7. 几种并发服务器模型的实现：多线程，多进程，select，poll，epoll
  8. eclipse打war包_jar包和war包的区别
  9. 如何解决w3wp占用CPU和内存问题
  10. 【bzoj 入门OJ】[NOIP 热身赛]Problem C: 星球联盟（并查集）
  11. 阿拉丁指数丨《2021 年度小程序互联网发展白皮书》4.5 亿+DAU 小程序的 6 大发展趋势
  12. DLL注入之全局钩子注入
  13. mac怎么压缩pdf文件最小
  14. 【表格】从1G到5G的移动通信发展历程（精简版）
  15. 一级标题段前段后一行设置方法
  16. 关于风险管理，如何将思维从项目升维到项目群？
  17. G1D5-Intriguing properties of neural networks
  18. 佳能canon e510打印机驱动 1.0 官E510 series XPS 打印机驱动程序 v. 5.62 (Windows)
  19. linux内核原子操作的实现
  20. DNS总是出现问题怎么办？

热门文章

  1. kindle出现电池感叹号，充电黄灯亮，怎么解决？按AWZ客服的回复弄好了。
  2. （练习篇）萤火虫esp32与小爱音响---实现笔记本电脑唤醒
  3. 示波器观察IIC通讯协议-STM32F4读写24C08EEPROM时序图-新人首更
  4. win32分割窗口的一个简易做法，非常好的编程思维（一）
  5. python 离群值_数据预处理初学者宝典：360° 掌握离群值识别
  6. 阿里云图像识别Java调用示例参考
  7. 搜索引擎优化与信息检索有什么关联
  8. Java实验作业13(星座测试系统)
  9. 刷脸支付：一场输不起的战役
  10. java二面_快手Java面试题分享，一二面(面经面试题附部分答案)