Dynamic DataSource 多数据源配置【 Springboot + DataSource + MyBatis Plus + Druid】

一、前言

MybatisPlus多数据源配置主要解决的是多数据库连接和切换的问题。在一些大型应用中，由于数据量的增长或者业务模块的增多，可能需要访问多个数据库。这时，就需要配置多个数据源。

二、Springboot + MyBatis Plus 数据源配置

2.1、单数据源配置

2.1.1、引用依赖

	<dependency>
		<groupId>com.baomidougroupId>
		<artifactId>mybatis-plus-boot-starterartifactId>
		<version>3.5.1version>
	dependency>
	<dependency>
		<groupId>mysqlgroupId>
		<artifactId>mysql-connector-javaartifactId>
		<version>8.0.28version>
	dependency>

2.1.2、application.yml 配置

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/db1?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai&useSSL=false
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
    

2.1.3、通用配置类

@Configuration
@MapperScan(basePackages = {"com.xx.**.mapper"})
public class MybatisPlusConfig {
    public MybatisPlusInterceptor mybatisPlusInterceptor(){
    	//新的分页插件配置方法（Mybatis Plus 3.4.0版本及其之后的版本）
        MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
        mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor());
        return mybatisPlusInterceptor;
    }
}

2.1.4、使用方式

这里便不过多的说明具体的使用方式了，和正常的MyBatis plus 单库一样

2.2、多数据源配置

2.2.1、引用依赖

	<dependency>
		<groupId>com.baomidougroupId>
		<artifactId>mybatis-plus-boot-starterartifactId>
		<version>3.5.1version>
	dependency>
	<dependency>
		<groupId>mysqlgroupId>
		<artifactId>mysql-connector-javaartifactId>
		<version>8.0.28version>
	dependency>
   
   <dependency>
        <groupId>com.alibabagroupId>
        <artifactId>druid-spring-boot-starterartifactId>
        <version>1.2.9version>
   dependency>	
	
	<dependency>
		<groupId>com.baomidougroupId>
		<artifactId>dynamic-datasource-spring-boot-starterartifactId>
		<version>3.1.0version>
	dependency>

2.2.2、在 application.yml

spring:
  # 配置数据源信息
  datasource:
    dynamic:
      # 设置默认的数据源或者数据源组,默认值为master
      primary: master
      # 严格匹配数据源,默认false,true未匹配到指定数据源时抛异常,false使用默认数据源
      strict: false
      datasource:
        master:
          url: jdbc:mysql://localhost:3306/test?serverTimezone=GMT%2B8&characterEncoding=utf-8&userSSL=false
          driver-class-name: com.mysql.cj.jdbc.Driver
          username: root
          password: 123456
        slave_1:
          url: jdbc:mysql://localhost:3306/demo?serverTimezone=GMT%2B8&characterEncoding=utf-8&userSSL=false
          driver-class-name: com.mysql.cj.jdbc.Driver
          username: root

    

2.2.3、通用配置类

@Configuration
@MapperScan(basePackages = {"com.xx.**.mapper"})
public class MybatisPlusConfig {
    public MybatisPlusInterceptor mybatisPlusInterceptor(){
    	//新的分页插件配置方法（Mybatis Plus 3.4.0版本及其之后的版本）
        MybatisPlusInterceptor mybatisPlusInterceptor = new MybatisPlusInterceptor();
        mybatisPlusInterceptor.addInnerInterceptor(new PaginationInnerInterceptor());
        return mybatisPlusInterceptor;
    }
}

2.2.4、准备 DataSourceType

public enum DataSourceType {
    MASTER,
    SLAVE,
    THIRD
}

2.2.5、自定义切换数据源的注解 DataSourceType

import java.lang.annotation.*;

/**
 * 定义切换数据源的注解
 *
 * @author: zhangxiaohu
 * @date: 2021/6/25 21:59
 * @Description:
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DataSource {

    /**
     * 切换数据源名称
     */
    DataSourceType value() default DataSourceType.MASTER;

}

