简介

主要介绍两种整合方式，分别是 springboot+mybatis 使用分包方式整合，和 springboot+druid+mybatisplus 使用注解方式整合。

一、表结构

在本地新建两个数据库，名称分别为db1和db2，新建一张user表，表结构如下：

SQL代码：

CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键',
  `name` varchar(25) NOT NULL COMMENT '姓名',
  `age` int(2) DEFAULT NULL COMMENT '年龄',
  `sex` tinyint(1) NOT NULL DEFAULT '0' COMMENT '性别：0-男，1-女',
  `addr` varchar(100) DEFAULT NULL COMMENT '地址',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8

二、多数据源整合

1. springboot+mybatis使用分包方式整合

1.1 主要依赖包

• spring-boot-starter-web
• mybatis-spring-boot-starter
• mysql-connector-java
• lombok

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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.9.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>multipledatasource</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>multipledatasource</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>
   
    <dependencies>
        <!-- spring 依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
         <!-- mysql 依赖 -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.0</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

1.2 application.yml 配置文件

server:
  port: 8080 # 启动端口
spring:
  datasource: 
    db1: # 数据源1
      jdbc-url: jdbc:mysql://localhost:3306/db1?characterEncoding=utf8&useUnicode=true&useSSL=false&serverTimezone=GMT%2B8
      username: root
      password: root
      driver-class-name: com.mysql.cj.jdbc.Driver
    db2: # 数据源2
      jdbc-url: jdbc:mysql://localhost:3306/db2?characterEncoding=utf8&useUnicode=true&useSSL=false&serverTimezone=GMT%2B8
      username: root
      password: root
      driver-class-name: com.mysql.cj.jdbc.Driver

注意事项

• 各个版本的 springboot 配置 datasource 时参数有所变化，例如低版本配置数据库 url 时使用 url 属性，高版本使用 jdbc-url 属性，请注意区分。

1.3 建立连接数据源的配置文件

第一个配置文件

@Configuration
@MapperScan(basePackages = "com.example.multipledatasource.mapper.db1", sqlSessionFactoryRef = "db1SqlSessionFactory")
public class DataSourceConfig1 {

    @Primary // 表示这个数据源是默认数据源, 这个注解必须要加，因为不加的话spring将分不清楚那个为主数据源（默认数据源）
    @Bean("db1DataSource")
    @ConfigurationProperties(prefix = "spring.datasource.db1") //读取application.yml中的配置参数映射成为一个对象
    public DataSource getDb1DataSource(){
        return DataSourceBuilder.create().build();
    }

