SpringBoot多数据源切换及多数据源事务控制实现过程(附成功案例)

原創 杨启盛 2019-08-09 15:09

一、概述

项目采用spring-boot 2.1.6，mybatis，并采用了mybatis-plus中间件，数据库为mysql5.6。

二、实现过程

2.1 实现多数据源

根据网上的大部分人的分享，我大概理清了思路，大致是这样：

1.写一个Holder通过改变ThreadLocal来直接修改数据源的名称
2.写一个注解，再在aop里配置一下，需要切换时通过注解来完成

这两种实现其实都是大同小异的，知道其实现原理才是最重要的。
第一步、创建数据源上下文分配对象：DataSourceContextHolder

package com.daodianlai.commons.jdbc;

import lombok.extern.slf4j.Slf4j;

/**
 * DataSourceContextHolder
 *
 * @author yangqisheng
 * @date 2019/08/08
 */
@Slf4j
public class DataSourceContextHolder {

    private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();

    /**
     * 设置数据库
     *
     * @param dataBase 数据库名称
     */
    public static void setDataBase(String dataBase) {
        log.debug("切换到{" + dataBase + "}数据库");
        contextHolder.set(dataBase);
    }

    /**
     * 获取当前数据库名称
     *
     * @return 数据库名称
     */
    public static String getDataBase() {
        return (contextHolder.get());
    }

    /**
     * 清除已设置的数据库
     */
    public static void clearDataData() {
        log.debug("清除{" + contextHolder.get() + "}数据库");
        contextHolder.remove();
    }
}

第二步、实现路由切换AbstractRoutingDataSource

package com.daodianlai.commons.jdbc;

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

/**
 * 动态数据源路由切换
 *
 * @author yangqisheng
 * @date 2019/08/08
 */
public class DynamicDataSource extends AbstractRoutingDataSource {

    @Override
    protected Object determineCurrentLookupKey() {
        return DataSourceContextHolder.getDataBase();
    }
}

下一步是创建多数据源，因为采用了Mybatis-Plus所以将数据源配置放在了MybatisPlusConfig里。

package com.daodianlai.commons.config;

import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
import com.daodianlai.commons.jdbc.DynamicDataSource;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.type.JdbcType;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;

/**
 * MybatisPlusConfig
 *
 * @author yangqisheng
 * @date 2019/07/17
 */
@Configuration
@MapperScan(basePackages = {
        "com.daodianlai.*.dao.mapper",
        "com.daodianlai.*.*.dao.mapper"
})
public class MybatisPlusConfig {

    /**
     * 分页插件
     */
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }

    /**
     * 获取默认到店来数据源
     *
     * @return 到店来数据源
     */
    @Bean(name = "defaultDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.default")
    public DataSource defaultDataSource() {
        return DataSourceBuilder.create().build();
    }

    /**
     * 获取aswpx数据源
     *
     * @return 微评选数据源
     */
    @Bean(name = "aswpxDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.aswpx")
    public DataSource aswpxDataSource() {
        return DataSourceBuilder.create().build();
    }

    /**
     * 获取hhd数据源
     *
     * @return hhd数据源
     */
    @Bean(name = "hhdDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.hhd")
    public DataSource hhdDataSource() {
        return DataSourceBuilder.create().build();
    }

    /**
     * 动态数据源: 通过AOP在不同数据源之间动态切换
     *
     * @return 动态数据源
     */
    @Primary
    @Bean(name = "dynamicDataSource")
    public DataSource dynamicDataSource(
            @Qualifier("defaultDataSource") DataSource defaultDataSource,
            @Qualifier("aswpxDataSource") DataSource aswpxDataSource,
            @Qualifier("hhdDataSource") DataSource hhdDataSource) {
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        // 默认数据源
        dynamicDataSource.setDefaultTargetDataSource(defaultDataSource);
        // 配置多数据源
        Map<Object, Object> dataSourceMap = new HashMap();
        dataSourceMap.put("defaultDataSource", defaultDataSource());
        dataSourceMap.put("aswpxDataSource", aswpxDataSource);
        dataSourceMap.put("hhdDataSource", hhdDataSource);
        //设置数据源Map
        dynamicDataSource.setTargetDataSources(dataSourceMap);
        return dynamicDataSource;
    }

    @Bean(name = "sqlSessionFactory")
    public SqlSessionFactory sqlSessionFactory() throws Exception {
        MybatisSqlSessionFactoryBean sqlSessionFactory = new MybatisSqlSessionFactoryBean();
        sqlSessionFactory.setDataSource(dynamicDataSource(defaultDataSource(), aswpxDataSource(), hhdDataSource()));

        MybatisConfiguration configuration = new MybatisConfiguration();
        configuration.setJdbcTypeForNull(JdbcType.NULL);
        configuration.setMapUnderscoreToCamelCase(true);
        configuration.setCacheEnabled(false);
        sqlSessionFactory.setConfiguration(configuration);
        //添加插件
        sqlSessionFactory.setPlugins(new Interceptor[]{
                paginationInterceptor()
        });
        return sqlSessionFactory.getObject();
    }
}

