SpringBoot+Mybatis多数据源连接

在实际的业务场景中，存在当个项目需要访问多个数据源进行数据读写的场景。除了使用JDBC直连数据库外，Mybatis也支持配置多个数据源。本文便记录如果在SpringBoot项目中使用Mybatis进行两个数据源的读写。

需求描述：在主数据库springbootdb存有用户信息表和用户-城市关系表，从数据库springbootdb_cluster存有城市信息表。开发一个接口根据用户名查找用户基本信息和用户所在城市信息。

在单数据源的场景下，我们没有介入SpringBoot创建Mybatis执行SQL所需的SqlSession的流程，SpringBoot自动从application.properties文件读取数据源信息以及Mybatis的SQL映射文件，并在项目入口文件通过MapperScan指定进行数据读写操作的dao接口。

@SpringBootApplication
// mapper 接口类扫描包配置
@MapperScan("org.spring.springboot.dao")
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class,args);
    }
}

为了实现Mybatis支持多数据源，我们需要介入数据源加载、生成不同数据源对应SqlSession、指定每个数据源对应的dao接口和SQL映射文件的几个流程。

参考资料：

GitHub（springboot-learning-example）

SpringBoot和Mybatis配置多数据源连接多个数据库

Spring Boot(七)：Mybatis 多数据源最简解决方案

开发环境

IDEA 2019.2.4 + JDK1.8 + maven 3.3.9 + mysql

数据准备

主数据库名称：springbootdb

建表和数据初始化脚本：用户信息表demo_user_t

drop table if exists demo_user_t;

CREATE TABLE demo_user_t ( 
user_id INT NOT NULL primary key, 
user_name VARCHAR (20),
user_age INT,
user_height NUMERIC,
brithday DATE, 
creation_date DATE, 
last_update_date DATE 
);

insert INTO demo_user_t VALUES(1000, 'Jason', 20, 178, current_date-5, current_date, current_date);
insert INTO demo_user_t VALUES(1001, 'Jony', 16, 170, current_date-14, current_date, current_date);
commit;


drop table if exists demo_user_city_t;

CREATE TABLE demo_user_city_t ( 
user_id INT NOT NULL,
city_id INT NOT NULL, 
enabled_flag INT,
creation_date DATE, 
last_update_date DATE 
);

insert INTO demo_user_city_t VALUES(1000, 2000, 1, current_date, current_date);
insert INTO demo_user_city_t VALUES(1001, 2001, 1, current_date, current_date);
commit;

从数据库名称：springbootdb_cluster

建表和数据初始化脚本：城市信息表demo_city_t

drop table if exists demo_city_t;

CREATE TABLE demo_city_t ( 
city_id INT NOT NULL primary key, 
city_name VARCHAR (50),
province_name VARCHAR(50),
description VARCHAR(100),
creation_date DATE, 
last_update_date DATE  
);

insert INTO demo_city_t VALUES(2000, 'beijing', 'BEIJING', '中国首都', current_date, current_date);
insert INTO demo_city_t VALUES(2001, 'shenzhen', 'GUANGDONG', '改革开放城市', current_date, current_date);
commit;

项目结构

• src/pom.xml文件配置依赖项.
• src/java/[package]/Application.java为应用启动入口。
• src/java/[package]/controller/存放定义对外开放的Restful API文件。
• src/java/[package]/service/存放支撑Restful API的服务接口定义类。
• src/java/[package]/service/impl/存放服务接口的实现类。
• src/java/[package]/dao/master存放进行主数据库读写操作的接口定义类。
• src/java/[package]/dao/cluster存放进行从数据库读写操作的接口定义类。
• src/java/[package]/config/ds/存放进行主、从数据源的加载配置类。多数源配置的核心实现。
• src/java/[package]/domain/存放用于向SQL传递执行参数以及接收SQL执行结果的POJO类。
• src/resource/mapper/master存放进行主数据库读写操作的接口对应的SQL脚本。
• src/resource/mapper/cluster存放进行从数据库读写操作的接口对应的SQL脚本。
• src/resource/application.properties文件配置SpringBoot应用的属性，对本文来说是主从数据源信息、mybatis的SQL映射文件路径放在congfig/ds/的数据源加载类中指定。

引入依赖

主要引入mybatis-spring-boot-starter、mysql-connector-java，数据库连接池使用spring boot默认的Hikari即可。

    <properties>
        <mybatis-spring-boot>1.2.0</mybatis-spring-boot>
        <mysql-connector>8.0.17</mysql-connector>
    </properties>

		<!-- Spring Boot Mybatis 依赖 -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>${mybatis-spring-boot}</version>
        </dependency>

        <!-- MySQL 连接驱动依赖 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql-connector}</version>
        </dependency>

项目属性配置

src/resource/application.properties文件。和单数源场景相比，不需要再这里设置mybatis对应的mapper文件路径，该配置项放在数据源加载代码中处理。

## master 数据源配置
master.datasource.jdbc-url=jdbc:mysql://localhost:3306/springbootdb?serverTimezone=UTC
master.datasource.username=root
master.datasource.password=123456
master.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

