springboot+mybatis+druid+atomikos解决动态多数据源并支持事务

最新推荐文章于 2023-04-17 15:27:44 发布

原创最新推荐文章于 2023-04-17 15:27:44 发布 · 4.6k 阅读

10 ·

CC 4.0 BY-SA版权

文章标签：

#Atomikos #Druid #springboot #mybatis

框架专栏收录该内容

1 篇文章

订阅专栏

一、项目说明

本用例基于springboot+mybatis+druid+atomikos 配置动态多数据源， 实现分布式事务。
源码仓库地址： https://github.com/lishuangqi/springboot-mybatis-druid-atomikos

根据网上的搭建始终没实现atomikos分布式事务，经过两天网上查询资料终于实现了。刚开始分布式事务加入后，多数据源切换不能用了，一个线程内执行了第一个数据源service后，第二数据service不触发动态切换数据源(http://localhost:8101/testTrans)。单独访问第二数据源方法又是可以切换的(http://localhost:8101/testTrans1，http://localhost:8101/testTrans2)。

经查找 springboot+mybatis解决多数据源切换事务控制不生效的问题https://blog.youkuaiyun.com/gaoshili001/article/details/79378902
springboot的生命式事务需要重写Transaction，就能切换数据源了。

原因：查看源代码中DataSourceTransactionManager这个类

当我们配置了事物管理器和拦截Service中的方法后，每次执行Service中方法前会开启一个事务，并且同时会缓存一些东西：DataSource、SqlSessionFactory、Connection等，所以，我们在外面再怎么设置要求切换数据源也没用，因为Conneciton都是从缓存中拿的，所以我们要想能够顺利的切换数据源，实际就是能够动态的根据DatabaseType获取不同的Connection，并且要求不能影响整个事物的特性。

JTA(Java Transaction API)：是J2EE的编程接口规范，它是XA协议的JAVA实现。它主要定义了：

一个事务管理器的接口javax.transaction.TransactionManager，定义了有关事务的开始、提交、撤回等>操作。
一个满足XA规范的资源定义接口javax.transaction.xa.XAResource，一种资源如果要支持JTA事务，就需要让它的资源实现该XAResource接口，并实现该接口定义的两阶段提交相关的接口。
如果我们有一个应用，它使用JTA接口实现事务，应用在运行的时候，就需要一个实现JTA的容器，一般情况下，这是一个J2EE容器，像JBoss，Websphere等应用服务器。但是，也有一些独立的框架实现了JTA，例如Atomikos, bitronix都提供了jar包方式的JTA实现框架。这样我们就能够在Tomcat或者Jetty之类的服务器上运行使用JTA实现事务的应用系统。
在上面的本地事务和外部事务的区别中说到，JTA事务是外部事务，可以用来实现对多个资源的事务性。它正是通过每个资源实现的XAResource来进行两阶段提交的控制。感兴趣的同学可以看看这个接口的方法，除了commit, rollback等方法以外，还有end(), forget(), isSameRM(), prepare()等等。光从这些接口就能够想象JTA在实现两阶段事务的复杂性。

Atomikos事务管理器： Atomikos是一个非常流行的开源事务管理器，并且可以嵌入到Spring Boot应用中。可以使用 spring-boot-starter-jta-atomikos Starter去获取正确的Atomikos库。Spring Boot会自动配置Atomikos，并将合适的 depends-on 应用到Spring Beans上，确保它们以正确的顺序启动和关闭。

二、动态多数据源，分布事务

这里我们创建druid数据源的时候，创建的是DruidXADataSource，它继承自DruidDataSource并支持XA分布式事务；
使用 AtomikosDataSourceBean 包装我们创建的DruidXADataSource，使得数据源能够被 JTA 事务管理器管理；

2.1 支持AOP动态数据源切换

编写多数据源注解，绑定到需要切换数据源到service上

import java.lang.annotation.*;

/**
 * 多数据源注解
 *
 * @author Mark sunlightcs@gmail.com
 * @since 1.0.0
 */
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface DataSource {
    String name() default "";
}

面向切面编程动态切换数据源

import com.lishuangqi.annotation.DataSource;
import com.lishuangqi.datasources.DataSourceNames;
import com.lishuangqi.datasources.DynamicDataSource;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.Order;

import java.lang.reflect.Method;

/**
 * 多数据源，切面处理类
 *
 * @author lishuangqi
 * @email lishuangqi88@163.com
 * @date 2019/5/16 22:20
 */
@Aspect
@Configuration
@Order(0)
public class DataSourceAspect {
    protected Logger logger = LoggerFactory.getLogger(getClass());

    @Pointcut("execution(* com.lishuangqi.*.service.impl.*.*(..)) && @target(com.wisesoft.annotation.DataSource)")
    public void dataSourcePointCut() {

    }

    @Around("dataSourcePointCut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        DataSource ds = null;
        Class<?> target = point.getTarget().getClass();
        MethodSignature signature = (MethodSignature) point.getSignature();
        Method method = signature.getMethod();
        ds = resolveDataSource(target, method);

        if (ds == null) {
            DynamicDataSource.setDataSource(DataSourceNames.BIGDATA);
            logger.info("set default datasource is " + DataSourceNames.BIGDATA);
        } else {
            DynamicDataSource.setDataSource(ds.name());
            logger.info("set datasource is " + ds.name());
        }
        return point.proceed();
    }

    @After("dataSourcePointCut()")
    public void restoreDataSource(JoinPoint point) {
        DynamicDataSource.clearDataSource();
    }

    /*
     * 获取最终的dataSource
     *
     * @param clazz
     * @param method
     */
    private DataSource resolveDataSource(Class<?> clazz, Method method) {
        try {
            DataSource ds = null;
            Class<?>[] types = method.getParameterTypes();
            // 默认使用类型注解
            if (clazz.isAnnotationPresent(DataSource.class)) {
                ds = clazz.getAnnotation(DataSource.class);
            }
            // 方法注解可以覆盖类型注解
            Method m = clazz.getMethod(method.getName(), types);
            if (m != null && m.isAnnotationPresent(DataSource.class)) {
                ds = m.getAnnotation(DataSource.class); 
            }
            return ds;
        } catch (Exception e) {
            System.out.println(clazz + ":" + e.getMessage());
        }
        return null;
    }
}

动态数据源切换，将当前使用的数据源名称保存到线程隔离的ThreadLocal中，核心继承AbstractRoutingDataSource，实现determineCurrentLookupKey() 方法

/**
 * 动态数据源
 * @author chenshun
 * @email sunlightcs@gmail.com
 * @date 2017/8/19 1:03
 */
public class DynamicDataSource extends AbstractRoutingDataSource {
    private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();

    public DynamicDataSource(DataSource defaultTargetDataSource, Map<Object, Object> targetDataSources) {
        super.setDefaultTargetDataSource(defaultTargetDataSource);
        super.setTargetDataSources(targetDataSources);
        super.afterPropertiesSet();
    }

    @Override
    protected Object determineCurrentLookupKey() {
        return getDataSource();
    }

    public static void setDataSource(String dataSource) {
        contextHolder.set(dataSource);
    }

    public static String getDataSource() {
        return contextHolder.get();
    }

    public static void clearDataSource() {
        contextHolder.remove();
    }

}

三、遇到的坑

问题1 DruidDataSource 切换为DruidXADataSource

XADataSource才能支持分布事务

问题2 java.lang.ClassNotFoundException: com.mysql.cj.api.jdbc.JdbcConnection

降mysql-connector-java 版springboot 2.1.4.RELEASE默认为8.0.15 ，改为6.0.6。
暂时不清楚原因，没研究。

 <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>6.0.6</version>
        </dependency>

问题3 重写sqlSessionFactory

SqlSessionFactoryBean 修改 MybatisSqlSessionFactoryBean，mybatis才能正常启动

@Primary
    @Bean(name = "sqlSessionFactory")
    public SqlSessionFactory sqlSessionFactory(@Qualifier("dynamicDataSource") DataSource dataSource)
            throws Exception {
        MybatisSqlSessionFactoryBean bean = new MybatisSqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        bean.setTransactionFactory(new MultiDataSourceTransactionFactory());
//        bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/**/*Dao.xml"));// 扫描指定目录的xml
        return bean.getObject();
    }
    @Bean(name="sqlSessionTemplate")
    @Primary
    public SqlSessionTemplate sqlSessionTemplate(@Qualifier("sqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
        return new SqlSessionTemplate(sqlSessionFactory);
    }

问题4 接入分布式事务后，动态数据源不能切换

重写Transaction


import com.alibaba.druid.support.logging.Log;
import com.alibaba.druid.support.logging.LogFactory;
import org.apache.ibatis.transaction.Transaction;
import org.springframework.jdbc.CannotGetJdbcConnectionException;
import org.springframework.jdbc.datasource.DataSourceUtils;

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

import static org.apache.commons.lang3.Validate.notNull;

/**
 * <P>多数据源切换，支持事务</P>
 *
 * @author lishuangqi
 * @date 2019/5/16 15:09
 * @since
 */
public class MultiDataSourceTransaction implements Transaction{
    private static final Log LOGGER = LogFactory.getLog(MultiDataSourceTransaction.class);

    private final DataSource dataSource;

    private Connection mainConnection;

    private String mainDatabaseIdentification;

    private ConcurrentMap<String, Connection> otherConnectionMap;


    private boolean isConnectionTransactional;

    private boolean autoCommit;


    public MultiDataSourceTransaction(DataSource dataSource) {
        notNull(dataSource, "No DataSource specified");
        this.dataSource = dataSource;
        otherConnectionMap = new ConcurrentHashMap<>();
        mainDatabaseIdentification=DynamicDataSource.getDataSource();
    }


    /**
     * {@inheritDoc}
     */
    @Override
    public Connection getConnection() throws SQLException {
        String databaseIdentification = DynamicDataSource.getDataSource();
        if (databaseIdentification.equals(mainDatabaseIdentification)) {
            if (mainConnection != null) return mainConnection;
            else {
                openMainConnection();
                mainDatabaseIdentification =databaseIdentification;
                return mainConnection;
            }
        } else {
            if (!otherConnectionMap.containsKey(databaseIdentification)) {
                try {
                    Connection conn = dataSource.getConnection();
                    otherConnectionMap.put(databaseIdentification, conn);
                } catch (SQLException ex) {
                    throw new CannotGetJdbcConnectionException("Could not get JDBC Connection", ex);
                }
            }
            return otherConnectionMap.get(databaseIdentification);
        }

    }


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

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

    /**
     * {@inheritDoc}
     */
    @Override
    public void commit() throws SQLException {
        if (this.mainConnection != null && !this.isConnectionTransactional && !this.autoCommit) {
            if (LOGGER.isDebugEnabled()) {
                LOGGER.debug("Committing JDBC Connection [" + this.mainConnection + "]");
            }
            this.mainConnection.commit();
            for (Connection connection : otherConnectionMap.values()) {
                connection.commit();
            }
        }
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void rollback() throws SQLException {
        if (this.mainConnection != null && !this.isConnectionTransactional && !this.autoCommit) {
            if (LOGGER.isDebugEnabled()) {
                LOGGER.debug("Rolling back JDBC Connection [" + this.mainConnection + "]");
            }
            this.mainConnection.rollback();
            for (Connection connection : otherConnectionMap.values()) {
                connection.rollback();
            }
        }
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void close() throws SQLException {
        DataSourceUtils.releaseConnection(this.mainConnection, this.dataSource);
        for (Connection connection : otherConnectionMap.values()) {
            DataSourceUtils.releaseConnection(connection, this.dataSource);
        }
    }

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

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

import javax.sql.DataSource;

/**
 * <P>支持Service内多数据源切换的Factory</P>
 *
 * @author lishuangqi
 * @date 2019/5/16 15:09
 * @since
 */
public class MultiDataSourceTransactionFactory extends SpringManagedTransactionFactory {
    @Override
    public Transaction newTransaction(DataSource dataSource, TransactionIsolationLevel level, boolean autoCommit) {
        return new MultiDataSourceTransaction(dataSource);
    }
}