Spring 声明式事务 @Transactional

棕豆兔＆

已于 2024-08-18 17:32:23 修改

阅读量292

点赞数 8

分类专栏： Spring 文章标签： spring java 数据库

于 2024-08-18 16:58:39 首次发布

本文链接：https://blog.csdn.net/m0_60462557/article/details/141280942

版权

Spring 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

Spring 声明式事务 @Transactional的使用很简单，只需要添加依赖，在需要的方法或者类上添加 @Transactional注解即可。

一、添加依赖

<dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-tx</artifactId>
</dependency>

在需要事务的方法上添加 @Transactional 注解就可以实现了，无需手动开启事务和提交事务，进入方法时自动开启事务，方法执行完会自动提交事务，如果中途发生了没有处理的异常会自动回滚事务。

代码示例：

@RequestMapping("/trans")
@RestController
public class TransactionalController {

 @Autowired
 private UserService userService;

 @Transactional
 @RequestMapping("/registry")
 public String registry(String name,String password){
 //用户注册
 userService.registryUser(name,password);
 return "注册成功";
 }
}

假设代码有异常：

@Slf4j
@RequestMapping("/trans")
@RestController
public class TransactionalController {

 @Autowired
 private UserService userService;

 @Transactional
 @RequestMapping("/registry")
 public String registry(String name,String password){
 //⽤户注册
 userService.registryUser(name,password);
 log.info("用户数据插⼊成功");
 //强制程序抛出异常
 int a = 10/0;
 return "注册成功";
 }
}

启动项目发现虽然日志显示数据插入成功，但数据库却没有新增数据，事务进行了回滚。

二、@Transactional 作用

@Transactional 可以用来修饰方法或类:

修饰方法时: 只有修饰public 方法时才生效(修饰其他方法时不会报错, 也不生效)[推荐]
修饰类时: 对 @Transactional 修饰的类中所有的 public 方法都生效。

方法/类被 @Transactional 注解修饰时，在目标方法执行开始之前，会自动开启事务，方法执行结束之后，自动提交事务。

如果在方法执行过程中，出现异常，且异常未被捕获，就进行事务回滚操作。

如果异常被程序捕获，方法就被认为是成功执行，依然会提交事务。

举例：（对异常进行捕获）

@Transactional
@RequestMapping("/registry")
public String registry(String name,String password){
 //⽤⼾注册
 userService.registryUser(name,password);
 log.info("⽤⼾数据插⼊成功");
 //对异常进⾏捕获
 try {
 //强制程序抛出异常
 int a = 10/0;
 }catch (Exception e){
 e.printStackTrace();
 }
 return "注册成功";
}

运行程序，发现虽然程序出错了，但是由于异常被捕获，所以事务依然得到了提交。

如果需要事务进行回滚，有以下两种方式：

重新抛出异常

@Transactional
@RequestMapping("/registry")
public String registry(String name,String password){
//⽤户注册
userService.registryUser(name,password);
log.info("⽤⼾数据插⼊成功");
 //对异常进⾏捕获
 try {
 //强制程序抛出异常
 int a = 10/0;
 }catch (Exception e){
 //将异常重新抛出去
 throw e;
 }
 return "注册成功";
}

手动回滚事务

使用 TransactionAspectSupport.currentTransactionStatus() 得到当前的事务，并使用用 setRollbackOnly 设置 setRollbackOnly

@Transactional
@RequestMapping("/registry")
public String registry(String name,String password){
//⽤户注册
userService.registryUser(name,password);
log.info("⽤户数据插⼊成功");
//对异常进行捕获
try {
//强制程序抛出异常
int a = 10/0;
}catch (Exception e){
// 手动回滚事务
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
}
return "注册成功";
}

三、@Transactional详解

@Transactional注解有三个常见的属性：

rollbackFor: 异常回滚属性。指定能够触发事务回滚的异常类型，可以指定多个异常类型。
isolation: 事务的隔离级别。默认值为 Isolation.DEFAULT

