1.阿里一面 五问 @Transactional
2.@Transactional 详解
3.Springboot之分布式事务框架Seata实现原理源码分析
4.深入了解Spring中的@Transactional
5.Spring事务注解@Transactional原理解析
6.「译」Spring 事务管理：@Transactional 深度解析｜by MarcoBehler.md

阿里一面 五问 @Transactional

       阿里一面深入解析@Transactional：事务管理的关键注解

       1. 作用范围：@Transactional 注解能用于方法级别，用于标记哪些方法需要事务管理，尤其在多数据源场景下，指定事务管理器至关重要。

       2. 属性详解：

        - rollbackFor：定义可导致事务回滚的异常类，如定义了ServletException，GUI builder源码将回滚所有匹配javax.servlet.ServletException及其子类的事务。

        - rollbackForClassName：类似rollbackFor，允许通过异常名称来指定回滚规则，但不支持通配符。

        - Propagation：设置事务传播行为，如REQUIRED表示在需要时才启动新事务，而readOnly则用于标记只读事务，可进行优化。

        - timeout：设置事务超时时间，仅在Propagation.REQUIRED或REQUIRES_NEW中起作用。

        - isolation：控制事务隔离级别，如READ_COMMITTED和ERIZABLE，有助于保证数据一致性。

       3. 注解失效情况：

        - 方法权限限制（非public）：事务无效。

        - 非公共方法被调用：@Transactional注解失效，因AOP代理机制。

        - 不同线程调用：不在同一事务中，可能导致事务失效。

       4. 何时开启事务：

        - 在带有@Transactional的代码执行到操作数据库的第一个语句时，事务才会启动。

        - 通过源码debug观察DataSourceTransactionManager的doBegin方法实现。

       5. 事务使用策略：

        - @Transactional 提供了便捷的事务控制，但需注意其失效场景和粒度问题。

        - 为避免不必要的影响，可根据具体业务场景选择手动控制事务的开启和关闭。

        - 总结：@Transactional不是万能的，应根据实际情况灵活运用，并遵循事务管理规范。

