Spring 面试题——事务

我会带着你远行 2024-03-23 18:04 15阅读 0赞

#### 目录 ####

*  1.谈谈对 Spring 事务的理解。
 *  2.Spring 管理事务的方式有哪几种？
 *  3.✨Spring 事务底层源码是如何实现的？
 *   *  3.1.后置处理
     *  3.2.事务执行
     *  3.3.总结
 *  4.@Transactional 注解有什么作用？它的常用属性有哪些？
 *  5.✨Spring 事务中的传播行为是指什么？具体有哪几种传播行为？
 *  6.Spring 中如何设置传播行为？

## 1.谈谈对 Spring 事务的理解。 ##

（1）**概念**：Spring 事务是 Spring 框架提供的一种**用于处理数据库事务的机制**。在传统的 JDBC 中，我们需要手动管理事务的开启、提交和回滚，这样的代码实现非常繁琐且容易出错，而 Spring 事务通过**对事务进行封装**，提供了一种更方便、更简单的方式来管理事务。

（2）**底层实现原理**：Spring 的事务管理是通过 `Spring AOP` 功能实现的，它**在方法调用前后进行事务的管理和控制**。以声明式事务管理为例，通过在方法或类上添加 `@Transactional` 注解，Spring 会在执行方法时自动为其创建事务，并在方法执行完成后根据执行结果决定是否提交或回滚事务。通过使用 Spring AOP 和事务管理，可以**实现业务逻辑和横切关注点的松耦合**，并实现更可维护和可扩展的代码。

（3）**特性**：Spring 事务的关键特性以下几点：

*  **多种管理事务的方式**：Spring 提供了多种管理事务的方式，例如**声明式事务**、**编程式事务**，我们根据实际情况选取对应的方式。
 *  **多种传播行为**：Spring 事务提供了 7 种传播行为，如 `REQUIRED`（如果没有事务，则创建一个新事务；如果有事务，则加入当前事务）、`REQUIRES_NEW`（无论是否存在事务，都创建一个新事务）、`NESTED`（嵌套事务，创建一个保存点，允许内部事务独立提交或回滚）等。这些传播行为**可以根据业务需求进行配置，实现对事务的精确控制**。
 *  **隔离级别**：Spring 事务支持多种隔离级别，如 `READ_UNCOMMITTED`（读未提交）、`READ_COMMITTED`（读已提交）、`REPEATABLE_READ`（可重复读）、`SERIALIZABLE`（串行化）等。通过配置隔离级别，我们可以控制事务对于其他事务的可见性和并发行为，确保数据的隔离性。
 *  **异常处理**：Spring 事务提供了异常处理机制，可以配置需要回滚的异常类型和不需要回滚的异常类型。当方法中抛出指定类型的异常时，事务将回滚或不回滚，从而可以**对事务执行过程中发生的异常进行精细的管理**。

## 2.Spring 管理事务的方式有哪几种？ ##

Spring 管理事务的方式有以下三种：

*  **编程式事务管理**：编程式事务管理是通过**在代码中编写事务管理相关的代码**实现的。这种方式需要手动控制事务的开启、提交和回滚，代码比较繁琐。在 Spring 中，可以使用 `TransactionTemplate` 或者直接使用 `PlatformTransactionManager` 接口的实现类来实现编程式事务管理。
 *  **声明式事务管理**：声明式事务管理是通过**在配置文件或者注解@Transactional 中声明事务的相关信息**来实现的。这种方式可以将事务的控制从代码中分离出来，使得代码更加简洁。在 Spring 中，可以使用 AOP 技术来实现声明式事务管理，通过在配置文件中配置切面和通知，使得 Spring 在执行方法时自动应用事务管理。

## 3.✨Spring 事务底层源码是如何实现的？ ##

Spring 事务的源码部分大体上可以分为 2 步：创建目标 Bean 的后置处理和事务执行。

### 3.1.后置处理 ###

（1）第一步就是后置处理，在创建目标 Bean 的后置处理器中，主要是做下面两件事情。

