SpringBoot+Mybatis配置多数据源并且实现事务一致性

最近博客写得少，不知道怎么说开场白了。呃，本文一共分三部分：SpringBoot+Mybatis环境搭建、两种方式配置多数据源、两种方式实现跨数据源事务，您可以直接跳到喜欢的部分，不过按顺序看完也不会花很多时间。。。

一、搭建SpringBoot+Mybatis框架环境

看标题就知道，这部分不是重点，所以简单说一下（如果你是小白那对不起了~）。

1、引入依赖

Mybatis整合包和jdbc驱动包，默认使用的是HikariDataSource数据源（如果你要使用阿里爸爸的Druid就要单独引入）。

        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.1</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

2、填写配置

application.yml写上数据源配置信息。

spring:
  datasource:
    username: test
    password: test
    url: jdbc:mysql://jiubugaosuni.com:8888/test?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=UTC
    driver-class-name: com.mysql.cj.jdbc.Driver

实际开发中还有其它更详细的配置，这里就不列了。还可以配置一下Mybatis的参数。

3、建立mapper接口及配置Mybatis扫描包

建一个mapper包并把所有DAO接口都放里面。比如StudentMapper长这样。

package cn.zhh.mapper;

import cn.zhh.entity.Student;

/**
 * 学生Mapper
 *
 * @author Zhou Huanghua
 * @date 2019/10/25 23:09
 */
public interface StudentMapper {

    /**
     * 插入一条学生记录
     *
     * @param student 学生信息
     * @return 插入数量
     */
    int insert(Student student);

    /**
     * 根据id删除学生记录
     *
     * @param id 学生id
     * @return 删除数量
     */
    int deleteById(Long id);
}

但是目前这些接口不会被Mybatis扫描到，所以需要在接口上面加一个Mapper注解。不过，更推荐配置Mybatis扫描包的方式，比如在启动类加一下这个：@MapperScan(basePackages = "cn.zhh.mapper.**")。好像在application.yml也是可以配的，没验证过。

4、Mapper.xml文件

