2021-01-24

SpringBoot 结合 Mybatis 实现对多源数据库操作

系统环境：

Java Jdk 版本：1.8
Mysql 版本：8.0.19
Mybatis 版本：3.5.6
SpringBoot 版本：2.4.2
Postgresql 版本：12.5

参考地址：

dynamic-datasource 官方文档

项目示例地址：

SpringBoot 实现多源数据库示例

如果本文对你有帮助，请帮忙 github 点颗星哦~

一、为什么需要操作多源数据库

在日常开发中，我们会经常遇见各式各样的需求。比如，一个应用中操作多个数据库，而且数据库可能不是一种类型的数据库，需要从多种数据库中读取数据，这种需求屡见不鲜。

应用操作多源数据库

二、如何实现多源数据库

目前使用 SpringBoot 实现多数据库实现方案比较多，这里只列出两种常用方案：

方案一：创建多个数据源配置类，在类中配置数据源使用不同的 Datasource，并且指定应用该数据源配置的生效的 Mapper 包路径。这样我们使用中调用不同包中的 Mapper 就会切换到不同的数据库中，执行对应的 SQL 操作。
方案二：使用 baomidou 开源的组件 dynamic-datasource 实现多源数据库切换。该组件内部针对多个数据库的配置与操作进行了封装，加上与 SpringBoot 结合实现自动化配置，我们使用中只要在 Service 类上或者 Service 内部方法上添加 @DS 注解，就能轻松实现不同类型的数据库切换。

两种方式都能使 SpringBoot 支持多数据库，不过方案一需要进行很多数据源的配置，相对复杂，不过可以灵活配置。而方案二的组件对数据源相关配置进行了封装，直接可以通过注解方式来切换不同的类型的数据库，非常简单方便。两种方案都有各自的优缺点，使用哪种还需要大家自信斟酌。

三、准备实验的测试环境

在下面我们会写两个示例，分别使用两种方案来实现 SpringBoot + Mybatis 对多源数据库的支持，不过我们需要提前准备演示的数据库及其用例。

准备两种类型的数据库，如下：

数据库一：mysql
数据库二：postgresql

Mysql 和 Postgresql 中创建数据库 db1 与 db2，命令如下：

Mysql： CREATE DATABASE db1;
Postgresql： CREATE DATABASE db2;

数据库创建完成后需要导入用于实验的表 SQL 文件，如下：

数据库一：mysql 实验的表 Sql 文件
数据库二：postgresql 实验的表 Sql 文件

两种类型数据库用于实验的表结构，如下：

数据库一：t_user_info 表：

id	name	gender	age
1	小豆丁	0	22

数据库二：t_account 表：

id	username	password	create_time	update_time
1	mydlq	123456	2021-01-01 00:00:00	2021-01-01 00:00:00

四、方案一配置数据源使用步骤

使用创建数据库配置类方式来实现多数据源支持，可以进行如下步骤：

1、配置文件添加数据库参数

需要在 SpringBoot 配置文件 application.yml 中，添加如下多个数据库连接配置。

1
datasource:
2
  ## 数据库一
3
  db1:
4
    driverClassName: com.mysql.cj.jdbc.Driver
5
    jdbc-url: jdbc:mysql://127.0.0.1:3306/db1?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8&useSSL=false
6
    username: root
7
    password: 123456
8
  ## 数据库二
9
  db2:
10
    driverClassName: org.postgresql.Driver
11
    jdbc-url: jdbc:postgresql://127.0.0.1:5432/db2?currentSchema=public
12
    username: postgre
13
    password: 123456

2、创建 Mapper 包

提前在项目目录中创建用于存放 Mapper 的包，如下所示中 db1 包中存放数据库一的相关操作接口，db2 包中存放操作数据库二的相关操作接口：

数据库一包路径：/src/main/java/mydlq/dao/db1
数据库二包路径：/src/main/java/mydlq/dao/db2

提前在项目的 /resources 目录下创建 Mapper 对应的 xml 的目录：

数据库一 Mapper 对应的 xml 文件目录：/src/main/resources/mappers/db1
数据库二 Mapper 对应的 xml 文件目录：/src/main/resources/mappers/db2

3、创建数据源配置类

这里我们需要创建两个数据源配置类，每个类都对应一个数据源的配置，内容如下：

数据库一配置类 Db1DataSourceConfig

