记录springboot+druid多数据源配置，以及加载数据库配置新增数据源

关于boot +druid多数据源内容网上都有，随便百度一大堆，此文关键是在多数据源中动态从数据库加载数据源，网上大部分内容都是配置两个数据源使用两个数据源，现在项目需求两个数据源存储基础数据，业务数据更具业务场景，有多个数据库，具体不定，比如一个集体公司，下边每一个子公司都有自己独立的业务数据库，那么不能在配置文件中每个都添加，需要在数据库中维护，同时业务关联改子公司时需要查询改子公司的数据。

下面具体内容：

maven - pom.xml配置：包与其他的自己更改

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>xxx</groupId>
    <artifactId>xxx</artifactId>
    <version>2.0.1</version>
    <packaging>jar</packaging>

    <name>xxx</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.6.RELEASE</version>
        <relativePath />
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <mybatisplus-spring-boot-starter.version>1.0.4</mybatisplus-spring-boot-starter.version>
        <velocity.version>1.7</velocity.version>
        <activiti.version>5.22.0</activiti.version>
        <mssql-version>4.0</mssql-version>
        <poi-version>3.15</poi-version>
        <qcloudsms-version>1.0.6</qcloudsms-version>
        <lang3-version>3.6</lang3-version>
        <mybatis-version>3.4.4</mybatis-version>
        <spring-mybatis-version>1.1.1</spring-mybatis-version>
        <io-version>2.5</io-version>
        <shiro-version>1.3.2</shiro-version>
        <druid-version>1.1.18</druid-version>
        <fastjson-version>1.2.31</fastjson-version>
        <configuration-version>1.10</configuration-version>
        <quartz-version>2.2.1</quartz-version>
        <swagger2-version>2.6.1</swagger2-version>
        <extras-shiro-version>1.2.1</extras-shiro-version>
        <jsoup-version>1.9.2</jsoup-version>
    </properties>

    <dependencies>
        <!-- java poi以及所依赖的包 -->
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi</artifactId>
            <version>${poi-version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-ooxml</artifactId>
            <version>${poi-version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-ooxml-schemas</artifactId>
            <version>${poi-version}</version>
        </dependency>
        <!-- aes加密解密包 -->
        <dependency>
            <groupId>commons-codec</groupId>
            <artifactId>commons-codec</artifactId>
        </dependency>
        <dependency>
            <groupId>com.github.qcloudsms</groupId>
            <artifactId>qcloudsms</artifactId>
            <version>${qcloudsms-version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>${lang3-version}</version>
        </dependency>
        <!-- 读写xml -->
        <dependency>
            <groupId>dom4j</groupId>
            <artifactId>dom4j</artifactId>
        </dependency>
        <!-- 读写xml依赖的包 -->
        <dependency>
            <groupId>jaxen</groupId>
            <artifactId>jaxen</artifactId>
            <!-- <version>1.1-beta-9</version> -->
        </dependency>
        <!--mssql驱动-->
        <dependency>
            <groupId>com.microsoft.sqlserver</groupId>
            <artifactId>sqljdbc4</artifactId>
            <version>${mssql-version}</version>
        </dependency>
        <!-- sqlserver驱动 -->
        <dependency>
            <groupId>net.sourceforge.jtds</groupId>
            <artifactId>jtds</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <!--web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <!-- 移除嵌入式tomcat插件 -->
            <!-- <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-tomcat</artifactId>
                </exclusion>
            </exclusions> -->
        </dependency>
        <!-- <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <scope>provided</scope>
        </dependency> -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>net.sourceforge.nekohtml</groupId>
            <artifactId>nekohtml</artifactId>
        </dependency>
        <!--mysql -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>${mybatis-version}</version>
        </dependency>
        <!--mybatis-spring-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>${spring-mybatis-version}</version>
        </dependency>
        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <!-- 连接池 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>${druid-version}</version>
        </dependency>
        <dependency>
            <groupId>commons-configuration</groupId>
            <artifactId>commons-configuration</artifactId>
            <version>${configuration-version}</version>
        </dependency>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>${io-version}</version>
        </dependency>
        <!--shiro -->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-core</artifactId>
            <version>${shiro-version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
            <version>${shiro-version}</version>
        </dependency>
        <!-- shiro ehcache -->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-ehcache</artifactId>
            <version>${shiro-version}</version>
        </dependency>
        <dependency>
            <groupId>com.github.theborakompanioni</groupId>
            <artifactId>thymeleaf-extras-shiro</artifactId>
            <version>${extras-shiro-version}</version>
        </dependency>
        <!-- utils -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>${fastjson-version}</version>
        </dependency>
        <!--velocity代码生成使用模板 -->
        <dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity</artifactId>
            <version>${velocity.version}</version>
        </dependency>
        <!-- ehchache -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>
        <dependency>
            <groupId>net.sf.ehcache</groupId>
            <artifactId>ehcache</artifactId>
        </dependency>
        <!--<dependency> -->
        <!--<groupId>org.springframework.boot</groupId> -->
        <!--<artifactId>spring-boot-starter-data-redis</artifactId> -->
        <!--</dependency> -->
        <!-- quartz -->
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>${quartz-version}</version>
            <exclusions>
                <exclusion>
                    <artifactId>slf4j-api</artifactId>
                    <groupId>org.slf4j</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <!-- SpringWebSocket依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-websocket</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
        </dependency>
        <!--activiti -->
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-engine</artifactId>
            <version>${activiti.version}</version>
        </dependency>

        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-spring</artifactId>
            <version>${activiti.version}</version>
        </dependency>
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-modeler</artifactId>
            <version>${activiti.version}</version>
        </dependency>
        <dependency>
            <groupId>org.activiti</groupId>
            <artifactId>activiti-diagram-rest</artifactId>
            <version>${activiti.version}</version>
        </dependency>

        <!--swagger2 -->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>${swagger2-version}</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>${swagger2-version}</version>
        </dependency>

        <!-- 添加redis支持 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

        <!-- xss过滤组件 -->
        <dependency>
            <groupId>org.jsoup</groupId>
            <artifactId>jsoup</artifactId>
            <version>${jsoup-version}</version>
        </dependency>

        <!--<dependency> -->
        <!--<groupId>org.crazycake</groupId> -->
        <!--<artifactId>shiro-redis</artifactId> -->
        <!--<version>2.4.2.1-RELEASE</version> -->
        <!--</dependency> -->
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <executable>true</executable>
                </configuration>
            </plugin>
        </plugins>
    </build>
    <repositories>
        <repository>
            <id>public</id>
            <name>aliyun nexus</name>
            <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
            <releases>
                <enabled>true</enabled>
            </releases>
        </repository>
    </repositories>

    <pluginRepositories>
        <pluginRepository>
            <id>public</id>
            <name>aliyun nexus</name>
            <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </pluginRepository>
    </pluginRepositories>
</project>

boot 中数据源配置：只给了数据源配置内容，其他配置按自己需求填写

spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.microsoft.sqlserver.jdbc.SQLServerDriver
    druid:
      default:
        url: jdbc:sqlserver://192.168.10.152:1433;DatabaseName=2.0
        username: sa
        password: sa123
        connection-error-retry-attempts: 1
        break-after-acquire-failure: true
      two:
        url: jdbc:sqlserver://192.168.10.152:1433;DatabaseName=-DATA
        username: sa
        password: sa123
        connection-error-retry-attempts: 0
        break-after-acquire-failure: trueinitial-size: 1
    minIdle: 3
    maxActive: 20
    # 配置获取连接等待超时的时间
    maxWait: 60000
    # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
    timeBetweenEvictionRunsMillis: 60000
    # 配置一个连接在池中最小生存的时间，单位是毫秒
    minEvictableIdleTimeMillis: 30000
    validationQuery: select 'x'
    testWhileIdle: true
    testOnBorrow: false
    testOnReturn: false
    # 打开PSCache，并且指定每个连接上PSCache的大小
    poolPreparedStatements: true
    maxPoolPreparedStatementPerConnectionSize: 20
    # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
    filters: stat,wall,slf4j
    # 通过connectProperties属性来打开mergeSql功能；慢SQL记录
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
    # 合并多个DruidDataSource的监控数据
    #useGlobalDataSourceStat: true

 需要一个dbconfig的配置类：

import com.alibaba.druid.pool.DruidAbstractDataSource;
import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
import com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter;
import com.alibaba.druid.wall.WallConfig;
import com.alibaba.druid.wall.WallFilter;

import com.xx.common.utils.DataSourceNames;
import com.xx.common.utils.SpringContextHolder;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
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 DruidDBConfig {
    public static Map<Object, Object> targetDataSources = new HashMap<>();

    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.druid.default")
    public DataSource oneDataSource() {
        DataSource dataSource = DruidDataSourceBuilder.create().build();
        return dataSource;
    }

    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.druid.two")
    public DataSource twoDataSource() {
        DataSource dataSource = DruidDataSourceBuilder.create().build();
        return dataSource;
    }

    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.druid.other")
    public DataSource otherDataSource() {
        DataSource dataSource = DruidDataSourceBuilder.create().build();
        return dataSource;
    }

    /**
     * 动态创建新的数据源
     * 
     * @param name
     * @param url
     * @param username
     * @param password
     * @param driver
     * @return
     */
    @ConfigurationProperties(prefix = "spring.datasource")
    public DruidDataSource createDataSource(String name, String url, String username, String password, String driver) {
        DruidDataSource source = (DruidDataSource) DruidDataSourceBuilder.create().build();
        source.setUrl(url);
        source.setUsername(username);
        source.setPassword(password);
        source.setDriverClassName(driver);
        targetDataSources.put(name, source);
        SpringContextHolder.getBean(DynamicDataSource.class).refreshDataSource();
        return source;
    }

    @Bean
    @Primary
    public DynamicDataSource dataSource(DataSource oneDataSource, DataSource twoDataSource,
            DataSource otherDataSource) {
        targetDataSources.put(DataSourceNames.DEFAULT, oneDataSource);
        targetDataSources.put(DataSourceNames.TWO, twoDataSource);
        targetDataSources.put(DataSourceNames.OTHER, otherDataSource);
        // 还有数据源,在targetDataSources中继续添加
        System.out.println("DataSources:" + targetDataSources);
        return new DynamicDataSource(oneDataSource, targetDataSources);
    }

    public Map<Object, Object> getTargetDataSources() {
        return targetDataSources;
    }

    @Bean
    public ServletRegistrationBean druidServlet() {
        ServletRegistrationBean reg = new ServletRegistrationBean();
        reg.setServlet(new StatViewServlet());
        reg.addUrlMappings("/druid/*");
        reg.addInitParameter("allow", ""); // 白名单
        return reg;
    }

    @Bean
    public FilterRegistrationBean filterRegistrationBean() {
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
        filterRegistrationBean.setFilter(new WebStatFilter());
        filterRegistrationBean.addUrlPatterns("/*");
        filterRegistrationBean.addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
        filterRegistrationBean.addInitParameter("profileEnable", "true");
        filterRegistrationBean.addInitParameter("principalCookieName", "USER_COOKIE");
        filterRegistrationBean.addInitParameter("principalSessionName", "USER_SESSION");
        filterRegistrationBean.addInitParameter("DruidWebStatFilter", "/*");
        return filterRegistrationBean;
    }

    @Bean
    public WallFilter wallFilter() {

        WallFilter wallFilter = new WallFilter();

        wallFilter.setConfig(wallConfig());

        return wallFilter;

    }

    @Bean
    public WallConfig wallConfig() {

        WallConfig config = new WallConfig();

        config.setMultiStatementAllow(true);// 允许一次执行多条语句

        config.setNoneBaseStatementAllow(true);// 允许非基本语句的其他语句

        return config;

    }
}

在此配置类中关键是 createDataSource() 方法；在此方法中调用了一个方法： SpringContextHolder.getBean(DynamicDataSource.class).refreshDataSource();

继续上代码：

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

import com.xx.common.utils.SpringContextHolder;

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


public class DynamicDataSource extends AbstractRoutingDataSource {
    private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();

    /**
     * 配置DataSource, defaultTargetDataSource为主数据库
     */
    public DynamicDataSource(DataSource defaultTargetDataSource, Map<Object, Object> targetDataSources) {
        super.setDefaultTargetDataSource(defaultTargetDataSource);
        super.setTargetDataSources(targetDataSources);
        super.afterPropertiesSet();
    }

    public void refreshDataSource() {
        DruidDBConfig dbConfig = SpringContextHolder.getBean(DruidDBConfig.class);
        super.setTargetDataSources(dbConfig.getTargetDataSources());
        super.afterPropertiesSet();
    }

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

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

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

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

标红的方法是让druid重新加载数据源，在druid中重新加载数据源原有的数据连接是不会丢失的。

以上两个方法是核心，其他网上给的都是配置两个或多个数据源，没有新建数据源，并让druid重新加载数据源。

注解：DataSource

import java.lang.annotation.*;

@Documented
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface DataSource {
    String value() default DataSourceNames.DEFAULT;
}

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
import com.xx.common.annotation.DataSource;
import com.xx.common.config.ApplicationContextRegister;
import com.xx.common.config.DruidDBConfig;
import com.xx.common.config.DynamicDataSource;
import com.xx.common.utils.DataSourceNames;
import com.xx.common.utils.HttpContextUtils;
import com.xx.common.utils.SpringContextHolder;
import com.xx.common.utils.StringUtils;
import com.xx.system.domain.SiteDO;
import com.xx.system.service.SiteService;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;


@Component
@Aspect
public class DataSourceAspect implements Ordered {
    @Autowired
    private SiteService siteService;

    protected Logger logger = LoggerFactory.getLogger(getClass());

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

    @Pointcut("@annotation(com.xx.common.annotation.DataSource)")
    public void dataSourcePointCut() {

    }

    @Before("dataSourcePointCut()")
    public void doBefore(JoinPoint joinPoint) {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        logger.info("方法名称: " + method.getName());
        DataSource dataSource = method.getAnnotation(DataSource.class);
        DruidDBConfig dynamicDataSourceConfig = SpringContextHolder.getBean(DruidDBConfig.class);
        Map<Object, Object> map = dynamicDataSourceConfig.getTargetDataSources();
        // 通过判断 DataSource 中的值来判断当前方法应用哪个数据源
        String value = dataSource.value();
        boolean flag;
        String name = "";
        switch (value) {
        case DataSourceNames.DEFAULT:
            flag = true;
            name = DataSourceNames.DEFAULT;
            break;
        case DataSourceNames.TWO:
            flag = true;
            name = DataSourceNames.TWO;
            break;
        case DataSourceNames.OTHER:
            flag = true;
            /**
             * 动态设定数据源，先着HttpServletRequest的参数中获取数据源连接id，如果获取不到从session中获取，
             * 这个可以自定义获取方法，redis，cacheT等都可以
             * 
             * 在根据id获取数据源，如果存在返回直接使用，如果不存在，新建一个数据源，并让重新加载数据源。
             */
            Long requestSid = HttpContextUtils.getRequestSid();
            name = requestSid.toString();
            if (map.get(name) != null) {
                break;
            } else {
                SiteDO site = siteService.get(requestSid);
                String url = "jdbc:sqlserver://" + site.getDbhost() + ":" + site.getDbport() + ";DatabaseName="
                        + site.getDbname();
                logger.info("数据源切换：" + url);
                DruidDataSource s = dynamicDataSourceConfig.createDataSource(name, url, site.getDbuser(),
                        site.getDbpwd(), "com.microsoft.sqlserver.jdbc.SQLServerDriver");
            }
            break;
        default:
            flag = false;
            break;
        }

        if (!flag) {
            logger.error("************注意************");
            name = DataSourceNames.DEFAULT;
            logger.info("加载到未知数据源，系统自动设置数据源为默认数据源！");
        }
        DynamicDataSource.setDataSource(name);
        logger.info("当前数据源: " + name);
        logger.info("当前数据源: " + ((DruidDataSource) map.get(name)).getUrl());
        logger.info("set datasource is " + name);
    }

    @After("dataSourcePointCut()")
    public void doAfter() {
        logger.info("*********准备清除数据源*********");
        DynamicDataSource.clearDataSource();
        logger.info("*********数据源清除成功*********");
    }

}

使用：默认数据源不用管，如果是配置数据源直接使用

import com.xx.common.annotation.DataSource;
import com.xx.common.utils.DataSourceNames;
import com.xx.demo.domain.User;
import com.xx.demo.service.UserService1;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.List;



@Controller
@RequestMapping
public class TestController {

    @Autowired
    private UserService1 userService1;
    /**
     * 默认的,不用注解也可以
     * @return
     */
    @GetMapping("/test/1")
    @ResponseBody
    //@DataSource(DataSourceNames.DEFAULT)
    List<User> test1(){
        return userService1.test1(12);
    }
    /**
     * 配置的
     * @return
     */
    @GetMapping("/test/2")
    @ResponseBody
    @DataSource(DataSourceNames.TWO)
    List<User> test2(){
        return userService1.test2(12);
    }
    /**
     * 数据库的
     * @return
     */
    @GetMapping("/test/3")
    @ResponseBody
    @DataSource(DataSourceNames.OTHER)
    List<User> test3(){
        return userService1.test3(12);
    }
}

其他utils：

HttpContextUtils 

import javax.servlet.http.HttpServletRequest;

import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

public class HttpContextUtils {
    public static HttpServletRequest getHttpServletRequest() {
        return ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
    }

    public static Long getRequestSid() {
        Long sid = 1L;
        HttpServletRequest request = getHttpServletRequest();
        String parameter = request.getParameter("sid");
        if (StringUtils.isEmpty(parameter)) {
            sid = (Long) request.getSession().getAttribute("sid");
        } else {
            sid = Long.valueOf(parameter);
        }
        return sid == null ? 1 : sid;
    }

}

DataSourceNames 此类可以使用枚举，常量类等。

public interface DataSourceNames {
    String DEFAULT = "DEFAULT";
    String TWO = "TWO";
    String OTHER = "OTHER";
}