Spring “事务的使用”和“事务的传播机制”（代码示例 + 详解）

亦凉 2023-09-24 23:09 98阅读 0赞

**目录**

一、Spring 事务的使用

1.1、编程式事务（了解即可）

1.2、注解实现声明式事务

1.2.1、@Transactional 注解的使用

1.2.2、参数说明

1.2.3、声明式事务对异常的处理

1.2.3、@Transational 的工作原理

二、Spring 事务的传播机制

2.1、事务传播机制是什么？

2.2、事务的传播机制有什么作用

2.3、事务的传播机制中有哪些？

2.3.1、支持当前调用链上的事务

2.3.2、不支持当前调用链上的事务

2.3.3、嵌套事务

2.4、代码示例

2.4.1、支持当前事务（REQUIRED）示例

2.4.2、嵌套事务示例

--------------------

# 一、Spring 事务的使用 #

--------------------

## 1.1、编程式事务（了解即可） ##

Spring 编程式事务的使用主要有 3 个步骤：

*  开启事务（获取事务）：通过 Spring Boot 中**内置的** DataSourceTransactionManager 的 getTransaction 方法，**并搭配内置的** TransactionDefinition **实例作为方法的参数**，来获取事务（此操作同时也会开启事务）。
 *  提交事务：DataSourceTransactionManager 创建出实例后，使用它的 commit 方法（参数是 getTransaction 方法的返回值，也就是 **TransactionStatus，它的本质就是一个事务**），就可以完成提交事务。
 *  回滚事务：通过 DataSourceTransactionManager 的 rollback 方法（**参数就是 事务**）进行事务的回滚。

具体的，如果我的业务逻辑是向数据库插入一条数据，如下代码示例：

import com.example.demo.entity.UserInfo;
    import com.example.demo.service.UserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.jdbc.datasource.DataSourceTransactionManager;
    import org.springframework.transaction.TransactionDefinition;
    import org.springframework.transaction.TransactionStatus;
    import org.springframework.util.StringUtils;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    @RequestMapping("/user")
    public class UserController {
    
        @Autowired
        private UserService userService;
    
        //事务管理
        @Autowired
        private DataSourceTransactionManager transactionManager;
    
        //事务属性设置（不设置有默认属性）
        @Autowired
        private TransactionDefinition transactionDefinition;
    
        @RequestMapping("/add")
        public int insertUserInfo(UserInfo userInfo) {
            //检验非空
            if(userInfo == null || !StringUtils.hasLength(userInfo.getUsername()) ||
            !StringUtils.hasLength(userInfo.getPassword())) {
                return 0;
            }
    
            // 1.开启事务
            TransactionStatus transactionStatus =
                    transactionManager.getTransaction(transactionDefinition);
    
            // 2.执行业务逻辑
            int result = userService.insertUserInfo(userInfo);
            System.out.println("添加:" + result + "个用户~");
    
    //        // 3.提交事务
    //        transactionManager.commit(transactionStatus);
    
            // 4.回滚事务(根据情况而定)
            transactionManager.rollback(transactionStatus);
    
            return result;
        }
    }

> Ps：一个事务若已经提交，则不可以进行回滚，否则会报错：“不可多次提交或回滚事务”。

## 1.2、注解实现声明式事务 ##

### 1.2.1、@Transactional 注解的使用 ###

在 Spring 提供了 @Transactional 注解实现事务，特点如下：

1.  可以添加在类上或方法上。
2.  添加在方法上（方法必须是 public，否则不生效）：在方法执行前自动开启事务，方法执行完（没有任何异常）自动提交事务，但如果方法执行期间出现异常，将会自动回滚事务；添加在类上：对所有的 public 方法生效；

具体的如下代码：

@Transactional //声明式事务
        @RequestMapping("/add")
        public Integer add(UserInfo userInfo) {
            //非空检验
            if(userInfo == null || !StringUtils.hasLength(userInfo.getUsername()) ||
                    !StringUtils.hasLength(userInfo.getPassword())) {
                return 0;
            }
            int result = userService.insertUserInfo(userInfo);
            System.out.println("添加:" + result + "个用户~");
            return result;
        }

### 1.2.2、参数说明 ###

![f7e0bea0249b4fb3b7b54bf48ef52aaf.png][]

> 值得注意的是 isolation 的隔离级别：
> 
> 读未提交（Read uncommitted）、读提交（read committed）、可重复读（repeatable read）和串⾏化 （Serializable）。

### 1.2.3、声明式事务对异常的处理 ###

@Transactional 在异常被捕获的情况下，不会进行事务的自动回滚，那么如果需求改变，需要在异常被捕获的情况下也进行回滚，该如何实现呢？

方法1：重新抛出异常（有点脱了裤子放屁的感觉），如下代码：