2.2.6、准备 DynamicDataSourceContextHolder

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
 * 动态数据源名称上下文处理
 *
 **/
public class DynamicDataSourceContextHolder {

    public static final Logger log = LoggerFactory.getLogger(DynamicDataSourceContextHolder.class);
    
    /**
     * 设置数据源
     * @param key
     */
    private static final ThreadLocal<String> CONTEXT_HOLDER = new ThreadLocal<>();

    /**
     * 设置数据源
     * @param key
     */
    public static void setDataSourceType(String dataSourceType) {
        log.info(" switch to {} data source", dataSourceType);
        CONTEXT_HOLDER.set(dataSourceType);
    }
 	/**
     * 获取数据源名称
     * @return
     */
    public static String getDataSourceType() {
        return CONTEXT_HOLDER.get();
    }

    /**
     * 删除当前数据源名称
     */
    public static void clearDataSourceType() {
        CONTEXT_HOLDER.remove();
    }

}

2.2.7、动态数据源

import com.dq.workflow.context.DynamicDataSourceContextHolder;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
 
/**
 * 动态数据源
 *
 **/
public class DynamicDataSource extends AbstractRoutingDataSource {
    @Override
    protected Object determineCurrentLookupKey() {
        return DynamicDataSourceContextHolder.getDataSourceType();
    }
}

2.2.8、在config中配置数据源

import com.dq.workflow.constants.DataSourceConstants;
import org.mybatis.spring.annotation.MapperScan;
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.context.annotation.PropertySource;
 
import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;


@Component
@Configuration
@PropertySource("classpath:application-test.yml")
@MapperScan({"com.dq.workflow.mapper","com.dq.workflow.activiti.mapper"})
public class DataSourceConfig {

    /**
     * 创建数据源db1
     * @return 数据源db1
     */
    @Bean(name = "masterDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.dynamic.datasource.master")
    public DataSource masterDataSource() {
        return DataSourceBuilder.create().build();
    }

    /**
     * 创建数据源db2
     * @return 数据源db2
     */
    @Bean(name = "slaveDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.dynamic.datasource.slave")
    public DataSource slaveDataSource() {
        return DataSourceBuilder.create().build();
    }

    /**
     * 数据源配置
     * @param db1数据源db1
     * @param db2数据源db2
     * @return 动态数据源切换对象。
     * @Description @Primary赋予该类型bean更高的优先级，使至少有一个bean有资格作为autowire的候选者。
     */
    @Primary
    @Bean(name = "dynamicDataSource")
    public DataSource dataSource(@Qualifier("masterDataSource") DataSource masterDataSource,
                                 @Qualifier("slaveDataSource") DataSource slaveDataSource) {
        Map<Object, Object> targetDataSourcesMap = new HashMap<>();
        //主数据源
        targetDataSourcesMap.put(DataSourceType.MASTER.name(), masterDataSource);
        //从数据源
        targetDataSourcesMap.put(DataSourceType.SLAVE.name(), slaveDataSource);
        // 设置默认数据源、其他数据源
        return new DynamicDataSource(masterDataSource, targetDataSourcesMap);
    }
}

2.2.9、在config中配置数据源 文件为 db.properties

这个是将原来 Springboot DB配置单独抽离为一个单独的配置文件 db.properties ，没有这种情况的可以不用看这部分

2.2.9.1、准备 DbProperties

public class DbProperties {

    public static String masterDriver;
    public static String masterUrl;
    public static String masterUserName;
    public static String masterPassword;
    public static String masterSchema;
    public static String masterEncrypted;

    public static String slaveDriver;
    public static String slaveUrl;
    public static String slaveUserName;
    public static String slavePassword;
    public static String slaveSchema;
    public static String slaveEncrypted;

}

2.2.9.2、在 application.yml 添加