1
@Configuration
2
@MapperScan(basePackages = Db1DataSourceConfig.PACKAGE, sqlSessionFactoryRef = Db1DataSourceConfig.PACKAGE)
3
public class Db1DataSourceConfig {
4

5
    /** 指定 Sql Session Factory 的 Bean 名称 */
6
    static final String SQL_SESSION_FACTORY = "db1SqlSessionFactory";
7
    /** 指定 Mapper 类的包路径 */
8
    static final String PACKAGE = "mydlq.dao.db1";
9
    /** 指定数据库 Mapper 对应的 xml 文件路径 */
10
    static final String MAPPER = "classpath:mappers/db1/*.xml";
11

12
    /**
13
     * 配置数据源，这里设置为 hikari 数据库连接池
14
     * @return DataSource
15
     */
16
    @Primary
17
    @Bean(name = "db1DataSource")
18
    @ConfigurationProperties("datasource.db1")
19
    public DataSource dataSource() {
20
        return DataSourceBuilder.create().type(HikariDataSource.class).build();
21
    }
22

23
    /**
24
     * 数据源事务管理器
25
     * @return 数据源事务管理器
26
     */
27
    @Primary
28
    @Bean(name = "db1TransactionManager")
29
    public DataSourceTransactionManager dataSourceTransactionManager(@Qualifier("db1DataSource") DataSource dataSource) {
30
        return new DataSourceTransactionManager(dataSource);
31
    }
32

33
    @Primary
34
    @Bean(name = SQL_SESSION_FACTORY)
35
    public SqlSessionFactory sqlSessionFactory(@Qualifier("db1DataSource") DataSource masterDataSource) throws Exception {
36
        final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
37
        sessionFactory.setDataSource(masterDataSource);
38
        sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(Db1DataSourceConfig.MAPPER));
39
        return sessionFactory.getObject();
40
    }
41

42
}

数据库二配置类 Db2DataSourceConfig

1
@Configuration
2
@MapperScan(basePackages = Db2DataSourceConfig.PACKAGE, sqlSessionFactoryRef = Db2DataSourceConfig.PACKAGE)
3
public class Db2DataSourceConfig {
4

5
    /** 指定 Sql Session Factory 的 Bean 名称 */
6
    static final String SQL_SESSION_FACTORY = "db2SqlSessionFactory";
7
    /** 指定 Mapper 类的包路径 */
8
    static final String PACKAGE = "mydlq.dao.db2";
9
    /** 指定数据库 Mapper 对应的 xml 文件路径 */
10
    static final String MAPPER = "classpath:mappers/db2/*.xml";
11

12
    /**
13
     * 配置数据源，这里设置为 hikari 数据库连接池
14
     * @return DataSource
15
     */
16
    @Primary
17
    @Bean(name = "db2DataSource")
18
    @ConfigurationProperties("datasource.db2")
19
    public DataSource dataSource() {
20
        return DataSourceBuilder.create().type(HikariDataSource.class).build();
21
    }
22

23
    /**
24
     * 数据源事务管理器
25
     * @return 数据源事务管理器
26
     */
27
    @Primary
28
    @Bean(name = "db2TransactionManager")
29
    public DataSourceTransactionManager dataSourceTransactionManager(@Qualifier("db2DataSource") DataSource dataSource) {
30
        return new DataSourceTransactionManager(dataSource);
31
    }
32

33
    @Primary
34
    @Bean(name = SQL_SESSION_FACTORY)
35
    public SqlSessionFactory sqlSessionFactory(@Qualifier("db2DataSource") DataSource masterDataSource) throws Exception {
36
        final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
37
        sessionFactory.setDataSource(masterDataSource);
38
        sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(Db2DataSourceConfig.MAPPER));
39
        return sessionFactory.getObject();
40
    }
41

42
}

我们在使用时，调用：

mydlq.dao.db1 包的 mapper 接口中的方法就会使用 Db1DataSourceConfig 的配置，切换数据库一读取数据。
mydlq.dao.db2 包的 mapper 接口中的方法就会使用 Db2DataSourceConfig 的配置，切换数据库二读取数据。

五、方案一示例：配置数据源实现

示例项目地址：SpringBoot + Mybatis 通过配置数据源方式实现多源数据库示例

使用创建数据库配置类方式来实现多数据源支持，这里直接使用上面准备的两种类型的数据库中两个表中的数据，实现一个项目中调用两种数据库进行查询。创建一个测试接口，将查询到的数据拼接在一起进行返回。示例代码如下：

1、Maven 引入相关依赖

Maven 的 pom.xml 文件引入 SpringBoot、Myabtis、Lombok、Mysql 和 Postgresql 相关依赖，内容如下：

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

6
    <parent>
7
        <groupId>org.springframework.boot</groupId>
8
        <artifactId>spring-boot-starter-parent</artifactId>
9
        <version>2.4.2</version>
10
    </parent>
11

12
    <groupId>mydlq.club</groupId>
13
    <artifactId>springboot-mybatis-many-database-config</artifactId>
14
    <version>0.0.1</version>
15
    <name>springboot-mybatis-many-database-config</name>
16
    <description>database demo</description>
17

18
    <properties>
19
        <java.version>1.8</java.version>
20
    </properties>
21

22
    <dependencies>
23
        <!-- SpringBoot Web -->
24
        <dependency>
25
            <groupId>org.springframework.boot</groupId>
26
            <artifactId>spring-boot-starter-web</artifactId>
27
        </dependency>
28
        <!-- Lombok -->
29
        <dependency>
30
            <groupId>org.projectlombok</groupId>
31
            <artifactId>lombok</artifactId>
32
        </dependency>
33
        <!-- Mysql -->
34
        <dependency>
35
            <artifactId>mysql-connector-java</artifactId>
36
            <groupId>mysql</groupId>
37
        </dependency>
38
        <!-- Postgresql -->
39
        <dependency>
