目录
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 "注册成功";
}
}
![](https://i-blog.csdnimg.cn/direct/039348639f534c8fabd696a7213f2aa1.png)
启动项目发现虽然日志显示数据插入成功,但数据库却没有新增数据,事务进行了回滚。
二、@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及其子类。
![](https://i-blog.csdnimg.cn/direct/9ea9a9ddc52e4f428317cf9595493bd3.png)
如果需要所有异常都回滚,需要来配置
@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 事务传播机制
事务传播机制就是: 多个事务方法存在调用关系时,事务是如何在这些方法间进行传播的。
事务传播机制解决的是一个事务在多个节点(方法)中传递的问题:
![](https://i-blog.csdnimg.cn/direct/6a54053215ea4e80a29d066efb56a6fd.png)
@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 )