@Transactional 详解

       @Transactional 是声明式事务管理编程中使用的注解

       1. 添加位置

       1）接口实现类或接口实现方法上，而不是接口类中。2）访问权限：public 的方法才起作用。@Transactional 注解应该只被应用到 public 方法上，这是由 Spring AOP 的本质决定的。系统设计：将标签放置在需要进行事务管理的方法上，而不是放在所有接口实现类上：只读的接口就不需要事务管理，由于配置了@Transactional就需要AOP拦截及事务的处理，可能影响系统性能。番摊游戏源码

       3）错误使用：

       1. 接口中A、B两个方法，A无@Transactional标签，B有，上层通过A间接调用B，此时事务不生效。2. 接口中异常（运行时异常）被捕获而没有被抛出。默认配置下，spring 只有在抛出的异常为运行时 unchecked 异常时才回滚该事务，也就是抛出的异常为RuntimeException 的子类(Errors也会导致事务回滚)，而抛出 checked 异常则不会导致事务回滚。可通过 @Transactional rollbackFor进行配置。3. 多线程下事务管理因为线程不属于 spring 托管，故线程不能默认使用 spring 的事务，也不能获取spring 注入的 bean。在被 spring 声明式事务管理的方法内开启多线程，多线程内的方法不被事务控制。一个使用了@Transactional 的方法，如果方法内包含多线程的使用，方法内部出现异常，不会回滚线程中调用方法的事务。

       2. 声明式事务管理实现方式：基于 tx 和 aop 名字空间的 xml 配置文件

       // 基本配置 // MyBatis 自动参与到 spring 事务管理中，无需额外配置，只要 org.mybatis.spring.SqlSessionFactoryBean 引用的数据源与 DataSourceTransactionManager 引用的数据源一致即可，否则事务管理会不起作用。 // 标签的声明，是在 Spring 内部启用 @Transactional 来进行事务管理，使用 @Transactional 前需要配置。

       3. @Transactional注解 @Transactional 实质是使用了 JDBC 的事务来进行事务控制的 @Transactional 基于 Spring 的动态代理的机制

       @Transactional 实现原理：1) 事务开始时，通过AOP机制，生成一个代理connection对象，并将其放入 DataSource 实例的某个与 DataSourceTransactionManager 相关的某处容器中。在接下来的整个事务中，客户代码都应该使用该 connection 连接数据库，执行所有数据库命令。[不使用该 connection 连接数据库执行的数据库命令，在本事务回滚的时候得不到回滚]（物理连接 connection 逻辑上新建一个会话session； DataSource 与 TransactionManager 配置相同的数据源）2) 事务结束时，回滚在第1步骤中得到的代理 connection 对象上执行的数据库命令，然后关闭该代理 connection 对象。（事务结束后，回滚操作不会对已执行完毕的SQL操作命令起作用）

       4. 声明式事务的管理实现本质：事务的两种开启方式：显示开启 start transaction | begin，通过 commit | rollback 结束事务 关闭数据库中自动提交 autocommit set autocommit = 0；MySQL 默认开启自动提交；通过手动提交或执行回滚操作来结束事务

       Spring 关闭数据库中自动提交：在方法执行前关闭自动提交，叉子电竞源码方法执行完毕后再开启自动提交

       // org.springframework.jdbc.datasource.DataSourceTransactionManager.java 源码实现 // switch to manual commit if necessary. this is very expensive in some jdbc drivers, // so we don't want to do it unnecessarily (for example if we've explicitly // configured the connection pool to set it already). if (con.getautocommit()) { txobject.setmustrestoreautocommit(true); if (logger.isdebugenabled()) { logger.debug("switching jdbc connection [" + con + "] to manual commit"); } con.setautocommit(false); }

       问题：

       关闭自动提交后，若事务一直未完成，即未手动执行 commit 或 rollback 时如何处理已经执行过的SQL操作？

       C3P0 默认的策略是回滚任何未提交的事务 C3P0 是一个开源的JDBC连接池，它实现了数据源和 JNDI 绑定，支持 JDBC3 规范和 JDBC2 的标准扩展。目前使用它的开源项目有 Hibernate，Spring等 JNDI(Java Naming and Directory Interface,Java命名和目录接口)是SUN公司提供的一种标准的Java命名系统接口，JNDI提供统一的客户端API，通过不同的访问提供者接口JNDI服务供应接口(SPI)的实现，由管理者将JNDI API映射为特定的命名服务和目录系统，使得Java应用程序可以和这些命名服务和目录服务之间进行交互

       ------------------------------------------------------------------------------------------------------------------------------- 5. spring 事务特性 spring 所有的事务管理策略类都继承自 org.springframework.transaction.PlatformTransactionManager 接口

       public interface PlatformTransactionManager { TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException; void commit(TransactionStatus status) throws TransactionException; void rollback(TransactionStatus status) throws TransactionException; }

       事务的隔离级别：是指若干个并发的事务之间的隔离程度

       1. @Transactional(isolation = Isolation.READ_UNCOMMITTED)：读取未提交数据(会出现脏读, 不可重复读) 基本不使用 2. @Transactional(isolation = Isolation.READ_COMMITTED)：读取已提交数据(会出现不可重复读和幻读) 3. @Transactional(isolation = Isolation.REPEATABLE_READ)：可重复读(会出现幻读) 4. @Transactional(isolation = Isolation.SERIALIZABLE)：串行化

       事务传播行为：如果在开始当前事务之前，一个事务上下文已经存在，此时有若干选项可以指定一个事务性方法的执行行为

       1. TransactionDefinition.PROPAGATION_REQUIRED： 如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。这是默认值。2. TransactionDefinition.PROPAGATION_REQUIRES_NEW： 创建一个新的事务，如果当前存在事务，则把当前事务挂起。3. TransactionDefinition.PROPAGATION_SUPPORTS： 如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。4. TransactionDefinition.PROPAGATION_NOT_SUPPORTED： 以非事务方式运行，如果当前存在事务，则把当前事务挂起。5. TransactionDefinition.PROPAGATION_NEVER： 以非事务方式运行，如果当前存在事务，则抛出异常。6. TransactionDefinition.PROPAGATION_MANDATORY： 如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。7. TransactionDefinition.PROPAGATION_NESTED： 如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则该取值等价于TransactionDefinition.PROPAGATION_REQUIRED。

       上表字段说明：

       1. value ：主要用来指定不同的事务管理器；主要用来满足在同一个系统中，存在不同的事务管理器。比如在Spring中，声明了两种事务管理器txManager1, txManager2。然后，用户可以根据这个参数来根据需要指定特定的txManager。2. value 适用场景：在一个系统中，需要访问多个数据源或者多个数据库，哦耶源码网则必然会配置多个事务管理器。3. REQUIRED_NEW：内部的事务独立运行，在各自的作用域中，可以独立的回滚或者提交；而外部的事务将不受内部事务的回滚状态影响。4. ESTED 的事务，基于单一的事务来管理，提供了多个保存点。这种多个保存点的机制允许内部事务的变更触发外部事务的回滚。而外部事务在混滚之后，仍能继续进行事务处理，即使部分操作已经被混滚。由于这个设置基于 JDBC 的保存点，所以只能工作在 JDB C的机制。5. rollbackFor：让受检查异常回滚；即让本来不应该回滚的进行回滚操作。6. noRollbackFor：忽略非检查异常；即让本来应该回滚的不进行回滚操作。

