Spring 事务（详解）

2024-06-04 8288阅读

4. Spring 事务

4.1 什么是事务？

将⼀组操作封装成⼀个执⾏单元，要么全部成功要么全部失败。

为什么要⽤事务？
⽐如转账分为两个操作：第⼀步操作：A 账户 -100 元，第⼆步操作：B 账户 +100 元。如果没有事务，第⼀步执⾏成功了，第⼆步执⾏失败了，那么 A 账户平⽩⽆故的 100 元就“⼈间蒸发”了。如果使⽤事务就可以解决这个问题，让这⼀组操作要么⼀起成功，要么⼀起失败。
4.1.1 事务特性

事务有4 ⼤特性（ACID）：原⼦性（Atomicity，或称不可分割性）、持久性（Consistency）
、⼀致性（Durability）和隔离性（Isolation，⼜称独⽴性）。
- 原⼦性：⼀个事务（transaction）中的所有操作，要么全部完成，要么全部不完成，不会结束在中
  间某个环节。事务在执⾏过程中发⽣错误，会被回滚（Rollback）到事务开始前的状态，就像这个
  事务从来没有执⾏过⼀样。
- ⼀致性：在事务开始之前和事务结束以后，数据库的完整性没有被破坏。这表示写⼊的资料必须完
  全符合所有的预设规则，这包含资料的精确度、串联性以及后续数据库可以⾃发性地完成预定的⼯
  作。
- 持久性：事务处理结束后，对数据的修改就是永久的，即便系统故障也不会丢失。
- 隔离性：数据库允许多个并发事务同时对其数据进⾏读写和修改的能⼒，隔离性可以防⽌多个事务
  并发执⾏时由于交叉执⾏⽽导致数据的不⼀致。事务隔离分为不同级别，包括读未提交（Read
  uncommitted）、读提交（read committed）、可重复读（repeatable read）和串行化（Serializable）。
  4.2 Spring 事务的实现
  
  MySQL 中的事务使⽤：
  事务在 MySQL 有 3 个重要的操作：开启事务、提交事务、回滚事务。
```
-- 开启事务
start transaction;
-- 业务执⾏
-- 提交事务
commit;
-- 回滚事务
rollback;
```
  4.2.1 Spirng 编程式事务
  
  步骤：
  1. 开启事务（获取事务）
  2. 提交事务
  3. 回滚事务
  SpringBoot 内置了两个对象：DataSourceTransactionManager ⽤来开启事务、提交或回滚事务，TransactionDefinition 是事务的属性，在开启事务的时候需要将TransactionDefinition 传递进去从⽽获得⼀个事务 TransactionStatus。
  示例：
```
@RestController
public class UserController {
	 @Resource
 	private UserService userService;
	 // JDBC 事务管理器
	 @Resource
	 private DataSourceTransactionManager dataSourceTransactionManager;
	 // 定义事务属性
	 @Resource
	 private TransactionDefinition transactionDefinition;
   	@RequestMapping("/sava")
	 public Object save(User user) {
		 // 开启事务
		 TransactionStatus transactionStatus = dataSourceTransactionManager.getTransaction(transactionDefinition);
 		// 插⼊数据库
 		int result = userService.save(user);
 		// 提交事务
 		dataSourceTransactionManager.commit(transactionStatus);
		// // 回滚事务
		// dataSourceTransactionManager.rollback(transactionStatus);
		 return result;
	 }
}
```
  4.2.2 Spring 声明式事务
  
  在需要的⽅法上添加 @Transactional 注解即可，⽆需⼿动开启事务和提交事务，进⼊⽅法时⾃动开启事务，⽅法执⾏完会⾃动提交事务，如果中途发⽣了没有处理的异常会⾃动回滚事务。
  示例：