40
            <groupId>org.postgresql</groupId>
41
            <artifactId>postgresql</artifactId>
42
            <scope>runtime</scope>
43
        </dependency>
44
        <!-- Mybatis SpringBoot -->
45
        <dependency>
46
            <groupId>org.mybatis.spring.boot</groupId>
47
            <artifactId>mybatis-spring-boot-starter</artifactId>
48
            <version>2.1.4</version>
49
        </dependency>
50
    </dependencies>
51

52
    <build>
53
        <plugins>
54
            <plugin>
55
                <groupId>org.springframework.boot</groupId>
56
                <artifactId>spring-boot-maven-plugin</artifactId>
57
            </plugin>
58
        </plugins>
59
    </build>
60

61
</project>

上面没有配置数据库连接池，由于 SpringBoot 2.x 以后默认引入 Hikari 连接池，性能很好，所以我们使用其默认连接池即可。

2、配置文件中添加相关参数

在 SpringBoot 配置文件 application.yml 中，配置数据库相关配置。由于我们会用到两个数据库，所以这里我们配置两套数据库配置：

db1：用于连接 mysql 数据库的配置。
db2：用于连接 postgresql 数据库的配置。

application.yml 文件内容如下：

1
datasource:
2
  db1:
3
    driverClassName: com.mysql.cj.jdbc.Driver
4
    jdbc-url: jdbc:mysql://127.0.0.1:3306/db1?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8&useSSL=false
5
    username: root
6
    password: 123456
7
  db2:
8
    driverClassName: org.postgresql.Driver
9
    jdbc-url: jdbc:postgresql://127.0.0.1:5432/db2?currentSchema=public
10
    username: postgre
11
    password: 123456

3、创建数据库配置类

数据库一配置类： Db1DataSourceConfig

1
import javax.sql.DataSource;
2
import com.zaxxer.hikari.HikariDataSource;
3
import org.apache.ibatis.session.SqlSessionFactory;
4
import org.mybatis.spring.SqlSessionFactoryBean;
5
import org.mybatis.spring.annotation.MapperScan;
6
import org.springframework.beans.factory.annotation.Qualifier;
7
import org.springframework.boot.context.properties.ConfigurationProperties;
8
import org.springframework.boot.jdbc.DataSourceBuilder;
9
import org.springframework.context.annotation.Bean;
10
import org.springframework.context.annotation.Configuration;
11
import org.springframework.context.annotation.Primary;
12
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
13
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
14

15
@Configuration
16
@MapperScan(basePackages = Db1DataSourceConfig.PACKAGE, sqlSessionFactoryRef = Db1DataSourceConfig.PACKAGE)
17
public class Db1DataSourceConfig {
18

19
    /** 指定 Sql Session Factory 的 Bean 名称 */
20
    static final String SQL_SESSION_FACTORY = "db1SqlSessionFactory";
21
    /** 指定 Mapper 类的包路径 */
22
    static final String PACKAGE = "mydlq.club.example.dao.db1";
23
    /** 指定数据库 Mapper 对应的 xml 文件路径 */
24
    static final String MAPPER = "classpath:mappers/db1/*.xml";
25

26
    /**
27
     * 配置数据源，这里设置为 hikari 数据库连接池
28
     * @return DataSource
29
     */
30
    @Primary
31
    @Bean(name = "db1DataSource")
32
    @ConfigurationProperties("datasource.db1")
33
    public DataSource dataSource() {
34
        return DataSourceBuilder.create().type(HikariDataSource.class).build();
35
    }
36

37
    /**
38
     * 数据源事务管理器
39
     * @return 数据源事务管理器
40
     */
41
    @Primary
42
    @Bean(name = "db1TransactionManager")
43
    public DataSourceTransactionManager dataSourceTransactionManager(@Qualifier("db1DataSource") DataSource dataSource) {
44
        return new DataSourceTransactionManager(dataSource);
45
    }
46

47
    @Primary
48
    @Bean(name = SQL_SESSION_FACTORY)
49
    public SqlSessionFactory sqlSessionFactory(@Qualifier("db1DataSource") DataSource masterDataSource) throws Exception {
50
        final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
51
        sessionFactory.setDataSource(masterDataSource);
52
        sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(Db1DataSourceConfig.MAPPER));
53
        return sessionFactory.getObject();
54
    }
55

56
}

数据库二配置类： Db2DataSourceConfig

1
import javax.sql.DataSource;
2
import com.zaxxer.hikari.HikariDataSource;
3
import org.apache.ibatis.session.SqlSessionFactory;
4
import org.mybatis.spring.SqlSessionFactoryBean;
5
import org.mybatis.spring.annotation.MapperScan;
6
import org.springframework.beans.factory.annotation.Qualifier;
7
import org.springframework.boot.context.properties.ConfigurationProperties;
8
import org.springframework.boot.jdbc.DataSourceBuilder;
9
import org.springframework.context.annotation.Bean;
10
import org.springframework.context.annotation.Configuration;
11
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
12
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
13