最后一步就是定义拦截器，切换数据源

1.默认数据源 DefultDataSourceAspect
2.aswpx数据源 AswpxDataSourceAspect
3. hhd数据源 HhdDataSourceAspect

下面给一下具体实现：

package com.daodianlai.commons.jdbc;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 * DefaultDataSourceAspect
 *
 * @author yangqisheng
 * @date 2019/08/08
 */
@Aspect
@Order(-1)
@Component
public class AswpxDataSourceAspect {

    @Pointcut("execution(* com.daodianlai.marketing.dao.mapper.*Mapper.*(..))")
    public void defaultAspect() {
    }

    @Before("defaultAspect()")
    public void before(JoinPoint defaultAspect) {
        // 切换数据源
        DataSourceContextHolder.setDataSource("defaultDataSource");
    }

    @After("aswpxAspect()")
    public void after(JoinPoint defaultAspect) {
        // 清除数据源
        DataSourceContextHolder.clearDataSource();
    }
}

package com.daodianlai.commons.jdbc;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 * AswpxDataSourceAspect
 *
 * @author yangqisheng
 * @date 2019/08/08
 */
@Aspect
@Order(-1)
@Component
public class AswpxDataSourceAspect {

    @Pointcut("execution(* com.daodianlai.aswpx.dao.mapper.*Mapper.*(..))")
    public void aswpxAspect() {
    }

    @Before("aswpxAspect()")
    public void before(JoinPoint aswpxAspect) {
        // 切换数据源
        DataSourceContextHolder.setDataSource("aswpxDataSource");
    }

    @After("aswpxAspect()")
    public void after(JoinPoint aswpxAspect) {
        // 清除数据源
        DataSourceContextHolder.clearDataSource();
    }
}

package com.daodianlai.commons.jdbc;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 * HhdDataSourceAspect
 *
 * @author yangqisheng
 * @date 2019/08/08
 */
@Aspect
@Order(-1)
@Component
public class HhdDataSourceAspect {

    @Pointcut("execution(* com.daodianlai.zpi.hhd.dao.mapper.*Mapper.*(..))")
    public void hhdAspect() {
    }

    @Before("hhdAspect()")
    public void before(JoinPoint hhdAspect) {
        // 切换数据源
        DataSourceContextHolder.setDataSource("hhdDataSource");
    }

    @After("hhdAspect()")
    public void after(JoinPoint hhdAspect) {
        // 清除数据源
        DataSourceContextHolder.clearDataSource();
    }
}

至此已经完成了多数据源的配置，下面给出数据源配置：

spring:
  application:
    name: daodianlai-marketing
  aop:
    proxy-target-class: true
    auto: true
  datasource:
    default:
      jdbc-url: jdbc:mysql://localhost:3306/dapdianlai?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai
      username: root
      password: 123456
      driver-class-name: com.mysql.cj.jdbc.Driver
    aswpx:
      jdbc-url: jdbc:mysql://localhost:3306/aswpx?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai
      username: root
      password: 123456
      driver-class-name: com.mysql.cj.jdbc.Driver
    hhd:
      jdbc-url: jdbc:mysql://localhost:3306/hhd?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai
      username: root
      password: longsu
      driver-class-name: com.mysql.cj.jdbc.Driver