（2）首先会获取到所有的切面信息，然后和目标 Bean 的所有方法进行匹配，然后找到目标 Bean 所有需要进行事务处理的方法，匹配成功的方法。此外，还需要将事务属性保存到缓存 `attributeCache` 中。`attributeCache` 是一个 Map 结构，其中的 `key` 保存的是方法对象，`value` 保存的是该方法对应的属性信息。

public abstract class AbstractFallbackTransactionAttributeSource implements TransactionAttributeSource {
        
    	
    	//...	
    
    	final Map<Object, TransactionAttribute> attributeCache = new ConcurrentHashMap<>();
    }

（3）然后就是**创建 AOP 代理对象**。在该过程中涉及到一个名为 `AbstractAutoProxyCreator` 的类，该类实现了 `BeanPostProcessor` 接口，并且重写了后置处理方法 `postProcessAfterInitialization`，该方法在 Bean 的初始化之后被调用，它允许开发者在初始化之前对 Bean 进行一些自定义的操作。postProcessAfterInitialization 方法中调用了 `wrapIfNecessary` 方法，该方法主要执行逻辑是：

*  根据已知的相关信息调用 `createProxy` 方法来获取目标 Bean 代理对象，Spring 源码中的 `AopProxy` 接口定义了创建代理对象的方法，并且它有两个实现类，分别对应 2 种创建 AOP 代理对象的方式：
    
     *  如果是基于接口的代理，则选择使用 `JDK` 动态代理，对应 `JdkDynamicAopProxy` 类；
     *  如果是基于类的代理，则选择使用 `CGLIB` 动态代理，对应 `CglibAopProxy` 类；

### 3.2.事务执行 ###

（1）回到业务逻辑，通过目标 Bean 的 AOP 代理对象，开始执行主方法。在执行事务时会调用 `TransactionInterceptor` 中的 `invoke` 方法，里面会调用事务执行的核心方法，即 `TransactionAspectSupport` 类中的 `invokeWithinTransaction` 方法，其源码如下：

public abstract class TransactionAspectSupport implements BeanFactoryAware, InitializingBean {
        
    
    	//...
    
    	protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
                final InvocationCallback invocation) throws Throwable {
        
            //获取我们的事务属源对象
            TransactionAttributeSource tas = getTransactionAttributeSource();
            //通过事务属性源对象获取到我们的事务属性信息
            final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
            //获取我们配置的事务管理器对象
            final PlatformTransactionManager tm = determineTransactionManager(txAttr);
            //从tx属性对象中获取出标注了@Transactionl的方法描述符
            final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);
    
            //处理声明式事务
            if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {
        
                //有没有必要创建事务
                TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
    
                Object retVal;
                try {
        
                    //调用钩子函数进行回调目标方法
                    retVal = invocation.proceedWithInvocation();
                }
                catch (Throwable ex) {
        
                    //抛出异常进行回滚处理
                    completeTransactionAfterThrowing(txInfo, ex);
                    throw ex;
                }
                finally {
        
                    //清空我们的线程变量中transactionInfo的值
                    cleanupTransactionInfo(txInfo);
                }
                //提交事务
                commitTransactionAfterReturning(txInfo);
                return retVal;
            }
            //编程式事务
            else {
        
              //这里不是我们的重点，省略...
            }
        }
    }

（2）`invokeWithinTransaction` 方法的主要执行逻辑如下：

*  **获取事务属性**：从 `attributeCache` 缓存中获取事务的缓存数据，即 `TransactionAttribute` 对象；
 *  **创建事务**：通过 `createTransactionIfNecessary` 方法创建并开启事务；
 *  **执行逻辑**：调用 `proceedWithInvocation` 方法，开始执行业务逻辑。在执行过程中可能出现以下两种情况：
    
     *  如果在执行过程中没有出现异常或者错误，则最后**提交事务**，整个流程结束；
     *  如果在执行过程中抛出异常，则会进入 `completeTransactionAfterThrowing` 方法，走后续的**事务回滚操作**。至于具体是否执行回滚操作，或者针对哪些指定的异常执行回滚操作，则与事务属性 `rollbackFor` 或者 `noRollbackFor` 的具体配置有关；

