配置SqlServer多数据源，根据选择的组织切换访问库

###本文采用注解的方式，有改进的请告诉我！ps:我这个有点啰嗦~

不指定方法访问某个类，根据前端选择而动态切换！！！看清楚！！！

方法指定访问哪个数据库的可以参考：

spring boot使用AbstractRoutingDataSource实现动态数据源切换_ChaseDreamBoy的博客-CSDN博客

pom文件，我是用的SqlServer

 <!-- SQL Server -->
        <dependency>
            <groupId>com.microsoft.sqlserver</groupId>
            <artifactId>mssql-jdbc</artifactId>
            <version>9.4.0.jre11</version>
        </dependency>

application.yml配置

spring:
  datasource:
    driver-class-name: com.microsoft.sqlserver.jdbc.SQLServerDriver
    druid:
#      数据源1
      first:
        url: jdbc:sqlserver://localhost:1433;database=test1
        username: root
        password: root
#      数据源2
      second:
        url: jdbc:sqlserver://localhost:1433;database=test2
        username: root
        password: root

定义一个CurDataSource注解类

import java.lang.annotation.*;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface CurDataSource {

}

新建常量存储于获取数据源,DataSourceNames 

/**
 * 增加多数据源，在此配置
 */
public interface DataSourceNames {
    String FIRST = "first";

    String SECOND = "second";

    String YN = "112";

    String ZB = "100";
}

新建类 DynamicDataSource

DynamicDataSource扩展Spring的AbstractRoutingDataSource抽象类，重写 determineCurrentLookupKey() 方法

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

import javax.sql.DataSource;
import java.util.Map;

/**
 * 扩展 Spring 的 AbstractRoutingDataSource 抽象类，重写 determineCurrentLookupKey 方法
 * 动态数据源
 * determineCurrentLookupKey() 方法决定使用哪个数据源
 **/
public class DynamicDataSource extends AbstractRoutingDataSource {
    /**
     * ThreadLocal 用于提供线程局部变量，在多线程环境可以保证各个线程里的变量独立于其它线程里的变量。
     * 也就是说 ThreadLocal 可以为每个线程创建一个【单独的变量副本】，相当于线程的 private static 类型变量。
     */
    private static final ThreadLocal<String> CONTEXT_HOLDER = new ThreadLocal<>();

    /**
     * 决定使用哪个数据源之前需要把多个数据源的信息以及默认数据源信息配置好
     *
     * @param defaultTargetDataSource 默认数据源
     * @param targetDataSources       目标数据源
     */
    public DynamicDataSource(DataSource defaultTargetDataSource, Map<Object, Object> targetDataSources) {
        super.setDefaultTargetDataSource(defaultTargetDataSource);
        super.setTargetDataSources(targetDataSources);
        super.afterPropertiesSet();
    }

    @Override
    protected Object determineCurrentLookupKey() {
        return getDataSource();
    }

    public static void setDataSource(String dataSource) {
        CONTEXT_HOLDER.set(dataSource);
    }

    public static String getDataSource() {
        return CONTEXT_HOLDER.get();
    }

    public static void clearDataSource() {
        CONTEXT_HOLDER.remove();
    }

}

新建多数据源配置类

配置多数据源的信息，生成多个(我这里是两个，对应application.yml中定义的数据源)数据源

import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;

@Configuration
public class DynamicDataSourceConfig {
    @Bean
    @ConfigurationProperties("spring.datasource.druid.first")
    public DataSource firstDataSource(){

        return DruidDataSourceBuilder.create().build();
    }

    @Bean
    @ConfigurationProperties("spring.datasource.druid.second")
    public DataSource secondDataSource(){
        return DruidDataSourceBuilder.create().build();
    }

    @Bean
    @Primary
    public DynamicDataSource dataSource(DataSource firstDataSource, DataSource secondDataSource) {
        Map<Object, Object> targetDataSources = new HashMap<>(5);
        targetDataSources.put(DataSourceNames.FIRST, firstDataSource);
        targetDataSources.put(DataSourceNames.SECOND, secondDataSource);
        return new DynamicDataSource(firstDataSource, targetDataSources);
    }
}

采用aop的方式，在需要修改数据源的地方使用注解方式去切换，然后切面修改ThreadLocal的内容

import lombok.extern.slf4j.Slf4j;
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.springframework.core.Ordered;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;
import java.util.stream.IntStream;

/**
 * 多数据源，切面处理类
 */
@Slf4j
@Aspect
@Component
public class DataSourceAspect implements Ordered {


    @Pointcut("@annotation(com.dingtalk.db.CurDataSource)")
    public void dataSourcePointCut() {

    }

    @Around("dataSourcePointCut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        MethodSignature signature = (MethodSignature) point.getSignature();
        Method method = signature.getMethod();
        method.getAnnotation(CurDataSource.class);

        String orgNo = null;
        String[] parameterNames = signature.getParameterNames();
        int orgIndex = IntStream.range(0, parameterNames.length)
                .filter(i -> parameterNames[i].equals("orgNo"))
                .findFirst()
                .orElse(-1);
        if (orgIndex >= 0) {
            orgNo = (String) point.getArgs()[orgIndex];
        }

        if (orgNo.equals(DataSourceNames.ZB)) {
            DynamicDataSource.setDataSource(DataSourceNames.FIRST);
        } else if (orgNo.equals(DataSourceNames.YN)){
            DynamicDataSource.setDataSource(DataSourceNames.SECOND);
        }

        try {
            return point.proceed();
        } finally {
            DynamicDataSource.clearDataSource();
            log.debug("clean datasource");
        }
    }

    @Override
    public int getOrder() {
        return 1;
    }
}

service中使用，直接在需要用到的方法上加上@CurDataSource注解，（我用的是orgNo去切面处理访问哪个数据库，所以哪怕没有用到都要把这个值带上，不然在DataSourceAspect类中获取不到这个，不知道orgNo是什么）