db:
  properties:
    path: C:\\MVNO\\src\\main\\resources\\db.properties

2.2.9.3、修改 DataSourceConfig

@Component
@Configuration
public class DataSourceConfig {

    @Value("${db.properties.path}")
    private String path;
    private PropertyResourceBundle externalProps;  
    @Override
    public void afterPropertiesSet() throws Exception {
        InputStream input = null;
        try {
            input = Files.newInputStream(Paths.get(path));
            this.externalProps = new PropertyResourceBundle(input);
        } catch (Exception ex) {
            log.error("Load external configuration file failed. path: {}. Cause: {}", path, ex.getMessage());
            throw new RuntimeException(ex);
        } finally {
            IoUtil.close(input);
        }
    }  

    public void initDbProperties(String path) {
        try {
            DbProperties.masterDriver = this.externalProps.getString("jdbc.mvno.driverClassName");
            DbProperties.masterUrl = this.externalProps.getString("jdbc.mvno.url");
            DbProperties.masterUserName = this.externalProps.getString("jdbc.mvno.username");
            DbProperties.masterPassword = this.externalProps.getString("jdbc.mvno.password");
            DbProperties.masterSchema = this.externalProps.getString("jdbc.mvno.schema");
            DbProperties.masterEncrypted = this.externalProps.getString("jdbc.mvno.encrypted");
            DbProperties.slaveDriver = this.externalProps.getString("jdbc.pbue.driverClassName");
            DbProperties.slaveUrl = this.externalProps.getString("jdbc.pbue.url");
            DbProperties.slaveUserName = this.externalProps.getString("jdbc.pbue.username");
            DbProperties.slavePassword = this.externalProps.getString("jdbc.pbue.password");
            DbProperties.slaveSchema = this.externalProps.getString("jdbc.pbue.schema");
            DbProperties.slaveEncrypted = this.externalProps.getString("jdbc.pbue.encrypted");
            if ("true".equalsIgnoreCase(DbProperties.masterEncrypted)) {
                DbProperties.masterPassword = Decryption.decrypt(DbProperties.masterPassword);
            }
            if ("true".equalsIgnoreCase(DbProperties.slaveEncrypted)) {
                DbProperties.slavePassword = Decryption.decrypt(DbProperties.slavePassword);
            }
        } catch (Exception ex) {
            log.error("Load db configuration failed. Cause: {}", ex.getMessage());
            throw new RuntimeException(ex);
        }
    }

    /**
     * 创建数据源db1
     * @return 数据源db1
     */
    @Bean(name = "masterDataSource")
    @Scope(ConfigurableListableBeanFactory.SCOPE_SINGLETON)
    public DataSource masterDataSource() {
        initDbProperties(path);
        DruidDataSource dataSource = DruidDataSourceBuilder.create().build();
        dataSource.setDriverClassName(DbProperties.masterDriver);
        dataSource.setUsername(DbProperties.masterUserName);
        dataSource.setPassword(DbProperties.masterPassword);
        dataSource.setUrl(DbProperties.masterUrl);
        dataSource.setMaxWait(60000);
        dataSource.setMinEvictableIdleTimeMillis(300000);
    }

    /**
     * 创建数据源db2
     * @return 数据源db2
     */
    @Bean(name = "slaveDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.dynamic.datasource.slave")
    public DataSource slaveDataSource() {
        initDbProperties(path);
        DruidDataSource dataSource = DruidDataSourceBuilder.create().build();
        dataSource.setDriverClassName(DbProperties.slaveDriver);
        dataSource.setUsername(DbProperties.slaveUserName);
        dataSource.setPassword(DbProperties.slavePassword);
        dataSource.setUrl(DbProperties.slaveUrl);
        dataSource.setMaxWait(60000);
        dataSource.setMinEvictableIdleTimeMillis(300000);
        return dataSource;
    }