### 3.3.总结 ###

总的来说，Spring 事务底层实现主要分为 2 步：

*  先匹配出目标 Bean 对象所有关于事务的切面列表，并将匹配成功的事务属性保存到 `advisorsCache` 缓存中；
 *  从缓存取出事务属性，然后创建事务、启动事务，执行业务逻辑，最后提交或者回滚事务。

> 相关文章：  
> [61 张图，剖析 Spring 事务，就是要钻到底！][61 _ Spring]  
> [Spring 面试题——AOP][Spring _AOP]

## 4.@Transactional 注解有什么作用？它的常用属性有哪些？ ##

（1）`@Transactional` 注解是一个**用于声明事务的注解，用于在方法或类级别上标记为事务性**。它的作用是**告诉 Spring 框架要对带有该注解的方法或类进行事务处理**。

（2）`@Transactional` 注解有以下几个常用属性：

*  `propagation`：指的是一个事务方法被另一个事务方法调用时，事务如何传播，**默认值为 REQUIRED**。
 *  `isolation`：表示事务的隔离级别，**默认值为 DEFAULT**。隔离级别指的是多个事务同时访问数据库时的数据隔离程度，常用的隔离级别包括：
    
     *  `DEFAULT`：使用数据库默认的隔离级别。
     *  `READ_UNCOMMITTED`：允许读取未提交的数据变更。
     *  `READ_COMMITTED`：只能读取已经提交的数据变更。
     *  `REPEATABLE_READ`：可重复读，确保多次读取的结果一致。
     *  `SERIALIZABLE`：串行化，最高的隔离级别，确保事务串行执行。
 *  `readOnly`：表示事务是否为只读事务，**默认值为 false**。如果将其设置为 true，表示该事务只读取数据而不更新数据，可以用于优化事务性能。
 *  `timeout`：表示事务的超时时间，**默认值为 -1，表示不超时**。超时时间是指事务执行的最长时间，超过该时间，则事务会被自动回滚。
 *  `rollbackFor`：指定异常类型数组，当方法抛出指定类型的异常时，事务会回滚。示例：@Transactional(rollbackFor = \{Exception.class\})
 *  `rollbackForClassName`：指定异常类型名称数组，当方法抛出指定类型的异常时，事务会回滚。示例：@Transactional(rollbackForClassName = \{“Exception”\})
 *  `noRollbackFor`：指定异常类型数组，当方法抛出指定类型的异常时，事务不会回滚。示例：@Transactional(noRollbackFor = \{CustomException.class\})
 *  `noRollbackForClassName`：指定异常类型名称数组，当方法抛出指定类型的异常时，事务不会回滚。示例：@Transactional(noRollbackForClassName = \{“CustomException”\})

（3）注意：回滚属性可以单独使用，也可以组合使用，以定义回滚策略。**如果不指定回滚属性，默认情况下，事务会在遇到 RuntimeException 及其子类抛出时回滚**。

> 相关知识点：  
> [MySQL 面试题——事务][MySQL]

（3）Transactional 注解的源码如下所示：

