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);
    }