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

一、前言

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

二、Springboot + MyBatis Plus 数据源配置

2.1、单数据源配置

2.1.1、引用依赖

com.baomidoumybatis-plus-boot-starter3.5.1mysqlmysql-connector-java8.0.28

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、引用依赖

com.baomidoumybatis-plus-boot-starter3.5.1mysqlmysql-connector-java8.0.28              com.alibaba        druid-spring-boot-starter        1.2.9   com.baomidoudynamic-datasource-spring-boot-starter3.1.0

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)@Documentedpublic @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 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 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@Configurationpublic 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 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 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)@Componentpublic 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 ignoreTabs=new ArrayList(){        {            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 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

          com.alibaba        druid-spring-boot-starter        {druid.version}        

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连接池

    org.springframework.boot    spring-boot-starter-jdbc

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 {  /**   * xml 自定义的查询方法   *    * @return   */  // @DataSource(value = DataSourceType.MASTER)  List findAll();  List findAllByOrgCode(@Param("orgCode") String orgCode);  }

  @Servicepublic interface DeptServiceImpl  implements DeptService {@Autowired   private DeptMapper deptMapper;  /**   *  使用 xml 自定义的查询方法   *    * @return   */   public List selectThreeTreeNode(String faultDate) {   return deptMapper.findAll();   }  /**   *  使用 mybatis plus 的查询方法   *    * @return   */   public List 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 {  @DataSource(value = DataSourceType.SLAVE)  List 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 selectThreeTreeNode(String faultDate) {   return treeMapper.selectThreeTreeNode();   }  /**   *  使用 mybatis plus 的查询方法   *    * @return   */   @DataSource(value = DataSourceType.SLAVE)   public List 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：可以理解为在事务中可以切换数据源