地表最强SpringBoot 各种回滚实战

2024-03-23码农

概念

事务定义

事务，就是一组操作数据库的动作集合。事务是现代数据库理论中的核心概念之一。如果一组处理步骤或者全部发生或者一步也不执行，我们称该组处理步骤为一个事务。当所有的步骤像一个操作一样被完整地执行，我们称该事务被提交。由于其中的一部分或多步执行失败，导致没有步骤被提交，则事务必须回滚到最初的系统状态。

事务特点

原子性： 一个事务中所有对数据库的操作是一个不可分割的操作序列，要么全做要么全不做

一致性： 数据不会因为事务的执行而遭到破坏

隔离性： 一个事务的执行，不受其他事务的干扰，即并发执行的事务之间互不干扰

持久性： 一个事务一旦提交，它对数据库的改变就是永久的。

事务实现机制

Spring 为事务管理提供了丰富的功能支持。Spring 事务管理分为编码式和声明式的两种方式。

编程式事务管理： 编程式事务管理使用 TransactionTemplate 或者直接使用底层的 PlatformTransactionManager 。对于编程式事务管理，spring推荐使用 TransactionTemplate 。

声明式事务管理： 建立在AOP之上的。其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。

声明式事务管理不需要入侵代码，更快捷而且简单，推荐使用。

声明式事务有两种方式：

一种是在配置文件（xml）中做相关的事务规则声明（因为很少用本文不讲解）

另一种是基于 @Transactional 注解的方式。注释配置是目前流行的使用方式，推荐使用。

在应用系统调用声明了 @Transactional 的目标方法时，Spring Framework 默认使用 AOP 代理，在代码运行时生成一个代理对象，根据 @Transactional 的属性配置信息，这个代理对象决定该声明 @Transactional 的目标方法是否由拦截器 TransactionInterceptor 来使用拦截，在 TransactionInterceptor 拦截时，会在目标方法开始执行之前创建并加入事务，并执行目标方法的逻辑，最后根据执行情况是否出现异常，利用抽象事务管理器 AbstractPlatformTransactionManager 操作数据源 DataSource 提交或回滚事务。

Spring AOP 代理有 CglibAopProxy 和 JdkDynamicAopProxy 两种，以 CglibAopProxy 为例，对于 CglibAopProxy ，需要调用其内部类的 DynamicAdvisedInterceptor 的 intercept 方法。对于 JdkDynamicAopProxy ，需要调用其 invoke 方法。

开启事务

注解@Transactional的使用

注解@Transactional常用配置

图片

Propagation的属性（事务的传播行为）

例如： @Transactional(propagation=Propagation.NOT_SUPPORTED,readOnly=true)

图片

事务5种隔离级别

例如： @Transactional(isolation = Isolation.READ_COMMITTED)

图片

使用注意事项（防止事务失效）

1.在具体的类（或类的方法）上使用 @Transactional 注解，而不要使用在类所要实现的任何接口上。

2. @Transactional 注解应该只被应用在 public 修饰的方法上。如果你在 protected 、 private 或者 package-visible 的方法上使用该注解，它也不会报错（IDEA会有提示），但事务并没有生效。

3.被外部调用的公共方法A有两个进行了数据操作的子方法B和子方法C的事务注解说明：

被外部调用的公共方法A未声明事务 @Transactional ，子方法B和C若是其他类的方法且各自声明事务，则事务由子方法B和C各自控制

被外部调用的公共方法A未声明事务 @Transactional ，子方法B和C若是本类的方法，则无论子方法B和C是否声明事务，事务均不会生效

被外部调用的公共方法A声明事务 @Transactional ，无论子方法B和C是不是本类的方法，无论子方法B和C是否声明事务，事务均由公共方法A控制

被外部调用的公共方法A声明事务 @Transactional ，子方法运行异常，但运行异常被子方法自己 try-catch 处理了，则事务回滚是不会生效的！

如果想要事务回滚生效，需要将子方法的事务控制交给调用的方法来处理：

方案1：子方法中不用 try-catch 处理运行异常

方案2：子方法的catch里面将运行异常抛出【 throw new RuntimeException(); 】

