SpringBoot 之数据源配置

关注

原创 2022-05-05 21:28:47 1.9w 阅读 AI 写同款· GEO 优化 ›

SpringBoot | 3.1 配置数据源 前面介绍了SpringBoot的自动配置原理，用一句话概括是：启动时加载所有，最终按照条件进行装配。本章节表面上是讲数据访问，但其核心还是讲SpringBoot的自动配置，只不过自动配置的对象是数据库相关的依赖（如：druid、MyBatis、MyBatis-Plugs等）。这些依赖的导入与装配都是SpringBoot帮我们自动完成的。SpringBoot默认使用的数据源是Hikari（下面有源码分析），以后我们将使用阿里的Druid数据源进行数据库相关配置与操作。数据源的自动配置原理（2.）；阅读详情

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() {
      
    }
}