专栏首页Java进阶源码分析 spring事务处理机制

源码分析 spring事务处理机制

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的事务管理如何在日常的开发中更灵活的使用

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 高效编程之hashmap你不看就会忘记的知识点

    以前菜得不能看的时候看Java的招聘要求:Java基础扎实,熟悉常用集合类,多线程,IO,网络编程,经常会疑惑,集合类不就ArrayList,HashMap会用...

    用户2141593
  • mysql uftb8mb4 储存 emoji 表情失败

    OK 没问题,设置 nick_name 为 utf8mb4 varchar(50)

    用户2141593
  • <二>深入理解Threadlocal 关于内存泄漏的思考

    什么是内存泄漏呢?对象已经没有在其它地方被使用了,但是垃圾回收器没办法移除它们,因为还在被引用着。

    用户2141593
  • 源码分析 spring事务处理机制

    Spring在TransactionDefinition接口中定义这些属性,以供PlatfromTransactionManager使用, PlatfromTr...

    矿泉水
  • WCF技术剖析之三十一: WCF事务编程[下篇]

    在WCF事务编程模型下,通过服务契约确定事务流转的策略(参阅《上篇》),通过事务绑定实施事务的流转(参阅《中篇》)。但是,对于事务绑定接收到并成功创建的事务来说...

    蒋金楠
  • 分布式事务处理你不得不听的踩坑故事-让你的代码经得起考验

    java架构师
  • mysql 谈谈innodb存储引擎

    5.7版本引入了模式自动转换的功能,但该语法依然保留了。 另外一个有趣的点是,在5.7版本中,你可以通过设置session_track_transactio...

    Java架构师历程
  • MySQL事务原理&实战【官方精译】

    事务隔离是数据库处理的基础之一。隔离是I中的首字母 ACID ; 隔离级别是在多个事务同时进行更改和执行查询时,对结果的性能和可靠性,一致性和可重复性之间的平衡...

    sunsky
  • 事务的隔离性

    事务的四大特性为原子性(Atomicity)、一致性(Consistency)、隔离性(Isolation)、持久性(Durability),本篇专门说说隔离性...

    你的益达
  • mysql之DDL

    一 简介:今天来DDL的变革 二 DDL演化方式: 1 copy table : 1 创建临时表2 copy数据到临时表 3 rename进行交换 缺点...

    梦_之_旅

扫码关注云+社区

领取腾讯云代金券