springBoot-mybatis+druid多数据源

AbstractRoutingDataSource引入依赖配置文件动态数据源配置实体类mapper层servicecontrollersql文件

配置多数据源有多种方式，这里使用的是AOP动态代理的方式进行动态切换的。所谓的动态数据源就是，多个数据源，可以进行切换，比如读写分离，读是一个数据源，写又是一个数据源。不过使用这种方式配置的动态数据源不适合动态扩展，当需要新增数据源的时候，只能重启服务进行重新配置，当然也可以使用nacos配置中新做动态刷新，我只是想到可以怎么做，但是具体没有做过。

动态数据源最核心的就是AbstractRoutingDataSource 这个抽象类，我们只需要继承这个抽象类，然后重写 determineCurrentLookupKey()方法给他返回一个数据源名称就可以了，到时候他会根据你返回的数据源名称去resolvedDataSources这个map集合中找，resolvedDataSources这个map集合的key就是数据源名称，value对应的就是具体的数据库连接。

    @Nullable
    protected abstract Object determineCurrentLookupKey();

这个是父类的方法，我们在子类进行重写。到时候父类会调用determineTargetDataSource()方法确定目标数据源，然后就调用到子类的实现，这也是人家留给我们的一个扩展，让我能动态的确定数据源。

    protected DataSource determineTargetDataSource() {
        Assert.notNull(this.resolvedDataSources, "DataSource router not initialized");
        Object lookupKey = this.determineCurrentLookupKey();
        DataSource dataSource = (DataSource)this.resolvedDataSources.get(lookupKey);
        if (dataSource == null && (this.lenientFallback || lookupKey == null)) {
            dataSource = this.resolvedDefaultDataSource;
        }

        if (dataSource == null) {
            throw new IllegalStateException("Cannot determine target DataSource for lookup key [" + lookupKey + "]");
        } else {
            return dataSource;
        }
    }

		
			org.springframework.boot
			spring-boot-starter-web
		

		
			org.springframework.boot
			spring-boot-starter-test
			test
		

        
            org.mybatis.spring.boot
            mybatis-spring-boot-starter
            1.3.1
        

		
			org.springframework.boot
			spring-boot-starter-aop
		

		
			mysql
			mysql-connector-java
            8.0.18
		
        
        
            com.alibaba
            druid-spring-boot-starter
            1.2.8
        
        
            com.github.pagehelper
            pagehelper
            5.3.0
        

    

spring:
  datasource:
      master:
            driver-class-name: com.mysql.cj.jdbc.Driver
            type: com.alibaba.druid.pool.DruidDataSource
            url: jdbc:mysql://127.0.0.1:3306/db1?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&serverTimezone=UTC
            username: root
            password: root
      slave:
            driver-class-name: com.mysql.cj.jdbc.Driver
            type: com.alibaba.druid.pool.DruidDataSource
            url: jdbc:mysql://122.132.222.110:3306/db2?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&serverTimezone=GMT%2B8
            username: root
            password: root

mybatis:
    type-aliases-package: com.compass.mapper
    mapper-locations: classpath:mapper
    @Bean("master")
    @Primary
    @ConfigurationProperties(prefix = "spring.datasource.master")
    public DataSource master() {
         return new DruidDataSource();
    }

    
    @Bean("slave")
    @ConfigurationProperties(prefix = "spring.datasource.slave")
    public DataSource slave() {
      return new DruidDataSource();
    }

    
    @Bean("dynamicDataSource")
    public DataSource dynamicDataSource() {
        DynamicRoutingDataSource dynamicRoutingDataSource = new DynamicRoutingDataSource();
        Map dataSourceMap = new HashMap<>(2);
        dataSourceMap.put("master", master());
        dataSourceMap.put("slave", slave());
        // 将 master 数据源作为默认指定的数据源
        dynamicRoutingDataSource.setDefaultTargetDataSource(master());
        // 将 master 和 slave 数据源作为指定的数据源
        dynamicRoutingDataSource.setTargetDataSources(dataSourceMap);

        // 将数据源的 key 放到数据源上下文的 key 集合中，用于切换时判断数据源是否有效
        DynamicDataSourceContextHolder.dataSourceKeys.addAll(dataSourceMap.keySet());
        return dynamicRoutingDataSource;
    }

    

    
//    @Bean("sqlSessionFactoryBean")
    public SqlSessionFactoryBean sqlSessionFactoryBean() throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        // 配置数据源，此处配置为关键配置，如果没有将 dynamicDataSource 作为数据源则不能实现切换
        sqlSessionFactoryBean.setDataSource(dynamicDataSource());

        // 配置分页插件
        setPagePlugins(sqlSessionFactoryBean);

        // 配置mapper映射路径
        sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper
    @Bean("sqlSessionFactory")
    public SqlSessionFactory sqlSessionFactory() throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();

        sqlSessionFactoryBean.setDataSource(dynamicDataSource());

        // 配置分页插件
        setPagePlugins(sqlSessionFactoryBean);

        // 配置mapper映射路径
        org.apache.ibatis.session.Configuration configuration = new org.apache.ibatis.session.Configuration();
        configuration.setMapUnderscoreToCamelCase(true);
        sqlSessionFactoryBean.setConfiguration(configuration);
        sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper
    public void  setPagePlugins(SqlSessionFactoryBean sqlSessionFactoryBean){
        Properties properties = new Properties();
        properties.setProperty("reasonable", "true");
        properties.setProperty("supportMethodsArguments", "true");
        properties.setProperty("pageSizeZero", "true");

        PageInterceptor interceptor = new PageInterceptor();
        interceptor.setProperties(properties);

        sqlSessionFactoryBean.setPlugins(new Interceptor[]{interceptor});
    }


    
    @Bean
    public PlatformTransactionManager transactionManager() {
        return new DataSourceTransactionManager(dynamicDataSource());
    }
}

3.控制动态数据源的AOP切面

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;


@Aspect
// 该切面应当先于 @Transactional 执行
@Order(-1)
@Component
public class DynamicDataSourceAspect {
    
    // @annotation:用来拦截所有被某个注解修饰的方法
    @Before("@annotation(targetDataSource))")
    public void switchDataSource(JoinPoint point, TargetDataSource targetDataSource) {
        if (!DynamicDataSourceContextHolder.containDataSourceKey(targetDataSource.value())) {
            System.out.println("DataSource [{}] doesn't exist, use default DataSource [{}] " + targetDataSource.value());
        } else {
            // 切换数据源
            DynamicDataSourceContextHolder.setDataSourceKey(targetDataSource.value());
            System.out.println("Switch DataSource to [{}] in Method [{}] " +
                    DynamicDataSourceContextHolder.getDataSourceKey() + point.getSignature());
        }
    }

    
    @After("@annotation(targetDataSource))")
    public void restoreDataSource(JoinPoint point, TargetDataSource targetDataSource) {
        // 将数据源置为默认数据源
        DynamicDataSourceContextHolder.clearDataSourceKey();
        System.out.println("Restore DataSource to [{}] in Method [{}] " +
                DynamicDataSourceContextHolder.getDataSourceKey() + point.getSignature());
    }
}

4.动态数据源的封装

import java.util.ArrayList;
import java.util.List;


public class DynamicDataSourceContextHolder {

    
    private static final ThreadLocal contextHolder = new ThreadLocal() {

        
        @Override
        protected String initialValue() {
            return "master";
        }
    };


    
    public static List