概述：
记录一次线上事务失效的原因
背景
由于业务需要，线上需要配置分库分表,所以需要引入多个数据源，其中方案是做历史数据的归档，热库数据只保留一定的天数，历史数据需要从归档库查询，所以老的热库数据源需要保留同时引入新的Sharding-jdbc归档数据源，多个数据源存在事务必须保证可用性，在事务管理器DataSourceTransactionManager需要设置数据源，来保证获取数据库连接Connection，在同一个connection中才能保证事务是存在的。因为做的是历史数据的归档，所以只需要保证热库的数据事务即可（错误的概念），正是因为这个观念造成了线上事务管理器全部不生效。
猜想
事务发现不生效几个猜想 1.Connection不是同一个 2.异常被吞并 3.有多线程切换？
使用姿势
Spring数据源错误配置（简化版本）：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
<import resource="classpath*:spring/datasource/order-datasource-x1.xml"/>
<import resource="classpath*:spring/datasource/order-datasource-x2.xml"/>
<!-- 动态数据源配置-->
<bean id="dynamicDataSource" class="com.xxx.datasource.OrderDynamicDataSource">
<property name="targetDataSources">
<map key-type="java.lang.String">
<!-- 指定lookupKey和与之对应的数据源,切换时使用的为key -->
<entry key="hotOrderDataSource" value-ref="hotDataSource"></entry>
<entry key="archiveDataSource" value-ref="archiveDataSource"></entry>
</map>
</property>
<!-- 这里可以指定默认的数据源 -->
<property name="defaultTargetDataSource" ref="hotDataSource" />
</bean>
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dynamicDataSource"/>
<property name="mapperLocations" value="classpath*:sqlMap/**/*.xml"/>
<property name="configLocation" value="classpath:mybatis/mybatis.xml"/>
</bean>
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.xxx.order.dao"/>
<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
</bean>
<!-- 实时热库 事务管理器 -->
<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="hotDataSource"/>
</bean>
<tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true" />
</beans>
编程式事务使用
importBaseSpringJDBCTest;
import org.junit.Test;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;
import org.springframework.transaction.support.TransactionCallback;
import org.springframework.transaction.support.TransactionTemplate;
import javax.annotation.Resource;
public class TransactionTest extends BaseSpringJDBCTest {
@Resource
private DataSourceTransactionManager transactionManager;
@Test
public void transactionTest() {
DefaultTransactionDefinition def = new DefaultTransactionDefinition();
def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
TransactionStatus status = transactionManager.getTransaction(def);
int i = 1;
try {
//执行本地操作
xxxxx
if (i == 1) {
throw new NullPointerException();
}
//提交事务
transactionManager.commit(status);
} catch (Throwable e) {
transactionManager.rollback(status);
throw e;
}
}
}
从上面的配置中，我们可以清晰的看到在事务管理器DataSourceTransactionManager中我们配置了热库的数据源
<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="hotDataSource"/>
</bean>
Mybatis中SqlSessionFactoryBean配置的数据源为Spring动态数据源
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dynamicDataSource"/>
<property name="mapperLocations" value="classpath*:sqlMap/**/*.xml"/>
<property name="configLocation" value="classpath:mybatis/mybatis.xml"/>
</bean>
问题就在于我们配置的事务管理器数据源与Mybatis SqlSessionFactoryBean不是同一个数据源，导致的事务不成效，为什么我只需要热库都是数据源，来为我的事务管理器提供事务链接，就不可以，具体原因我们详细分析。
回顾下事务的流程
先简单的说事务，事务简而言之就是为了保证，在一系列数据库操作中,能够同时成功或者同时失败，毕竟原子性要保证的。首先回到JDBC链接数据库的时代。
JDBC连接DB事务操作
Connection con =null;
Statement st=null;
ResultSet rs=null;
PreparedStatement ps=null;
public void startTransaction(){
con = DBCManager.getConnect();//获取连接对象
try {
//设置事务的提交方式为非自动提交：
con.setAutoCommit(false);
String sql ="delete from user where id = 10";
String sql1 = "update user set name ='liu' where id =1";
//分别执行事务
ps = con.prepareStatement(sql);
ps.executeUpdate();
ps = con.prepareStatement(sql1);
ps.executeUpdate();
//在try块内添加事务的提交操作，表示操作无异常，提交事务。
con.commit();
} catch (SQLException e) {
try {
//在catch块内添加回滚事务，表示操作出现异常，撤销事务：
con.rollback();
} catch (SQLException e1) {
e1.printStackTrace();
}
e.printStackTrace();
}finally{
try {
//设置事务提交方式为自动提交：
con.setAutoCommit(true);
} catch (SQLException e) {
e.printStackTrace();
}
DBCManager.release(rs, ps, con);
}
}
首先，设置事务的提交方式为非自动提交：
conn.setAutoCommit(false);接下来，将需要添加事务的代码放入try catch块中。
然后，在try块内添加事务的提交操作，表示操作无异常，提交事务。conn.commit();
尤其不要忘记，在catch块内添加回滚事务，表示操作出现异常，撤销事务：conn.rollback();
最后，设置事务提交方式为自动提交：conn.setAutoCommit(true);
事务操作简单概述就是，我们保证在一个Connection下开启事务，就能保证我们我们一批数据的完整性，只要我们的事务操作中在当前线程中不切换链接就能保证事务是存在的。说到这里可能就有疑问，不考虑多线程切换的情况下，我们的事务操作经过Spring封装DataSourceTransactionManager中只要开启了事务，事务内就不会进行切换链接，原因就是在ConnectionHolder中暂且保存了我们的链接。下次在进行数据操作，直接从ConnectionHolder中获取链接，操作就保证了链接是同一个。
验证
源码之下即真理。
Spring事务管理
首先我们看事务管理器获取Connection，在DataSourceTransactionManager#doGetTransaction中首先获取ConnectionHolder放置在DataSourceTransactionManager.DataSourceTransactionObject中，我们注意到是从TransactionSynchronizationManager.getResource(this.dataSource)通过我们注入的数据源获取holder
第一步我们编程事务，获取事务的状态TransactionStatus，TransactionStatus接口具体作用我们可以通过接口一览。
TransactionStatus用于保存当前事物状态，比如是否只能回滚、是否包含回滚点、是否只读，其实现类内部包含事物操作对象transaction
事物操作对象transaction包含不同的实现,比如JDBC的DataSourceTransactionObject、Hibernate的HibernateTransactionObject等。
public interface TransactionStatus extends SavepointManager, Flushable {
//是否是一个新的事物
boolean isNewTransaction();
//判断是否有回滚点
boolean hasSavepoint();
//将一个事务标识为不可提交的。在调用完setRollbackOnly()后只能被回滚
//在大多数情况下，事务管理器会检测到这一点，在它发现事务要提交时会立刻结束事务。
//调用完setRollbackOnly()后，数数据库可以继续执行select，但不允许执行update语句，因为事务只可以进行读取操作，任何修改都不会被提交。
void setRollbackOnly();
boolean isRollbackOnly();
@Override
void flush();
//判断事物是否已经完成
boolean isCompleted();
}
接下来我们获取事务，我们通过数据源得到一个ConnectionHolder保存在事务管理器中，获取ConnectionHolder，是通过TransactionSynchronizationManager.getResource获取，这个方法非常重要。
我们看方法都可以猜到，第一次获取链接肯定不存在的，毕竟我们还没有进行存储。接下来操作肯定是要得到一个连接，从哪里得到，当然是通过我们注入的dataSource得到链接。
核心code：TransactionSynchronizationManager.bindResource(this.getDataSource(), txObject.getConnectionHolder());
我们注意到ConnectionHolder进行了存储，存储的key是获取的dataSource()，此时的dataSource为我们注入的热库datasource。
可以清晰的看到存储在ThreadLoacl与线程绑定。
最后初始化我们的事务参数，整个事务开启完成，返回我们的TransactionStatus 供事务管理使用。到此事务初始化已经完成。接下来我们看下Mybatis得到链接过程。
Mybatis 链接获取
首先我们进入Mybatis代理，找到我们最关心的事务管理器和最核心的Mybatis是如何获取链接的。
进入执行方法,寻找事务管理器；
事务管理器为org.mybatis.spring.transaction.SpringManagedTransaction，通过包名我们可以清晰的知道，Mybatis整合Spring需要的事务管理器，最终交给Spring处理事务，Spring管理事务，那必须通过事务管理器获取链接。
public static Connection doGetConnection(DataSource dataSource) throws SQLException {
Assert.notNull(dataSource, "No DataSource specified");
ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource);
if (conHolder != null && (conHolder.hasConnection() || conHolder.isSynchronizedWithTransaction())) {
conHolder.requested();
if (!conHolder.hasConnection()) {
logger.debug("Fetching resumed JDBC Connection from DataSource");
conHolder.setConnection(dataSource.getConnection());
}
return conHolder.getConnection();
}
// Else we either got no holder or an empty thread-bound holder here.
logger.debug("Fetching JDBC Connection from DataSource");
Connection con = dataSource.getConnection();
if (TransactionSynchronizationManager.isSynchronizationActive()) {
logger.debug("Registering transaction synchronization for JDBC Connection");
// Use same Connection for further JDBC actions within the transaction.
// Thread-bound object will get removed by synchronization at transaction completion.
ConnectionHolder holderToUse = conHolder;
if (holderToUse == null) {
holderToUse = new ConnectionHolder(con);
}
else {
holderToUse.setConnection(con);
}
holderToUse.requested();
TransactionSynchronizationManager.registerSynchronization(
new ConnectionSynchronization(holderToUse, dataSource));
holderToUse.setSynchronizedWithTransaction(true);
if (holderToUse != conHolder) {
TransactionSynchronizationManager.bindResource(dataSource, holderToUse);
}
}
return con;
}
在获取链接的过程中
找到这里我们看到了一段熟悉的代码ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource); 通过数据源获取链接，此时的数据源为我们注入的Spring动态数据源，所以链接是一个新的链接，新的链接默认提交方式为自动提交事务。所以真相大白，就是因为们数据源设置不匹配导致，两次的链接不同，导致了Spring管理的事务失效。
整个流程核心点：
Sping开启事务，将链接与线程绑定，放入TransactionSynchronizationManager，key为数据源，value为链接的包装
TransactionSynchronizationManager.bindResource(this.getDataSource(), txObject.getConnectionHolder());
Mybatis通过配置的数据源获取链接的包装
ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource);
通过以上分析，大概了解了事务的处理流程，我们出错的原因，就在于不了解事务，以为了事务是随着我们设置数据源匹配的，所以还是了解技术，才能正确的使用技术。
