Spring面试题汇总4：关于Spring事务的面试题

Posted 2021-05-14 黄小斜

数据库事务和 Spring 事务是一般面试都会被提到，很多朋友写惯了代码，很少花时间去整理归纳这些东西，结果本来会的东西，居然吞吞吐吐答不上来。
下面是我收集到一些关于Spring事务的问题，希望能帮助大家过关。

事务是逻辑处理原子性的保证手段，通过使用事务控制，可以极大的避免出现逻辑处理失败导致的脏数据等问题。

事务最重要的两个特性：

事务的传播级别：定义了事务在 传播 方面的控制范围。
数据的隔离级别：定义了事务在 数据库读写 方面的控制范围。
事务的7种传播级别：
1） PROPAGATION_REQUIRED ：默认的spring事务传播级别，使用该级别的特点是，如果上下文中已经存在事务，那么就加入到事务中执行，如果当前上下文中不存在事务，则新建事务执行。所以这个级别通常能满足处理大多数的业务场景。

2）PROPAGATION_SUPPORTS ：从字面意思就知道，supports，支持，该传播级别的特点是，如果上下文存在事务，则支持事务加入事务，如果没有事务，则使用非事务的方式执行。所以说，并非所有的包在 transactionTemplate.execute 中的代码都会有事务支持。这个通常是用来处理那些并非原子性的非核心业务逻辑操作。应用场景较少。

3）PROPAGATION_MANDATORY ： 该级别的事务要求上下文中必须要存在事务，否则就会抛出异常！配置该方式的传播级别是有效的控制上下文调用代码遗漏添加事务控制的保证手段。比如一段代码不能单独被调用执行，但是一旦被调用，就必须有事务包含的情况，就可以使用这个传播级别。

4）PROPAGATION_REQUIRES_NEW：从字面即可知道，new，每次都要一个新事务，该传播级别的特点是，每次都会新建一个事务，并且同时将上下文中的事务挂起，执行当前新建事务完成以后，上下文事务恢复再执行。

这是一个很有用的传播级别，举一个应用场景：现在有一个发送100个红包的操作，在发送之前，要做一些系统的初始化、验证、数据记录操作，然后发送100 封红包，然后再记录发送日志，发送日志要求100%的准确，如果日志不准确，那么整个父事务逻辑需要回滚。
怎么处理整个业务需求呢？就是通过这个 PROPAGATION_REQUIRES_NEW 级别的事务传播控制就可以完成。发送红包的子事务不会直接影响到父事务的提交和回滚。

5）PROPAGATION_NOT_SUPPORTED ：这个也可以从字面得知，not supported ，不支持，当前级别的特点就是上下文中存在事务，则挂起事务，执行当前逻辑，结束后恢复上下文的事务。

这个级别有什么好处？

可以帮助你将事务极可能的缩小。我们知道一个事务越大，它存在的风险也就越多。所以在处理事务的过程中，要保证尽可能的缩小范围。比如一段代码，是每次逻辑操作都必须调用的，再比如循环1000次的某个非核心业务逻辑操作。这样的代码如果包在事务中，势必造成事务太大，导致出现一些难以考虑周全的异常情况。所以这个事务这个级别的传播级别就派上用场了。用当前级别的事务模板抱起来就可以了。

6）PROPAGATION_NEVER ：该事务更严格，上面一个事务传播级别只是不支持而已，有事务就挂起，而PROPAGATION_NEVER传播级别要求上下文中不能存在事务，一旦有事务，就抛出 runtime异常 ，强制停止执行！这个级别上辈子跟事务有仇。

7）PROPAGATION_NESTED:字面也可知道，nested，嵌套级别事务。该传播级别特征是，如果上下文中存在事务，则嵌套事务执行，如果不存在事务，则新建事务。

那么什么是嵌套事务呢？

很多人都不理解，我看过一些博客，都是有些理解偏差。

嵌套 是子事务套在父事务中执行，子事务是父事务的一部分，在进入子事务之前，父事务建立一个回滚点，叫 save point，然后执行子事务，这个子事务的执行也算是父事务的一部分，然后子事务执行结束，父事务继续执行。
重点就在于那个 save point 。看几个问题就明了了：

如果子事务回滚，会发生什么？

父事务会回滚到进入子事务前建立的 save point，然后尝试其他的事务或者其他的业务逻辑，父事务之前的操作不会受到影响，更不会自动回滚。

如果父事务回滚，会发生什么？

父事务回滚，子事务也会跟着回滚！为什么呢，因为父事务结束之前，子事务是不会提交的，我们说子事务是父事务的一部分，正是这个道理。那么：

