【Spring】Spring事务和事务传播机制

一.为什么需要事务？

事务定义：

将⼀组操作封装成⼀个执行单元（封装到⼀起），要么全部成功，要么全部失败

为什么要用事务？

比如转账分为两个操作：

第一步操作：A 账户 -100 元。
第⼆步操作：B 账户 +100 元。

如果没有事务，第⼀步执行成功了，第⼆步执行失败了，那么 A 账户平白无故的 100 元就“人间蒸发”了。而如果使用事务就可以解决这个问题，让这一组操作要么一起成功，要么一起失败

二.Spring 中事务的实现

Spring 中的事务操作分为两类：

1. 编程式事务（手动写代码操作事务）。
2. 声明式事务（利用注解自动开启和提交事务）

2.1 MySQL 中的事务使用

事务在 MySQL 有 3 个重要的操作：开启事务、提交事务、回滚事务。

-- 开启事务
start transaction;
-- 业务执⾏
-- 提交事务
commit;
-- 回滚事务
rollback;

2.2 Spring 编程式事务

Spring 手动操作事务和上面 MySQL 操作事务类似，它也是有 3 个重要操作步骤：

• 开启事务（获取事务）。
• 提交事务。
• 回滚事务。

SpringBoot 内置了两个对象，DataSourceTransactionManager 用来获取事务（开启事务）、提交或回滚事务的，而 TransactionDefinition 是事务的属性，在获取事务的时候需要将 TransactionDefinition 传递进去从而获得⼀个事务 TransactionStatus

从上述代码可以看出，以上代码虽然可以实现事务，但操作也很繁琐，有没有更简单的实现方法呢？请看下面声明式事务

2.3 Spring 声明式事务（自动）

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

执行流程:方法执行之前先开启事务，当方法成功执行完成之后会自动提交事务;但是如果在执行途中发生了异常，那么事务会自动回滚。

2.3.1 @Transactional 作用范围

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

• 修饰方法时：需要注意只能应用到 public 方法上，否则不生效。推荐此种用法。
• 修饰类时：表明该注解对该类中所有的 public 方法都生效。

2.3.2 @Transactional 参数说明

2.3.3 注意事项

@Transactional 在异常被捕获的情况下，不会进行事务自动回滚

@RestController
public class UserController {
	 @Resource
	 private UserService userService;
	 @RequestMapping("/save")
	 @Transactional
	 public Object save(User user) {
		 // 插⼊数据库
		 int result = userService.save(user);
		 try {
			 // 执⾏了异常代码(0不能做除数)
			 int i = 10 / 0;
		 } catch (Exception e) {
		 	 System.out.println(e.getMessage());
		 }
		 return result;
	 }
}

事务不会⾃动回滚解决⽅案

解决方案1：对于捕获的异常，事务是会自动回滚的，因此解决方案1就是可以将异常重新抛出，具体实现如下：

@RequestMapping("/save")
@Transactional(isolation = Isolation.SERIALIZABLE)
public Object save(User user) {
	 // 插⼊数据库
	 int result = userService.save(user);
	 try {
		 // 执⾏了异常代码(0不能做除数)
		 int i = 10 / 0;
	 } catch (Exception e) {
		 System.out.println(e.getMessage());
		 // 将异常重新抛出去
		 throw e;
	 }
	 return result;
}

解决方案2：手动回滚事务，在方法中使用 TransactionAspectSupport.currentTransactionStatus() 可以得到当前的事务，然后设置回滚方法 setRollbackOnly 就可以实现回滚了

@RequestMapping("/save")
@Transactional(isolation = Isolation.SERIALIZABLE)
public Object save(User user) {
	 // 插⼊数据库
	 int result = userService.save(user);
	 try {
		 // 执⾏了异常代码(0不能做除数)
		 int i = 10 / 0;
	 } catch (Exception e) {
		 System.out.println(e.getMessage());
		 // ⼿动回滚事务
		 TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
	 }
	 return result;
}

需要导入的包：import org.springframework.transaction.interceptor.TransactionAspectSupport;

2.3.4 @Transactional 工作原理

• @Transactional 是基于 AOP 实现的，AOP 又是使用动态代理实现的。如果目标对象实现了接口，默认情况下会采用 JDK 的动态代理，如果⽬标对象没有实现了接口,会使用 CGLIB 动态代理。
• @Transactional 在开始执行业务之前，通过代理先开启事务，在执行成功之后再提交事务。如果中途遇到的异常，则回滚事务。
• @Transactional 实现思路预览：
  
  @Transactional 具体执行细节如下图所示：
  

---

三.事务隔离级别

3.1 事务特性回顾

事务有4 大特性（ACID），原子性、持久性、一致性和隔离性，具体概念如下：