    /**
     * 数据源配置
     * @param db1数据源db1
     * @param db2数据源db2
     * @return 动态数据源切换对象。
     * @Description @Primary赋予该类型bean更高的优先级，使至少有一个bean有资格作为autowire的候选者。
     */
    @Primary
    @Bean(name = "dynamicDataSource")
    public DataSource dataSource(@Qualifier("masterDataSource") DataSource masterDataSource,
                                 @Qualifier("slaveDataSource") DataSource slaveDataSource) {
        Map<Object, Object> targetDataSourcesMap = new HashMap<>();
        //主数据源
        targetDataSourcesMap.put(DataSourceType.MASTER.name(), masterDataSource);
        //从数据源
        targetDataSourcesMap.put(DataSourceType.SLAVE.name(), slaveDataSource);
        // 设置默认数据源、其他数据源
        return new DynamicDataSource(masterDataSource, targetDataSourcesMap);
    }
}

2.2.9.4、修改 DynamicDataSource

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

import javax.sql.DataSource;
import java.util.Map;
public class DynamicDataSource extends AbstractRoutingDataSource{

    public DynamicDataSource(DataSource defaultTargetDataSource, Map<Object, Object> targetDataSourcesMap) {
        super.setDefaultTargetDataSource(defaultTargetDataSource);
        super.setTargetDataSources(targetDataSourcesMap);
        super.afterPropertiesSet();
    }


    @Override
    protected Object determineCurrentLookupKey() {
        return DynamicDataSourceContextHolder.getDataSourceType();
    }
}

2.2.10、Aop方式拦截

import cn.xiyou.config.DataSource;
import cn.xiyou.config.DynamicDataSourceContextHolder;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;


@Aspect
@Order(1)
@Component
public class DataSourceAspect {

    private Logger log = LoggerFactory.getLogger(getClass());

    @Pointcut("@annotation(cn.xiyou.config.DataSource)")
    public void dsPointCut() {

    }

    @Around("dsPointCut()")
    public Object around(ProceedingJoinPoint point) {
        MethodSignature signature = (MethodSignature) point.getSignature();
        Method method = signature.getMethod();
        DataSource dataSource = method.getAnnotation(DataSource.class);
        if (dataSource != null) {
            log.info("【before数据源名】" + dataSource.value().name());
            DynamicDataSourceContextHolder.setDataSourceType(dataSource.value().name());
            log.info("【after数据源名】" + dataSource.value().name());
        }
        Object obj = null;
        try {
            obj = point.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        } finally {
            // 销毁数据源 在执行方法之后
            DynamicDataSourceContextHolder.clearDataSourceType();
        }
        return obj;
    }

}

2.2.11、配置动态表前缀 DynamicTableName

我这边配置这个是因为存在跨账号查询数据库表的情况,这里请根据实际项目情况配置，没有这种需求请跳过
1、这里 IgnoreDBEnum 是用来过滤要查询 系统默认表的，系统表不能加前缀查询，否则会报视图不存在的SQL 问题。
2、使用 if(DataSourceType.SLAVE.name().equalsIgnoreCase(DynamicDataSourceContextHolder.getDataSourceType()))实现动态加表前缀

public enum IgnoreDBEnum {

	ALL_TABLES,
	ALL_TAB_COLUMNS,
	ALL_TAB_PRIVS, 
	ALL_CONSTRAINTS, 
	ALL_CONS_COLUMNS ;
	
}