@Target({
        ElementType.METHOD, ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Inherited
    @Documented
    public @interface Transactional {
        
    
    	@AliasFor("transactionManager")
    	String value() default "";
    
    	@AliasFor("value")
    	String transactionManager() default "";
    
    	Propagation propagation() default Propagation.REQUIRED;
    
    	Isolation isolation() default Isolation.DEFAULT;
    
    	int timeout() default TransactionDefinition.TIMEOUT_DEFAULT;
    
    	boolean readOnly() default false;
    
    	Class<? extends Throwable>[] rollbackFor() default {
        };
    
    	String[] rollbackForClassName() default {
        };
    
    	Class<? extends Throwable>[] noRollbackFor() default {
        };
    
    	String[] noRollbackForClassName() default {
        };
    
    }

> 相关文章：  
> [拜托！面试请不要再问我 @Transactional][_Transactional]  
> [MySQL 面试题——事务][MySQL]

## 5.✨Spring 事务中的传播行为是指什么？具体有哪几种传播行为？ ##

（1） 事务中的传播行为解决的核心问题是**多个声明了事务的方法相互调用的时候存在的事务嵌套问题**，那么这个事务的行为应该如何进行传递呢？比如说 `methodA()` 调用 `methodB()`，两个方法都显示地开启了事务，那么 methodB() 是开启一个新事务，还是继续在 methodA() 的事务中执行呢？这就取决于**事务的传播行为**。

（2）所以 Spring 为了解决这个问题，定义了以下 7 种事务传播行为：

<table> 
 <thead> 
  <tr> 
   <th>传播属性</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>REQUIRED</td> 
   <td>如果有事务在运行，当前的方法就在这个事务内运行，否则，就<strong>启动一个新的事务</strong>，并在自己的事务内运行（默认的）</td> 
  </tr> 
  <tr> 
   <td>REQUIRED_NEW</td> 
   <td>无论当前是否存在事务，<strong>都必须创建一个新事务</strong>。如果当前存在事务，将会被挂起，并在新事务结束后恢复。即使外部事务回滚，新事务也不受影响</td> 
  </tr> 
  <tr> 
   <td>NESTED</td> 
   <td>如果有事务在运行，当前的方法就应该在这个事务的<strong>嵌套</strong>事务内运行．否则，就启动一个新的事务，并在它自己的事务内运行</td> 
  </tr> 
  <tr> 
   <td>MANDATORY</td> 
   <td><strong>强制事务执行</strong>，当前的方法必须运行在事务内部；如果没有正在运行的事务，就抛出异常</td> 
  </tr> 
  <tr> 
   <td>SUPPORTS</td> 
   <td><strong>支持事务</strong>，如果有事务在运行，当前的方法就在这个事务内运行；否则以非事务的方式执行</td> 
  </tr> 
  <tr> 
   <td>NOT_SUPPORTED</td> 
   <td><strong>不支持事务</strong>，以非事务的方式执行，如果有运行的事务，将它挂起</td> 
  </tr> 
  <tr> 
   <td>NEVER</td> 
   <td><strong>以非事务的方式执行</strong>，如果有运行的事务，就抛出异常</td> 
  </tr> 
 </tbody> 
</table>

> Spring 事务中的事务传播行为是指**在一个方法内部调用另一个带有事务的方法时，事务如何传播到被调用的方法中的行为**。

## 6.Spring 中如何设置传播行为？ ##

（1）在 Spring 中设置事务传播行为，可以通过**在 @Transactional 注解中设置 propagation 属性来实现**。propagation 属性的默认值是 REQUIRED，也就是使用当前事务，如果不存在则新建事务。

（2）例如，使用 REQUIRED 传播行为的示例：

@Service
    @Transactional(propagation = Propagation.REQUIRED)
    public class UserServiceImpl implements UserService {
        
        // ...
    }

在这个示例中，@Transactional 注解的 propagation 属性被设置为 REQUIRED，也就是**在该方法内使用当前事务，如果不存在则新建一个事务**。可以根据需要将 propagation 属性设置为其他的传播行为，如 SUPPORTS、MANDATORY、REQUIRES\_NEW、NOT\_SUPPORTED、NEVER 或 NESTED。

[61 _ Spring]: https://mp.weixin.qq.com/s/5HVpCjouOFsLfvC93XfLzw
[Spring _AOP]: https://xgqngu.blog.csdn.net/article/details/131967817
[MySQL]: https://xgqngu.blog.csdn.net/article/details/132029425
[_Transactional]: https://mp.weixin.qq.com/s/rlfRjCb8EOrpt3xnF7isBw