Spring 事务

回顾 MySQL 事务的使用

MySQL 事务有三个重要的操作：

1. 开启事务 (start transaction)

2. 提交事务 (commit)

3. 回滚事务 (rollback)

一、Spring 事务的实现方式

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

1. 手动操作事务

2. 声明式自动提交事务

顾名思义，前者就是我们需要通过代码来使用事务；后者只需注解即可搞定。

1. Spring 手动操作事务

(1) 开启事务并提交事务

我们演示往数据库的 userinfo 表中插入一行记录。

UserController 类：

@RestController
public class UserController {

    @Resource
    private UserService userService;

    // Spring 框架提供的手动操作事务的两个类
    @Autowired
    private DataSourceTransactionManager transactionManager;
    @Autowired
    private TransactionDefinition transactionDefinition;

    /**
     * 手动式事务
     */
    @RequestMapping("/add")
    public int add(UserInfo userInfo) {
        if (userInfo == null || !StringUtils.hasLength(userInfo.getUsername())
                || !StringUtils.hasLength(userInfo.getPassword())) {
            return 0;
        }

        // 1. 开启事务 (获取事务)
        TransactionStatus transactionStatus = transactionManager.getTransaction(transactionDefinition);
        int result = userService.add(userInfo);
        System.out.println("受影响的行数：" + result);

        // 2. 自定义提交事务，(或回滚事务)
        transactionManager.commit(transactionStatus);
        return result;
    }
}

UserService 类：

@Service
public class UserService {

    @Resource
    private UserMapper userMapper;

    public int add(UserInfo userInfo) {
        return userMapper.add(userInfo);
    }
}

UserMapper 接口：

@Mapper
public interface UserMapper {

    // 1. 向 userinfo 表中添加一个新用户
    int add(UserInfo userInfo);

}

