源码分析 spring事务处理机制

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/world6/article/details/79425804

Spring在TransactionDefinition接口中定义这些属性,以供PlatfromTransactionManager使用, PlatfromTransactionManager是Spring事务管理的核心接口。

接口代码如下:

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


事务的传播属性有:

PROPAGATION_REQUIRED 如果存在一个事务,则支持当前事务。如果没有事务则开启一个新的事务。(默认的传播属性)

PROPAGATION_REQUIRES_NEW 总是开启一个新的事务。如果一个事务已经存在,则将这个存在的事务挂起。

PROPAGATION_SUPPORTS 如果存在一个事务,支持当前事务。如果没有事务,则非事务的执行。

PROPAGATION_MANDATORY 如果已经存在一个事务,支持当前事务。如果没有一个活动的事务,则抛出异常。

PROPAGATION_NOT_SUPPORTED 总是非事务地执行,并挂起任何存在的事务。

PROPAGATION_NEVER 总是非事务地执行,如果存在一个活动事务,则抛出异常;

PROPAGATION_NESTED如果一个活动的事务存在,则运行在一个嵌套的事务中. 如果没有活动事务, 则按TransactionDefinition.PROPAGATION_REQUIRED 属性执行。


当我们的程序调用到 把被 @Transaction 注解修饰的方法时,会被spring的AOP切面拦截,该方法会被进行增强,其中就包含了spring对该方法进行事务管理。spring会对不同的传播属性进行不同的事务处理。spring 通过 AbstractPlatformTransactionManager这个类来管理事务。

方法如下:

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

AbstractPlatformTransactionManager处理已经存在的事务:

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

加个抽离无关代码的总结,对流程更清晰一点


下篇将会介绍spring的事务管理如何在日常的开发中更灵活的使用


展开阅读全文

没有更多推荐了,返回首页