推荐在resources目录下新建一个和Mapper接口一样的包，把xml文件都放里面，然后什么都不用配置。比如StudentMapper对应的StudentMapper.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="cn.zhh.mapper.StudentMapper">

    <resultMap id="BaseResultMap" type="cn.zhh.entity.Student">
        <result column="id" jdbcType="BIGINT" property="id"/>
        <result column="name" jdbcType="VARCHAR" property="name"/>
        <result column="code" jdbcType="VARCHAR" property="code"/>
        <result column="sex" jdbcType="TINYINT" property="sex"/>
        <result column="create_time" jdbcType="DATE" property="createTime"/>
        <result column="last_update_time" jdbcType="DATE" property="lastUpdateTime"/>
        <result column="is_deleted" jdbcType="TINYINT" property="isDeleted"/>
    </resultMap>

    <insert id="insert" parameterType="cn.zhh.entity.Student">
        INSERT INTO student (`name`, `code`, `sex`) VALUES (#{name, jdbcType=VARCHAR}, #{code, jdbcType=VARCHAR}, #{sex, jdbcType=TINYINT})
    </insert>

    <delete id="deleteById" parameterType="java.lang.Long">
        DELETE FROM student WHERE id = #{id, jdbcType=BIGINT}
    </delete>
</mapper>

另外，在Mapper接口的上面也是可以写sql的，但是那样不推荐，第一是灵活性有限复杂的搞不了，第二是不利于统一管理维护。

总结Q&A    Q：你这写得太简单了吧！？A：毕竟这不是重点(*^_^*)。

二、两种方式配置多数据源

啥叫多数据源？简单来说就是一个系统需要操作多个数据库（同实例或者不同实例），一个读这个写那个，一个读那个写这个。

1、动态切换数据源 

在进入一个方法执行DB操作之前，根据配置（注解或者包名啥的）切换到对应的那个数据源，执行完成后再切换回去（可选），这个方法执行前执行后通过AOP处理。

这种方式之前写过对应的博客（传送门），此处不再赘述。

如果方法使用事务的话，可能会导致切换失败。我在项目使用时遇到过，当时由于工期紧没去深入研究，直接采用了第二种实现方式。下图是当时百度了一下看到的

2、不同的mapper接口包使用不同的数据源

通过配置不同的Mapper接口扫描路径使用不同的SqlSessionTemplate来实现。不同的SqlSessionTemplate就是不同的SqlSessionFactory，也就是不同的DataSource。

1）配置两个不同的数据源

application.yml配置两个数据源信息。

spring:
  datasource:
    username: test
    password: test
    url: jdbc:mysql://jiubugaosuni.com:8888/test?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=UTC
    driver-class-name: com.mysql.cj.jdbc.Driver
  datasource2:
      username: test2
      password: test2
      url: jdbc:mysql://biexiangzhidao.net:6666/test2?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=UTC
      driver-class-name: com.mysql.cj.jdbc.Driver

Java Bean的方式注册两个数据源。注意选择一个加上@Primary，这样基于Type方式的注入（如@Autowired）就可以使用它作为默认的注入对象了。

/**
 * 数据源配置
 *
 * @author Zhou Huanghua
 * @date 2019/10/26 0:24
 */
@Configuration
public class DataSourceConfig {

    @Bean
    @Primary
    public DataSource dataSource(@Value("${spring.datasource.username}") String username,
                                 @Value("${spring.datasource.password}") String password,
                                 @Value("${spring.datasource.url}") String url,
                                 @Value("${spring.datasource.driver-class-name}") String driverClassName) {
        return createDataSource(username, password, url, driverClassName);
    }

    @Bean
    public DataSource dataSource2(@Value("${spring.datasource2.username}") String username,
                                  @Value("${spring.datasource2.password}") String password,
                                  @Value("${spring.datasource2.url}") String url,
                                  @Value("${spring.datasource2.driver-class-name}") String driverClassName) {
        return createDataSource(username, password, url, driverClassName);
    }

    private DataSource createDataSource(String username, String password, String url, String driverClassName) {
        HikariDataSource dataSource = new HikariDataSource();
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        dataSource.setJdbcUrl(url);
        dataSource.setDriverClassName(driverClassName);
        return dataSource;
    }
}

2）配置两套Mapper接口扫描路径，并指定对应的SqlSessionTemplate

这里我们使用一个外部类两个静态内部类的方式使用Java Bean配置，分成两个独立的类也是可以的。两个basePackages设置不同的sqlSessionTemplateRef属性：mapper包的将使用第一个数据源，mapper2包的将使用第二个数据源。使用@Primary的目的同上。

/**
 * MybatisConfig配置类
 *
 * @author Zhou Huanghua
 * @date 2019/10/26 0:31
 */
public class MybatisConfig {

    @Configuration
    @MapperScan(
            basePackages = "cn.zhh.mapper",
            sqlSessionTemplateRef = "sqlSessionTemplate")
    public static class Db1 {

        @Bean
        @Primary
        public SqlSessionFactory sqlSessionFactory(@Qualifier("dataSource") DataSource dataSource) throws Exception {
            SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
            factoryBean.setDataSource(dataSource);
            return factoryBean.getObject();
        }

        @Bean
        @Primary
        public SqlSessionTemplate sqlSessionTemplate(@Qualifier("sqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
            return new SqlSessionTemplate(sqlSessionFactory);
        }

        @Bean
        @Primary
        public DataSourceTransactionManager dataSourceTransactionManager(@Qualifier("dataSource") DataSource dataSource) {
            return new DataSourceTransactionManager(dataSource);
        }
    }

    @Configuration
    @MapperScan(
            basePackages = "cn.zhh.mapper2",
            sqlSessionTemplateRef = "sqlSessionTemplate2")
    public static class Db2 {

        @Bean
        public SqlSessionFactory sqlSessionFactory2(@Qualifier("dataSource2") DataSource dataSource) throws Exception {
            SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
            factoryBean.setDataSource(dataSource);
            return factoryBean.getObject();
        }

        @Bean
        public SqlSessionTemplate sqlSessionTemplate2(@Qualifier("sqlSessionFactory2") SqlSessionFactory sqlSessionFactory) throws Exception {
            return new SqlSessionTemplate(sqlSessionFactory);
        }

        @Bean
        public DataSourceTransactionManager dataSourceTransactionManager2(@Qualifier("dataSource2") DataSource dataSource) {
            return new DataSourceTransactionManager(dataSource);
        }
    }
}

3）使用不同数据源的Mapper接口和mapper.xml放到不同的包

4）使用事务时指定对应的事务管理器

如果是第一个数据源使用事务，则不需要指定，因为它的事务管理器注册时加了@Primary。其它数据源要使用的话则指定对应的事务管理器。如第二个数据源的事务管理器注册时这样写的

那么在使用事务时，就需要指定对应事务管理器

因为@Transactional只能指定一个事务管理器，并且注解不允许重复，所以就只能使用一个数据源的事务管理器了。那么对于一个方法涉及到多个数据源操作需要保证事务一致性的怎么办呢？请继续往下看。

三、两种方式实现跨数据源事务

1、atomikos

atomikos是实现了XA的一种分布式事务处理工具。XA协议就是两阶段提交，更详细的说明放在第二种方式那里去讲。

这也是推荐大家使用的，毕竟人家是流行框架。我呢就不详细讲了，童鞋们去Google一下会有你想要的。

2、注解+切面 = 自己实现

先说一下两阶段提交：首先多个数据源的事务分别都开起来，然后各事务分别去执行对应的sql（此所谓第一阶段提交），最后如果都成功就把事务全部提交，只要有一个失败就把事务都回滚——此所谓第二阶段提交。

前面说过，Transactional注解只能指定一个数据源的事务管理器。我们重新定义一个，让它支持指定多个数据源的事务管理器，然后我们在使用了这个注解的方法前后进行所谓的两阶段协议。

/**
 * 多数据源事务注解
 *
 * @author Zhou Huanghua
 * @date 2019/10/26 1:16
 */
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface MultiDataSourceTransactional {

    /**
     * 事务管理器数组
     */
    String[] transactionManagers();
}

说到方法前后，相信很多人想到了AOP。那么就用Spring的Aspect来完成我们的想法吧。 

先来回顾一下它的切入点

• @Before:  标识一个前置增强方法，相当于BeforeAdvice的功能。
• @After:  后置增强，不管是抛出异常或者正常退出都会执行。
• @AfterReturning:  后置增强，似于AfterReturningAdvice, 方法正常退出时执行。
• @AfterThrowing:  异常抛出增强，相当于ThrowsAdvice。
• @Around: 环绕增强，相当于MethodInterceptor。

咋一看，@Around是可以的：ProceedingJoinPoint的proceed方法是执行目标方法，在它前面声明事务，try...catch...一下如果有异常就回滚没异常就提交。不过，最开始用这个的时候，好像发现有点问题，具体记不住了，大家可以试一下。因为当时工期紧没仔细研究，就采用了下面这种

@Before + @AfterReturning + @AfterThrowing组合，看名字和功能简直是完美契合啊！但是有一个问题，不同方法怎么共享那个事务呢？成员变量？对，没错。但是又有线程安全问题咋办？ThreadLocal帮你解决(*^_^*)。

直接上代码

/**
 * 多数据源事务切面
 * ※采用Around似乎不行※
 *
 * @author Zhou Huanghua
 * @date 2019/10/26 1:16
 */
@Component
@Aspect
public class MultiDataSourceTransactionAspect {

    /**
     * 线程本地变量：为什么使用栈？※为了达到后进先出的效果※
     */
    private static final ThreadLocal<Stack<Pair<DataSourceTransactionManager, TransactionStatus>>> THREAD_LOCAL = new ThreadLocal<>();

    /**
     * 用于获取事务管理器
     */
    @Autowired
    private ApplicationContext applicationContext;

    /**
     * 事务声明
     */
    private DefaultTransactionDefinition def = new DefaultTransactionDefinition();
    {
        // 非只读模式
        def.setReadOnly(false);
        // 事务隔离级别：采用数据库的
        def.setIsolationLevel(TransactionDefinition.ISOLATION_DEFAULT);
        // 事务传播行为
        def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
    }

    /**
     * 切面
     */
    @Pointcut("@annotation(cn.zhh.annotation.MultiDataSourceTransactional)")
    public void pointcut() {
    }

    /**
     * 声明事务
     *
     * @param transactional 注解
     */
    @Before("pointcut() && @annotation(transactional)")
    public void before(MultiDataSourceTransactional transactional) {
        // 根据设置的事务名称按顺序声明，并放到ThreadLocal里
        String[] transactionManagerNames = transactional.transactionManagers();
        Stack<Pair<DataSourceTransactionManager, TransactionStatus>> pairStack = new Stack<>();
        for (String transactionManagerName : transactionManagerNames) {
            DataSourceTransactionManager transactionManager = applicationContext.getBean(transactionManagerName, DataSourceTransactionManager.class);
            TransactionStatus transactionStatus = transactionManager.getTransaction(def);
            pairStack.push(new Pair(transactionManager, transactionStatus));
        }
        THREAD_LOCAL.set(pairStack);
    }

    /**
     * 提交事务
     */
    @AfterReturning("pointcut()")
    public void afterReturning() {
        // ※栈顶弹出（后进先出）
        Stack<Pair<DataSourceTransactionManager, TransactionStatus>> pairStack = THREAD_LOCAL.get();
        while (!pairStack.empty()) {
            Pair<DataSourceTransactionManager, TransactionStatus> pair = pairStack.pop();
            pair.getKey().commit(pair.getValue());
        }
        THREAD_LOCAL.remove();
    }

    /**
     * 回滚事务
     */
    @AfterThrowing(value = "pointcut()")
    public void afterThrowing() {
        // ※栈顶弹出（后进先出）
        Stack<Pair<DataSourceTransactionManager, TransactionStatus>> pairStack = THREAD_LOCAL.get();
        while (!pairStack.empty()) {
            Pair<DataSourceTransactionManager, TransactionStatus> pair = pairStack.pop();
            pair.getKey().rollback(pair.getValue());
        }
        THREAD_LOCAL.remove();
    }
}

需要注意的点：

• 1）声明事务和提交事务或者回滚事务的顺序应该相反的，就是先进后出，所以采用了栈来存储。
• 2）线程执行结束后记得清空本地变量。
• 3）Pair用来存储一对数据，很多场景能够派上用场取代Map。
• 4）可以参照@Transactional的那些属性升级功能，比如隔离级别回滚异常等。

用法的话就是下面这样子啦，亲测可用（student和user在不同数据库的表）。

废话不说，本文结束。

所有代码均已上传至Github，点此前往