@Transactional //声明式事务
        @RequestMapping("/add")
        public Integer add(UserInfo userInfo) {
            //插入一条信息到数据库
            int result = userService.insertUserInfo(userInfo);
    
            try {
                int i = 1 / 0;
            } catch(Exception e) {
                System.out.println(e.getMessage());
                throw e;
            }
            System.out.println("添加:" + result + "个用户~");
            return result;
        }

方法2：手动回滚事务，如下代码：

@Transactional //声明式事务
        @RequestMapping("/add")
        public Integer add(UserInfo userInfo) {
            //插入一条信息到数据库
            int result = userService.insertUserInfo(userInfo);
    
            try {
                int i = 1 / 0;
            } catch(Exception e) {
                System.out.println(e.getMessage());
                //手动回滚
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            }
            System.out.println("添加:" + result + "个用户~");
            return result;
        }

> Ps：TransactionAspectSupport表示事务的切面建议、currentTransactionStatus表示获取当前事务、setRollbackOnly表示进行回滚。

### 1.2.3、@Transational 的工作原理 ###

@Transaction 是基于 AOP 实现的，而 AOP 又是使用动态代理实现的。若目标对象实现了接口，默认使用 JDK 的动态代理，若目标对象没有实现接口，则会使用 CGLIB 动态代理。

@Transational 在开始执行业务之前，通过代理先开启事务，在执行成功之后再提交事务。若中途遇到异常，则进行回滚事务。

# 二、Spring 事务的传播机制 #

--------------------

## 2.1、事务传播机制是什么？ ##

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

*例如这样一种情况：现在有方法一和方法二，方法一有事务，方法二没有事务，方法一会调用到方法二，那么当方法二中出现了异常，是否要进行回滚呢？*事务的传播机制就是用来解决这种类似的问题~

## 2.2、事务的传播机制有什么作用 ##

事务的传播机制是保证一个事务在多个调用方法间的可控性。

*例如这样一种情况：现在有方法一和方法二，方法一有事务，方法二没有事务，方法一会调用到方法二，那么当方法二中出现了异常，是否要进行回滚呢？**通过事务的传播机制，就会告诉你该如何进行处理~***

![8648ccf1c19840eba419d083208082b1.png][]

## 2.3、事务的传播机制中有哪些？ ##

从大的方向上看，主要分为以下三种~

### 2.3.1、支持当前调用链上的事务 ###

*  Propagation.REQUIRED（需要有）：**默认的事务隔离级别**，表示如果当前调用链存在事务，则加入该事务；如果没有事务，则**为当前方法创建一个事务**。
 *  Propagation.SUPPORTS（可以有）：如果当前调用链存在事务，则加入该事务，如果当前调用链没有事务，就以非事务方式执行。
 *  Propagation.MANDATORY（强制有）：如果当前调用链存在事务，则加入该事务；如果当前调用链没有事务，则抛出异常。

### 2.3.2、不支持当前调用链上的事务 ###

*  Propagation.REQUIRES\_NEW：如果当前调用链存在事务，则把当前调用链这个事务挂起，为当前方法创建一个新的事务（与调用链事务互不干扰，若新事务提交或回滚，则开启调用链事务），如果当前调用链没有事务，则为当前方法创建一个事务。
 *  Propagation.NOT\_SUPPORTED：如果当前调用链存在事务，则把当前调用链的事务挂起，也就是说 **Propagation.NOT\_SUPPORTED 修饰的方法，以非事务的方式运行**。
 *  Propagation.NEVER：以非事务的方式运行，并且若当前调用链存在事务，则抛出异常。

### 2.3.3、嵌套事务 ###

Propagation.NESTED：表示当前调用链存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前调用链没有事务，则等价于 PROPAGATION\_REQUIRED（为当前方法创建事务）。

> Ps：Propagation.REQUIRES\_NEW 和 Propagation.NESTED 区别主要是 **NESTED 和主事务是一个事务，而 REQUIRES\_NEW 是不同事务。**

## 2.4、代码示例 ##

这里我将用两个示例来说明（这两个如果你能拿捏住，其他的就没问题~），这里的调用链如下图：

![f08f402554d44e5ea5ca5899c722c25c.png][]

### 2.4.1、支持当前事务（REQUIRED）示例 ###

首先开始事务，使用 UserService 插入一条用户数据，然后再执行（故意制造错误）报错，最后观察执行结果，如下代码：

**UserController如下：**

**LogService如下：**

import com.example.demo.entity.UserInfo;
    import com.example.demo.mapper.UserMapper;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    @Service
    public class UserService {
    
        @Autowired
        UserMapper userMapper;
    
        public int insertUserInfo(UserInfo userInfo) {
            int result = userMapper.insertUserInfo(userInfo);
            int e = 1 / 0;
            return result;
        }
    
    }

