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 事务隔离级别：

  1. READ UNCOMMITTED：读未提交，也叫未提交读，该隔离级别的事务可以看到其他事务中未提交的数据。该隔离级别因为可以读取到其他事务中未提交的数据，⽽未提交的数据可能会发⽣回滚，因此我们把该级别读取到的数据称之为脏数据，把这个问题称之为脏读。
  2. READ COMMITTED：读已提交，也叫提交读，该隔离级别的事务能读取到已经提交事务的数据，因此它不会有脏读问题。但由于在事务的执⾏中可以读取到其他事务提交的结果，所以在不同时间 的相同 SQL 查询中，可能会得到不同的结果，这种现象叫做不可重复读。
  3. REPEATABLE READ：可重复读，是 MySQL 的默认事务隔离级别，它能确保同⼀事务多次查询的结果⼀致。但也会有新的问题，⽐如此级别的事务正在执⾏时，另⼀个事务成功的插⼊了某条数据，但因为它每次查询的结果都是⼀样的，所以会导致查询不到这条数据，⾃⼰重复插⼊时⼜失败 （因为唯⼀约束的原因）。明明在事务中查询不到这条信息，但⾃⼰就是插⼊不进去，这就叫幻读 （Phantom Read）。
  4. 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

       
       韶关网站建设  网站建设公司模板  包装设计公司  手机网  厦门网页设计培训班  开发一款软件大概需要多少钱