源码分析 spring事务处理机制

	public interface TransactionDefinition {
		
		int getPropagationBehavior(); //返回事务的传播行为。 
		
		int getIsolationLevel(); //返回事务的隔离级别，事务管理器根据它来控制另外一个事务可以看到本事务内的哪些数据。
		
		int getTimeout(); //返回事务必须在多少秒内完成。
		
		boolean isReadOnly(); //事务是否只读，事务管理器能够根据这个返回值进行优化，确保事务是只读的。 
	}

public final TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException {  
        //doGetTransaction()方法是抽象方法，具体的实现由具体的事务处理器提供  
        Object transaction = doGetTransaction();  
        boolean debugEnabled = logger.isDebugEnabled();  
        //如果没有配置事务属性，则使用默认的事务属性  
        if (definition == null) {  
            definition = new DefaultTransactionDefinition();  
        }  
        //检查当前线程是否存在事务  
        if (isExistingTransaction(transaction)) {  
            //处理已存在的事务  
            return handleExistingTransaction(definition, transaction, debugEnabled);  
        }  
        //检查事务属性中timeout超时属性设置是否合理  
        if (definition.getTimeout() < TransactionDefinition.TIMEOUT_DEFAULT) {  
            throw new InvalidTimeoutException("Invalid transaction timeout", definition.getTimeout());  
        }  
        //对事务属性中配置的事务传播特性处理  
        //如果事务传播特性配置的是mandatory，当前没有事务存在，抛出异常  
        if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {  
            throw new IllegalTransactionStateException(  
                    "No existing transaction found for transaction marked with propagation 'mandatory'");  
        }  
        //如果事务传播特性为required、required_new或nested  
        else if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||  
                definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||  
            definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {  
            SuspendedResourcesHolder suspendedResources = suspend(null);  
            if (debugEnabled) {  
                logger.debug("Creating new transaction with name [" + definition.getName() + "]: " + definition);  
            }  
            //创建事务  
            try {  
                //不激活和当前线程绑定的事务，因为事务传播特性配置要求创建新的事务  
                boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);  
                //创建一个新的事务状态  
                DefaultTransactionStatus status = newTransactionStatus(  
                        definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);  
                //创建事务的调用，具体实现由具体的事务处理器提供  
                doBegin(transaction, definition);  
                //初始化和同步事务状态  
                prepareSynchronization(status, definition);  
                return status;  
            }  
            catch (RuntimeException ex) {  
                resume(null, suspendedResources);  
                throw ex;  
            }  
            catch (Error err) {  
                resume(null, suspendedResources);  
                throw err;  
            }  
        }  
        else {  
        //创建空事务，否则就创建一个空事务，没有实际事务，但可能同步。（实际上就是不使用事务）
            boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);  
            //准备事务状态  
            return prepareTransactionStatus(definition, null, true, newSynchronization, debugEnabled, null);  
        }  
    }  

	private TransactionStatus handleExistingTransaction(  
            TransactionDefinition definition, Object transaction, boolean debugEnabled)  
            throws TransactionException {  
        //如果事务传播特性为：never，则抛出异常  
        if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NEVER) {  
            throw new IllegalTransactionStateException(  
                    "Existing transaction found for transaction marked with propagation 'never'");  
        }  
        //如果事务传播特性是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);  
        }  
        //如果事务传播特性是required_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);  
                prepareSynchronization(status, definition);  
                return status;  
            }  
            catch (RuntimeException beginEx) {  
                resumeAfterBeginException(transaction, suspendedResources, beginEx);  
                throw beginEx;  
            }  
            catch (Error beginErr) {  
                resumeAfterBeginException(transaction, suspendedResources, beginErr);  
                throw beginErr;  
            }  
        }  
        //如果事务传播特性是nested嵌套事务  
        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() + "]");  
            }  
            //如果允许使用savepoint保存点保存嵌套事务  
            if (useSavepointForNestedTransaction()) {  
                //为当前事务创建一个保存点  
                DefaultTransactionStatus status =  
                        prepareTransactionStatus(definition, transaction, false, false, debugEnabled, null);  
                status.createAndHoldSavepoint();  
                return status;  
            }  
            //如果不允许使用savepoint保存点保存嵌套事务  
            else {  
                //使用JTA的嵌套commit/rollback调用  
                boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);  
                DefaultTransactionStatus status = newTransactionStatus(  
                        definition, transaction, true, newSynchronization, debugEnabled, null);  
                doBegin(transaction, definition);  
                prepareSynchronization(status, definition);  
                return status;  
            }  
        }  
        //对于事务传播特性为supported和required的处理  
        if (debugEnabled) {  
            logger.debug("Participating in existing transaction");  
        }  
        //校验已存在的事务，如果已有事务与事务属性配置不一致，则抛出异常  
        if (isValidateExistingTransaction()) {  
            //如果事务隔离级别不是默认隔离级别  
            if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {  
                //获取当前事务的隔离级别  
                Integer currentIsolationLevel = TransactionSynchronizationManager.getCurrentTransactionIsolationLevel();  
            //如果获取到的当前事务隔离级别为null获取不等于事务属性配置的隔离级别  
                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);  
    }