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

待我称王封你为后i 2024-02-21 11:09 55阅读 0赞

## 一、前言 ##

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

## 二、Springboot + MyBatis Plus 数据源配置 ##

### 2.1、单数据源配置 ###

#### 2.1.1、引用依赖 ####

#### 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.baomidou</groupId>
    		<artifactId>mybatis-plus-boot-starter</artifactId>
    		<version>3.5.1</version>
    	</dependency>
    	<dependency>
    		<groupId>mysql</groupId>
    		<artifactId>mysql-connector-java</artifactId>
    		<version>8.0.28</version>
    	</dependency>
       
       <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.2.9</version>
       </dependency>	
    	
    	<dependency>
    		<groupId>com.baomidou</groupId>
    		<artifactId>dynamic-datasource-spring-boot-starter</artifactId>
    		<version>3.1.0</version>
    	</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、通用配置类 ####

#### 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 ####

> 我这边配置这个是因为存在跨账号查询数据库表的情况,这里请根据实际项目情况配置，没有这种需求请跳过

public enum HbueDBEnum {
        
    
        HMVNO_LOOKUP_DP_ZONE_OPER,
        HBUE_LOOKUP_VPLMN_OPERATOR,
        HMVNO_LOOKUP_SDR_RATE,
        HMVNO_LOOKUP_MSP_EVENT_PLAN,
        HMVNO_LOOKUP_TOPUP_AMOUNT;
    }

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 MonthTableNameHandler implements TableNameHandler {
        
    
        private final List<String> tablelist=new ArrayList<String>(){
        
            {
        
                for (HbueDBEnum tables : HbueDBEnum.values()) {
        
                    add(tables.name());
                }
            }
        };
    
    
        @Override
        public String dynamicTableName(String sql, String tableName) {
        
            if(tablelist.contains(tableName)){
        
                return DbProperties.slaveSchema + "." + tableName;
            }else {
        
                return DbProperties.masterSchema + "." + tableName;
            }
        }
     }

![在这里插入图片描述][f6dc7451b1664591b55bdf1825b88b6b.png]  
![在这里插入图片描述][d08ff9f82ff4487fa3735a4128000164.png]

#### 2.2.12、数据源关闭连接问题 ####

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

##### 2.2.12.1、application.yml 配置 #####

###### 2.2.12.1.1、druid ######

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

<dependency>
           <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <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.12.1.2、hikari ######

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

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
    </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.12.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.13、多数据源配置的使用 ####

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

##### 2.2.13.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.13.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.13.3、实现效果 #####

![在这里插入图片描述][d724b3c41d1d4278ab296cbe00e5cd94.png]

##### 2.2.13.4、 Q&A #####

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

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

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

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

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

###### 2.2.13.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.13.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：可以理解为在事务中可以切换数据源

[f6dc7451b1664591b55bdf1825b88b6b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/21/04d1c7dffa2245e3a0a6fe470d62cb9f.png
[d08ff9f82ff4487fa3735a4128000164.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/21/4cbab4703b8249f98647882963678b5c.png
[d724b3c41d1d4278ab296cbe00e5cd94.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/21/e98c1b40227a4915929e9e893b80ed38.png