14
@Configuration
15
@MapperScan(basePackages = Db2DataSourceConfig.PACKAGE, sqlSessionFactoryRef = "db2SqlSessionFactory")
16
public class Db2DataSourceConfig {
17

18
    /** 指定 Sql Session Factory 的 Bean 名称 */
19
    static final String SQL_SESSION_FACTORY = "db2SqlSessionFactory";
20
    /** 指定 Mapper 类的包路径 */
21
    static final String PACKAGE = "mydlq.club.example.dao.db2";
22
    /** 指定数据库 Mapper 对应的 xml 文件路径 */
23
    static final String MAPPER = "classpath:mappers/db2/*.xml";
24

25
    /**
26
     * 配置数据源，设置为 hikari
27
     * @return DataSource
28
     */
29
    @Bean(name = "db2DataSource")
30
    @ConfigurationProperties("datasource.db2")
31
    public DataSource masterDataSource() {
32
        return DataSourceBuilder.create().type(HikariDataSource.class).build();
33
    }
34

35
    /**
36
     * 数据源事务管理器
37
     * @return 数据源事务管理器
38
     */
39
    @Bean(name = "db2TransactionManager")
40
    public DataSourceTransactionManager masterTransactionManager() {
41
        return new DataSourceTransactionManager(masterDataSource());
42
    }
43

44
    @Bean(name = SQL_SESSION_FACTORY)
45
    public SqlSessionFactory masterSqlSessionFactory(@Qualifier("db2DataSource") DataSource masterDataSource) throws Exception {
46
        final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
47
        sessionFactory.setDataSource(masterDataSource);
48
        sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(Db2DataSourceConfig.MAPPER));
49
        return sessionFactory.getObject();
50
    }
51

52
}

注解说明：

@ConfigurationProperties：从配置文件中读取指定前缀的配置参数。
@MapperScan：指定数据库配置对哪些包的 Mapper 生效，指定数据库 SQL 会话工厂。
@Primary：声明这是一个主数据源（默认数据源），多数据源配置时必不可少。
@Qualifier：显式选择传入的 Bean，根据配置的名称指定使用哪个 Bean。

4、创建实体类

数据库一的实体类： UserInfo

1
import lombok.Data;
2

3
@Data
4
public class UserInfo {
5
    /** 主键 */
6
    private Integer id;
7
    /** 姓名 */
8
    private String name;
9
    /** 性别（0:男，1:女）*/
10
    private String gender;
11
    /** 岁数 */
12
    private Byte age;
13
}

数据库二的实体类： Account

1
import java.time.LocalDateTime;
2
import lombok.Data;
3

4
@Data
5
public class Account {
6
    /** 主键 */
7
    private Integer id;
8
    /** 用户名 */
9
    private String username;
10
    /** 密码 */
11
    private String password;
12
    /** 创建时间 */
13
    private LocalDateTime createTime;
14
    /** 更新时间 */
15
    private LocalDateTime updateTime;
16
}

5、创建操作数据库的 Mapper 类和 Xml 文件

数据库一

创建 Mapper 类 UserInfoMapper

1
import mydlq.club.example.model.db1.UserInfo;
2
import org.apache.ibatis.annotations.Mapper;
3

4
@Mapper
5
public interface UserInfoMapper {
6

7
    /**
8
     * 根据主键查找数据
9
     *
10
     * @param id 主键ID
11
     * @return 数据
12
     */
13
    UserInfo selectByPrimaryKey(Integer id);
14

15
}

位置 /resources/mappers/db1 创建 Mapper 文件 UserInfoMapper.xml

1
<?xml version="1.0" encoding="UTF-8"?>
2
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
3
<mapper namespace="mydlq.club.example.dao.db1.UserInfoMapper">
4

5
  <resultMap id="BaseResultMap" type="mydlq.club.example.model.db1.UserInfo">
6
    <id column="id" jdbcType="INTEGER" property="id" />
7
    <result column="name" jdbcType="VARCHAR" property="name" />
8
    <result column="gender" jdbcType="VARCHAR" property="gender" />
9
    <result column="age" jdbcType="TINYINT" property="age" />
10
  </resultMap>
11

12
  <select id="selectByPrimaryKey" parameterType="java.lang.Integer" resultMap="BaseResultMap">
13
    SELECT id, `name`, gender, age
14
    FROM t_user_info
15
    WHERE id = #{id,jdbcType=INTEGER}
16
  </select>
17

18
</mapper>

数据库二

创建 Mapper 类 AccountMapper

1
import mydlq.club.example.model.db2.Account;
2
import org.apache.ibatis.annotations.Mapper;
3

4
@Mapper
5
public interface AccountMapper {
6
    /**
7
     * 根据主键查找数据
8
     *
9
     * @param id 主键ID
10
     * @return 数据
11
     */
12
    Account selectByPrimaryKey(Integer id);
13

14
}

位置 /resources/mappers/db2 创建 Mapper 文件 AccountMapper.xml

1
<?xml version="1.0" encoding="UTF-8"?>
2
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
3
<mapper namespace="mydlq.club.example.dao.db2.AccountMapper">
4

5
  <resultMap id="BaseResultMap" type="mydlq.club.example.model.db2.Account">
