本用例基于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
,定义了有关事务的开始、提交、撤回等>操作。javax.transaction.xa.XAResource
,一种资源如果要支持JTA事务,就需要让它的资源实现该XAResource
接口,并实现该接口定义的两阶段提交相关的接口。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 事务管理器管理;
编写多数据源注解,绑定到需要切换数据源到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
问题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);
}
}
http://localhost:8101/testTrans
http://localhost:8101/testTrans1
http://localhost:8101/testTrans2
springboot+mybatis解决多数据源切换事务控制不生效的问题
https://blog.csdn.net/gaoshili001/article/details/79378902