输入 url，插入用户 “zhangsan” 运行结果如下，如下图：

![1ca849542c5f4328922dc84cfe92f02b.png][]

![d96b6802004c422b85aa738b248d2741.png][]

可以观察到成功插入数据后引发的算数异常，按照我们设置的事务，是会进行回滚的，接下来观察数据库验证我们的结果：

![76d162137f8b48ddb7f65748bd41d47a.png][]

**结果分析：**由于我们设置的事务是REQUIRED，它**表示调用链上若存在事务，则加入到事务中，若没有就会为这当前方法创建一个事务**，因此在 UserService 方法上即使没有事务，也会加入到当前调用链创建好的事务当中，即使引发了异常，也会进行数据的回滚~

### 2.4.2、嵌套事务示例 ###

首先开始事务，使用 UserService 的 insertUserInfo 插入一条用户数据，然后再执行 insert 方法再插入一条用户数据（这里故意引发异常），插入完后报错，最后观察执行结果，如下代码：

**UserController如下：**

**UserService如下：**

import com.example.demo.entity.UserInfo;
    import com.example.demo.mapper.UserMapper;
    import org.apache.catalina.User;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Propagation;
    import org.springframework.transaction.annotation.Transactional;
    
    @Service
    public class UserService {
    
        @Autowired
        UserMapper userMapper;
    
        public int insertUserInfo(UserInfo userInfo) {
            int result = userMapper.insertUserInfo(userInfo);
    
            return result;
        }
    
        @Transactional(propagation = Propagation.NESTED)
        public int insert() {
            UserInfo userInfo = new UserInfo();
            userInfo.setUsername("lisi");
            userInfo.setPassword("123");
            int result = userMapper.insertUserInfo(userInfo);
            //制造异常
            int a = 1 / 0;
            return result;
        }
    
    }

**运行结果如下：**

![6f45cf3aaf174e6aab8d489a6ae62e5c.png][]

![0fd90f8fc3f043f3911dcdb8863f5553.png][]

![ef0f59ced63949d88ae66bdfff31afa7.png][]

数据库结果如下：

![3bea3f005b85472e897192746ff6a44b.png][]

**结果分析：**在 UserController 中开启事务，UserService 中调用 insertUserInfo 插入一条数据，接着调用 insert 方法（使用 NESTED 嵌套上一个调用类的事务）插入一条数据，插入完后引发异常，于是进行回滚当前事务，因此第二条数据添加失败，**又因为是嵌套事务，所以第二条数据添加失败进行回滚之后，会继续向上找调用他的方法和事务，再次进行回滚，因此第一条用户信息也添加失败**，最终没用向用户表中添加任何数据~、

![e7e65a12ef754b13aa8a075d3aff5e0a.gif][]

[f7e0bea0249b4fb3b7b54bf48ef52aaf.png]: https://img-blog.csdnimg.cn/f7e0bea0249b4fb3b7b54bf48ef52aaf.png
[8648ccf1c19840eba419d083208082b1.png]: https://img-blog.csdnimg.cn/8648ccf1c19840eba419d083208082b1.png
[f08f402554d44e5ea5ca5899c722c25c.png]: https://img-blog.csdnimg.cn/f08f402554d44e5ea5ca5899c722c25c.png
[1ca849542c5f4328922dc84cfe92f02b.png]: https://img-blog.csdnimg.cn/1ca849542c5f4328922dc84cfe92f02b.png
[d96b6802004c422b85aa738b248d2741.png]: https://img-blog.csdnimg.cn/d96b6802004c422b85aa738b248d2741.png
[76d162137f8b48ddb7f65748bd41d47a.png]: https://img-blog.csdnimg.cn/76d162137f8b48ddb7f65748bd41d47a.png
[6f45cf3aaf174e6aab8d489a6ae62e5c.png]: https://img-blog.csdnimg.cn/6f45cf3aaf174e6aab8d489a6ae62e5c.png
[0fd90f8fc3f043f3911dcdb8863f5553.png]: https://img-blog.csdnimg.cn/0fd90f8fc3f043f3911dcdb8863f5553.png
[ef0f59ced63949d88ae66bdfff31afa7.png]: https://img-blog.csdnimg.cn/ef0f59ced63949d88ae66bdfff31afa7.png
[3bea3f005b85472e897192746ff6a44b.png]: https://img-blog.csdnimg.cn/3bea3f005b85472e897192746ff6a44b.png
[e7e65a12ef754b13aa8a075d3aff5e0a.gif]: https://img-blog.csdnimg.cn/e7e65a12ef754b13aa8a075d3aff5e0a.gif