“重点解读一下jdbc-url”
正常我们设置数据源的时候用的都是url，这里为什么用的是jdbc-url呢？我是在这篇文章里找到的答案，有兴趣可以去看一下。

jdbcUrl is required with driverClassName错误解决
https://blog.csdn.net/newbie_907486852/article/details/81391525

好了，我做了系统测试，运行正常，那么多数据源这事做完了吗？
答案是“没有”！
当我在service的方法上加了一个事务注解后，报错了，代码如下

@Transactional(rollbackFor = {Exception.class})
public void updateData() {
    aswpxMapper.excute("update t_user set num = num + 1");
    daodianlaiMapper.excute("update t_visit set num = num + 1");
}

系统报了以下错误：

### Cause: java.sql.SQLSyntaxErrorException: Table 'daodianlai.t_visit' doesn't exist

很明显，是数据源没切回来，那么什么原因呢？
这篇文章讲得很详细，感兴趣的可以移步去看看

spring项目中多数据源无法切换的原因分析
https://blog.csdn.net/puhaiyang/article/details/88013712

所以，怎么才能实现切换动态数据源还能控制事务呢？
我在这篇文章里找到了方案，并自己成功实现了。

springboot+mybatis解决多数据源切换事务控制不生效的问题
https://blog.csdn.net/gaoshili001/article/details/79378902

下面我给出最终的实现代码，多数据源，分布式事务代码。
采用的是jpa+atomikos方案

根据Spring官方介绍，要想自己控制事务，则必须实现Transaction接口，所以我们来创建动态数据源事务实现类DynamicDataSourceTransaction

DynamicDataSourceTransaction.java

package com.daodianlai.commons.jdbc;

import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.transaction.Transaction;
import org.springframework.jdbc.CannotGetJdbcConnectionException;
import org.springframework.jdbc.datasource.DataSourceUtils;
import org.springframework.util.Assert;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

/**
 * 动态数据源事务
 *
 * @author yangqisheng
 * @date 2019/08/09
 */
@Slf4j
public class DynamicDataSourceTransaction implements Transaction {

    private final DataSource dataSource;
    private Connection defaultConnection;
    private String dataBaseName;
    private ConcurrentMap<String, Connection> dynamicConnectionMap;
    private boolean isConnectionTransactional;
    private boolean autoCommit;

    public DynamicDataSourceTransaction(DataSource dataSource) {
        Assert.notNull(dataSource, "No DataSource specified");
        this.dataSource = dataSource;
        this.dynamicConnectionMap = new ConcurrentHashMap<>();
        this.dataBaseName = DataSourceContextHolder.getDataBase();
    }

    @Override
    public Connection getConnection() throws SQLException {
        String dataBase = DataSourceContextHolder.getDataBase();
        if (dataBase.equals(dataBaseName)) {
            if (defaultConnection != null) {
                return defaultConnection;
            }
            openMainConnection();
            dataBaseName = dataBase;
            return defaultConnection;
        } else {
            if (!dynamicConnectionMap.containsKey(dataBase)) {
                try {
                    Connection conn = dataSource.getConnection();
                    dynamicConnectionMap.put(dataBase, conn);
                } catch (SQLException ex) {
                    throw new CannotGetJdbcConnectionException("Could not get JDBC Connection", ex);
                }
            }
            return dynamicConnectionMap.get(dataBase);
        }
    }

    private void openMainConnection() throws SQLException {
        this.defaultConnection = DataSourceUtils.getConnection(this.dataSource);
        this.autoCommit = this.defaultConnection.getAutoCommit();
        this.isConnectionTransactional = DataSourceUtils.isConnectionTransactional(this.defaultConnection, this.dataSource);

        if (log.isDebugEnabled()) {
            log.debug(
                    "JDBC Connection ["
                            + this.defaultConnection
                            + "] will"
                            + (this.isConnectionTransactional ? " " : " not ")
                            + "be managed by Spring");
        }
    }

    @Override
    public void commit() throws SQLException {
        if (this.defaultConnection != null && !this.isConnectionTransactional && !this.autoCommit) {
            if (log.isDebugEnabled()) {
                log.debug("Committing JDBC Connection [" + this.defaultConnection + "]");
            }
            this.defaultConnection.commit();
            for (Connection connection : dynamicConnectionMap.values()) {
                connection.commit();
            }
        }
    }