xml 文件：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.demo.mapper.UserMapper">

    <insert id="add">
        insert into userinfo(id, username, password) values(null, #{username},#{password})
    </insert>

</mapper>

展示结果：

(2) 开启事务并回滚事务

我们将 UserController 类中的 " 提交事务 " 代码改成 " 回滚事务 " 代码。

// 回滚事务
transactionManager.rollback(transactionStatus);

展示结果：

备注： 可以看到，在上面的第二幅图中，MyBatis 的打印日志并没有 committing 这样的日志信息，所以按照我们感觉来说，回滚事务就好像什么事儿也没发生一样。

但实际上，数据就是先提交了，后回滚了。在上面的第三幅图中，字段 id 是自增主键，它的值从 32 跳到了 34 号，而中间的 33 号就是刚刚回滚的数据，而 34 号是我后来在数据库中手动插入的数据。

2. Spring 声明式自动提交事务

从上面的 Spring 手动操作事务中，可以看到它的操作较为繁琐，实际上它的功能也较为单一。所以就引入了注解的方式来使用事务。

使用注解的方式很简单，就是在需要的方法上添加 " @Transactional " 注解，那么默认情况下，在进入被此注解修饰的方法前，自动开启事务；在方法结束后，自动提交事务；如果在方法内中途出现异常，则自动回滚事务。

注意： Spring Boot 单元测试也用到了此注解，那里的用法是做到不污染数据库，而在事务这里，用法又不一样了。

使用的代码如下：

(1) 开启事务并提交事务

UserController 类：

@RestController
public class UserController {

    @Resource
    private UserService userService;
    
    /**
     * 声明式事务
     */
    @Transactional
    @RequestMapping("/add2")
    public int add2(UserInfo userInfo) {
        if (userInfo == null || !StringUtils.hasLength(userInfo.getUsername())
                || !StringUtils.hasLength(userInfo.getPassword())) {
            return 0;
        }
        int result = userService.add(userInfo);
        System.out.println("受影响的行数：" + result);

        return result;
    }
}

展示结果：

(2) 开启事务并回滚事务

如果我们在刚刚的代码中，加上了下面这样会报错的代码，那么系统就会自动对事务进行回滚。

int a = 10 / 0;

展示结果：

注意事项

实际上，在上面的 Spring 声明式自动回滚事务时，并不是那么简单智能的。当我们为方法上加上了 " @Transactional " 注解后，Spring 只有在 " 发现了异常 / 捕获到异常 " 后，才能自动回滚。

也就是说，在异常被我们用 try - catch 包裹起来后，系统就不会为我们回滚事务了。因为 Spring 会认为你的程序没有问题，因为你加上了 try - catch，就证明你意识到了异常并能够解决它。

比方说，如果我们在代码中写成了下面这样，系统就不会为我们回滚事务。

UserController 类：

@RestController
public class UserController {

    @Resource
    private UserService userService;
    
    @Transactional
    @RequestMapping("/add3")
    public int add3(UserInfo userInfo) {
        if (userInfo == null || !StringUtils.hasLength(userInfo.getUsername())
                || !StringUtils.hasLength(userInfo.getPassword())) {
            return 0;
        }
        int result = userService.add(userInfo);
        System.out.println("受影响的行数：" + result);
        try{
            int num = 10 / 0;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
}

展示结果：

分析： 从上面的结果来看，虽然对于前端来说没有展现出问题，但实际上后端已经出现了异常，如果我们需要让系统为我们在 try - catch 也包裹的情况下，也回滚事务，就需要使用下面的两种方案。

解决方案1：抛出异常

try{
    int num = 10 / 0;
} catch (Exception e) {
    throw e;
}

解决方案2：手动回滚事务

try{
    int num = 10 / 0;
} catch (Exception e) {
   TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
}

结论： 虽然两个解决方案都能够让系统为之自动回滚，但更推荐使用第二种解决方案，因为第一种方案在使用的时候，依旧抛出来了异常，前端也一定会收到 500 这样的错误状态码，这样一来，使用 try - catch 已经没有了最初的意义。而第二种方案，既能够做到真正的捕获异常，也能够回滚事务。

二、Spring 事务的隔离级别

Spring 事务的隔离级别共有五种，都是以枚举的方式呈现出来的，它和 MySQL 事务的隔离级别是一样的，只不过 Spring 多了一个 DEFAULT.

DEFAULT 表示以连接的数据库的事务隔离级别为主，如果是程序连接了 MySQL，那么默认就是可重复读；如果程序连接了 Oracle，那么默认就是读已提交。

注意事项

1. 当 Spring 中设置了事务隔离级别和连接的数据库 (MySQL)事务隔离级别发生冲突的时候，那么最终以 Spring 的为准，因为说到底是程序在起作用。

2. Spring 中的事务隔离级别机制的实现有个前提：当前连接的数据库具有事务隔离级别的功能。(一些老版本的数据库可能压根就不支持隔离级别)

三、Spring 事务的传播机制

Spring 事务传播机制定义了多个包含了事务的方法在相互调用时，事务是如何在这些方法间进传递的。实际上，事务方法在相互调用的时候，是非常复杂的，如何将各个事务的调用链按我们预期设想的那样调用，这就是 Spring 事务的传播机制所为我们提供的规则。

也就是说，事务传播机制解决的是多个事务之间传递的问题。

比方说：事务方法B 调用了事务方法A， 事务A 应该如何处理呢？事务A 难道是在事务B 中运行吗？还是另起一个事务呢？这就需要根据场景，需要我们自己设置了。

1. 七种 Spring 事务传播机制

① Propagation.REQUIRED：默认的事务传播级别，它表示如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。

② Propagation.SUPPORTS：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。

③ Propagation.MANDATORY：如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。(mandatory：强制性)

④ Propagation.REQUIRES_NEW：表示创建一个新的事务，如果当前存在事务，则把当前事务挂起。也就是说，不管外部方法是否开启事务，此时修饰的内部方法会新开启自己的事务，且开启的事务相互独立，互不干扰。

⑤ Propagation.NOT_SUPPORTED：以非事务方式运行，如果当前存在事务，则把当前事务挂起。

⑥ Propagation.NEVER：以非事务方式运行，如果当前存在事务，则抛出异常。

⑦ Propagation.NESTED：如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则该取值等价于 PROPAGATION_REQUIRED.

2. 事务传播机制的应用

如下，事务C 调用了事务B，事务B 调用了 事务A.

① 如果将三个事务的传播机制都设置为 Propagation.REQUIRED，如果事务A 出现了异常，三个事务都会回滚。

② 如果将三个事务的传播机制都设置为 Propagation.REQUIRES_NEW，如果事务A 出现了异常，不影响 事务B 和 事务C.

③ 如果将三个事务的传播机制都设置为 Propagation.NESTED，如果事务A 出现了异常，不影响 事务B 和 事务C.

3. 嵌套事务和默认的加入事务有什么区别

NESTED 嵌套事务能够实现部分事务的回滚，这是因为事务中有一个保存点，嵌套事务进入之后相当于新建了一个保存点，而回滚时只回滚到当前保存点的地方。这就相当于存档，类似于单机的通关游戏，当你今天通过了 10 关，游戏系统就会保存前 10 关的进度，当你明天打开游戏时，依然可以从第 11 关开始玩。

然而，当使用 REQUIRED 加入事务时，如果一个事务发生了回滚，那么所有事务都会回滚。

四、" @Transactional " 注解提供的属性

五、" @Transactional " 注解的作用范围

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