import com.baomidou.mybatisplus.extension.plugins.handler.TableNameHandler;
import com.mvno.common.db.HbueDBEnum;
import com.mvno.common.domain.DbProperties;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class  DynamicTableNameHandler implements TableNameHandler {

    private final List<String> ignoreTabs=new ArrayList<String>(){
        {
            for (IgnoreDBEnum tables : IgnoreDBEnum.values()) {
                add(tables.name());
            }
        }
    };


    @Override
    public String dynamicTableName(String sql, String tableName) {
        if (ignoreTabs != null && ignoreTabs.size() > 0) {
            for (String ignoreTab : ignoreTabs) {
                if (ignoreTab.equalsIgnoreCase(tableName)) {
                    return tableName;
                }
            }
        }
        log.info("Data Source Type: {}", DynamicDataSourceContextHolder.getDataSourceType());
        if(DataSourceType.SLAVE.name().equalsIgnoreCase(DynamicDataSourceContextHolder.getDataSourceType())){
            return DbProperties.slaveSchema + "." + tableName;
        }else{

            return DbProperties.masterSchema + "." + tableName;
        }
    }
 }   

2.2.12、继承 InnerInterceptor

import com.baomidou.mybatisplus.core.plugins.InterceptorIgnoreHelper;
import com.baomidou.mybatisplus.core.toolkit.PluginUtils;
import com.baomidou.mybatisplus.core.toolkit.TableNameParser;
import com.baomidou.mybatisplus.extension.plugins.inner.InnerInterceptor;
import com.mvno.common.utils.MvnoSqlHolder;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.SqlCommandType;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class MvnoSqlInnerInterceptor implements InnerInterceptor {

    private MonthTableNameHandler tableNameHandler;


    @Override
    public void beforePrepare(StatementHandler sh, Connection connection, Integer transactionTimeout) {
            PluginUtils.MPStatementHandler mpSh = PluginUtils.mpStatementHandler(sh);
            MappedStatement ms = mpSh.mappedStatement();
            SqlCommandType sct = ms.getSqlCommandType();
            if (sct == SqlCommandType.SELECT || sct == SqlCommandType.UPDATE || sct == SqlCommandType.DELETE) {
                if (InterceptorIgnoreHelper.willIgnoreDynamicTableName(ms.getId())) {
                    return;
                }
                PluginUtils.MPBoundSql mpBs = mpSh.mPBoundSql();
                mpBs.sql(this.changeTable(mpBs.sql(),connection));
            }
    }

    protected String changeTable(String sql) {
        TableNameParser parser = new TableNameParser(sql);
        List<TableNameParser.SqlToken> names = new ArrayList<>();
        parser.accept(names::add);
        StringBuilder builder = new StringBuilder();
        int last = 0;
        for (TableNameParser.SqlToken name : names) {
            int start = name.getStart();
            if (start != last) {
                builder.append(sql, last, start);
                builder.append(tableNameHandler.dynamicTableName(sql, name.getValue()));
            }
            last = name.getEnd();
        }
        if (last != sql.length()) {
            builder.append(sql.substring(last));
        }
        return builder.toString();
    }

    public InnerInterceptor setTableNameHandler(DynamicTableNameHandler tableNameHandler) {
        this.tableNameHandler = tableNameHandler;
        return this;
    }
}

2.2.13、数据源关闭连接问题

[com.alibaba.druid.util.JdbcUtils:109 ] - close statement error
java.sql.SQLRecoverableException: 关闭的连接

2.2.13.1、application.yml 配置

2.2.13.1.1、druid

这里引入的是专门为spring boot打造的druid-spring-boot-starter,如果引入的是druid则需要配置xml

   <dependency>
       <groupId>com.alibabagroupId>
        <artifactId>druid-spring-boot-starterartifactId>
        <version>{druid.version}version>
    dependency>
    

druid参数可以不写，会按照默认参数处理，需要指定type

spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql:///:3306/数据库名?useSSL=false&useUnicode=true&characterEncoding=UTF-8
    username:
    password:
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      initial-size: 10 # 初始化时建立物理连接的个数。初始化发生在显示调用init方法，或者第一次getConnection时
      min-idle: 10 # 最小连接池数量
      maxActive: 200 # 最大连接池数量
      maxWait: 60000 # 获取连接时最大等待时间，单位毫秒。配置了maxWait之后，缺省启用公平锁，并发效率会有所下降，如果需要可以通过配置
      timeBetweenEvictionRunsMillis: 60000 # 关闭空闲连接的检测时间间隔.Destroy线程会检测连接的间隔时间，如果连接空闲时间大于等于minEvictableIdleTimeMillis则关闭物理连接。
      minEvictableIdleTimeMillis: 300000 # 连接的最小生存时间.连接保持空闲而不被驱逐的最小时间
      validationQuery: SELECT 1 FROM DUAL # 验证数据库服务可用性的sql.用来检测连接是否有效的sql 因数据库方言而差, 例如 oracle 应该写成 SELECT 1 FROM DUAL
      testWhileIdle: true # 申请连接时检测空闲时间，根据空闲时间再检测连接是否有效.建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRun
      testOnBorrow: false # 申请连接时直接检测连接是否有效.申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。
      testOnReturn: false # 归还连接时检测连接是否有效.归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。
      poolPreparedStatements: true # 开启PSCache
      maxPoolPreparedStatementPerConnectionSize: 20 #设置PSCache值
      connectionErrorRetryAttempts: 3 # 连接出错后再尝试连接三次
      breakAfterAcquireFailure: true # 数据库服务宕机自动重连机制
      timeBetweenConnectErrorMillis: 300000 # 连接出错后重试时间间隔
      asyncInit: true # 异步初始化策略
      remove-abandoned: true # 是否自动回收超时连接
      remove-abandoned-timeout: 1800 # 超时时间(以秒数为单位)
      transaction-query-timeout: 6000 # 事务超时时间
      filters: stat,wall,log4j2
      useGlobalDataSourceStat: true #合并多个DruidDataSource的监控数据
      connectionProperties: druid.stat.mergeSql\=true;druid.stat.slowSqlMillis\=5000 #通过connectProperties属性来打开mergeSql功能；慢SQL记录

2.2.13.1.2、hikari

在spring boot2中引入jdbc的时候如果没有显式指定数据库连接池，默认使用的就是hikari连接池

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-jdbcartifactId>
dependency>

druid一样，可以使用默认参数

spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql:///:3306/数据库名?useSSL=false&useUnicode=true&characterEncoding=UTF-8
    username:
    password:
    type: com.zaxxer.hikari.HikariDataSource
    hikari:
    # 连接池中允许的最小连接数。缺省值：10
      minimum-idle: 10
    # 连接池中允许的最大连接数。缺省值：10
      maximum-pool-size: 100
    # 自动提交
      auto-commit: true
    # 一个连接idle状态的最大时长（毫秒），超时则被释放（retired），缺省:10分钟
      idle-timeout: 600
    # 连接池名字
      pool-name: 泡泡的HikariCP
    # 一 个连接的生命时长（毫秒），超时而且没被使用则被释放（retired），缺省:30分钟，建议设置比数据库超时时长少30秒
      max-lifetime: 1800000
    # 等待连接池分配连接的最大时长（毫秒），超过这个时长还没可用的连接则发生SQLException， 缺省:30秒
      connection-timeout: 30000    

2.2.13.2、在config中配置

