springboot+mybatis+druid+atomikos解决动态多数据源并支持分布式事务
一、 项目说明
本用例基于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.csdn.net/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 [email protected]
* @since 1.0.0
*/
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface DataSource {
String name() default "";
}
面向切面编程动态切换数据源
import com.wisesoft.annotation.DataSource;
import com.wisesoft.datasources.DataSourceNames;
import com.wisesoft.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 [email protected]
* @date 2019/5/16 22:20
*/
@Aspect
@Configuration
@Order(0)
public class DataSourceAspect {
protected Logger logger = LoggerFactory.getLogger(getClass());
@Pointcut("execution(* com.wisesoft.*.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 [email protected]
* @date 2017/8/19 1:03
*/
public class DynamicDataSource extends AbstractRoutingDataSource {
private static final ThreadLocal contextHolder = new ThreadLocal<>();
public DynamicDataSource(DataSource defaultTargetDataSource, Map 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。
暂时不清楚原因，没研究。
mysql
mysql-connector-java
6.0.6
问题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;
/**
* 多数据源切换，支持事务
*
* @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 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;
/**
* 支持Service内多数据源切换的Factory
*
* @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);
}
}四、测试结果
4.1 测试分布式事务
http://localhost:8101/testTrans
http://localhost:8101/testTrans1
http://localhost:8101/testTrans2
五、参考资料
springboot+mybatis解决多数据源切换事务控制不生效的问题
https://blog.csdn.net/gaoshili001/article/details/79378902