事务的提交，是什么情况？

是 " 父事务先提交，然后子事务提交 " ，还是 " 子事务先提交，父事务再提交 " ？
答案是第二种情况，还是那句话，子事务是父事务的一部分，由父事务统一提交。

现在你再体会一下这个”嵌套“，是不是有那么点意思？

以上是事务的7个传播级别，在日常应用中，通常可以满足各种业务需求，但是除了传播级别，在读取数据库的过程中，如果两个事务并发执行，那么彼此之间的数据是如何影响的呢？

数据隔离级别分为不同的四种：
SERIALIZABLE ：最严格的级别，事务串行执行，资源消耗最大；
REPEATABLE READ ：保证了一个事务不会修改已经由另一个事务读取但未提交（回滚）的数据。避免了“脏读取”和“不可重复读取”的情况，但是带来了更多的性能损失。
READ COMMITTED ：大多数主流数据库的默认事务等级，保证了一个事务不会读到另一个并行事务已修改但未提交的数据，避免了“脏读取”。该级别适用于大多数系统。
READ UNCOMMITED ：保证了读取过程中不会读取到非法数据。
上面的解释其实每个定义都有一些拗口，其中涉及到几个术语：脏读、不可重复读、幻读。
这里解释一下：

脏读（Dirty reads） ：所谓的脏读，其实就是读到了别的事务回滚前的脏数据。比如事务B执行过程中修改了数据X，在未提交前，事务A读取了X，而事务B却回滚了，这样事务A就形成了脏读。

不可重复读（non-repeatable reads） ：不可重复读字面含义已经很明了了，比如事务A首先读取了一条数据，然后执行逻辑的时候，事务B将这条数据改变了，然后事务A再次读取的时候，发现数据不匹配了，就是所谓的不可重复读了。

幻读（phantom reads） ：小的时候数手指，第一次数十10个，第二次数是11个，怎么回事？产生幻觉了？
幻读也是这样子，事务A首先根据条件索引得到10条数据，然后事务B改变了数据库一条数据，导致也符合事务A当时的搜索条件，这样事务A再次搜索发现有11条数据了，就产生了幻读。

一个对照关系表：

隔离级别 脏读（Dirty reads） 不可重复读（non-repeatable reads） 幻读（phantom reads）
SERIALIZABLE 不会 不会 不会
REPEATABLE READ 不会 不会 会
READ COMMITED 不会 会 会
READ UNCOMMITED 会 会 会
所以最安全的，是 SERIALIZABLE，但是伴随而来也是高昂的性能开销。
另外，事务常用的两个属性：

readonly：设置事务为只读以提升性能。
timeout：设置事务的超时时间，一般用于防止大事务的发生。
还是那句话，事务要尽可能的小！

思考一个问题
最后引入一个问题：

一个逻辑操作需要检查的条件有20条，能否为了减小事务而将检查性的内容放到事务之外呢？

很多系统都是在 DAO 的内部开始启动事务，然后进行操作，最后提交或者回滚。这其中涉及到代码设计的问题。小一些的系统可以采用这种方式来做，但是在一些比较大的系统，

逻辑较为复杂的系统中，势必会将过多的业务逻辑嵌入到 DAO 中，导致 DAO 的复用性下降。所以这不是一个好的实践。

来回答这个问题：能否为了缩小事务，而将一些业务逻辑检查放到事务外面？

答案是：对于核心的业务检查逻辑，不能放到事务之外，而且必须要作为分布式下的并发控制！

一旦在事务之外做检查，那么势必会造成事务 A 已经检查过的数据被事务 B 所修改，导致事务 A 徒劳无功而且出现并发问题，直接导致业务控制失败。

所以，在分布式的高并发环境下，对于核心业务逻辑的检查，要采用加锁机制。

比如事务开启需要读取一条数据进行验证，然后逻辑操作中需要对这条数据进行修改，最后提交。

这样的一个过程，如果读取并验证的代码放到事务之外，那么读取的数据极有可能已经被其他的事务修改，当前事务一旦提交，又会重新覆盖掉其他事务的数据，导致数据异常。

所以在进入当前事务的时候，必须要将这条数据锁住，使用 for update 就是一个很好的在分布式环境下的控制手段。

一种好的实践方式是使用编程式事务而非声明式，尤其是在较为规模的项目中。对于事务的配置，在代码量非常大的情况下，将是一种折磨，而且人肉的方式，绝对不能避免这种问题。

将 DAO 保持针对一张表的最基本操作，然后业务逻辑的处理放入 manager 和 service 中进行，同时使用编程式事务更精确的控制事务范围。