Springboot之分布式事务框架Seata实现原理源码分析

       在Springboot 2.2. + Seata 1.3.0环境中，Seata通过GlobalTransactionScanner实现全局事务管理。首先，它会扫描带有@GlobalTransactional注解的方法类，作为BeanPostProcessor处理器，通过InstantiationAwareBeanPostProcessor的postProcessAfterInitialization方法中的wrapIfNecessary方法进行全局事务拦截。

       GlobalTransactionScanner判断类方法是否有@GlobalTransactional注解，如果没有则直接返回，否则创建GlobalTransactionalInterceptor。拦截器负责全局事务的执行，包括事务开始、执行本地业务、提交和回滚等步骤。例如，事务开始时，Seata通过SPI技术将xid绑定到当前线程，执行过程中会记录undo log以实现回滚。

       Seata自动配置会创建代理数据源（DataSourceProxy），在数据源方法调用时进行代理处理。当调用带有全局事务的方法时，如RestTemplate和Feign，拦截器会传递XID到请求头中，确保跨服务的事务一致性。参与者（被调用服务）通过SeataHandlerInterceptor拦截器获取并绑定XID，然后通过ConnectionProxy代理进行数据库操作，其中ConnectionContext用于判断是否为全局事务。

       总结来说，燕塘溯源码Seata的核心机制是通过代理、拦截器和XID的传递，确保分布式环境下的事务处理协调和一致性。

深入了解Spring中的@Transactional

       事务是不可分割的操作集合，确保数据的原子性、一致性、隔离性和持久性。Spring中事务管理支持编程式和声明式两种方式。

       编程式事务需要在代码中手动管理，而声明式事务则通过注解或XML配置实现。推荐使用声明式事务，其中@Transactional注解广泛用于标记事务操作。

       使用@Transactional注解标记方法时，需考虑propagation参数，该参数定义了事务的传播行为。方法A调用事务方法B时，事务传播到方法A中，propagation属性决定此行为。

       在声明式事务中，@Transactional注解利用Spring的AOP思想实现事务管理。Spring AOP将通用功能抽取为切面，避免代码侵入业务逻辑。在调用目标方法前，代理类插入切面，Spring在运行时将切面织入到管理的Bean中，实现方法的事务控制。

       了解Spring AOP的关键术语后，通过源码分析，可以看到Spring通过TransactionAutoConfiguration配置启用事务管理。@Transactional注解的实现涉及自动代理创建器和代理过程，最终生成代理对象以执行事务操作。

       总结而言，通过在方法上添加@Transactional注解并配置propagation参数，Spring能够实现声明式事务管理，利用AOP思想在运行时织入切面，确保方法执行的事务一致性。