4.默认情况下，Spring会对unchecked异常进行事务回滚，也就是默认对 RuntimeException() 异常或是其子类进行事务回滚。如果是checked异常则不回滚，例如空指针异常、算数异常等会被回滚；文件读写、网络问题Spring就没法回滚。

若想对所有异常（包括自定义异常）都起作用，注解上面需配置异常类型： @Transactional(rollbackFor = Exception. class

5.数据库要支持事务，如果是mysql，要使用innodb引擎，myisam不支持事务

6.事务 @Transactional 由spring控制时，它会在抛出异常的时候进行回滚。如果自己使用try-catch捕获处理了，是不生效的。如果想事务生效可以进行手动回滚或者在catch里面将异常抛出【 throw new RuntimeException(); 】

方案一：手动抛出运行时异常（缺陷是不能在catch代码块自定义返回值）

try{
....
}catch(Exception e){
logger.error("",e);
throw new RuntimeException(e);
}

方案二：手动进行回滚【 TransactionAspectSupport.currentTransactionStatus().setRollbackOnly(); 】

try{
...
}catch(Exception e){
log.error("fail",e);
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
returnfalse;
}

@Transactional 可以放在Controller下面直接起作用，看到网上好多同学说要放到 @Component 下面或者 @Service 下面，经过试验，可以不用放在这两个下面也起作用。

@Transactional 引入包问题，它有两个包：

import javax.transaction.Transactional;
// 和
import org.springframework.transaction.annotation.Transactional; // 推荐

这两个都可以用，对比了一下他们两个的方法和属性，发现后面的比前面的强大。建议使用后面的。

使用场景

自动回滚

直接抛出，不try/catch

@Override
@Transactional(rollbackFor = Exception. class)
public Object submitOrder() throws Exception {
success();
//假如exception这个操作数据库的方法会抛出异常，方法success()对数据库的操作会回滚。
exception();
return ApiReturnUtil.success();
}

手动回滚

进行try/catch，回滚并抛出

@Override
@Transactional(rollbackFor = Exception. class)
public Object submitOrder (){
success();
try {
exception();
} catch (Exception e) {
e.printStackTrace();
// 手动回滚事务
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
return ApiReturnUtil.error();
}
return ApiReturnUtil.success();
}

回滚部分异常

使用【 Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint(); 】设置回滚点。

使用【 TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint); 】回滚到savePoint。

@Override
@Transactional(rollbackFor = Exception. class)
public Object submitOrder (){
success();
//只回滚以下异常，
Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
try {
exception();
} catch (Exception e) {
e.printStackTrace();
// 手工回滚事务
TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
return ApiReturnUtil.error();
}
return ApiReturnUtil.success();
}

手动创建、提交、回滚事务

PlatformTransactionManager 这个接口中定义了三个方法 getTransaction 创建事务，commit 提交事务，rollback 回滚事务。它的实现类是 AbstractPlatformTransactionManager 。

@Autowired
priDataSourceTransactionManager dataSourceTransactionManager;
@Autowired
TransactionDefinition transactionDefinition;
// 手动创建事务
TransactionStatus transactionStatus = dataSourceTransactionManager.getTransaction(transactionDefinition);
// 手动提交事务
dataSourceTransactionManager.commit(transactionStatus);
// 手动回滚事务。（最好是放在catch 里面，防止程序异常而事务一直卡在哪里未提交）
dataSourceTransactionManager.rollback(transactionStatus);

事务失效不回滚的原因及解决方案

异常被捕获导致事务失效

在spring boot 中，使用事务非常简单，直接在方法上面加入 @Transactional 就可以实现。

@GetMapping("delete")
@ResponseBody
@Transactional
public void delete(@RequestParam("id") int id) {
try {
//delete country
this.repository.delete(id);
if(id == 1){
throw Exception("测试事务");
}
//delete city
this.repository.deleteByCountryId(id);
}catch (Exception e){
logger.error("delete false:" + e.getMessage());
}
}

发现事务不回滚，即 this.repository.delete(id)； 成功把数据删除了。

原因：

默认spring事务只在发生未被捕获的 RuntimeException 时才回滚。

spring aop 异常捕获原理：被拦截的方法需显式抛出异常，并不能经任何处理，这样aop代理才能捕获到方法的异常，才能进行回滚，默认情况下aop只捕获 RuntimeException 的异常，但可以通过配置来捕获特定的异常并回滚。