## cluster 数据源配置
cluster.datasource.jdbc-url=jdbc:mysql://localhost:3306/springbootdb_cluster?serverTimezone=UTC
cluster.datasource.username=root
cluster.datasource.password=123456
cluster.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

POJO配置

在src/java/[package]/domain/先创建City.java以及User.java两个POJO类即可。

package org.spring.springboot.domain;
/* 用户实体类 */
public class User {
    private Long userId;
    private String userName;
    private String userAge;
    private Long cityId;
    private City city;
    //省略getter和setter方法
}

package org.spring.springboot.domain;
/* 城市实体类 */
public class City {
    private Long cityId;
    private String provinceName;
    private String cityName;
    private String description;
	//省略getter和setter方法
}

DAO配置

创建两个文件夹(包)分别存放主从数据源的dao接口类，便于在数据源加载类中根据路径设定每个数据源对应的dao接口。

• 创建master文件夹存放主数据源的dao接口UserDao.java

package org.spring.springboot.dao.master;

import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.spring.springboot.domain.User;

/* 用户 DAO 接口类 */
// @Mapper注解可不加
@Mapper
public interface UserDao {

    /**
     * 根据用户名获取用户信息
     *
     * @param userName
     * @return
     */
    User findByName(@Param("userName") String userName);
}

• 创建cluster文件夹存放从数据源的dao接口CityDao.java

package org.spring.springboot.dao.cluster;

import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.spring.springboot.domain.City;

/* 城市 DAO 接口类 */
// @Mapper注解可不加
@Mapper
public interface CityDao {

    /**
     * 根据城市名称，查询城市信息
     *
     * @param cityId 城市
     */
    City findById(@Param("cityId") Long cityId);
}

Mapper配置

和Dao对应，也创建两个文件夹分别存放主从数据源Dao接口对应的SQL映射文件，目的也是方便在创建数据源的SqlSessionFactory时根据路径设定每个数据源对应的dao接口。

• 创建master文件夹存放主数据源的dao接口对应的SQL映射文件UserMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="org.spring.springboot.dao.master.UserDao">
	<resultMap id="BaseResultMap" type="org.spring.springboot.domain.User">
		<result column="user_id" property="userId" />
		<result column="user_name" property="userName" />
		<result column="user_age" property="userAge" />
		<result column="city_id" property="cityId" />
	</resultMap>

	<select id="findByName" resultMap="BaseResultMap" parameterType="java.lang.String">
		SELECT
			t.user_id,
			t.user_name,
			t.user_age,
			uc.city_id
		FROM
			demo_user_t t
			JOIN demo_user_city_t uc ON t.user_id = uc.user_id
		WHERE
			1 = 1
			AND t.user_name = #{userName}
	</select>
</mapper>

• 创建cluster文件夹存放从数据源的dao接口对应的SQL映射文件CityMapper.xml。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="org.spring.springboot.dao.cluster.CityDao">
	<resultMap id="BaseResultMap" type="org.spring.springboot.domain.City">
		<result column="city_id" property="cityId" />
		<result column="province_name" property="provinceName" />
		<result column="city_name" property="cityName" />
		<result column="description" property="description" />
	</resultMap>

	<select id="findById" resultMap="BaseResultMap" parameterType="java.lang.Long">
		SELECT
			t.city_id,
			t.city_name,
			t.province_name,
			t.description
		FROM
			demo_city_t t
		WHERE
			1 = 1
			AND t.city_id = #{cityId}
	</select>
</mapper>

数据源配置

这一步是多数据源配置的核心，涉及读取项目配置文件中数据源信息并创建DataSource、对DataSource设置事务、根据DataSource和Mapper文件路径创建SqlSessionFactory、为每个数据源指定对应的Dao接口（通过包路径执行）。

• 在[package].config.ds下创建主数据源的配置类MasterDataSourceConfig.java。多数据源场景需要设置1个主数据源，给主数据源配置类的每个方法加上@Primary即可。

package org.spring.springboot.config.ds;
/* 省略包导入部分代码 */

@Configuration
// 扫描Dao接口,并给dao注入指定的sqlSessionFactoryRef
@MapperScan(basePackages = MasterDataSourceConfig.PACKAGE, sqlSessionFactoryRef = "masterSqlSessionFactory")
public class MasterDataSourceConfig {

    // 精确到 master 目录，以便跟其他数据源隔离
    static final String PACKAGE = "org.spring.springboot.dao.master";
    static final String MAPPER_LOCATION = "classpath:mapper/master/*.xml";

    //从配置文件读取数据源信息并创建DataSource
    @Bean(name = "masterDataSource")
    @ConfigurationProperties(prefix = "master.datasource")
    @Primary //声明是主数据源
    public DataSource masterDataSource() {
        return DataSourceBuilder.create().build();
    }
	
    //数据源事务设置
    @Bean(name = "masterTransactionManager")
    @Primary
    public DataSourceTransactionManager masterTransactionManager() {
        return new DataSourceTransactionManager(masterDataSource());
    }
	