Spring事务注解@Transactional原理解析

       事务管理是应用系统开发的关键部分，Spring 提供了丰富且方便的事务管理解决方案，显著简化了代码编写并提高了可维护性。

       以原生JDBC事务处理与Spring的事务处理进行对比，原生代码中充斥着复杂且重复的事务管理逻辑，而使用Spring则通过简单的注解即可实现。例如，针对保存三张表数据的需求（country、city、category），若采用原生JDBC，代码会显得冗长且难于维护。而在Spring中，通过设置特定的事务属性，如`Propagation.REQUIRES_NEW`，只需在对应方法上添加`@Transactional`注解，Spring便会自动处理事务，极大简化了代码。

       Spring的声明式事务机制，通过`TransactionAutoConfiguration`类自动配置事务相关组件，并由`TransactionInterceptor`类执行事务处理逻辑，实现了对带有`@Transactional`注解的方法的代理。此单例对象确保了所有事务逻辑的一致性和高效性。

       在使用`@Transactional`注解时，需要关注其属性的含义，包括`propagation`和`isolation`。`propagation`属性定义了事务的传播行为，如是否需要新事务、是否在当前事务中进行等。`isolation`属性则决定了事务的隔离级别，确保不同事务之间数据的一致性。

       进一步深入了解`@Transactional`注解的实现细节，可参阅Spring源码。GitHub和Gitee提供该代码的同步版本，方便开发者深入研究。