换句话说在service的方法中不使用 try catch 或者在 catch 中最后加上 throw new RuntimeExcetpion() 抛出运行异常，这样程序异常时才能被aop捕获进而回滚。

解决方案：

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>4.3.2.RELEASE</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>1.8.9</version>
</dependency>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>aspectj-maven-plugin</artifactId>
<version>1.9</version>
<configuration>
<showWeaveInfo>true</showWeaveInfo>
<aspectLibraries>
<aspectLibrary>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
</aspectLibrary>
</aspectLibraries>
</configuration>
<executions>
<execution>
<goals>
<goal>compile</goal>
<goal>test-compile</goal>
</goals>
</execution>
</executions>
</plugin>

解决方案

方案1、在类上（或者最外层的公共方法）加事务

@Service
@Slf4j
public class MyTransactional {
// 最外层公共方法。自动回滚事务方式，insertOrder()方法报错后事务回滚，且线程中止，后续逻辑无法执行
@Transactional
public void test1() {
this.insertOrder();
System.out.println("11111111111111111");
}
// 最外层公共方法。手动回滚事务方式，insertOrder()方法报错后事务回滚，可以继续执行后续逻辑
@Transactional
public void test2() {
try {
insertOrder();
} catch (Exception e) {
log.error("faild to ...", e);
// 手动回滚事务
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
// 其他操作
}
// 其他操作
}
// 进行数据库操作的方法（private 或 public 均可）
private void insertOrder() {
//insert log info
//insertOrder
//updateAccount
}
}

方案 2、使用AspectJ 取代 Spring AOP 代理

上面的两个问题 @Transactional 注解只应用到 public 方法和自调用问题，是由于使用 Spring AOP 代理造成的。为解决这两个问题，可以使用 AspectJ 取代 Spring AOP 代理。

需要将下面的 AspectJ 信息添加到 xml 配置信息中。

AspectJ 的 xml 配置信息

<tx:annotation-driven mode="aspectj" />
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource" />
</bean>
</bean class="org.springframework.transaction.aspectj.AnnotationTransactionAspect" factory-method="aspectOf">
<property name="transactionManager" ref="transactionManager" />
</bean>

同时在 Maven 的 pom 文件中加入 spring-aspects 和 aspectjrt 的 dependency 以及 aspectj-maven-plugin 。

AspectJ 的 pom 配置信息

方案1：例如service层处理事务，那么service中的方法中不做异常捕获，或者在catch语句中最后增加 throw new RuntimeException(); 语句，以便让aop捕获异常再去回滚，并且在service的上层要继续捕获这个异常。

方案2：在service层方法的catch语句中进行手动回滚，这样上层就无需去处理异常。

@GetMapping("delete")
@ResponseBody
@Transactional
public Object delete(@RequestParam("id") int id){
if (id < 1){
return new MessageBean(101,"parameter wrong: id = " + id) ;
}
try {
//delete country
this.countryRepository.delete(id);
//delete city
this.cityRepository.deleteByCountryId(id);
return new MessageBean(200,"delete success");
}catch (Exception e){
logger.error("delete false:" + e.getMessage());
// 手动回滚
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
return new MessageBean(101,"delete false");
}
}

自调用导致事务失效

问题描述及原因

在 Spring 的 AOP 代理下，只有目标方法由外部调用，目标方法才由 Spring 生成的代理对象来管理，否则会造成自调用问题。

若同一类中的没有 @Transactional 注解的方法内部调用有 @Transactional 注解的方法，有 @Transactional 注解的方法的事务被忽略，不会发生回滚。见示例代码展示。

自调用问题示例：

@Service
public class OrderService {
private void insert() {
insertOrder();
}
@Transactional
public void insertOrder() {
//insert log info
//insertOrder
//updateAccount
}
}
// insertOrder() 尽管有@Transactional 注解，但它被内部方法 insert()调用，事务被忽略，出现异常事务不会发生回滚，并且会报错类似于：org.springframework.transaction.NoTransactionException: No transaction aspect-managed TransactionStatus in scope（翻译：没有Transaction无法回滚事务。自调用导致@Transactional 失效。）