• 原子性：⼀个事务（transaction）中的所有操作，要么全部完成，要么全部不完成，不会结束在中间某个环节。事务在执行过程中发生错误，会被回滚（Rollback）到事务开始前的状态，就像这个事务从来没有执行过⼀样。

• ⼀致性：在事务开始之前和事务结束以后，数据库的完整性没有被破坏。这表示写入的资料必须完全符合所有的预设规则，这包含资料的精确度、串联性以及后续数据库可以自发性地完成预定的工作。

• 持久性：事务处理结束后，对数据的修改就是永久的，即便系统故障也不会丢失。

• 隔离性：数据库允许多个并发事务同时对其数据进行读写和修改的能力，隔离性可以防止多个事务并发执行时由于交叉执行而导致数据的不一致。事务隔离分为不同级别，包括读未提交（Readuncommitted）、读提交（read committed）、可重复读（repeatable read）和串行化（Serializable）。

上⾯ 4 个属性，可以简称为ACID。

原子性（Atomicity，或称不可分割性）
一致性（Consistency）
隔离性（Isolation，⼜称独立性）
持久性（Durability）。

而这 4 种特性中，只有隔离性（隔离级别）是可以设置的。

为什么要设置事务的隔离级别？

设置事务的隔离级别是用来保障多个并发事务执行更可控，更符合操作者预期的

3.2 Spring 中设置事务隔离级别

Spring 中事务隔离级别可以通过 @Transactional 中的 isolation 属性进行设置，具体操作如下图所示：

3.2.1 MySQL 事务隔离级别有 4 种

1. READ UNCOMMITTED：读未提交，也叫未提交读，该隔离级别的事务可以看到其他事务中未提交的数据。该隔离级别因为可以读取到其他事务中未提交的数据，而未提交的数据可能会发生回滚，因此我们把该级别读取到的数据称之为脏数据，把这个问题称之为脏读。
2. READ COMMITTED：读已提交，也叫提交读，该隔离级别的事务能读取到已经提交事务的数据，因此它不会有脏读问题。但由于在事务的执行中可以读取到其他事务提交的结果，所以在不同时间的相同 SQL 查询中，可能会得到不同的结果，这种现象叫做不可重复读。
3. REPEATABLE READ：可重复读，是 MySQL 的默认事务隔离级别，它能确保同⼀事务多次查询的结果⼀致。但也会有新的问题，比如此级别的事务正在执行时，另⼀个事务成功的插入了某条数据，但因为它每次查询的结果都是一样的，所以会导致查询不到这条数据，自己重复插入时又失败（因为唯一约束的原因）。明明在事务中查询不到这条信息，但自己就是插入不进去，这就叫幻读（Phantom Read）。
4. SERIALIZABLE：序列化，事务最高隔离级别，它会强制事务排序，使之不会发生冲突，从而解决了脏读、不可重复读和幻读问题，但因为执行效率低，所以真正使用的场景并不多

• 脏读：一个事务读取到了另⼀个事务修改的数据之后，后⼀个事务又进行了回滚操作，从而导致第一个事务读取的数据是错误的。
• 不可重复读：⼀个事务两次查询得到的结果不同，因为在两次查询中间，有另一个事务把数据修改了。
• 幻读：一个事务两次查询中得到的结果集不同，因为在两次查询中另一个事务有新增了一部分数据。

在数据库中通过以下 SQL 查询全局事务隔离级别和当前连接的事务隔离级别：

select @@global.tx_isolation,@@tx_isolation;

以上 SQL 的执行结果如下：

3.2.2 Spring 事务隔离级别有 5 种

1. Isolation.DEFAULT：以连接的数据库的事务隔离级别为主。
2. Isolation.READ_UNCOMMITTED：读未提交，可以读取到未提交的事务，存在脏读。
3. Isolation.READ_COMMITTED：读已提交，只能读取到已经提交的事务，解决了脏读，存在不可重复读。
4. Isolation.REPEATABLE_READ：可重复读，解决了不可重复读，但存在幻读（MySQL默认级别）。
5. Isolation.SERIALIZABLE：串行化，可以解决所有并发问题，但性能太低

从上述介绍可以看出，相比于 MySQL 的事务隔离级别，Spring 的事务隔离级别只是多了⼀个 Isolation.DEFAULT（以数据库的全局事务隔离级别为主）

Spring 中事务隔离级别只需要设置 @Transactional 里的 isolation 属性即可，具体实现代码如下：

@RequestMapping("/save")
@Transactional(isolation = Isolation.SERIALIZABLE)
public Object save(User user) {
 	// 业务实现
}

---

四.Spring 事务传播机制

4.1 事务传播机制是什么？

Spring 事务传播机制定义了多个包含了事务的方法，相互调用时，事务是如何在这些方法间进行传递的。