「译」Spring 事务管理：@Transactional 深度解析｜by MarcoBehler.md

       原文链接为： Spring Transaction Management: @Transactional In-Depth | MarcoBehler

       你可以通过本文，对@Transactional 注解在 Spring 事务管理中的运行机制，形成一个简明实用的理解。

       唯一的阅读前提？你需要对数据库 ACID 原则有个大致了解，即数据库事务是什么，我们为什么需要它。此外，本文没有覆盖分布式事务和反应式事务（reactive transactions），尽管在 Spring 中下文提到的一些通用原则也是适用的。

       在本文中，你将学到 Spring 事务抽象框架的核心概念，同时会有很多示例代码帮助你理解。

       相对于 Spring 官方文档，本文不会让你迷失在 Spring 的上层概念里。 相反你会以不同寻常的路径来学习 Spring 事务管理。从底层开始，一层层向上。也就是说，你将从普通原始的 JDBC 事务学起。

       普通的 JDBC 事务是如何工作的？如何 start, commit 或 rollback JDBC 事务？最终，他们都做了同样的事来开启和关闭（或称为“管理”）数据库事务。纯 JDBC 事务管理代码如下：这 4 行高度简化的代码，就是 Spring@Transactional 为你在背后做的所有事情。在下一章节中，你将会学到他们是如何工作的。在此之前，我们还有一丁点知识点要补充。

       如何使用 JDBC 隔离级别和保存点（savepoints）？如果你已经使用过 Spring@Transactional 注解，你可能碰到过类似用法：我们会在后文更加详细的介绍 Spring 嵌套事务和隔离级别，在这重复提及，是因为这些参数最终可提炼成如下 JDBC 代码：

       Spring 或 Spring Boot 的事务是如何工作的？既然现在你对 JDBC 事务有了基础的理解，让我们再去探究下纯粹的 Spring 核心事务。这里所讲都可 1:1 适用于 Spring Boot 和 Sring MVC，但又做了一些补充。到底什么是 Spring 事务管理或事务抽象框架？记住，事务管理可简单理解为：Spring 如何 start, commit 或 rollback JDBC 事务？是不是听着和前文讲得很相似？抓住重点：基于 JDBC 你只有一个方法（setAutocommit(false)）来开启事务管理，Spring 提供了许多不同，但更方便的封装来做相同的事情。

       如何使用 Spring 编程式事务管理？最初，但现在很少使用方式，是在 Spring 通过编程定义事务：通过TransactionTemplate 或者直接使用 PlatformTransactionManager。代码示例如下「译者注：参见配套项目 BookingServcie 实现」：与 JDBC 示例 比较：尽管这是一个不小的改进，但编程式事务管理并不是 Spring 事务框架主要关注的。相反，声明式事务管理才是重头戏。让我们一探究竟

       如何使用 Spring 的@Transactional 注解（声明式事务管理）？让我们看下时下的 Spring 事务管理通常怎么用：这是怎么做到的？没有了冗余的 XML 配置和额外的编码。相反，你只需要做两件事：所以，为了让@Transactional 工作，你需要：现在，我说 Spring 透明的为你处理事务，到底在指什么？ 在有了 JDBC 事务示例 的知识储备后，@Transactional 标注的 UserService 可以翻译简化成：这个示例看起来像魔术，让我们继续探究下 Spring 是如何为你自动插入这些连接代码的。

       CGLIB & JDK 代理 - 在@Transactional 之下？Spring 不能真的像我上面做的那样，去重写你的 Java 类来插入连接代码（除非你使用字节码增强等高级技术，在这我们暂时忽略它）

       你的registerUser() 方法还是只是调用了 userDao.save(user)，这是无法实时改变的。但是 Spring 有它的优势。在核心层，它有一个 IoC 容器。它实例化一个UserService 单例并可自动注入到任何需要 UserService 的 Bean 中。不管何时你在一个 Bean 上使用@Transactional，Spring 使用了个小伎俩。它不是直接实例化一个 UserService 原始对象，而是一个 UserService 的事务代理对象。借助 Cglib library 的能力，它可以使用子类继承代理（proxy-through-subclassing）的方式来实现。当然还有其他方式可以构造代理对象（例如 Dynamic JDK proxies 「译者注：这要求代理对象有相应接口类」），这里暂不做展开。

       你的UserService 可以动态生成代理类，并且代理可以帮你管理事务。但是并不是代理类本身去处理事务状态（open，commit，close），而是委托给了事务管理器（transaction manager）。

       你的UserService 有一个 invoice() 事务方法。它调用了另外一个 InvoiceService 类上的 createPdf() 事务方法。然而从 Spring 看来，这里有 2 个逻辑事务存在：第一个在UserService，另外一个在 InvoiceService。Spring 足够智能知道让两个 @Transactional 标记的方法，在底层使用同一个物理数据库事务。

       更改事务传播模式为requires_new 告诉 Spring：createPDF() 需要在它自己的、独立于其他任何已经在的事务里执行。这意味着你的底层代码会打开 2（物理）连接/事务 到数据库。Spring 依旧能够机智的把 2 个 逻辑事务（ invoice()/createPdf() ）映射到两个不同的物理数据库事务上。

       每个 Spring 传播模式在 数据库或 JDBC 连接层面到底做了什么？练习： 在原始 Java 实现那节，我展示了 JDBC 能够对事务进行的所有操作。花几分钟思考下，每个 Spring 传播模式在数据库或 JDBC 连接层面到底做了什么。然后再看下下面的解答。

       答案：如你所见，大多数传播模式并没有在数据库或 JDBC 层面做什么事情。更多的是通过 Spring 来组织你的代码，告诉 Spring 如何/什么时候/哪里需要事务处理。

       在示例中，任何时候你调用UserService 的 myMethod() 方法，Spring 期望这里有一个打开的事务。它不会为自己开启，相反，在没有已开启事务的情况下调用方法，Spring 会抛出异常。请记住这 “逻辑事务处理”的补充知识点。

       @Transactional 上隔离级别（Isolation Levels）代表什么？这是个抖机灵的问题，但当你如下配置的时候，到底发生了什么？哈，这可以简单地等价于：然而数据库事务隔离级别，是一个复杂的主题，你需要自己花些时间去掌握。Pstgres 的官方文档中的 isolation levels 章节，是个不错的入门文档。

       最容易踩的@Transactional 的坑？这里有一个 Spring 新手经常踩的坑，看下如下代码：你有一个UserService 类，事务方法 invoice 内部调用了事务方法 createPdf()。所以，当有人调用invoice() 的时候，最终有个多少个物理事务被打开？答案不是 2 个，而是 1 个，为什么呢？让我们回到本文中代理那章节。Spring 为你创建了UserService 代理类，但代理类内部的方法调用，是无法被代理的。也就是说，没有新的事务为你生成。这里有技巧（例如： self-injection 「译者注：参见示例项目 InnerCallSercie」），可以帮助你绕过该限制。但主要收获是：始终牢记代理事务的边界。

       在 Spring Boot 或 Spring MVC 中使用@Transactional？我们目前只是讨论了纯粹的核心 Spring 上的用法。那在 Spring Boot 或 Spring MVC 中会有什么使用差异吗？答案是：没有。无论使用何种框架（或更确切地说：Spring 生态系统中的所有框架），您都将始终使用 @Transactional 注解，配合事务管理器，以及@EnableTransactionManagement 注解。没有其他用法了。但是，与 Spring Boot 的唯一区别是，通过 JDBC 自动配置，它会自动设置@EnableTransactionManagement 注解，并为你创建 PlatformTransactionManager。

       关于 Spring 回滚的部分，将会在下一次文章修订中补充。Spring Boot 内回滚是通过@Transactional 注解上 rollback 系列配置实现的，读者可查阅源码注释了解使用方式，注释还是写得很完备的，本质上也是根据配置条件，确定何时调用 commit，何时调用 rollback。

       Spring 和 JPA / Hibernate 事务管理是如何一起工作的？目标：同步 Spring@Transactional 和 Hibernate / JPA。在这个节点上，你期望 Spring 可以和其他数据库框架，类似 Hibernate（一个流行的 JPA 实现）或 Jooq 等整合。让我来看一个纯粹的 Hibernate 示例（注意：直接使用 Hibernate 还是通过 JPA 使用 Hibernate 都没关系）。用 Hibernate 将UserService 重写如下：然而上述代码有一个大问题：但最终我们还是可以将 Spring 和 Hibernate 无缝整合，也就是说他们其实可以理解对象的事务概念。代码如下：这是怎么做到的？使用 HibernateTransactionManager 有一个非常简单的解决此集成问题的方法：相比在 Spring 配置里使用 DataSourcePlatformTransactionManager，你可以替换成 HibernateTransactionManager（如果使用了原生 Hibernate）或 JpaTransactionManager（如果通过 JPA 使用了 Hibernate）。这个定制化的 HibernateTransactionManager 会确保：与往常一样，一图胜千言（不过请注意，代理和真实服务之间的流程在这被高度抽象和简化了）。

       理解 Spring 事务管理后，你应该对 Spring 框架是如何处理事务，以及如何应用于其他 Spring 类库（例如 Spring Boot 或 Spring WebMVC）有了一个很好的了解。最大的收获应是：最终使用哪种框架都无关紧要，这一切可以映射到 JDBC 的基础概念上。正确理解它们（记住：getConnection()，setAutocommit(false)，commit()），在以后碰到复杂的企业级项目的使用，你能更容易抓住本质。

       到目前为止，你已经对 Spring 事务管理有了全面的了解，希望你在实践中能够灵活运用这些知识，解决实际项目中的事务问题。感谢阅读。