    @Override
    public void rollback() throws SQLException {
        if (this.defaultConnection != null && !this.isConnectionTransactional && !this.autoCommit) {
            if (log.isDebugEnabled()) {
                log.debug("Rolling back JDBC Connection [" + this.defaultConnection + "]");
            }
            this.defaultConnection.rollback();
            for (Connection connection : dynamicConnectionMap.values()) {
                connection.rollback();
            }
        }
    }

    @Override
    public void close() {
        DataSourceUtils.releaseConnection(this.defaultConnection, this.dataSource);
        for (Connection connection : dynamicConnectionMap.values()) {
            DataSourceUtils.releaseConnection(connection, this.dataSource);
        }
    }

    @Override
    public Integer getTimeout() {
        return null;
    }
}

重写动态数据源事务管理工厂
DynamicDataSourceTransactionFactory.java

package com.daodianlai.commons.jdbc;

import org.apache.ibatis.session.TransactionIsolationLevel;
import org.apache.ibatis.transaction.Transaction;
import org.mybatis.spring.transaction.SpringManagedTransactionFactory;

import javax.sql.DataSource;

/**
 * 重写动态数据源事务管理工厂
 *
 * @author yangqisheng
 * @date 2019/08/09
 */
public class DynamicDataSourceTransactionFactory extends SpringManagedTransactionFactory {

    @Override
    public Transaction newTransaction(DataSource dataSource, TransactionIsolationLevel level, boolean autoCommit) {
        return new DynamicDataSourceTransaction(dataSource);
    }
}

当然最后一步，我们完全的重写了MybatisPlusConfig
新MybatisPlusConfig.java

package com.daodianlai.commons.config;

import com.atomikos.icatch.jta.UserTransactionImp;
import com.atomikos.icatch.jta.UserTransactionManager;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
import com.daodianlai.commons.jdbc.DynamicDataSource;
import com.daodianlai.commons.jdbc.DynamicDataSourceTransactionFactory;
import com.mysql.cj.jdbc.MysqlXADataSource;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.type.JdbcType;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jta.atomikos.AtomikosDataSourceBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.DependsOn;
import org.springframework.context.annotation.Primary;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.transaction.jta.JtaTransactionManager;

import javax.sql.DataSource;
import javax.transaction.TransactionManager;
import javax.transaction.UserTransaction;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;

/**
 * MybatisPlusConfig
 *
 * @author yangqisheng
 * @date 2019/07/17
 */
@Configuration
@EnableTransactionManagement
@MapperScan(basePackages = {
        "com.daodianlai.*.dao.mapper",
        "com.daodianlai.*.*.dao.mapper"
})
public class MybatisPlusConfig {

