SpringBoot配置多个数据源（不同的）

首先添加依赖包：

com.microsoft.sqlserver
sqljdbc4
4.0

不然启动会提示错误：找不到驱动

配置文件（配置文件的要求很严格不然会参数注入失败甚至不会连接
spring:
datasource:
type:
master:
url，这些层次要分明）：

spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    master:
      url: jdbc:mysql://地址:端口号/usthe?useUnicode=true&characterEncoding=utf-8&useSSL=false
      username: root
      password: root
      driver-class-name: com.mysql.jdbc.Driver
      platform: mysql
      initialSize: 1
      minIdle: 1
      maxActive: 20
      # 配置获取连接等待超时的时间
      maxWait: 60000
      # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
      timeBetweenEvictionRunsMillis: 60000
      # 配置一个连接在池中最小生存的时间，单位是毫秒
      minEvictableIdleTimeMillis: 300000
      validationQuery: select 1
      testWhileIdle: true
      testOnBorrow: false
      testOnReturn: false
      # 打开PSCache，并且指定每个连接上PSCache的大小
      poolPreparedStatements: false
      maxPoolPreparedStatementPerConnectionSize: 20
      # 配置监控统计拦截的filters，stat用于监控界面，'wall'用于防火墙防御sql注入, slf4j用于druid记录sql日志
      #      filters: stat,slf4j,wall
      filters: stat,slf4j
      # 通过connectProperties属性来打开mergeSql功能；慢SQL记录
      connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
      # 合并多个DruidDataSource的监控数据
      useGlobalDataSourceStat: false
    #      type: com.alibaba.druid.pool.DruidDataSource
    //这里特别说清楚格式一定要严格，否则回去不到数据，这个是SqlService数据库的配置
      third:
        url: jdbc:sqlserver://ip地址:端口;/表名?DatabaseName=true
        username: 用户名
        password: 密码
        //驱动
        driver-class-name: com.microsoft.sqlserver.jdbc.SQLServerDriver

连接代码：使用了连接池，此后在连接其他数据源只要修改路径、账号和密码即可

package com.bsj.sim.config.database;

import com.alibaba.druid.filter.Filter;
import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.wall.WallConfig;
import com.alibaba.druid.wall.WallFilter;
import com.bsj.sim.util.mybatis.DataSourceEnv;
import com.bsj.sim.util.mybatis.MybatisFactory;
import org.apache.ibatis.datasource.pooled.PooledDataSource;
import org.apache.ibatis.mapping.Environment;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;

import javax.sql.DataSource;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;


@Configuration
@MapperScan(basePackages = DataSourceConfiguration.PACKAGE, sqlSessionFactoryRef = "masterSqlSessionFactory")
public class DataSourceConfiguration {

    // 当前这个包精确到 master 目录，以便跟其他数据源隔离
    static final String PACKAGE = "com.bsj.sim.mapper";
    //必须在com.bsj.sim.mapper包下的xml格式
    static final String MAPPER_LOCATION = "classpath:mapper/*.xml";

    private static final Logger logger = LoggerFactory.getLogger(DataSourceConfiguration.class);

    static DataSourceEnv env = DataSourceEnv.base;

    static DataSourceEnv report = DataSourceEnv.reportBase;

    @Value("${spring.datasource.url}")
    private String url;
    @Value("${spring.datasource.username}")
    private String userName;
    @Value("${spring.datasource.password}")
    private String password;
    @Value("${spring.datasource.master.driver-class-name}")
    private String driver;
    @Value("${spring.datasource.master.maxActive}")
    private int maxActive;
    @Value("${spring.datasource.master.filters}")
    private String filters;
    @Value("${spring.datasource.master.initialSize}")
    private int initialSize;
    @Value("${spring.datasource.master.minIdle}")
    private int minIdle;
    @Value("${spring.datasource.master.maxWait}")
    private int maxWait;
    @Value("${spring.datasource.master.timeBetweenEvictionRunsMillis}")
    private int timeBetweenEvictionRunsMillis;
    @Value("${spring.datasource.master.minEvictableIdleTimeMillis}")
    private int minEvictableIdleTimeMillis;
    @Value("${spring.datasource.master.validationQuery}")
    private String validationQuery;
    @Value("${spring.datasource.master.testWhileIdle}")
    private boolean testWhileIdle;
    @Value("${spring.datasource.master.testOnBorrow}")
    private boolean testOnBorrow;
    @Value("${spring.datasource.master.testOnReturn}")
    private boolean testOnReturn;
    @Value("${spring.datasource.master.poolPreparedStatements}")
    private boolean poolPreparedStatements;
    @Value("${spring.datasource.master.maxPoolPreparedStatementPerConnectionSize}")
    private int maxPoolPreparedStatementPerConnectionSize;
    @Value("${spring.datasource.master.connectionProperties}")
    private String connectionProperties;
    @Value("${spring.datasource.master.useGlobalDataSourceStat}")
    private boolean useGlobalDataSourceStat;

