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

一、前言

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

二、Springboot + MyBatis Plus 数据源配置

2.1、单数据源配置

2.1.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>

2.1.2、application.yml 配置

spring:datasource:url: jdbc:mysql://localhost:3306/db1?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai&useSSL=falseusername: rootpassword: 123456driver-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><!-- 集成druid连接池 --><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:# 设置默认的数据源或者数据源组,默认值为masterprimary: master# 严格匹配数据源,默认false,true未匹配到指定数据源时抛异常,false使用默认数据源strict: falsedatasource:master:url: jdbc:mysql://localhost:3306/test?serverTimezone=GMT%2B8&characterEncoding=utf-8&userSSL=falsedriver-class-name: com.mysql.cj.jdbc.Driverusername: rootpassword: 123456slave_1:url: jdbc:mysql://localhost:3306/demo?serverTimezone=GMT%2B8&characterEncoding=utf-8&userSSL=falsedriver-class-name: com.mysql.cj.jdbc.Driverusername: 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 {@Overrideprotected 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;  @Overridepublic 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();}@Overrideprotected 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());}}};@Overridepublic String dynamicTableName(String sql, String tableName) {if(tablelist.contains(tableName)){return DbProperties.slaveSchema + "." + tableName;}else {return DbProperties.masterSchema + "." + tableName;}}}   

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.Driverurl: jdbc:mysql:///:3306/数据库名?useSSL=false&useUnicode=true&characterEncoding=UTF-8username:password:type: com.alibaba.druid.pool.DruidDataSourcedruid: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 DUALtestWhileIdle: true # 申请连接时检测空闲时间，根据空闲时间再检测连接是否有效.建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRuntestOnBorrow: false # 申请连接时直接检测连接是否有效.申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。testOnReturn: false # 归还连接时检测连接是否有效.归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。poolPreparedStatements: true # 开启PSCachemaxPoolPreparedStatementPerConnectionSize: 20 #设置PSCache值connectionErrorRetryAttempts: 3 # 连接出错后再尝试连接三次breakAfterAcquireFailure: true # 数据库服务宕机自动重连机制timeBetweenConnectErrorMillis: 300000 # 连接出错后重试时间间隔asyncInit: true # 异步初始化策略remove-abandoned: true # 是否自动回收超时连接remove-abandoned-timeout: 1800 # 超时时间(以秒数为单位)transaction-query-timeout: 6000 # 事务超时时间filters: stat,wall,log4j2useGlobalDataSourceStat: 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.Driverurl: jdbc:mysql:///:3306/数据库名?useSSL=false&useUnicode=true&characterEncoding=UTF-8username:password:type: com.zaxxer.hikari.HikariDataSourcehikari:# 连接池中允许的最小连接数。缺省值：10minimum-idle: 10# 连接池中允许的最大连接数。缺省值：10maximum-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 {@Autowiredprivate 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 {@Autowiredprivate 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、实现效果

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