    /**
     * 分页插件
     */
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }

    @Primary
    @Bean(name = "defaultDataSourceProperties")
    @Qualifier("defaultDataSourceProperties")
    @ConfigurationProperties(prefix = "spring.datasource.default")
    public DataSourceProperties defaultDataSourceProperties() {
        return new DataSourceProperties();
    }

    /**
     * 获取默认到店来数据源
     *
     * @return 到店来数据源
     */
    @Bean(name = "defaultDataSource", initMethod = "init", destroyMethod = "close")
    @ConfigurationProperties(prefix = "spring.datasource.default")
    public DataSource defaultDataSource() throws SQLException {
        MysqlXADataSource mysqlXaDataSource = new MysqlXADataSource();
        mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);
        mysqlXaDataSource.setUrl(defaultDataSourceProperties().getUrl());
        mysqlXaDataSource.setUser(defaultDataSourceProperties().getUsername());
        mysqlXaDataSource.setPassword(defaultDataSourceProperties().getPassword());

        AtomikosDataSourceBean xaDataSource = new AtomikosDataSourceBean();
        xaDataSource.setXaDataSource(mysqlXaDataSource);
        xaDataSource.setUniqueResourceName("default");
        xaDataSource.setBorrowConnectionTimeout(60);
        xaDataSource.setMaxPoolSize(20);
        return xaDataSource;
    }

    @Bean(name = "aswpxDataSourceProperties")
    @Qualifier("aswpxDataSourceProperties")
    @ConfigurationProperties(prefix = "spring.datasource.aswpx")
    public DataSourceProperties aswpxDataSourceProperties() {
        return new DataSourceProperties();
    }

    /**
     * 获取微评选数据源
     *
     * @return 微评选数据源
     */
    @Bean(name = "aswpxDataSource", initMethod = "init", destroyMethod = "close")
    @ConfigurationProperties(prefix = "spring.datasource.aswpx")
    public DataSource aswpxDataSource() throws SQLException {
        MysqlXADataSource mysqlXaDataSource = new MysqlXADataSource();
        mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);
        mysqlXaDataSource.setUrl(aswpxDataSourceProperties().getUrl());
        mysqlXaDataSource.setUser(aswpxDataSourceProperties().getUsername());
        mysqlXaDataSource.setPassword(aswpxDataSourceProperties().getPassword());

        AtomikosDataSourceBean xaDataSource = new AtomikosDataSourceBean();
        xaDataSource.setXaDataSource(mysqlXaDataSource);
        xaDataSource.setUniqueResourceName("aswpx");
        xaDataSource.setBorrowConnectionTimeout(60);
        xaDataSource.setMaxPoolSize(20);
        return xaDataSource;
    }

    @Bean(name = "hhdDataSourceProperties")
    @Qualifier("hhdDataSourceProperties")
    @ConfigurationProperties(prefix = "spring.datasource.hhd")
    public DataSourceProperties hhdDataSourceProperties() {
        return new DataSourceProperties();
    }

    /**
     * 获取慧惠多数据源
     *
     * @return 慧惠多数据源
     */
    @Bean(name = "hhdDataSource", initMethod = "init", destroyMethod = "close")
    @ConfigurationProperties(prefix = "spring.datasource.hhd")
    public DataSource hhdDataSource() throws SQLException {
        MysqlXADataSource mysqlXaDataSource = new MysqlXADataSource();
        mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);
        mysqlXaDataSource.setUrl(hhdDataSourceProperties().getUrl());
        mysqlXaDataSource.setUser(hhdDataSourceProperties().getUsername());
        mysqlXaDataSource.setPassword(hhdDataSourceProperties().getPassword());

        AtomikosDataSourceBean xaDataSource = new AtomikosDataSourceBean();
        xaDataSource.setXaDataSource(mysqlXaDataSource);
        xaDataSource.setUniqueResourceName("hhd");
        xaDataSource.setBorrowConnectionTimeout(60);
        xaDataSource.setMaxPoolSize(20);
        return xaDataSource;
    }

    /**
     * 动态数据源: 通过AOP在不同数据源之间动态切换
     *
     * @return 动态数据源
     */
    @Primary
    @Bean(name = "dynamicDataSource")
    public DataSource dynamicDataSource(
            @Qualifier("defaultDataSource") DataSource defaultDataSource,
            @Qualifier("aswpxDataSource") DataSource aswpxDataSource,
            @Qualifier("hhdDataSource") DataSource hhdDataSource) throws SQLException {
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        // 默认数据源
        dynamicDataSource.setDefaultTargetDataSource(defaultDataSource);
        // 配置多数据源
        Map<Object, Object> dataSourceMap = new HashMap();
        dataSourceMap.put("defaultDataSource", defaultDataSource());
        dataSourceMap.put("aswpxDataSource", aswpxDataSource);
        dataSourceMap.put("hhdDataSource", hhdDataSource);
        //设置数据源Map
        dynamicDataSource.setTargetDataSources(dataSourceMap);
        return dynamicDataSource;
    }

    @Bean(name = "sqlSessionFactory")
    public SqlSessionFactory sqlSessionFactory() throws Exception {
        MybatisSqlSessionFactoryBean sqlSessionFactory = new MybatisSqlSessionFactoryBean();
        //设置动态数据源
        sqlSessionFactory.setDataSource(dynamicDataSource(defaultDataSource(), aswpxDataSource(), hhdDataSource()));
        //设置动态数据源事务管理
        sqlSessionFactory.setTransactionFactory(new DynamicDataSourceTransactionFactory());

        MybatisConfiguration configuration = new MybatisConfiguration();
        configuration.setJdbcTypeForNull(JdbcType.NULL);
        configuration.setMapUnderscoreToCamelCase(true);
        configuration.setCacheEnabled(false);
        sqlSessionFactory.setConfiguration(configuration);
        //添加插件
        sqlSessionFactory.setPlugins(new Interceptor[]{
                paginationInterceptor()
        });
        return sqlSessionFactory.getObject();
    }

    @Bean(name = "userTransaction")
    public UserTransaction userTransaction() throws Throwable {
        UserTransactionImp userTransactionImp = new UserTransactionImp();
        userTransactionImp.setTransactionTimeout(10000);
        return userTransactionImp;
    }

    @Bean(name = "userTransactionManager", initMethod = "init", destroyMethod = "close")
    public TransactionManager userTransactionManager() {
        UserTransactionManager userTransactionManager = new UserTransactionManager();
        userTransactionManager.setForceShutdown(true);
        return userTransactionManager;
    }

    // 默认事务管理器
    @Bean(name = "transactionManager")
    @DependsOn({"userTransaction", "userTransactionManager"})
    public PlatformTransactionManager transactionManager() throws Throwable {
        UserTransaction userTransaction = userTransaction();
        TransactionManager userTransactionManager = userTransactionManager();
        JtaTransactionManager jtaTransactionManager = new JtaTransactionManager(userTransaction, userTransactionManager);
        jtaTransactionManager.setAllowCustomIsolationLevels(true);
        return jtaTransactionManager;
    }
}