特别注意的，对于事务内部一些可能抛出异常的情况，捕获要谨慎，不能随便的 catch Exception 导致事务的异常被吃掉而不能正常回滚。

Spring配置声明式事务：

配置 DataSource
配置事务管理器
事务的传播特性
那些类那些方法使用事务
Spring 配置文件中关于事务配置总是由三个组成部分，分别是 DataSource、TransactionManager 和代理机制这三部分，无论哪种配置方式，一般变化的只是代理机制这部分。

DataSource、TransactionManager 这两部分只是会根据数据访问方式有所变化，比如使用 Hibernate 进行数据访问 时，DataSource 实际为 SessionFactory，TransactionManager 的实现为 HibernateTransactionManager。

根据代理机制的不同，Spring 事务的配置又有几种不同的方式：

第一种方式：每个 Bean 都有一个代理

第二种方式：所有Bean共享一个代理基类

第三种方式：使用拦截器

第四种方式：使用 tx 标签配置的拦截器

第五种方式：全注解

补充
传播级别 Spring 的源码注释org.springframework.transaction.annotation.Propagation：

/**
 * Support a current transaction, create a new one if none exists.
 * Analogous to EJB transaction attribute of the same name.
 * <p>This is the default setting of a transaction annotation.
 */
REQUIRED(TransactionDefinition.PROPAGATION_REQUIRED),

/**
 * Support a current transaction, execute non-transactionally if none exists.
 * Analogous to EJB transaction attribute of the same name.
 * <p>Note: For transaction managers with transaction synchronization,
 * {@code SUPPORTS} is slightly different from no transaction at all,
 * as it defines a transaction scope that synchronization will apply for.
 * As a consequence, the same resources (JDBC Connection, Hibernate Session, etc)
 * will be shared for the entire specified scope. Note that this depends on
 * the actual synchronization configuration of the transaction manager.
 * @see org.springframework.transaction.support.AbstractPlatformTransactionManager#setTransactionSynchronization
 */
SUPPORTS(TransactionDefinition.PROPAGATION_SUPPORTS),

/**
 * Support a current transaction, throw an exception if none exists.
 * Analogous to EJB transaction attribute of the same name.
 */
MANDATORY(TransactionDefinition.PROPAGATION_MANDATORY),

/**
 * Create a new transaction, and suspend the current transaction if one exists.
 * Analogous to the EJB transaction attribute of the same name.
 * <p><b>NOTE:</b> Actual transaction suspension will not work out-of-the-box
 * on all transaction managers. This in particular applies to
 * {@link org.springframework.transaction.jta.JtaTransactionManager},
 * which requires the {@code javax.transaction.TransactionManager} to be
 * made available to it (which is server-specific in standard Java EE).
 * @see org.springframework.transaction.jta.JtaTransactionManager#setTransactionManager
 */
REQUIRES_NEW(TransactionDefinition.PROPAGATION_REQUIRES_NEW),

/**
 * Execute non-transactionally, suspend the current transaction if one exists.
 * Analogous to EJB transaction attribute of the same name.
 * <p><b>NOTE:</b> Actual transaction suspension will not work out-of-the-box
 * on all transaction managers. This in particular applies to
 * {@link org.springframework.transaction.jta.JtaTransactionManager},
 * which requires the {@code javax.transaction.TransactionManager} to be
 * made available to it (which is server-specific in standard Java EE).
 * @see org.springframework.transaction.jta.JtaTransactionManager#setTransactionManager
 */
NOT_SUPPORTED(TransactionDefinition.PROPAGATION_NOT_SUPPORTED),

/**
 * Execute non-transactionally, throw an exception if a transaction exists.
 * Analogous to EJB transaction attribute of the same name.
 */
NEVER(TransactionDefinition.PROPAGATION_NEVER),

/**
 * Execute within a nested transaction if a current transaction exists,
 * behave like {@code REQUIRED} otherwise. There is no analogous feature in EJB.
 * <p>Note: Actual creation of a nested transaction will only work on specific
 * transaction managers. Out of the box, this only applies to the JDBC
 * DataSourceTransactionManager. Some JTA providers might support nested
 * transactions as well.
 * @see org.springframework.jdbc.datasource.DataSourceTransactionManager
 */
NESTED(TransactionDefinition.PROPAGATION_NESTED);

Spring 官方文档对 Spring 事务的说明：
https://docs.spring.io/spring-framework/docs/current/reference/html/data-access.html#transaction
————————————————
版权声明：本文为CSDN博主「crazy-tiger」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/u013490280/article/details/109707578