6
    <id column="id" jdbcType="BIGINT" property="id" />
7
    <result column="username" jdbcType="VARCHAR" property="username" />
8
    <result column="password" jdbcType="VARCHAR" property="password" />
9
    <result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
10
    <result column="update_time" jdbcType="TIMESTAMP" property="updateTime" />
11
  </resultMap>
12

13
  <select id="selectByPrimaryKey" parameterType="java.lang.Integer" resultMap="BaseResultMap">
14
    SELECT id, username, "password", create_time, update_time
15
    FROM t_account
16
    WHERE id = #{id,jdbcType=INTEGER}
17
  </select>
18

19
</mapper>

6、创建测试的 Service 类

创建测试的 Service 类，类中创建 findUserInfo() 和 findAccount() 两个方法，分别通过 AccountMapper 和 UserInfoMapper 访问 Mysql 和 Postgresql 两个数据库获取数据。

1
import mydlq.club.example.dao.db1.UserInfoMapper;
2
import mydlq.club.example.dao.db2.AccountMapper;
3
import mydlq.club.example.model.db1.UserInfo;
4
import mydlq.club.example.model.db2.Account;
5
import org.springframework.beans.factory.annotation.Autowired;
6
import org.springframework.stereotype.Service;
7

8
@Service
9
public class TestService {
10

11
    @Autowired
12
    private AccountMapper accountMapper;
13
    @Autowired
14
    private UserInfoMapper userInfoMapper;
15

16
    /**
17
     * 数据库一，查询用户信息
18
     * @param id 主键ID
19
     * @return 用户信息
20
     */
21
    public UserInfo findUserInfo(Integer id){
22
        return userInfoMapper.selectByPrimaryKey(id);
23
    }
24

25
    /**
26
     * 数据库二，查询账户数据
27
     * @param id 主键ID
28
     * @return 账户数据
29
     */
30
    public Account findAccount(Integer id){
31
        return accountMapper.selectByPrimaryKey(id);
32
    }
33

34
}

7、创建测试的 Controller 类

创建测试用的 Controller 类，里面调用上面创建的 Service 类中查询两个数据库数据的方法 findUserInfo() 和 findAccount() 来获取两个库中的数据，并提供测试访问的接口 /test，方便后续进行测试。

1
import mydlq.club.example.model.AccountUserInfo;
2
import mydlq.club.example.model.db1.UserInfo;
3
import mydlq.club.example.model.db2.Account;
4
import mydlq.club.example.service.TestService;
5
import org.springframework.beans.factory.annotation.Autowired;
6
import org.springframework.web.bind.annotation.GetMapping;
7
import org.springframework.web.bind.annotation.RestController;
8

9
@RestController
10
public class TestController {
11

12
    @Autowired
13
    private TestService testService;
14

15
    /**
16
     * 同时查询两个库的数据
17
     * @return 查询结果
18
     */
19
    @GetMapping("/test")
20
    public Object hello1() {
21
        // 查询账户数据
22
        Account account = testService.findAccount(1);
23
        // 查询用户信息
24
        UserInfo userInfo = testService.findUserInfo(1);
25
        // 创建响应对象
26
        AccountUserInfo accountUserInfo = new AccountUserInfo();
27
        accountUserInfo.setAccount(account);
28
        accountUserInfo.setUserInfo(userInfo);
29
        return accountUserInfo;
30
    }
31

32
}

8、创建 SpringBoot 启动类

创建 SpringBoot 启动类：

1
import org.springframework.boot.SpringApplication;
2
import org.springframework.boot.autoconfigure.SpringBootApplication;
3

4
@SpringBootApplication
5
public class Application {
6

7
    public static void main(String[] args) {
8
        SpringApplication.run(Application.class, args);
9
    }
10

11
}

9、访问接口进行测试

输入地址：http://localhost:8080/test 测试是否能够从”mysql”和”postgresql”两个数据库中获取数据，结果如下：

1
{
2
    "userInfo": {
3
        "id": 1,
4
        "name": "小豆丁",
5
        "gender": "0",
6
        "age": 22
7
    },
8
    "account": {
9
        "id": 1,
10
        "username": "mydlq",
11
        "password": "123456",
12
        "createTime": "2021-01-01T00:00:00",
13
        "updateTime": "2021-01-01T00:00:00"
14
    }
15
}

根据上面测试结果可知，按上面配置确实能够实现从不同类型的数据库中读取数据，不过这种方法需要对创建多个数据源配置类才能适配多个数据库，实际使用起来还是比较繁琐的。下面将会演示如何使用 dynamic-datasource 提供的注解方式来实现多源数据库。

六、方案二使用数据库切换组件步骤

使用 dynamic-datasource 来支持多源数据库要简单的多，这里简单介绍下它的使用，如果想详细了解可以访问其官方文档，里面有详细的介绍如何使用该插件。

dynamic-datasource 官方文档地址：https://dynamic-datasource.com/

1、Maven 引入 dynamic-datasource 依赖

Maven 中引入 dynamic-datasource-spring-boot-starter 依赖：

1
<dependency>
2
    <groupId>com.baomidou</groupId>
3
    <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