initial-size: 10 # 初始化时建立物理连接的个数。初始化发生在显示调用init方法，或者第一次getConnection时
min-idle: 10 # 最小连接池数量
maxActive: 200 # 最大连接池数量
maxWait: 60000 # 获取连接时最大等待时间，单位毫秒。配置了maxWait之后，缺省启用公平锁，并发效率会有所下降，如果需要可以通过配置
timeBetweenEvictionRunsMillis: 60000 # 关闭空闲连接的检测时间间隔.Destroy线程会检测连接的间隔时间，如果连接空闲时间大于等于minEvictableIdleTimeMillis则关闭物理连接。
minEvictableIdleTimeMillis: 300000 # 连接的最小生存时间.连接保持空闲而不被驱逐的最小时间
validationQuery: SELECT 1 FROM DUAL # 验证数据库服务可用性的sql.用来检测连接是否有效的sql 因数据库方言而差, 例如 oracle 应该写成 SELECT 1 FROM DUAL
testWhileIdle: true # 申请连接时检测空闲时间，根据空闲时间再检测连接是否有效.建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRun
testOnBorrow: false # 申请连接时直接检测连接是否有效.申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。
testOnReturn: false # 归还连接时检测连接是否有效.归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。
poolPreparedStatements: true # 开启PSCache
maxPoolPreparedStatementPerConnectionSize: 20 #设置PSCache值
connectionErrorRetryAttempts: 3 # 连接出错后再尝试连接三次
breakAfterAcquireFailure: true # 数据库服务宕机自动重连机制
timeBetweenConnectErrorMillis: 300000 # 连接出错后重试时间间隔
asyncInit: true # 异步初始化策略
remove-abandoned: true # 是否自动回收超时连接
remove-abandoned-timeout: 1800 # 超时时间(以秒数为单位)
transaction-query-timeout: 6000 # 事务超时时间
filters: stat,wall,log4j2
useGlobalDataSourceStat: true #合并多个DruidDataSource的监控数据
connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000 #通过connectProperties属性来打开mergeSql功能；慢SQL记录

        DruidDataSource dataSource = DruidDataSourceBuilder.create().build();
        dataSource.setDriverClassName(DbProperties.slaveDriver);
        dataSource.setUsername(DbProperties.slaveUserName);
        dataSource.setPassword(DbProperties.slavePassword);
        dataSource.setUrl(DbProperties.slaveUrl);
        dataSource.setMaxWait(60000);
        dataSource.setMinEvictableIdleTimeMillis(300000);

2.2.14、多数据源配置的使用

• 1、使用 @DS 注解切换数据源时，使用springboot数据源的自动配置，需要将DataSourceConfig配置注释掉
• 2、使用 @DataSource 自定义注解时，排除springboot数据源的自动配置，引入DataSourceConfig配置

2.2.14.1、使用master主数据源（​​不需做任何操作​​，和之前单数据库一样）

import java.util.List;

import cn.xiyou.config.DataSource;
import cn.xiyou.config.DataSourceType;
import cn.xiyou.pojo.Dept;
import org.apache.ibatis.annotations.Param;

public interface DeptMapper   extends BaseMapper<Dept> {

  /**
   * xml 自定义的查询方法
   * 
   * @return
   */
  // @DataSource(value = DataSourceType.MASTER)
  List<Dept> findAll();

  List<Dept> findAllByOrgCode(@Param("orgCode") String orgCode);
  
}

@Service
public interface DeptServiceImpl  implements DeptService {

	@Autowired
   private DeptMapper deptMapper;
  /**
   *  使用 xml 自定义的查询方法
   * 
   * @return
   */
   public List<Dept> selectThreeTreeNode(String faultDate) {
   		return deptMapper.findAll();
   }
  /**
   *  使用 mybatis plus 的查询方法
   * 
   * @return
   */
   public List<Dept> list(String faultDate) {
   		return deptMapper.list();
   }

}

2.2.14.2、使用slave数据源

import cn.xiyou.config.DataSource;
import cn.xiyou.config.DataSourceType;
import cn.xiyou.pojo.ZTree;

import java.util.List;

public interface TreeMapper   extends BaseMapper<ZTree> {


  @DataSource(value = DataSourceType.SLAVE)
  List<ZTree> selectThreeTreeNode();

  @DataSource(value = DataSourceType.SLAVE)
  @Select("SELECT COUNT(*) AS total FROM HBUE_LOOKUP_VPLMN_OPERATOR")
  int findCount();

}

@Service
@DS("slave")
public interface TreeServiceImpl  implements TreeService {