最后做了测试，完美切换数据源，并实现事务回滚。

package com.daodianlai.task;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

/**
 * MoreTranTask
 *
 * @author yangqisheng
 * @date 2019/08/09
 */
@Slf4j
@Component
public class MoreTranTask {

    @Autowired
    private MoreTranService moreTranService;

    @Scheduled(cron = "0 * * * * ?")
    public void run() {
        log.info(">>>>【多事务测试】开始");
        moreTranService.updateData();
        log.info(">>>>【多事务测试】结束");
    }
}

package com.daodianlai.task;

import com.daodianlai.aswpx.dao.mapper.AswpxMapper;
import com.daodianlai.commons.jdbc.DataSourceContextHolder;
import com.daodianlai.zpi.sdcbd.dao.mapper.DaodianlaiMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

/**
 * MoreTranService
 *
 * @author yangqisheng
 * @date 2019/08/09
 */
@Slf4j
@Service
public class MoreTranService {

    @Autowired
    private AswpxMapper aswpxMapper;
    @Autowired
    private DaodianlaiMapper daodianlaiMapper;

    @Transactional(
            transactionManager = "transactionManager",
            propagation = Propagation.REQUIRED, readOnly = false,
            rollbackFor = {Exception.class})
    public void updateData() {
        aswpxMapper.excute("update t_user set num = num + 1");
        daodianlaiMapper.excute("update t_visit set num = num + 1");
        //此处会报错，引发事务回滚
        int a = 1 / 0;
    }
}

希望大家调试顺利~

發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

美团面试：说说Netty的零拷贝技术？

零拷貝技術（Zero-Copy）是一個大家耳熟能詳的技術名詞了，它主要用於提升 IO（Input & Output）的傳輸性能。 那麼問題來了，爲什麼零拷貝技術能提升 IO 性能？ 1.零拷貝技術和性能 在傳統的 IO 操作中，當我們需要讀

Java中文社羣 2024-06-07 14:39:30

2024 Web 新特性 - 使用 Popover API 创建弹窗

Popover API 爲開發者提供了一種聲明式的方式來創建各種類型的彈窗。目前已在所有三大瀏覽器引擎中可用，並正式成爲 Baseline 2024 的一部分。 一直以來，我們在實現彈出式菜單、提示框或信息卡片時，往往依賴於各種JavaSc

劉漢貴 2024-06-07 14:33:29