4
    <version>3.3.1</version>
5
</dependency>

2、配置文件添加数据库参数

需要在 SpringBoot 配置文件 application.yml 中添加多数据源的数据库连接配置。

1
spring:
2
  datasource:
3
    dynamic:
4
      primary: db1  #设置默认的数据源或者数据源组，默认值即为 master
5
      strict: false #设置严格模式，默认false不启动. 启动后在未匹配到指定数据源时候会抛出异常,不启动则使用默认数据源。
6
      datasource:
7
        db1:
8
          url: jdbc:mysql://127.0.0.1:3306/db1?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8&useSSL=false
9
          username: root
10
          password: 123456
11
          driver-class-name: com.mysql.cj.jdbc.Driver
12
        db2:
13
          url: jdbc:postgresql://127.0.0.1:5432/db2?currentSchema=public
14
          username: postgre
15
          password: 123456
16
          driver-class-name: org.postgresql.Driver
17

18
## 配置 mapper 对应的 xml 文件目录
19
mybatis:
20
  mapper-locations: classpath:mappers/db1/*.xml,classpath*:/mappers/db2/*.xml

3、Service 类或者方法添加 @DS 注解

在 Service 类或者类中方法上添加 @DS 注解来标识使用哪个数据库。

1
@DS("db1")  //默认使用数据库1
2
@Service
3
public class TestService {
4

5
    /**
6
     * 切换到数据库一读取数据
7
     */
8
    @DS("db1")
9
    public UserInfo findUserInfo(Integer id){
10
        ...
11
    }
12

13
    /**
14
     * 切换到数据库二读取数据
15
     */
16
    @DS("db2")
17
    public Account findAccount(Integer id){
18
        ...
19
    }
20

21
}

注解 @DS 可以配置在类或者方法上，同时存在就近原则，方法上注解优先于类上注解。上面类和方法上都加了 @DS 注解，如果类中方法上添加 @DS 注解，那则在调用数据库 Dao 方法时，使用以类上面的 @DS 注解中指定的数据库。如果方法上面添加了该注解，则使用注解中指定的数据库。当然，如果类和方法上都没有加注解的话，那么将会使用配置文件中 spring.datasource.dynamic.primary 指定的默认数据库。

注意：该组件实现方式是通过 Spring 的 AOP 进行数据源处理的，所以方法调用同一个类中的其它方法是不生效的（会使用配置的默认数据库），必须通过引入操作数据库的 Bean 来调用切换数据库的方法才能正常使用。

七、方案二示例：使用数据库切换组件实现

示例项目地址：SpringBoot + Mybatis 通过使用 dynamic-datasource 实现多源数据库示例

使用组件 dynamic-datasource 来实现多数据源支持，这里直接读取上面准备的两种类型的数据库中两个表中的数据，实现一个项目中调用两种数据库进行查询。创建一个测试接口，将查询到的数据拼接在一起进行返回。示例代码如下：

1、Maven 引入相关依赖

Maven 的 pom.xml 文件引入 SpringBoot、Myabtis、Lombok、dynamic-datasource、Mysql 和 Postgresql 相关依赖，内容如下：

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

6
    <parent>
7
        <groupId>org.springframework.boot</groupId>
8
        <artifactId>spring-boot-starter-parent</artifactId>
9
        <version>2.4.1</version>
10
    </parent>
11

12
    <groupId>mydlq.club</groupId>
13
    <artifactId>springboot-mybatis-many-database-dynamic</artifactId>
14
    <version>0.0.1</version>
15
    <name>springboot-mybatis-many-database-dynamic</name>
16
    <description>database demo</description>
17

18
    <properties>
19
        <java.version>1.8</java.version>
20
    </properties>
21

22
    <dependencies>
23
        <!-- SpringBoot Web -->
24
        <dependency>
25
            <groupId>org.springframework.boot</groupId>
26
            <artifactId>spring-boot-starter-web</artifactId>
27
        </dependency>
28
        <!-- Lombok -->
29
        <dependency>
30
            <groupId>org.projectlombok</groupId>
31
            <artifactId>lombok</artifactId>
32
        </dependency>
33
        <!-- Mysql -->
34
        <dependency>
35
            <artifactId>mysql-connector-java</artifactId>
36
            <groupId>mysql</groupId>
37
        </dependency>
38
        <!-- Postgresql -->
39
        <dependency>
40
            <groupId>org.postgresql</groupId>
41
            <artifactId>postgresql</artifactId>
42
            <scope>runtime</scope>
43
        </dependency>
44
        <!-- Mybatis SpringBoot -->
45
        <dependency>
46
            <groupId>org.mybatis.spring.boot</groupId>
47
            <artifactId>mybatis-spring-boot-starter</artifactId>
48
            <version>2.1.4</version>
49
        </dependency>
50
        <!-- Dynamic Datasource -->
51
        <dependency>
52
            <groupId>com.baomidou</groupId>
53
            <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
54
            <version>3.3.1</version>
55
        </dependency>
56
    </dependencies>
57

58
    <build>
59
        <plugins>
60
            <plugin>
61
                <groupId>org.springframework.boot</groupId>