4.2 为什么需要事务传播机制？

事务隔离级别是保证多个并发事务执行的可控性的（稳定性的），而事务传播机制是保证一个事务在多个调用方法间的可控性的（稳定性的）。

事务隔离级别解决的是多个事务同时调用一个数据库的问题，如下图所示：

而事务传播机制解决的是⼀个事务在多个节点（方法）中传递的问题，如下图所示：

4.3 事务传播机制有哪些？

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

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

以上 7 种传播⾏为，可以根据是否支持当前事务分为以下 3 类：

以情侣关系为例来理解以上分类：

4.4 Spring 事务传播机制使用和各种场景演示

4.4.1 支持当前事务（REQUIRED）

以下代码实现中，先开启事务先成功插入一条用户数据，然后再执行日志报错，而在日志报错是发生了异常，观察 propagation = Propagation.REQUIRED 的执行结果

@RestController
public class UserController {
	 @Resource
	 private UserService userService;
	 @Resource
	 private LogService logService;
	 
	 @RequestMapping("/save")
	 @Transactional(propagation = Propagation.REQUIRED)
	 public Object save(User user) {
		 // 插⼊⽤户操作
		 userService.save(user);
		 // 插⼊⽇志
		 logService.saveLog("⽤户插⼊：" + user.getName());
		 return true;
	 }
}

UserService 实现代码如下：

@Service
public class UserService {
	 @Resource
	 private UserMapper userMapper;
	 @Transactional(propagation = Propagation.REQUIRED)
	 public int save(User user) {
		 System.out.println("执⾏ save ⽅法.");
		 return userMapper.save(user);
	 }
}

LogService 实现代码如下：

@Service
public class LogService {
	 @Resource
	 private LogMapper logMapper;
	 @Transactional(propagation = Propagation.REQUIRED)
	 public int saveLog(String content) {
		 // 出现异常
		 int i = 10 / 0;
		 return logMapper.saveLog(content);
	 }
}

执行结果：程序报错，数据库没有插入任何数据

执行流程描述：

1. UserService 中的保存方法正常执行完成。
2. LogService 保存日志程序报错，因为使用的是 Controller 中的事务，所以整个事务回滚。
3. 数据库中没有插入任何数据，也就是步骤 1 中的用户插入方法也回滚了。

4.4.2 NESTED 嵌套事务

UserController 实现代码如下

@RequestMapping("/save")
@Transactional
public Object save(User user) {
	 // 插⼊⽤户操作
	 userService.save(user);
	 return true;
}

UserService 实现代码如下

@Transactional(propagation = Propagation.NESTED)
public int save(User user) {
	 int result = userMapper.save(user);
	 System.out.println("执⾏ save ⽅法.");
	 // 插⼊⽇志
	 logService.saveLog("⽤户插⼊：" + user.getName());
	 return result;
}

LogService 实现代码如下

@Transactional(propagation = Propagation.NESTED)
public int saveLog(String content) {
	 // 出现异常
	 int i = 10 / 0;
	 return logMapper.saveLog(content);
}

最终执行结果，用户表和日志表都没有添加任何数据

执行流程描述：

1. UserController 中调用了 UserService 的添加方法，UserService 使用 NESTED 修饰循环嵌套了 UserController 的事务，并成功执行了添加方法。
2. UserService 中调用了 LogService 的添加方法，LogService 使用 NESTED 修饰循环嵌套了上⼀个调用类的事务，执行了添加方法，但在执行的过程中出现了异常，回顾当前事务，日志添加失败。
3. 因为是嵌套事务，所以日志添加回顾之后，往上找调用它的方法和事务回滚了用户添加，所以用户添加也失败了，所以最终的结果是用户表和日志表都没有添加任何数据。

4.4.3 嵌套事务和加入事务有什么区别？

• 整个事务如果全部执行成功，二者的结果是一样的。
• 如果事务执行到一半失败了，那么加入事务整个事务会全部回滚；而嵌套事务会局部回滚，不会影响上⼀个方法中执行的结果

嵌套事务只所以能够实现部分事务的回滚，是因为事务中有⼀个保存点（savepoint）的概念，嵌套事务进入之后相当于新建了⼀个保存点，而滚回时只回滚到当前保存点，因此之前的事务是不受影响的

---

总结

Spring 事务使⽤中，重点的内容有 3 个：

1. 在 Spring 项目中使用事务，用两种方法手动操作和声明式自动提交，其中后者使用的最多，在方法上添加 @Transactional 就可以实现了。
2. 设置事务的隔离级别 @Transactional(isolation = Isolation.SERIALIZABLE)，Spring 中的事务隔离级别有 5 种。
3. 设置事务的传播机制 @Transactional(propagation = Propagation.REQUIRED)，Spring 中的事务传播级别有 7 种