	@Autowired
   private TreeMapper treeMapper;
  /**
   *  使用 xml 自定义的查询方法
   * 
   * @return
   */
   @DataSource(value = DataSourceType.SLAVE)
   public List<ZTree> selectThreeTreeNode(String faultDate) {
   		return treeMapper.selectThreeTreeNode();
   }

  /**
   *  使用 mybatis plus 的查询方法
   * 
   * @return
   */
   @DataSource(value = DataSourceType.SLAVE)
   public List<ZTree> list(String faultDate) {
   		return deptMapper.list();
   }

}

2.2.14.3、实现效果

2.2.14.4、 Q&A

2.2.14.4.1 @Transactional 和 @DS 注解一起使用时, @DS失效的问题

这是因为 @Transactional 开启事务后, 就不会重新拿数据源,因为@DS也得通过切面去获取数据源, 这样就导致了@DS失效.

要解决的话, 就在要切换数据源的方法上也打上@DS, 或者多个数据源有修改操作可以都打上事务注解并改变传播机制,(但这其实是分布式事务的范畴, 这样操作不能保证事务了, plus也提供了
@DSTransactional 来支持, 不够需要借助seata)

2.2.14.4.2 针对@Transactional与@DSTransactional做一个简单的解释。

@Transactional是spring的注解目的就是开启事务，所以在该注解被扫描到的时候就去获取DataSource，此时DynamicDataSourceContextHolder队列中无任务元素，所以获取到的dsKey就是null，之后通过DynamicRoutingDataSource方法中的determinePrimaryDataSource获取主库的DataSource。
@DSTransactional是mp中的注解，该注解下的所有@DS注解在invoke方法中向DynamicDataSourceContextHolder中压入元素，之后在获取determineDataSource的时候或获取到一个dsKey从而选择正确的DataSource。

2.2.14.4.3. 低于V3.3.3版本无法切换数据源的问题

这是因为在V3.3.3版本之前, DruidDataSourceAutoConfigure会比DynamicDataSourceAutoConfiguration先注册, 导致数据库有读取druid的配置, 所以会出现 ,没有druid配置启动报错; 数据源无法切换等等原因, 官方在V3.3.3这个版本修复了, 但是这个版本有个其他的重点bug,官方不让下载, 所以github上找不到这个版本的描述, 只在官网有描述

分两步解决的,

1、去除 druid pom坐标
2、在 DynamicDataSourceAutoConfiguration 上指定优于 DruidDataSourceAutoConfigure加载
解决办法就是排除DruidDataSourceAutoConfigure 类;

2.2.14.4.4、一般使用都是在需要切换数据库在使用中发现经常出现几个小问题，

1、发现配置多数据源之后批量执行的方法都走的主库。

2、针对相同库的事务如何处理。

3、针对不同库的事务如何处理。

在使用多数据源的时候可以开启debug日志查看在每次创建SqlSession之后选用的是哪个数据源。例如：

• 1、针对问题1，在使用mp的时候可能执行一些批量的方法，比如saveBatch等，进入saveBatch方法中可以看到在这个方法上默认有@Transactional注解，对于该注解默认使用的都是主库，所以对于从库的一些操作因为无法切换从库产生一些问题。解决方法：

针对问题1的：同一个源的批量操作，可以在外部方法使用@DS(“bbb”)优先指定需要操作的源。

针对问题1的：不同源的批量操作，可以考虑自己实现批量操作等。

• 2、针对问题2，针对相同库的事务，可以使用@DS与@Transactional搭配实现

• 3、针对问题3，这对不同库的事务，可以使用@DSTransactional实现

总结一些：对于mp的多数据源的事务或者查询问题首先看每次sql执行时选择的源，另外使用@DS与@Transactional与@DSTransactional三个注解基本可以解决遇到的事务失效等问题。

针对三个注解给一个描述语：

@DS：就是用来切换数据源

@Transactional：默认只针对主库

@DSTransactional：可以理解为在事务中可以切换数据源