    @Primary
    @Bean("db1SqlSessionFactory")
    public SqlSessionFactory db1SqlSessionFactory(@Qualifier("db1DataSource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        // mapper的xml形式文件位置必须要配置，不然将报错：no statement （这种错误也可能是mapper的xml中，namespace与项目的路径不一致导致）
        bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath*:mapping/db1/*.xml"));
        return bean.getObject();
    }

    @Primary
    @Bean("db1SqlSessionTemplate")
    public SqlSessionTemplate db1SqlSessionTemplate(@Qualifier("db1SqlSessionFactory") SqlSessionFactory sqlSessionFactory){
        return new SqlSessionTemplate(sqlSessionFactory);
    }
}

第二个配置文件

@Configuration
@MapperScan(basePackages = "com.example.multipledatasource.mapper.db2", sqlSessionFactoryRef = "db2SqlSessionFactory")
public class DataSourceConfig2 {

    @Bean("db2DataSource")
    @ConfigurationProperties(prefix = "spring.datasource.db2")
    public DataSource getDb1DataSource(){
        return DataSourceBuilder.create().build();
    }

    @Bean("db2SqlSessionFactory")
    public SqlSessionFactory db1SqlSessionFactory(@Qualifier("db2DataSource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath*:mapping/db2/*.xml"));
        return bean.getObject();
    }

    @Bean("db2SqlSessionTemplate")
    public SqlSessionTemplate db1SqlSessionTemplate(@Qualifier("db2SqlSessionFactory") SqlSessionFactory sqlSessionFactory){
        return new SqlSessionTemplate(sqlSessionFactory);
    }
}

1.4 具体实现

注意事项

• 在 service 层中根据不同的业务注入不同的 dao 层
• 如果是主从复制- -读写分离：比如 db1 中负责增删改，db2 中负责查询。但是需要注意的是负责增删改的数据库必须是主库（master）

2. springboot+druid+mybatisplus使用注解整合

2.1 主要依赖包

• spring-boot-starter-web
• mybatis-plus-boot-starter
• dynamic-datasource-spring-boot-starter # 配置动态数据源
• druid-spring-boot-starter # 阿里的数据库连接池
• mysql-connector-java
• lombok

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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <parent>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-parent</artifactId>
       <version>2.1.9.RELEASE</version>
       <relativePath/> <!-- lookup parent from repository -->
   </parent>
   <groupId>com.example</groupId>
   <artifactId>mutipledatasource2</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <name>mutipledatasource2</name>
   <description>Demo project for Spring Boot</description>

   <properties>
       <java.version>1.8</java.version>
   </properties>

   <dependencies>
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-web</artifactId>
       </dependency>
       <dependency>
           <groupId>com.baomidou</groupId>
           <artifactId>mybatis-plus-boot-starter</artifactId>
           <version>3.2.0</version>
       </dependency>
       <dependency>
           <groupId>com.baomidou</groupId>
           <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
           <version>2.5.6</version>
       </dependency>
       <dependency>
           <groupId>mysql</groupId>
           <artifactId>mysql-connector-java</artifactId>
           <scope>runtime</scope>
       </dependency>
       <dependency>
           <groupId>com.alibaba</groupId>
           <artifactId>druid-spring-boot-starter</artifactId>
           <version>1.1.20</version>
       </dependency>
       <dependency>
           <groupId>org.projectlombok</groupId>
           <artifactId>lombok</artifactId>
           <optional>true</optional>
       </dependency>
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-test</artifactId>
           <scope>test</scope>
       </dependency>
   </dependencies>

   <build>
       <plugins>
           <plugin>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-maven-plugin</artifactId>
           </plugin>
       </plugins>
   </build>

   <profiles>
       <profile>
           <id>local1</id>
           <properties>
               <profileActive>local1</profileActive>
           </properties>
           <activation>
               <activeByDefault>true</activeByDefault>
           </activation>
       </profile>
       <profile>
           <id>local2</id>
           <properties>
               <profileActive>local2</profileActive>
           </properties>
       </profile>
   </profiles>
</project>

2.2 application.yml 配置文件

server:
  port: 8080
spring:
  datasource:
    dynamic:
      primary: db1 # 配置默认数据库
      datasource:
        db1: # 数据源1配置
          url: jdbc:mysql://localhost:3306/db1?characterEncoding=utf8&useUnicode=true&useSSL=false&serverTimezone=GMT%2B8
          username: root
          password: root
          driver-class-name: com.mysql.cj.jdbc.Driver
        db2: # 数据源2配置
          url: jdbc:mysql://localhost:3306/db2?characterEncoding=utf8&useUnicode=true&useSSL=false&serverTimezone=GMT%2B8
          username: root
          password: root
          driver-class-name: com.mysql.cj.jdbc.Driver
      durid:
        initial-size: 1
        max-active: 20
        min-idle: 1
        max-wait: 60000
  autoconfigure:
    exclude:  com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceAutoConfigure # 去除druid配置

• DruidDataSourceAutoConfigure会注入一个DataSourceWrapper，其会在原生的spring.datasource下找 url, username, password 等。动态数据源 URL 等配置是在 dynamic 下，因此需要排除，否则会报错。排除方式有两种，一种是上述配置文件排除，还有一种可以在项目启动类排除：

@SpringBootApplication(exclude = DruidDataSourceAutoConfigure.class)
public class Application {
  public static void main(String[] args) {
    SpringApplication.run(Application.class, args);
  }
}

2.3 给使用非默认数据源添加注解@DS

@DS 可以注解在方法上和类上，同时存在方法注解优先于类上注解。
注解在 service 实现或 mapper 接口方法上，不要同时在 service 和 mapper 注解。

@DS("db2") 
public interface UserMapper extends BaseMapper<User> {
}

@Service
@DS("db2")
public class ModelServiceImpl extends ServiceImpl<ModelMapper, Model> implements IModelService {}

  @Select("SELECT * FROM user")
  @DS("db2")
  List<User> selectAll();

一、前言

多数据源的配置，是一个相对比较常见的需求。

什么是数据源？数据源就是javax.sql.DataSource，所有实现了这个接口的DataSource就叫做数据源，现在比较常用阿里巴巴的DruidDataSource，支持监控多数据源下的sql运行状况，便于以此实现以sql为核心的应用系统，比如BI报表系统、BI工具、ETL工具等。而这些场景下的业务sql通常是属于动态数据源，它们的操作对象来自于不同的数据库类型，或不同的数据库实例，通常被存放在某个业务表中，还可能需要被新增、删除和修改，因而我们不能像使用Mybatis那样，预先定义好要执行的所有sql，然后放在Mybatis的mapper配置文件中，这种Jdbc操作方式就显得不恰当，换用spring-jdbc的JdbcTemplate刚好可以完美地解决这个问题。

二、实现思路

2.1 配置数据源属性

这里选用DruidDataSource作为我们的业务数据源，一般在application.properties中为其配置各项Druid连接池属性，如下：

2.2 自定义业务数据源Bean

实现自己的DruidDataSource，加载上面的Druid数据源配置，初始化DruidDataSource实例，以线程安全的方式缓存在一Map<String, DruidDataSource>中，并提供获取数据源和关闭数据源的方法。如下：

package com.cjia.common.jdbc;

import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.util.StringUtils;
import com.cjia.common.exception.SourceException;
import com.cjia.model.SqlDBConfig;
import com.cjia.utils.MD5Util;

import lombok.extern.slf4j.Slf4j;

@Slf4j
@Component
public class JdbcDataSource extends DruidDataSource {

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

    @Value("${source.max-active:10}")
    private int maxActive;

    @Value("${source.initial-size:5}")
    private int initialSize;

    @Value("${source.min-idle:3}")
    private int minIdle;

    @Value("${source.max-wait:30000}")
    private int maxWait;

    @Value("${spring.datasource.druid.time-between-eviction-runs-millis}")
    private int timeBetweenEvictionRunsMillis;

    @Value("${spring.datasource.druid.min-evictable-idle-time-millis}")
    private int minEvictableIdleTimeMillis;

    @Value("${spring.datasource.druid.test-while-idle}")
    private boolean testWhileIdle;

    @Value("${spring.datasource.druid.test-on-borrow}")
    private boolean testOnBorrow;

    @Value("${spring.datasource.druid.test-on-return}")
    private boolean testOnReturn;

    @Value("${spring.datasource.druid.filters}")
    private String filters;

    @Value("${source.break-after-acquire-failure:true}")
    private boolean breakAfterAcquireFailure;

    @Value("${source.connection-error-retry-attempts:0}")
    private int connectionErrorRetryAttempts;

    private static volatile Map<String, DruidDataSource> map = new HashMap<>();

    public synchronized void removeDatasource(String jdbcUrl, String username, String password) {
        String key = getKey(jdbcUrl, username, password);
        if (map.containsKey(key)) {
            map.remove(key);
        }
    }

    public synchronized DruidDataSource getDataSource(SqlDBConfig sqlDBConfig) throws SourceException {
    	String jdbcUrl = sqlDBConfig.getUrl();
    	String username = sqlDBConfig.getUsername();
    	String password = sqlDBConfig.getPassword();
    	String key = getKey(jdbcUrl, username, password);
        if (!map.containsKey(key) || null == map.get(key)) {
            DruidDataSource instance = new JdbcDataSource();
            String className = null;
            try {
                className = DriverManager.getDriver(jdbcUrl.trim()).getClass().getName();
            } catch (SQLException e) {
            }
            if (StringUtils.isEmpty(className)) {
            	throw new SourceException("Driver Class Not null: DbId=" + sqlDBConfig.getDbId());
            } else {
                instance.setDriverClassName(className);
            }
            instance.setUrl(jdbcUrl.trim());
            instance.setUsername(username);
            instance.setPassword(password);
            instance.setInitialSize(initialSize);
            instance.setMinIdle(minIdle);
            instance.setMaxActive(maxActive);
            instance.setMaxWait(maxWait);
            instance.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
            instance.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
            instance.setTestWhileIdle(false);
            instance.setTestOnBorrow(testOnBorrow);
            instance.setTestOnReturn(testOnReturn);
            try {
				instance.setFilters(filters);
			} catch (SQLException ex) {
				log.error("druid configuration initialization filter", ex);
			}
            instance.setConnectionErrorRetryAttempts(connectionErrorRetryAttempts);
            instance.setBreakAfterAcquireFailure(breakAfterAcquireFailure);

            try {
                instance.init();
            } catch (Exception e) {
                log.error("Exception during pool initialization", e);
                throw new SourceException(e.getMessage());
            }
            map.put(key, instance);
        }
        return map.get(key);
    }

    private String getKey(String jdbcUrl, String username, String password) {
        StringBuilder sb = new StringBuilder();
        if (!StringUtils.isEmpty(username)) {
            sb.append(username);
        }
        if (!StringUtils.isEmpty(password)) {
            sb.append(":").append(password);
        }
        sb.append("@").append(jdbcUrl.trim());
        return MD5Util.md5(sb.toString(), MD5Util.SEC_KEY);
    }
}

2.3 动态构造JdbcTemplate

首先，注入上一步自定义的业务数据源JdbcDataSource，接着，JdbcTemplate提供了传入DataSource的构造方式，获取到JdbcTemplate对象后，调用它丰富的API执行业务sql，如下：

// 获取初始化后的druid数据源，SqlDBConfig存放了jdbcUrl、username、password
DruidDataSource dataSource = jdbcDataSource.getDataSource(sqlDBConfig);
List<Map<String, Object>> result = new JdbcTemplate(dataSource).queryForList(sql, paramArgs);

以上。

一、前言

• 大家好，我是小诚，不知不觉上一次更文已经是20多天前了！其实这段时间也一直没有闲着，一个是在梳理之前的文章知识和资源，用于搭建技术圈子，另外一个就是在思考自己的一个输出方向，社区发展得很迅速，热榜各种各类的文章都有，深思熟虑后，还是坚持文章在精不在多，质量标准更加重要，所以今后博文的方向会更加偏向实战和经验，争取分享更加有价值的博文！

• 如果文章对你有帮助，可以帮忙一键三连和专栏订阅哦！ 技术圈子经过这段时间的筹划，已经初步成型！有兴趣、志同道合的小伙伴可以查看左边导航栏的技术圈子介绍，期待你们的加入！

• 本篇文章重点介绍SpringBoot集合MyBatis和MyBatis-Plus整合多数据源方面的知识！

🚅 二、专栏推荐

  良心推荐： 下面的相关技术专栏还在免费分享哦，大家可以帮忙点点订阅哦！

  JAVA进阶知识大全

  算法日记修行

🚔 三、整合多数据源需要了解的知识

  1、何时会使用到多数据源

  一个技术的出现、应用必然是为了解决存在的某些问题，多数据源出现常见的场景如下：

  （1）、与第三方对接时，有些合作方并不会为了你的某些需求而给你开发一个功能，他们可以提供给你一个可以访问数据源的只读账号，你需要获取什么数据由你自己进行逻辑处理，这时候就避免不了需要进行多数据源整合了。

  （2）、业务数据达到了一个量级，使用单一数据库存储达到了一个瓶颈，需要进行分库分表等操作进行数据管理，在操作数据时，不可避免的涉及到多数据源问题。

  2、多数据源整合有哪些方式

  参考了网上的许多材料，发现整合方式无外乎以下几种：

  （1）、使用分包方式，不同的数据源配置不同的MapperScan和mapper文件

  （2）、使用APO切片方式，实现动态数据源切换(如果对Aop不是很熟悉，欢迎查看我之前的一篇文章，这知识保熟哦！【什么是面向切面编程?】)

  （3）、使用数据库代理中间件，如Mycat等

  3、不同方式之间的区别

  （1）、分包方式可以集合JTA(JAVA Transactional API)实现分布式事务，但是整个流程的实现相对来说比较复杂。

  （2）、AOP动态配置数据源方式缺点在于无法实现全局分布式事务，所以如果只是对接第三方数据源，不涉及到需要保证分布式事务的话，是可以作为一种选择。

  （3）、使用数据库代理中间件方式是现在比较流行的一种方式，很多大厂也是使用这种方式，开发者不需要关注太多与业务无关的问题，把它们都交给数据库代理中间件去处理，大量的通用的数据聚合，事务，数据源切换都由中间件来处理，中间件的性能与处理能力将直接决定应用的读写性能，比较常见的有Mycat、TDDL等。现在阿里出了100%自研的分布式数据库OceanBase，从最底层支持分布式，性能也非常强大，大家感兴趣的可以去了解下！

  4、本文实战选择的方式

  鉴于本次遇到需求的整合多数据源的场景是需要 对接第三方的数据，暂不涉及到分布式事务问题 ，所以本文实战整合多数据源使用的方式是【分包方式】实现简单的多数据源整合，至于其他方式和分布式事务的坑，后面再慢慢填吧(o(╥﹏╥)o)！

🚢 四、SpringBoot+MyBatis整合多数据源

🔴 4.1 说明

  本次案例涉及到的代码比较多，因此文章只贴出部分，全部案例代码已经上传到Gitee，需要者可直接访问：【SpringBoot结合MyBatis整合多数据源】，项目结构如下：

🟠 4.2 涉及依赖包

• spring-boot-starter-web -- web相关支持
• mybatis-spring-boot-starter -- springboot整合mybatis依赖
• mysql-connector-java -- mysql数据驱动
• lombok -- 自动生成实体类常用方法依赖包
• hutool-all -- 常用方法封装依赖包

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.2.0</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.13</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.4.5</version>
        </dependency>

🟡 4.3 项目配置

# 项目启动端口
server:
  port: 9090

# 项目 名称
spring:
  application:
    name: multi-datasource-instance
  datasource:
    # 主数据库
    master:
      # 注意，整合多数据源时如果使用springboot默认的数据库连接池Hikari，指定连接数据使用的是jdbc-url而不是url属性
      jdbc-url: jdbc:mysql://localhost:3306/test1?serverTimezone=UTC&useUnicode=true&characterEncoding=utf8&useSSL=false
      username: root
      password: 123456
      driver-class-name: com.mysql.cj.jdbc.Driver
    # 副数据库
    slave:
      # 注意，整合多数据源时如果使用springboot默认的数据库连接池Hikari，指定连接数据使用的是jdbc-url而不是url属性
      jdbc-url: jdbc:mysql://localhost:3306/test2?serverTimezone=UTC&useUnicode=true&characterEncoding=utf8&useSSL=false
      username: root
      password: 123456
      driver-class-name: com.mysql.cj.jdbc.Driver

🟢 4.4 编写主副数据库数据源配置

  1、主数据源相关配置：主要是指定主数据源、扫描的mapper地址、事务管理器等信息。

@Configuration
// 指定主数据库扫描对应的Mapper文件，生成代理对象
@MapperScan(basePackages ="com.diary.it.multi.datasource.mapper" ,sqlSessionFactoryRef = "masterSqlSessionFactory")
public class MasterDataSourceConfig {

    // mapper.xml所在地址
    private static final String MAPPER_LOCATION = "classpath*:mapper/*.xml";


    /**
     * 主数据源，Primary注解必须增加，它表示该数据源为默认数据源
     * 项目中还可能存在其他的数据源，如获取时不指定名称，则默认获取这个数据源，如果不添加，则启动时候回报错
     */
    @Primary
    @Bean(name = "masterDataSource")
    // 读取spring.datasource.master前缀的配置文件映射成对应的配置对象
    @ConfigurationProperties(prefix = "spring.datasource.master")
    public DataSource dataSource() {
        DataSource build = DataSourceBuilder.create().build();
        return build;
    }

    /**
     * 事务管理器，Primary注解作用同上
     */
    @Bean(name = "masterTransactionManager")
    @Primary
    public PlatformTransactionManager dataSourceTransactionManager(@Qualifier("masterDataSource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

    /**
     * session工厂，Primary注解作用同上
     */

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

}

  2、副数据源相关配置：主要是指定数据源、扫描的mapper地址、事务管理器等信息。

@Configuration
// 指定从数据库扫描对应的Mapper文件，生成代理对象
@MapperScan(basePackages = "com.diary.it.multi.datasource.mapper2", sqlSessionFactoryRef = "slaveSqlSessionFactory")
public class SlaveDataSourceConfig {
    // mapper.xml所在地址
    private static final String MAPPER_LOCATION = "classpath*:mapper2/*.xml";

    /**
     * 数据源
     */
    @Bean(name = "slaveDataSource")
    // 读取spring.datasource.slave前缀的配置文件映射成对应的配置对象
    @ConfigurationProperties(prefix = "spring.datasource.slave")
    public DataSource dataSource() {
        DataSource build = DataSourceBuilder.create().build();
        return build;
    }


    /**
     * 事务管理器
     */
    @Bean(name = "slaveTransactionManager")
    public PlatformTransactionManager dataSourceTransactionManager(@Qualifier("slaveDataSource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

    /**
     * session工厂
     */

    @Bean(name = "slaveSqlSessionFactory")
    public SqlSessionFactory sqlSessionFactory(@Qualifier("slaveDataSource") DataSource dataSource) throws Exception {
        final SqlSessionFactoryBean sessionFactoryBean = new SqlSessionFactoryBean();
        sessionFactoryBean.setDataSource(dataSource);
        sessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(SlaveDataSourceConfig.MAPPER_LOCATION));
        return sessionFactoryBean.getObject();
    }

}

4.5 执行结果

  完成上面的步骤后，就跟我们平常写业务逻辑的方式一样，在service中写业务逻辑，在mapper中写sql语句等，下面看看执行结果！

4.6 整合中遇到的问题

  看完上面的教程，是不是发现其实整合多数据源其实也挺简单的！但是，完全按照教学流程整合还是遇到各种问题的现象真的太常见了，下面博主就总结下整合中遇到的各种问题，如果你在整合过程中也遇到了，可以直接按照博主的解决方案来哦(贴心吧！)。

  问题1、出现 jdbcUrl is required with driverClassName异常

  原因： SpringBoot2.x后默认的数据库连接池就是HikariCP(号称史上最快，性能最高)，HikariCP连接池中命名规则和其他的连接池不太一样，指定连接数据库的地址时，它使用的是jdbc-url而不是url，所以如果我们不指定数据库连接池如druid而使用springboot默认的连接池的话，需要将配置中连接数据库的url改成jdbc-url属性。

  问题2、 出现 Invalid bound statement (not found)异常

  原因：

    （1）、在定义数据源配置信息时没有指定SqlSessionFactoryBean扫描的mapper.xml文件的位置即 sessionFactoryBean.setMapperLocations(xxx)。

    （2）、mapper.xml文件中namespace属性对应的路径不准确或者对应方法的id名称、parameterType属性不对

    （3）、xxxMapper.java的方法返回值是List,而select元素没有正确配置ResultMap,或者只配置ResultType

  问题3、 出现 required a single bean, but 2 were found异常

  原因： 因为我们在指定主副数据源配置时已经使用MapperScan注解进行扫描对应的mapper.java，此时被扫描到的mapper.java已经生成代理类到Spring容器，如果此时在启动类中再使用MapperScan扫描则会成出现上面的问题(奇怪的是：这个问题我换一台电脑就不报错了，所以出现这个问题先按照这个方案解决吧)

  问题4、 主数据源配置类中为什么添加Primary注解

  原因： 因为整合了多数据源，所以DataSource、PlatformTransactionManager等实例都会注入多个到Spring容器中，Primary注解的作用就是：当我们使用自动配置的方式如Autowired注入Bean时，如果这个Bean有多个候选者，如果其中一个候选者具有@Primary注解修饰，该候选者会被选中，作为自动配置的值。

  问题5、 com.mysql.jdbc.Driver 和 com.mysql.cj.jdbc.Driver的区别

  原因： 细心的小伙伴会发现，在数据库配置中driver-class-name属性的值为com.mysql.cj.jdbc.Driver，其实com.mysql.jdbc.Driver 是 对应mysql-connector-java 5驱动的，com.mysql.cj.jdbc.Driver 是 mysql-connector-java 6及之后的数据库驱动的，如果使用了6.x后的mysql数据库驱动还继续使用com.mysql.jdbc.Driver 则启动时会报deprecated(过时的)，同时使用mysql6.x后的驱动需要指定时区serverTimezone:

五、SpringBoot+Mybatis-Plus整合多数据源

  上面Mybatis使用分包的方式整合多数据源多少还是有些麻烦的，但是使用MyBatis-Plus就比较简单了，MyBatis-Plus官方就支持了多数据源，使用的时候只需要一个注解就可以实现，整合多数据源的时候推荐使用该种方式。

🟥 5.1 说明

  本次案例涉及到的代码比较多，因此文章只贴出部分，全部案例代码已经上传到Gitee，需要者可直接访问：【实战-SpringBoot结合MyBatis-Plus整合多数据源】，mybatis-plus多数据源支持：

  项目结构如下：

🟧 5.2 涉及的依赖包

• spring-boot-starter-web -- web相关支持
• mybatis-plus-boot-starter-- springboot整合mybatis-plus依赖
• dynamic-datasource-spring-boot-starter -- mybatis-plus管理数据源依赖
• mysql-connector-java -- mysql数据驱动
• lombok -- 自动生成实体类常用方法依赖包
• hutool-all -- 常用方法封装依赖包

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
            <version>3.4.1</version>
        </dependency>

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.3</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.4.5</version>
        </dependency>

🟨 5.3 相关配置

# 启动端口
server:
  port: 9091

# 项目名称
spring:
  application:
    name: multi-datasource-instance2
  datasource:
    # 采用动态选取
    dynamic:
      primary: master #设置默认的数据源或者数据源组,默认值即为master
      strict: false #严格匹配数据源,默认false. true未匹配到指定数据源时抛异常,false使用默认数据源
      datasource:
        # 主数据库
        master:
          url: jdbc:mysql://localhost:3306/test1?serverTimezone=UTC&useUnicode=true&characterEncoding=utf8&useSSL=false
          username: root
          password: 123456
          driver-class-name: com.mysql.cj.jdbc.Driver
        # 副数据库
        slave:
          url: jdbc:mysql://localhost:3306/test2?serverTimezone=UTC&useUnicode=true&characterEncoding=utf8&useSSL=false
          username: root
          password: 123456
          driver-class-name: com.mysql.cj.jdbc.Driver

🟩 5.4 使用方式
 

🟦 5.5 执行结果