62
                <artifactId>spring-boot-maven-plugin</artifactId>
63
            </plugin>
64
        </plugins>
65
    </build>
66

67
</project>

上面没有配置数据库连接池，由于 SpringBoot 2.x 以后默认引入 Hikari 连接池，性能很好，所以我们使用其默认连接池即可。

2、配置文件中添加相关参数

在 SpringBoot 配置文件 application.yml 中，配置数据库相关配置。由于我们会用到两个数据库，所以这里我们配置两套数据库配置：

db1：用于连接 mysql 数据库的配置。
db2：用于连接 postgresql 数据库的配置。

application.yml 文件内容如下：

1
spring:
2
  datasource:
3
    dynamic:
4
      primary: db1 #设置默认的数据源或者数据源组,默认值即为master
5
      strict: false #设置严格模式,默认false不启动. 启动后在未匹配到指定数据源时候会抛出异常,不启动则使用默认数据源。
6
      datasource:
7
        db1:
8
          url: jdbc:mysql://192.168.2.31:30336/db1?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8&useSSL=false
9
          username: root
10
          password: 123456
11
          driver-class-name: com.mysql.cj.jdbc.Driver
12
        db2:
13
          url: jdbc:postgresql://192.168.2.31:30432/db2?currentSchema=public
14
          username: postgre
15
          password: 123456
16
          driver-class-name: org.postgresql.Driver
17

18
## 指定 Mapper 对应的 xml 文件目录地址
19
mybatis:
20
  mapper-locations: classpath:mappers/db1/*.xml,classpath*:/mappers/db2/*.xml

3、创建实体类

数据库1的实体类： UserInfo

1
import lombok.Data;
2

3
@Data
4
public class UserInfo {
5
    /** 主键 */
6
    private Integer id;
7
    /** 姓名 */
8
    private String name;
9
    /** 性别（0:男，1:女）*/
10
    private String gender;
11
    /** 岁数 */
12
    private Byte age;
13
}

数据库2的实体类： Account

1
import java.time.LocalDateTime;
2
import lombok.Data;
3

4
@Data
5
public class Account {
6
    /** 主键 */
7
    private Integer id;
8
    /** 用户名 */
9
    private String username;
10
    /** 密码 */
11
    private String password;
12
    /** 创建时间 */
13
    private LocalDateTime createTime;
14
    /** 更新时间 */
15
    private LocalDateTime updateTime;
16
}

4、创建操作数据库的 Mapper 类和 Xml 文件

数据库1

创建 Mapper 类 UserInfoMapper

1
import mydlq.club.example.model.db1.UserInfo;
2
import org.apache.ibatis.annotations.Mapper;
3

4
@Mapper
5
public interface UserInfoMapper {
6

7
    /**
8
     * 根据主键查找数据
9
     *
10
     * @param id 主键ID
11
     * @return 数据
12
     */
13
    UserInfo selectByPrimaryKey(Integer id);
14

15
}

位置 /resources/mappers/db1 创建 Mapper 文件 UserInfoMapper.xml

1
<?xml version="1.0" encoding="UTF-8"?>
2
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
3
<mapper namespace="mydlq.club.example.dao.db1.UserInfoMapper">
4

5
  <resultMap id="BaseResultMap" type="mydlq.club.example.model.db1.UserInfo">
6
    <id column="id" jdbcType="INTEGER" property="id" />
7
    <result column="name" jdbcType="VARCHAR" property="name" />
8
    <result column="gender" jdbcType="VARCHAR" property="gender" />
9
    <result column="age" jdbcType="TINYINT" property="age" />
10
  </resultMap>
11

12
  <select id="selectByPrimaryKey" parameterType="java.lang.Integer" resultMap="BaseResultMap">
13
    SELECT id, `name`, gender, age
14
    FROM t_user_info
15
    WHERE id = #{id,jdbcType=INTEGER}
16
  </select>
17

18
</mapper>

数据库2

创建 Mapper 类 AccountMapper

1
import mydlq.club.example.model.db2.Account;
2
import org.apache.ibatis.annotations.Mapper;
3

4
@Mapper
5
public interface AccountMapper {
6
    /**
7
     * 根据主键查找数据
8
     *
9
     * @param id 主键ID
10
     * @return 数据
11
     */
12
    Account selectByPrimaryKey(Integer id);
13

14
}

位置 /resources/mappers/db2 创建 Mapper 文件 AccountMapper.xml

1
<?xml version="1.0" encoding="UTF-8"?>
2
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
3
<mapper namespace="mydlq.club.example.dao.db2.AccountMapper">
4

5
  <resultMap id="BaseResultMap" type="mydlq.club.example.model.db2.Account">
6
    <id column="id" jdbcType="BIGINT" property="id" />
7
    <result column="username" jdbcType="VARCHAR" property="username" />
8
    <result column="password" jdbcType="VARCHAR" property="password" />
9
    <result column="create_time" jdbcType="TIMESTAMP" property="createTime" />
10
    <result column="update_time" jdbcType="TIMESTAMP" property="updateTime" />
11
  </resultMap>
12