    //根据DataSource和mapper映射文件路径创建SqlSessionFactory
    @Bean(name = "masterSqlSessionFactory")
    @Primary
    public SqlSessionFactory masterSqlSessionFactory(@Qualifier("masterDataSource") DataSource masterDataSource)
            throws Exception {
        final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(masterDataSource);
        sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver()
                .getResources(MasterDataSourceConfig.MAPPER_LOCATION));
        return sessionFactory.getObject();
    }

/* SqlSessionTemplate不创建也没发现有什么影响 */
//    @Bean(name = "masterSqlSessionTemplate")
//    @Primary
//    public SqlSessionTemplate masterSqlSessionTemplate(@Qualifier("masterSqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
//        return new SqlSessionTemplate(sqlSessionFactory);
//    }
}

• 在[package].config.ds下创建主数据源的配置类clusterDataSourceConfig.java。

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

    // 精确到 cluster 目录，以便跟其他数据源隔离
    static final String PACKAGE = "org.spring.springboot.dao.cluster";
    static final String MAPPER_LOCATION = "classpath:mapper/cluster/*.xml";

    @Bean(name = "clusterDataSource")
    @ConfigurationProperties(prefix = "cluster.datasource")
    public DataSource clusterDataSource() {
        return DataSourceBuilder.create().build();
    }

    @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(ClusterDataSourceConfig.MAPPER_LOCATION));
        return sessionFactory.getObject();
    }
}

Sevice接口及实现

• src/java/[package]/service/UserService.java定义有哪些服务可以支撑API功能。

package org.spring.springboot.service;
import org.spring.springboot.domain.User;
/* 用户业务接口层 */
public interface UserService {
    User findByName(String userName);
}

• src/java/[package]/service/impl/UserServiceImpl.java实现UserService定义的接口，会调用Dao的方法对数据库进行读写。使用方式和单数据源场景一致，可以同时使用不同数据源的dao。

package org.spring.springboot.service.impl;

import org.spring.springboot.dao.cluster.CityDao;
import org.spring.springboot.dao.master.UserDao;
import org.spring.springboot.domain.City;
import org.spring.springboot.domain.User;
import org.spring.springboot.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/* 用户业务实现层 */
@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao; // 主数据源

    @Autowired
    private CityDao cityDao; // 从数据源

    @Override
    public User findByName(String userName) {
        User user = userDao.findByName(userName);
        City city = cityDao.findById(user.getCityId());
        user.setCity(city);
        return user;
    }
}

Restful API定义

src/java/[package]/controller/UserRestController.java定义对外开放的Restful API，而API的实现逻辑由service承接。

package org.spring.springboot.controller;
/* 省略导包 */

/* 用户控制层 */
@RestController
public class UserRestController {

    @Autowired
    private UserService userService;

    @RequestMapping(value = "/api/user", method = RequestMethod.GET)
    public User findByName(@RequestParam(value = "userName", required = true) String userName) {
        return userService.findByName(userName);
    }
}

项目入口

在单数据源场景需要给加上注解@MapperScan("org.spring.springboot.dao")指定dao接口的扫描路径，在多数据源场景下，由于在数据源配置中已经为每个数据源的SqlSessionFactory指定，因此在项目入口不需要。

package org.spring.springboot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {

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

启动验证

在项目入口文件下，右键运行即可，控制台消息：

调用API接口进行测试：

控制台显示Hikari数据库连接池启动了两个连接：

改用Durid连接池

如果不想用Spring boot自带的Hikari连接池，而是使用阿里的Durid连接池，需要修改的地方只有3处。

引入依赖

在pom.xml增加如下配置项

   <properties>
        <druid>1.0.18</druid>
    </properties>

    <dependencies>
        <!-- Druid 数据连接池依赖 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>${druid}</version>
        </dependency>
	</dependencies>

增加Durid相关配置项

在application.properies文件中增加如下配置项

spring.datasource.durid.test-on-borrow=true
spring.datasource.durid.test-while-idle=true
spring.datasource.durid.test-on-return=false
spring.datasource.durid.validation-query=SELECT 1

修改数据源配置

数据源配置类中改用Durid生成DataSource。以主数据源为例，只需要做如下修改：

	/* 新增部分 */
	@Value("${master.datasource.jdbc-url}")
    private String url;

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

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

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

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

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

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

    @Value("${spring.datasource.durid.validation-query}")
    private String validationQuery;

    @Bean(name = "clusterDataSource")
    public DataSource clusterDataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(driverClass);
        dataSource.setUrl(url);
        dataSource.setUsername(user);
        dataSource.setPassword(password);
        dataSource.setTestOnBorrow(testOnBorrow);
        dataSource.setTestWhileIdle(testWhileIdle);
        dataSource.setTestOnReturn(testOnReturn);
        dataSource.setValidationQuery(validationQuery);
        return dataSource;
    }

	/* 注释掉用Hikari生成DataSource的部分 */
//    @Bean(name = "masterDataSource")
//    @ConfigurationProperties(prefix = "master.datasource")
//    @Primary
//    public DataSource masterDataSource() {
//        return DataSourceBuilder.create().build();
//    }

从数据源做相同修改即可。

启动测试：