Spring声明式事务@Transactional的用法解读

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;
 }
}

NESTED 和 REQUIRED 区别：

• 整个事务如果全部执行成功，二者的结果是一样的。
• 如果事务一部分执行成功，REQUIRED加入事务会导致整个事务全部回滚。NESTED嵌套事务可以实现局部回滚，不会影响上一个方法中执行的结果。

一个非常形象的比喻：

比如一对新人要结婚了, 关于是否需要房子：

• 1. Propagation.REQUIRED : 需要有房子。 如果你有房，我们就一起住，如果你没房，我们就一起买房。(如果当前存在事务，则加入该事务。如果当前没有事务，则创建一个新的事务)
• 2. Propagation.SUPPORTS : 可以有房子。如果你有房, 那就一起住。如果没房，那就租房。 (如果当前存在事务，则加入该事务。如果当前没有事务，则以非事务的方式继续运行)
• 3. Propagation.MANDATORY : 必须有房子。要求必须有房，如果没房就不结婚。(如果当前存在事务, 则加⼊该事务。如果当前没有事务，则抛出异常)
• 4. Propagation.REQUIRES_NEW : 必须买新房。不管你有没有房，必须要两个人一起买房。即使有房也不住。(创建一个新的事务. 如果当前存在事务, 则把当前事务挂起)
• 5. Propagation.NOT_SUPPORTED : 不需要房。不管你有没有房, 我都不住，必须租房。(以非事务方式运行，如果当前存在事务，则把当前事务挂起)
• 6. Propagation.NEVER : 不能有房子。(以非事务方式运行，如果当前存在事务，则抛出异常)
• 7. Propagation.NESTED : 如果你没房，就一起买房。如果你有房，我们就以房子为根据地。做点生意。(如果如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行。如果当前没有事务，则该取值等价于 PROPAGATION_REQUIRED )

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。

最新评论