13
  <select id="selectByPrimaryKey" parameterType="java.lang.Integer" resultMap="BaseResultMap">
14
    SELECT id, username, "password", create_time, update_time
15
    FROM t_account
16
    WHERE id = #{id,jdbcType=INTEGER}
17
  </select>
18

19
</mapper>

5、创建测试的 Service 类

创建测试的 Service 类，类中创建 findUserInfo() 和 findAccount() 两个方法，并且：

在 findUserInfo() 方法上加上 @DS("db1") 注解，表示调用方法时切换数据库一获取数据。
在 findAccount() 方法上加上 @DS("db2") 注解，表示调用方法时切换数据库二获取数据。

这样我们使用 findUserInfo() 和 findAccount() 方法时就会从不同的数据库中获取数据。

1
import com.baomidou.dynamic.datasource.annotation.DS;
2
import mydlq.club.example.dao.db1.UserInfoMapper;
3
import mydlq.club.example.dao.db2.AccountMapper;
4
import mydlq.club.example.model.db1.UserInfo;
5
import mydlq.club.example.model.db2.Account;
6
import org.springframework.beans.factory.annotation.Autowired;
7
import org.springframework.stereotype.Service;
8

9
@Service
10
public class TestService {
11

12
    @Autowired
13
    private AccountMapper accountMapper;
14
    @Autowired
15
    private UserInfoMapper userInfoMapper;
16

17
    /**
18
     * 通过 @DS 注解指定使用 DB1 数据库，查询用户信息
19
     * @param id 主键ID
20
     * @return 用户信息
21
     */
22
    @DS("db1")
23
    public UserInfo findUserInfo(Integer id){
24
        return userInfoMapper.selectByPrimaryKey(id);
25
    }
26

27
    /**
28
     * 通过 @DS 注解指定使用 DB2 数据库，查询账户数据
29
     * @param id 主键ID
30
     * @return 账户数据
31
     */
32
    @DS("db2")
33
    public Account findAccount(Integer id){
34
        return accountMapper.selectByPrimaryKey(id);
35
    }
36

37
}

7、创建测试的 Controller 类

创建测试用的 Controller 类，里面调用上面创建的 Service 类中查询两个数据库数据的方法 findUserInfo() 和 findAccount() 来获取两个库中的数据，并提供测试访问的接口 /test，方便后续进行测试。

1
import mydlq.club.example.model.AccountUserInfo;
2
import mydlq.club.example.model.db1.UserInfo;
3
import mydlq.club.example.model.db2.Account;
4
import mydlq.club.example.service.TestService;
5
import org.springframework.beans.factory.annotation.Autowired;
6
import org.springframework.web.bind.annotation.GetMapping;
7
import org.springframework.web.bind.annotation.RestController;
8

9
@RestController
10
public class TestController {
11

12
    @Autowired
13
    private TestService testService;
14

15
    /**
16
     * 同时查询两个库的数据
17
     * @return 查询结果
18
     */
19
    @GetMapping("/test")
20
    public Object hello1() {
21
        // 查询账户数据
22
        Account account = testService.findAccount(1);
23
        // 查询用户信息
24
        UserInfo userInfo = testService.findUserInfo(1);
25
        // 创建响应对象
26
        AccountUserInfo accountUserInfo = new AccountUserInfo();
27
        accountUserInfo.setAccount(account);
28
        accountUserInfo.setUserInfo(userInfo);
29
        return accountUserInfo;
30
    }
31

32
}

8、创建 SpringBoot 启动类

创建 SpringBoot 启动类：

1
import org.springframework.boot.SpringApplication;
2
import org.springframework.boot.autoconfigure.SpringBootApplication;
3

4
@SpringBootApplication
5
public class Application {
6

7
    public static void main(String[] args) {
8
        SpringApplication.run(Application.class, args);
9
    }
10

11
}

9、访问接口进行测试

输入地址：http://localhost:8080/test 测试是否能够从”mysql”和”postgresql”两个数据库中获取数据，结果如下：

1
{
2
    "userInfo": {
3
        "id": 1,
4
        "name": "小豆丁",
5
        "gender": "0",
6
        "age": 22
7
    },
8
    "account": {
9
        "id": 1,
10
        "username": "mydlq",
11
        "password": "123456",
12
        "createTime": "2021-01-01T00:00:00",
13
        "updateTime": "2021-01-01T00:00:00"
14
    }
15
}

根据上面测试结果可知，使用 dynamic-datasource 实现多源数据库是非常方便的，能够正常从两个不同类型的数据库中读取数据，并且使用插件的注解方式要比使用配置数据源方式简单的多。

八、使用多源数据库切换注意事项

使用时虽然能对多个数据库操作，不过设计到事务时，例如使用 Spring 的 @Transactional 注解添加到事务的方法上，如果方法中只操作一个数据库是可以正常执行事务的。如果操作多个数据库，事务是无法正常执行的。如果想对多个数据库进行事务，需要使用分布式事务来解决该问题。

---END---

如果本文对你有帮助，可以关注我的公众号 "小豆丁技术栈" 了解最新动态，顺便也请帮忙 Github 点颗星哦，感谢~