```
@RequestMapping("/save")
@Transactional
public Object save(User user) {
	int result = userService.save(user);
 	return result;
}
```
  示例：使⽤以下代码，分别设置 @Transactional 注解和不设置 @Transactional
  
  4.2.2.1 @Transactional 作⽤范围
  
  @Transactional 可以⽤来修饰⽅法或类：
  - 修饰⽅法时：需要注意只能应⽤到 public ⽅法上，否则不⽣效。推荐此种⽤法
  - 修饰类时：表明该注解对该类中所有的 public ⽅法都⽣效
    4.2.2.2 @Transactional 参数
    
    
    
    4.2.2.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;
    }
}
```
    4.2.2.3.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;
}
```
    4.2.2.3.2 解决方案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().setRollbackOnl y();
    }
    return result;
}
```
    4.2.2.4 @Transactional 工作原理
    
    @Transactional 是基于 AOP 实现的，AOP ⼜是使⽤动态代理实现的。如果⽬标对象实现了接⼝，默认情况下会采⽤ JDK 的动态代理，如果⽬标对象没有实现了接⼝,会使⽤ CGLIB 动态代理。 @Transactional 在开始执⾏业务之前，通过代理先开启事务，在执⾏成功之后再提交事务。如果中途遇到的异常，则回滚事务。
    
    4.3 Spring 事务的隔离级别
    - 事务的隔离级别：数据库允许多个并发事务同时对其数据进⾏读写和修改的能⼒，隔离性可以防⽌多个事务并发执⾏时由于交叉执⾏⽽导致数据的不⼀致。事务隔离分为不同级别，包括读未提交（Read uncommitted）、读提交（read committed）、可重复读（repeatable read）和串⾏化（Serializable）。
      4.3.1 Spring 事务的隔离级别
      - MySQL 事务隔离级别：
        READ UNCOMMITTED：读未提交，也叫未提交读，该隔离级别的事务可以看到其他事务中未提交的数据。该隔离级别因为可以读取到其他事务中未提交的数据，⽽未提交的数据可能会发⽣回滚，因此我们把该级别读取到的数据称之为脏数据，把这个问题称之为脏读。
        READ COMMITTED：读已提交，也叫提交读，该隔离级别的事务能读取到已经提交事务的数据，因此它不会有脏读问题。但由于在事务的执⾏中可以读取到其他事务提交的结果，所以在不同时间的相同 SQL 查询中，可能会得到不同的结果，这种现象叫做不可重复读。
        REPEATABLE READ：可重复读，是 MySQL 的默认事务隔离级别，它能确保同⼀事务多次查询的结果⼀致。但也会有新的问题，⽐如此级别的事务正在执⾏时，另⼀个事务成功的插⼊了某条数据，但因为它每次查询的结果都是⼀样的，所以会导致查询不到这条数据，⾃⼰重复插⼊时⼜失败（因为唯⼀约束的原因）。明明在事务中查询不到这条信息，但⾃⼰就是插⼊不进去，这就叫幻读（Phantom Read）。
        SERIALIZABLE：序列化，事务最⾼隔离级别，它会强制事务排序，使之不会发⽣冲突，从⽽解决
        了脏读、不可重复读和幻读问题，但因为执⾏效率低，所以真正使⽤的场景并不多。
        脏读：⼀个事务读取到了另⼀个事务修改的数据之后，后⼀个事务⼜进⾏了回滚操作，从⽽导致第⼀个事务读取的数据是错误的。
        不可重复读：⼀个事务两次查询得到的结果不同，因为在两次查询中间，有另⼀个事务把数据修改了。
        幻读：⼀个事务两次查询中得到的结果集不同，因为在两次查询中另⼀个事务有新增了⼀部分数据。
        查询MySQL事务隔离级别：
        select @@global.tx_isolation,@@tx_isolation; // 全局事务隔离级别 // 当前连接的事务隔离级别
        
        执行结果：
        
        4.3.1.1 Spring 中设置事务隔离级别
        
        Isolation.DEFAULT：以连接的数据库的事务隔离级别为主。
        Isolation.READ_UNCOMMITTED：读未提交，可以读取到未提交的事务，存在脏读。
        Isolation.READ_COMMITTED：读已提交，只能读取到已经提交的事务，解决了脏读，存在不可重复读。
        Isolation.REPEATABLE_READ：可重复读，解决了不可重复读，但存在幻读（MySQL默认级别）。
        Isolation.SERIALIZABLE：串⾏化，可以解决所有并发问题，但性能太低。
        4.3.1.2 Spring 中事务隔离级别的设置
        
        Spring 中事务隔离级别可以通过 @Transactional 中的 isolation 属性进⾏设置。
        示例：
        
        @RequestMapping("/save") @Transactional(isolation = Isolation.SERIALIZABLE) public Object save(User user) { // 业务实现 }
        
        4.4 Spring 事务的传播机制
        
        4.4.1 事务传播机制是什么？
        
        Spring 事务传播机制定义了多个包含了事务的⽅法，相互调⽤时，事务是如何在这些⽅法间进⾏传递的。
        
        4.4.2 事务传播机制的作用
        
        事务传播机制是保证⼀个事务在多个调⽤⽅法间的可控性的（稳定性的）。
        
        4.4.3 Spring 事务传播机制
        
        Propagation.REQUIRED：默认的事务传播级别，它表示如果当前存在事务，则加⼊该事务；如果当前没有事务，则创建⼀个新的事务。
        Propagation.SUPPORTS：如果当前存在事务，则加⼊该事务；如果当前没有事务，则以⾮事务的⽅式继续运⾏。
        Propagation.MANDATORY：（mandatory：强制性）如果当前存在事务，则加⼊该事务；如果当前没有事务，则抛出异常。
        Propagation.REQUIRES_NEW：表示创建⼀个新的事务，如果当前存在事务，则把当前事务挂起。也就是说不管外部⽅法是否开启事务，Propagation.REQUIRES_NEW 修饰的内部⽅法会新开启⾃⼰的事务，且开启的事务相互独⽴，互不⼲扰。
        Propagation.NOT_SUPPORTED：以⾮事务⽅式运⾏，如果当前存在事务，则把当前事务挂起。
        Propagation.NEVER：以⾮事务⽅式运⾏，如果当前存在事务，则抛出异常。
        Propagation.NESTED：如果当前存在事务，则创建⼀个事务作为当前事务的嵌套事务来运⾏；如果当前没有事务，则该取值等价于 PROPAGATION_REQUIRED。
        以情侣关系为例来理解：
        
        4.4.4 Spring 事务传播机制使用示例
        
        4.4.4.1 REQUIRED