spring---transaction（4）---源代码分析(事务的状态TransactionStatus)
写在前面
TransactionStatus表示一个具体的事务状态（这里应用到了Java的一个多继承，接口允许多继承）
TransactionStatus它继承了SavepointManager接口，SavepointManager是对事务中上述保存点功能的封装（Spring利用保存点功能实现了事务的嵌套功能。后面会详细说明）
public interface SavepointManager { Object createSavepoint() throws TransactionException; void rollbackToSavepoint(Object savepoint) throws TransactionException; void releaseSavepoint(Object savepoint) throws TransactionException; }
public interface TransactionStatus extends SavepointManager, Flushable { //是否是一个新的事物 boolean isNewTransaction(); //是否有保存点 boolean hasSavepoint(); void setRollbackOnly(); //是否已被标记为回滚 boolean isRollbackOnly();
@Override void flush(); boolean isCompleted(); }
DefaultTransactionStatus
常用的TransactionStatus接口实现为DefaultTransactionStatus：
public class DefaultTransactionStatus extends AbstractTransactionStatus { private final Object transaction; private final boolean newTransaction; private final boolean newSynchronization; private final boolean readOnly; private final boolean debug; private final Object suspendedResources; }
目前jdbc事务是通过Connection来实现事务的，Hibernate是通过它自己定义的Transaction来实现的，所以各家的事务都不同，所以Spring只能以Object transaction的形式来表示各家的事务，事务的回滚和提交等操作都会最终委托给上述Object transaction来完成。
Object transaction的职责就是提交回滚事务，这个transaction的选择可能如下：
- DataSourceTransactionObject
- HibernateTransactionObject
- JpaTransactionObject
详细信息分别如下：
- DataSourceTransactionObject：
我们使用了dataSource来获取连接，要想实现事务功能，必然需要使用Connection，所以它中肯定有一个Connection来执行事务的操作。DataSourceTransactionObject中有一个ConnectionHolder，它封装了一个Connection。
- HibernateTransactionObject：
我们使用了hibenrate,此时要想实现事务功能，必然需要通过hibernate自己定义的Transaction来实现。
HibernateTransactionObject中含有一个SessionHolder，和上面的ConnectionHolder一样，它封装了一个Session,有了Session，我们就可以通过Session来产生一个Hibernate的Transaction，从而实现事务操作。
DefaultTransactionStatus的获取
DefaultTransactionStatus的获取是事务管理器的方法，这里的实现是AbstractPlatformTransactionManager提供的模板方法
在获取Object transaction之后，先进行判断，是否是已存在的事务。因为这个Object transaction的获取过程就是直接从线程绑定的获取的,可能当前线程已经存在事务
@Override public final TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException {
//获取相应的Object transaction Object transaction = doGetTransaction(); //就是依据和当前线程绑定的ConnectionHolder中是否已存在事务(也是依据和当前线程绑定的SessionHolder是否已存在事务) if (isExistingTransaction(transaction)) {
//如果是已存在事务：则需要对事务的传播属性进行处理，如下即上述截图中的的handleExistingTransaction方法： return handleExistingTransaction(definition, transaction, debugEnabled); }
... }
如果是已存在事务：则需要对事务的传播属性进行处理，如下即上述截图中的的handleExistingTransaction方法
private TransactionStatus handleExistingTransaction( TransactionDefinition definition, Object transaction, boolean debugEnabled) throws TransactionException { // PROPAGATION_NEVER：不允许存在事务，如果存在抛出异常 if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NEVER) { throw new IllegalTransactionStateException( "Existing transaction found for transaction marked with propagation 'never'"); } // PROPAGATION_NOT_SUPPORTED：不支持事务，如果存在事务，则需将事务挂起，保存起来，当执行完成之后，需要将挂起的事务继续恢复 if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NOT_SUPPORTED) { if (debugEnabled) { logger.debug("Suspending current transaction"); } Object suspendedResources = suspend(transaction); boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS); return prepareTransactionStatus( definition, null, false, newSynchronization, debugEnabled, suspendedResources); } //PROPAGATION_REQUIRES_NEW：开启一个新的事务，如果当前存在事务则把当前事务挂起来 if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW) { if (debugEnabled) { logger.debug("Suspending current transaction, creating new transaction with name [" + definition.getName() + "]"); } SuspendedResourcesHolder suspendedResources = suspend(transaction); try { boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER); DefaultTransactionStatus status = newTransactionStatus( definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
//可以看到，创建新的事务，就会调用doBegin(transaction, definition);方法，将事务开启。 doBegin(transaction, definition); prepareSynchronization(status, definition); return status; } catch (RuntimeException beginEx) { resumeAfterBeginException(transaction, suspendedResources, beginEx); throw beginEx; } catch (Error beginErr) { resumeAfterBeginException(transaction, suspendedResources, beginErr); throw beginErr; } } if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) { if (!isNestedTransactionAllowed()) { throw new NestedTransactionNotSupportedException( "Transaction manager does not allow nested transactions by default - " + "specify 'nestedTransactionAllowed' property with value 'true'"); } if (debugEnabled) { logger.debug("Creating nested transaction with name [" + definition.getName() + "]"); } if (useSavepointForNestedTransaction()) { // Create savepoint within existing Spring-managed transaction, // through the SavepointManager API implemented by TransactionStatus. // Usually uses JDBC 3.0 savepoints. Never activates Spring synchronization. DefaultTransactionStatus status = prepareTransactionStatus(definition, transaction, false, false, debugEnabled, null); status.createAndHoldSavepoint(); return status; } else { // Nested transaction through nested begin and commit/rollback calls. // Usually only for JTA: Spring synchronization might get activated here // in case of a pre-existing JTA transaction. boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER); DefaultTransactionStatus status = newTransactionStatus( definition, transaction, true, newSynchronization, debugEnabled, null); doBegin(transaction, definition); prepareSynchronization(status, definition); return status; } } // Assumably PROPAGATION_SUPPORTS or PROPAGATION_REQUIRED.
//PROPAGATION_SUPPORTS 和 PROPAGATION_REQUIRED 如果当前存在事务，则仍旧使用该事物 if (debugEnabled) { logger.debug("Participating in existing transaction"); } if (isValidateExistingTransaction()) { if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) { Integer currentIsolationLevel = TransactionSynchronizationManager.getCurrentTransactionIsolationLevel(); if (currentIsolationLevel == null || currentIsolationLevel != definition.getIsolationLevel()) { Constants isoConstants = DefaultTransactionDefinition.constants; throw new IllegalTransactionStateException("Participating transaction with definition [" + definition + "] specifies isolation level which is incompatible with existing transaction: " + (currentIsolationLevel != null ? isoConstants.toCode(currentIsolationLevel, DefaultTransactionDefinition.PREFIX_ISOLATION) : "(unknown)")); } } if (!definition.isReadOnly()) { if (TransactionSynchronizationManager.isCurrentTransactionReadOnly()) { throw new IllegalTransactionStateException("Participating transaction with definition [" + definition + "] is not marked as read-only but existing transaction is"); } } } boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER); return prepareTransactionStatus(definition, transaction, false, newSynchronization, debugEnabled, null); }
事务的挂起
对于DataSourceTransactionManager来说，事务的挂起，就是把当前线程关联的ConnectionHolder解除绑定、同理事务的恢复就是把上述ConnectionHolder再重新绑定到当前线程，继续执行该事务
@Override protected Object doSuspend(Object transaction) { DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction; txObject.setConnectionHolder(null);
//解除绑定dataSource, conHolder 至 TransactionSynchronizationManager ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.unbindResource(this.dataSource); return conHolder; } @Override protected void doResume(Object transaction, Object suspendedResources) { ConnectionHolder conHolder = (ConnectionHolder) suspendedResources;
//重新绑定dataSource, conHolder 至 TransactionSynchronizationManager TransactionSynchronizationManager.bindResource(this.dataSource, conHolder); }