    @Bean     //声明其为Bean实例
    @Primary  //在同样的DataSource中，首先使用被标注的DataSource
    public DruidDataSource dataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        /*数据源主要配置*/
        dataSource.setUrl(url);
        dataSource.setUsername(userName);
        dataSource.setPassword(password);
        dataSource.setDriverClassName(driver);

        /*数据源补充配置*/
        dataSource.setMaxActive(maxActive);
        dataSource.setInitialSize(initialSize);
        dataSource.setMinIdle(minIdle);
        dataSource.setMaxWait(maxWait);
        dataSource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
        dataSource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
        dataSource.setValidationQuery(validationQuery);
        dataSource.setTestOnBorrow(testOnBorrow);
        dataSource.setTestOnReturn(testOnReturn);
        dataSource.setTestWhileIdle(testWhileIdle);
        dataSource.setPoolPreparedStatements(poolPreparedStatements);
        dataSource.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);
        dataSource.setConnectionProperties(connectionProperties);
        dataSource.setUseGlobalDataSourceStat(useGlobalDataSourceStat);
        try {
            dataSource.setFilters(filters);
        } catch (SQLException e) {
            System.err.println("druid configuration initialization filter: " + e);
        }
        dataSource.setConnectionProperties(connectionProperties);
        //多语句
        WallConfig wallConfig = new WallConfig();
        wallConfig.setMultiStatementAllow(true);
        WallFilter wallFilter = new WallFilter();
        wallFilter.setConfig(wallConfig);
        List<Filter> filters1 = new ArrayList<>();
        filters1.add(wallFilter);
        dataSource.setProxyFilters(filters1);
        return dataSource;
    }

    @Bean(name = "masterTransactionManager")
    @Primary
    public DataSourceTransactionManager masterTransactionManager() {
        return new DataSourceTransactionManager(dataSource());
    }

    @Bean(name = "masterSqlSessionFactory")
    @Primary
    public SqlSessionFactory masterSqlSessionFactory(@Qualifier("dataSource") DataSource masterDataSource)
            throws Exception {
        final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(masterDataSource);
        sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver()
                .getResources(DataSourceConfiguration.MAPPER_LOCATION));
        return sessionFactory.getObject();
    }

}

这是配置SqlService的配置类

package com.bsj.pmc.config.database;

import com.alibaba.druid.pool.DruidDataSource;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;

import javax.sql.DataSource;

@Configuration
@MapperScan(basePackages = PmcDataSourceConfig.PACKAGE, sqlSessionFactoryRef = "clusterSqlSessionFactory")
public class PmcDataSourceConfig {

    // 精确到 cluster 目录，以便跟其他数据源隔离
    static final String PACKAGE = "com.bsj.pmc.pmcMapper";
    static final String MAPPER_LOCATION = "classpath:pmcMapper/*.xml";

    @Value("${spring.datasource.third.url}")
    private String url;

    @Value("${spring.datasource.third.username}")
    private String user;

    @Value("${spring.datasource.third.password}")
    private String password;

    @Value("${spring.datasource.third.driver-class-name}")
    private String driverClass;

    @Bean(name = "clusterDataSource")
    public DataSource clusterDataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(driverClass);
        dataSource.setUrl(url);
        dataSource.setUsername(user);
        dataSource.setPassword(password);
        return dataSource;
    }

    @Bean(name = "clusterTransactionManager")
    public DataSourceTransactionManager clusterTransactionManager() {
        return new DataSourceTransactionManager(clusterDataSource());
    }

    @Bean(name = "clusterSqlSessionFactory")
    public SqlSessionFactory clusterSqlSessionFactory(@Qualifier("clusterDataSource") DataSource clusterDataSource)
            throws Exception {
        final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(clusterDataSource);
        sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver()
                .getResources(PmcDataSourceConfig.MAPPER_LOCATION));
        return sessionFactory.getObject();
    }

}