开发视频会议系统：使用GPU解码渲染视频

      現在，使用視頻會議系統遠程協同辦公、溝通交流，已經非常普遍了。如果我們要開發自己的視頻會議系統，那麼，GPU解碼渲染技術是不可缺少的。       在視頻會議系統中，經常需要同時觀看會議中多個參會人員的視頻圖像，另外，還可能需要

zhuweisky 2024-06-07 14:33:09

C#/.NET/.NET Core优秀项目和框架2024年5月简报

前言 公衆號每月定期推廣和分享的C#/.NET/.NET Core優秀項目和框架（每週至少會推薦兩個優秀的項目和框架當然節假日除外），公衆號推文中有項目和框架的介紹、功能特點、使用方式以及部分功能截圖等（打不開或者打開GitHub很慢的同

追逐時光 2024-06-07 14:28:29

计划做点事情-还是跳槽

【最近想做什麼了】 和之前一樣，模板還是跳槽 【爲什麼要做這個】 和之前一樣，但是還是想再寫一遍 現在的工作，錢少事多離家遠 現在的自己，人窮有家要搞錢 【要在什麼時間達到什麼樣的目標，分段計劃是怎樣的】 目前可信考試是過了， 太簡單了，算

eonie 2024-06-07 14:26:39

好久没来了-20240607

【今天又是什麼日子】 今天是2024年6月7日，星期五，其實也沒有很特別 只不過剛好是今年高考的第一天，寫這個的時候上午的考試應該完了 高考很重要，每一天都很重要 年輕很好，每一天也很好 且行且珍惜 【上次來是什麼時候】 上次來還是上個月月

eonie 2024-06-07 14:26:39

vscode win11 配置go

官網安裝後, vscode會自動識別. 右下角選go.(不能選go module) 然後安裝go插件.之後運行即可. 如果自動安裝delve啥的出錯. 就先自己配置. go env -w GOPROXY=https://goproxy.cn

張博的博客 2024-06-07 14:26:29

构建Arm版jdk1.8 docker基础镜像

前言 jdk1.8的docker鏡像默認是cpu架構爲x64的，在arm架構或者aarch64 上運行java應用需要自己構建一個對應cpu架構的jdk基礎鏡像 過程 首先去Oracle官網下載對應的Arm架構的1.8版本jdk 下載好後

M_mxy 2024-06-07 14:23:19

微软RPA工具Power Automate Desktop

什麼是RPA RPA（機器人流程自動化）系統是一種應用程序，它通過模仿用戶在電腦上的操作方法, 實現自動化操作流程, 協助人在計算機、手機等計算設備中完成重複的工作流任務。 Power Automate Desktop 2021年3月2日

2018 2024-06-07 14:20:58

Power Automate Desktop 安装完，登录后老是提示one driver 错误

Power Automate Desktop  安裝完，登錄後老是提示one driver 錯誤

2018 2024-06-07 14:20:58

在线课䟫

https://www.edx.org/edxchina   https://www.coursera.org/   https://www.xuetangx.com/search?query=%E9%83%91%E6%AF%93%E7%

2018 2024-06-07 14:20:58

高分通过RPA高级认证

 

2018 2024-06-07 14:20:58

k8s网络问题以及容器跨宿主机通信原理 k8s组件和网络插件挂掉，演示已有的pod是否正常运行 k8s组件和网络插件挂掉，演示已有的pod是否正常运行

【0】資源配置文件 [root@mcwk8s03 mcwtest]# ls mcwdeploy.yaml [root@mcwk8s03 mcwtest]# cat mcwdeploy.yaml apiVersion: apps/v1 k

馬昌偉 2024-06-07 14:19:58

dubbo~全局异常拦截器的使用与设计缺陷

異常攔截器ExceptionMapper 在JAX-RS（Java API for RESTful Web Services）中，ExceptionMapper接口用於將Java異常映射到HTTP響應。通過實現ExceptionMapper

張佔嶺 2024-06-07 14:18:38

微前端学习笔记（1）：微前端总体架构概述，从微服务发微

從最初的CS架構，如MFC Java Swing 等，到BS架構，JSP PHP，再到前端後端分離，前端從jquery  GWT-Ext  到 Handlebars ，再到angularJS/Vue/React，反觀java 世界，學好 S

zhoulujun 2024-06-07 14:14:28