关联博文:
SpringBoot中事务执行原理分析(一)
SpringBoot中事务执行原理分析(二)
SpringBoot中事务执行原理分析(三)
SpringBoot中事务执行原理分析(四)
SpringBoot中事务执行原理分析(五)
SpringBoot中事务执行原理分析(六)
SpringBoot中事务执行原理分析补充篇
你认真研究过Spring中的@EnableTransactionManagement注解吗?
接上文SpringBoot中事务执行原理分析(五)后,本文我们分析一下事务处理过程中的事务同步管理器TransactionSynchronizationManager
与事务同步对象TransactionSynchronization
。
【1】事务同步管理器
这里指的是TransactionSynchronizationManager
。管理每个线程的资源和事务同步的中央委托。
通常用于资源管理代码,但不用于应用程序代码。其支持一个资源一个key,不支持覆盖。也就是说即使对于同一个key,资源的更新只能是先remove后set。如果synchronization是激活的,那么支持多个事务同步对象。
资源管理代码应该通过 getResource
检查线程绑定的资源,例如JDBC连接或Hibernate会话。这种代码通常不应该将资源绑定到线程,因为这是事务管理器的责任。另一种选择是,如果事务同步处于活动状态,则在首次使用时延迟绑定,以执行跨越任意数量资源的事务。
事务同步必须由事务管理器通过initSynchronization()
和clearSynchronization()
进行激活和停用。这由 AbstractPlatformTransactionManager
自动支持,因此所有标准的Spring事务管理器自动支持,例如org.springframework.transaction.jta.JtaTransactionManager
和org.springframework.jdbc.datasource.DataSourceTransactionManager
。
资源管理代码只应在该管理器处于活动状态时注册事务同步对象,可以通过isSynchronizationActive
进行检查;否则非活动状态它应该立即执行资源清理。如果事务同步未处于活动状态,则表示当前没有事务,或者事务管理器不支持事务同步。
举例来说事务同步用于在JTA事务中始终返回相同的资源,例如,对于任何给定的数据源DataSource或SessionFactory,分别返回JDBC Connection或Hibernate Session。
如下所示在TransactionSynchronizationManager中持有了几个静态常量ThreadLocal对象。
public abstract class TransactionSynchronizationManager {
//线程上下文中保存着【DataSource:ConnectionHolder】的Map对象。线程可以通过该属性获取到同一个Connection对象。
private static final ThreadLocal<Map<Object, Object>> resources = new NamedThreadLocal<>("Transactional resources");
//事务同步器,是Spring交由程序员进行扩展的代码,每个线程可以注册N个事务同步器。
//这是一个Set哦
private static final ThreadLocal<Set<TransactionSynchronization>> synchronizations = new NamedThreadLocal<>("Transaction synchronizations");
// 保存当前事务的名称
private static final ThreadLocal<String> currentTransactionName = new NamedThreadLocal<>("Current transaction name");
// 保存只读状态-- 当前事务是否是只读
private static final ThreadLocal<Boolean> currentTransactionReadOnly = new NamedThreadLocal<>("Current transaction read-only status");
// 保存当前事务的隔离级别
private static final ThreadLocal<Integer> currentTransactionIsolationLevel = new NamedThreadLocal<>("Current transaction isolation level");
// 保存标志 - 事务是否开启
private static final ThreadLocal<Boolean> actualTransactionActive = new NamedThreadLocal<>("Actual transaction active");
}
该资源管理器还提供了许多资源管理、事务名称|状态等的管理,其中对资源管理的核心方法则是bindResource(绑定资源)和doUnbindResource(解绑资源)
绑定资源
如下所示,其尝试从线程上下文本地对象resources中获取map,如果map为null则实例化map并放入Object key, Object value
。
//这里key通常是DataSource
public static void bindResource(Object key, Object value) throws IllegalStateException {
Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);
Assert.notNull(value, "Value must not be null");
Map<Object, Object> map = resources.get();
// set ThreadLocal Map if none found
if (map == null) {
map = new HashMap<>();
resources.set(map);
}
Object oldValue = map.put(actualKey, value);
// Transparently suppress a ResourceHolder that was marked as void...
if (oldValue instanceof ResourceHolder && ((ResourceHolder) oldValue).isVoid()) {
oldValue = null;
}
if (oldValue != null) {
throw new IllegalStateException("Already value [" + oldValue + "] for key [" +
actualKey + "] bound to thread [" + Thread.currentThread().getName() + "]");
}
if (logger.isTraceEnabled()) {
logger.trace("Bound value [" + value + "] for key [" + actualKey + "] to thread [" +
Thread.currentThread().getName() + "]");
}
}
解绑资源
如下所示简单来讲就是其从线程本地对象resources中获取map,从中移除actualKey并返回。
private static Object doUnbindResource(Object actualKey) {
Map<Object, Object> map = resources.get();
if (map == null) {
return null;
}
Object value = map.remove(actualKey);
// Remove entire ThreadLocal if empty...
if (map.isEmpty()) {
resources.remove();
}
// Transparently suppress a ResourceHolder that was marked as void...
if (value instanceof ResourceHolder && ((ResourceHolder) value).isVoid()) {
value = null;
}
if (value != null && logger.isTraceEnabled()) {
logger.trace("Removed value [" + value + "] for key [" + actualKey + "] from thread [" +
Thread.currentThread().getName() + "]");
}
return value;
}
【2】事务同步对象
在前面我们分析提交或者回滚过程中,常常看到beforeCommit、beforeCompletion、afterCommit以及afterCompletion这几个钩子函数。其就是TransactionSynchronization 提供的,用来在事务提交/回滚前后做一些处理工作。
public interface TransactionSynchronization extends Flushable {
// 正确提交时的完成状态
int STATUS_COMMITTED = 0;
// 正确回滚时的完成状态
int STATUS_ROLLED_BACK = 1;
//启发式混合完成或系统错误情况下
int STATUS_UNKNOWN = 2;
//挂起同步,如果TransactionSynchronizationManager 有管理资源则接触资源绑定
default void suspend() {
}
//恢复同步,如果事务同步管理器有管理资源则重新绑定
default void resume() {
}
// 如果适用,将底层会话刷新到数据存储:例如,Hibernate/JPA会话。
@Override
default void flush() {
}
//在事务提交前触发 RuntimeException 将会传播给调用方,
//不要在此处抛出TransactionException的子类
default void beforeCommit(boolean readOnly) {
}
//在事务提交/回滚前触发
default void beforeCompletion() {
}
//事务成功提交后触发
default void afterCommit() {
}
//在事务提交/回滚后触发
default void afterCompletion(int status) {
}
}
beforeCommit
在事务提交之前(在“完成之前”)调用。例如,可以将事务性O/R映射会话刷新到数据库。
此回调并不意味着事务将实际提交。调用此方法后,仍可能发生回滚决策。这种回调是为了执行只有在提交仍然有机会发生时才相关的工作,例如将SQL语句刷新到数据库。
请注意,异常将传播到提交调用方,并导致事务回滚。
beforeCompletion
在事务提交/回滚之前调用。可以在事务完成之前执行资源清理。
即使beforeCommit引发异常,此方法也将在beforeCommit之后调用。此回调允许在事务完成之前关闭资源,以获得任何结果。
afterCommit
在事务提交后调用。在主事务成功提交后,可以立即执行进一步的操作。例如,可以在主事务成功提交后应执行的进一步操作,如确认消息或电子邮件。
事务已经提交,但事务资源可能仍然处于活动状态并且可以访问。因此,此时触发的任何数据访问代码仍将“参与”原始事务,允许执行一些清理(不再执行提交!),除非它明确声明需要在单独的事务中运行。因此:对于从这里调用的任何事务操作,使用PROPAGATION_REQUIRES_NEW。
afterCompletion
在事务提交/回滚后调用。可以在事务完成后执行资源清理。
与afterCommit相同的是,这里事务已经提交(或者回滚),但事务资源可能仍然处于活动状态并且可以访问。因此,此时触发的任何数据访问代码仍将“参与”原始事务,允许执行一些清理(不再执行提交!),除非它明确声明需要在单独的事务中运行。因此:对于从这里调用的任何事务操作,使用PROPAGATION_REQUIRES_NEW。
【3】SqlSessionSynchronization
SqlSessionSynchronization是SqlSessionUtils的静态内部类,继承自TransactionSynchronizationAdapter,后置实现了TransactionSynchronization接口。
我们以SqlSessionSynchronizationw为例分析其做了哪些事情。
private static final class SqlSessionSynchronization extends TransactionSynchronizationAdapter {
//持有SqlSession
private final SqlSessionHolder holder;
private final SqlSessionFactory sessionFactory;
private boolean holderActive = true;
public SqlSessionSynchronization(SqlSessionHolder holder, SqlSessionFactory sessionFactory) {
notNull(holder, "Parameter 'holder' must be not null");
notNull(sessionFactory, "Parameter 'sessionFactory' must be not null");
this.holder = holder;
this.sessionFactory = sessionFactory;
}
//获取其执行顺序
@Override
public int getOrder() {
// order right before any Connection synchronization
return DataSourceUtils.CONNECTION_SYNCHRONIZATION_ORDER - 1;
}
// 挂起,实际是解除资源绑定,这里key就是this.sessionFactory
@Override
public void suspend() {
if (this.holderActive) {
LOGGER.debug(() -> "Transaction synchronization suspending SqlSession [" + this.holder.getSqlSession() + "]");
TransactionSynchronizationManager.unbindResource(this.sessionFactory);
}
}
//恢复,实际是绑定资源,key -sessionFactory ,value - holder
@Override
public void resume() {
if (this.holderActive) {
LOGGER.debug(() -> "Transaction synchronization resuming SqlSession [" + this.holder.getSqlSession() + "]");
TransactionSynchronizationManager.bindResource(this.sessionFactory, this.holder);
}
}
//核心是触发sqlsession的commit
@Override
public void beforeCommit(boolean readOnly) {
// Connection commit or rollback will be handled by ConnectionSynchronization or
// DataSourceTransactionManager.
// But, do cleanup the SqlSession / Executor, including flushing BATCH statements so
// they are actually executed.
// SpringManagedTransaction will no-op the commit over the jdbc connection
// TODO This updates 2nd level caches but the tx may be rolledback later on!
//如果线程本地对象actualTransactionActive 储存资源不为null
if (TransactionSynchronizationManager.isActualTransactionActive()) {
try {
//触发sqlsession的commit,将会清理本地缓存,flushStatements
this.holder.getSqlSession().commit();
} catch (PersistenceException p) {
if (this.holder.getPersistenceExceptionTranslator() != null) {
DataAccessException translated = this.holder.getPersistenceExceptionTranslator()
.translateExceptionIfPossible(p);
if (translated != null) {
throw translated;
}
}
throw p;
}
}
}
//如果referenceCount小于1,则关闭SqlSession,重置holder、holderActive
@Override
public void beforeCompletion() {
// Issue #18 Close SqlSession and deregister it now
// because afterCompletion may be called from a different thread
//也就是referenceCount小于1
if (!this.holder.isOpen()) {
//解除资源绑定,key是sessionFactory
TransactionSynchronizationManager.unbindResource(sessionFactory);
//重置holderActive为false
this.holderActive = false;
//触发sqlsession的close方法
this.holder.getSqlSession().close();
}
}
//如果holderActive为true,则关闭SqlSession,重置holder、holderActive
@Override
public void afterCompletion(int status) {
//如果holderActive为true
if (this.holderActive) {
// afterCompletion may have been called from a different thread
// so avoid failing if there is nothing in this one
//尝试解除资源绑定
TransactionSynchronizationManager.unbindResourceIfPossible(sessionFactory);
//重置holderActive为false
this.holderActive = false;
//触发sqlsession的close方法
this.holder.getSqlSession().close();
}
this.holder.reset();
}
}