propagation: 事务的传播机制。默认值为 Propagation.REQUIRED

3.1 rollbackFor

@Transactional 默认只在遇到运行时异常和Error时才会回滚，非运行时异常不回滚。即

Exception的子类中，除了RuntimeException及其子类。

如果需要所有异常都回滚，需要来配置 @Transactional 注解当中的 rollbackFor 属性，通过rollbackFor 这个属性指定出现何种异常类型时事务进行回滚。

@Transactional(rollbackFor = Exception.class)
@RequestMapping("/r2")
public String r2(String name,String password) throws IOException {

 //⽤户注册
 userService.registryUser(name,password);
 log.info("⽤户数据插⼊成功");
 if (true){
 throw new IOException();
 }
 return "r2";
}

运行程序会发现虽然程序抛出了异常，但是事务依然进行了提交。

3.2 事务隔离级别

事务隔离级别解决的是多个事务同时调用一个数据库的问题：

Spring 中事务隔离级别有5 种:

Isolation.DEFAULT : 以连接的数据库的事务隔离级别为主；
Isolation.READ_UNCOMMITTED : 读未提交，对应SQL标准中 READ UNCOMMITTED；
Isolation.READ_COMMITTED : 读已提交，对应SQL标准中 READ COMMITTED；
Isolation.REPEATABLE_READ : 可重复读，对应SQL标准中 REPEATABLE READ；
Isolation.SERIALIZABLE : 串行化，对应SQL标准中 SERIALIZABLE。

public enum Isolation {
 DEFAULT(-1),
 READ_UNCOMMITTED(1),
 READ_COMMITTED(2),
 REPEATABLE_READ(4),
 SERIALIZABLE(8);
 private final int value;
 private Isolation(int value) {
 this.value = value;
 }
 public int value() {
 return this.value;
 }
}

Spring 中事务隔离级别可以通过 @Transactional 中的 isolation 属性进行设置：

@Transactional(isolation = Isolation.READ_COMMITTED)
@RequestMapping("/r3")
public String r3(String name,String password) throws IOException {
 //... 
 return "r3";
}

3.3 Spring 事务传播机制

事务传播机制就是: 多个事务方法存在调用关系时，事务是如何在这些方法间进行传播的。

事务传播机制解决的是一个事务在多个节点(方法)中传递的问题：

@Transactional 注解支持事务传播机制的设置, 通过 propagation 属性来指定传播行为。

Spring 事务传播机制有以下 7 种：

Propagation.REQUIRED：默认的事务传播级别。如果当前存在事务, 则加入该事务。如果当前没有事务，则创建一个新的事务.
Propagation.SUPPORTS：如果当前存在事务，则加入该事务。如果当前没有事务，则以非事务的方式继续运行。
Propagation.MANDATORY：强制性。如果当前存在事务, 则加入该事务。如果当前没有事务，则抛出异常。
Propagation.REQUIRES_NEW : 创建一个新的事务。如果当前存在事务，则把当前事务挂起。也就是说不管外部方法是否开启事务，Propagation.REQUIRES_NEW 修饰的内部方法都会新开启自己的事务，且开启的事务相互独立，互不干扰。
Propagation.NOT_SUPPORTED : 以非事务方式运行，如果当前存在事务，则把当前事务挂起(不用)。
Propagation.NEVER : 以非事务方式运行，如果当前存在事务, 则抛出异常。
Propagation.NESTED : 如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行。如果当前没有事务，则该取值等价于 PROPAGATION_REQUIRED。

public enum Propagation {
 REQUIRED(0),
 SUPPORTS(1),
 MANDATORY(2),
 REQUIRES_NEW(3),
 NOT_SUPPORTED(4),
 NEVER(5),
 NESTED(6);
 private final int value;
 private Propagation(int value) {
 this.value = value;
 }
 public int value() {
 return this.value;
 }
}