Spring(SpringBoot)--事务传播机制--应用/实例/详解

客官°小女子只卖身不卖艺 2024-04-03 08:32 51阅读 0赞

## 一、简介 ##

本文介绍Spring中的事务的传播机制，并且用实例说明它的用法。

本内容也是Java后端面试常见的问题。

## 二、概述 ##

Spring在TransactionDefinition接口中规定了7种类型的事务传播行为。Propagation枚举则引用了这些类型，开发过程中我们一般直接用Propagation枚举。常用的三项已经加粗。

![91e46a48d8874a4b93b651629ec78451.png][]

本处所测试的皆是运行addEmpByRequired方法。

## 三、七中事务传播机制 ##

### 3.1、**Propagation.REQUIRED(默认是这个)** ###

![d4b0009c303a14e4ef1599ad50f8b1e5.png][]

**员工service**

@Service
    public class EmployeeServiceImpl implements EmployeeService {
     
        @Autowired
        EmployeeMapper employeeMapper;
     
        @Autowired
        DepartmentService departmentService;
     
        /**
         * 添加员工的同时添加部门
         * REQUIRED 传播
         * @param name 员工姓名
         */
        @Override
        @Transactional(propagation = Propagation.REQUIRED)
        public void addEmpByRequired(String name) {
            Employee employee = new Employee();
            employee.setDeptId(1);
            employee.setName(name);
            employee.setAddress("邯郸");
            employeeMapper.insertSelective(employee);
            departmentService.addDept("jishubu");
            int i = 1/0;
        }
    }

**部门service**

@Service
    public class DepartmentServiceImpl implements DepartmentService {
     
        @Autowired
        DepartmentMapper departmentMapper;
     
        @Override
        public void addDeptByRequired(String name) {
            Department department = new Department();
            department.setName(name);
            departmentMapper.insertSelective(department);
            // int i = 1/0;
        }
    }

*  上述代码中，无论int i =1/0 这个异常出现在哪里，添加员工和添加部门都会回滚。因为 REQUIRED 会让添加员工和添加部门变为一个事务。
 *  如果在addDeptByRequired上添加@Transactional(propagation = Propagation.REQUIRED)，在addEmpByRequired不添加事务，则addDeptByRequired是一个事务，addEmpByRequired并不是一个事务。因为addDeptByRequired开启了一个事务，但是addEmpByRequired并不存在一个事务中。

### 3.2、**Propagation.SUPPORTS** ###

**员工service**

@Override
        @Transactional(propagation = Propagation.REQUIRED)
        public void addEmpBySupports(String name) {
            Employee employee = new Employee();
            employee.setDeptId(2);
            employee.setName(name);
            employee.setAddress("邯郸");
            employeeMapper.insertSelective(employee);
            departmentService.addDeptBySupports("jishubu");
            // int i = 1/0;
        }

**部门service**

@Override
        @Transactional(propagation = Propagation.SUPPORTS)
        public void addDeptBySupports(String name) {
            Department department = new Department();
            department.setName(name);
            departmentMapper.insertSelective(department);
            int i = 1/0;
        }

*  关于这个属性，在以上代码中，主要是添加到addDeptBySupports上的，也就是被调用方法上。因为添加到addEmpBySupports就不以事务的方式运行了。
 *  然后，如果addEmpBySupports为事务，则addDeptBySupports也为事务。如果addEmpBySupports不是事务，则addDeptBySupports也不是事务。

### 3.3、**Propagation.MANDATORY** ###

**员工service**

@Override
        // @Transactional(propagation = Propagation.REQUIRED)
        public void addEmpByMandatory(String name) {
            System.out.println("aaaaaa");
            Employee employee = new Employee();
            employee.setDeptId(3);
            employee.setName(name);
            employee.setAddress("邯郸");
            employeeMapper.insertSelective(employee);
            departmentService.addDeptByMandatory("jishubu");
            int i = 1/0;
        }

**部门service**

@Override
        @Transactional(propagation = Propagation.MANDATORY)
        public void addDeptByMandatory(String name) {
            Department department = new Department();
            department.setName(name);
            departmentMapper.insertSelective(department);
            int i = 1/0;
        }

*  这个属性也是添加到addDeptByMandatory（被调用者） 上的。若添加到addEmpByMandatory（调用者）上，则直接抛出异常。
 *  该属性添加到addDeptByMandatory上， 如果addEmpByMandatory有事务，则addDeptByMandatory加入到addEmpByMandatory的事务中，如果addEmpByMandatory没有事务，则直接抛出异常。

### 3.4、**Propagation.REQUIRES\_NEW** ###

![8676b7809835cc5b03bed86b71d1cafb.png][]

**员工service**

@Override
        @Transactional(propagation = Propagation.REQUIRES_NEW)
        public void addEmpByRequiresNew(String name) {
            Employee employee = new Employee();
            employee.setDeptId(4);
            employee.setName(name);
            employee.setAddress("邯郸");
            employeeMapper.insertSelective(employee);
            departmentService.addDeptByRequiresNew("jishubu");
            int i = 1/0;
        }

**部门service**

@Override
        @Transactional(propagation = Propagation.REQUIRES_NEW)
        public void addDeptByRequiresNew(String name) {
            Department department = new Department();
            department.setName(name);
            departmentMapper.insertSelective(department);
            // int i = 1/0;
        }

*  这个属性应该是除了REQUIRED用的最多的。这个属性也是针对被调用者的（addDeptByRequiresNew）。
 *  不管调用者（addEmpByRequiresNew）是否存在事务，被调用者（addDeptByRequiresNew）都会新开一个事务，相当于被调用者都存在于自己的事务中和调用者没有关系。
 *  如上述代码，addEmpByRequiresNew会回滚，但addDeptByRequiresNew不会回滚。因为他们是两个事务。

### 3.5、 **Propagation.NOT\_SUPPORTED** ###

**员工service**

@Override
        @Transactional(propagation = Propagation.REQUIRED)
        public void addEmpByNotSupported(String name) {
            Employee employee = new Employee();
            employee.setDeptId(5);
            employee.setName(name);
            employee.setAddress("邯郸");
            employeeMapper.insertSelective(employee);
            departmentService.addDeptByNotSupported("jishubu");
            int i = 1/0;
        }

**部门service**

@Override
        @Transactional(propagation = Propagation.NOT_SUPPORTED)
        public void addDeptByNotSupported(String name) {
            Department department = new Department();
            department.setName(name);
            departmentMapper.insertSelective(department);
            int i = 1/0;
        }

*  这个属性如果放在调用者（addEmpByNotSupported）上，则是以非事务方式运行。
 *  如果放在被调用者（addDeptByNotSupported）上，该方法（addDeptByNotSupported）以非事务运行，调用者如果有事务，则运行单独的事务（挂起）。
 *  上述代码，会出现添加员工回滚，添加部门不回滚。

### 3.6、**Propagation.NEVER** ###

**员工service**

@Override
        @Transactional(propagation = Propagation.REQUIRED)
        public void addEmpByNever(String name) {
            Employee employee = new Employee();
            employee.setDeptId(6);
            employee.setName(name);
            employee.setAddress("邯郸");
            employeeMapper.insertSelective(employee);
            departmentService.addDeptByNever("jishubu");
            int i = 1/0;
        }

**部门service**

@Override
        @Transactional(propagation = Propagation.NEVER)
        public void addDeptByNever(String name) {
            Department department = new Department();
            department.setName(name);
            departmentMapper.insertSelective(department);
            int i = 1/0;
        }

*  这个属性如果在调用者上，则直接以非事务运行。如果作用在被调用者上，则看调用者是否有事务，如果调用者有事务，则抛出异常，如果没有事务，则以非事务运行。
 *  上述代码中，则会抛出异常。（并不是除0异常，而是：Existing transaction found for transaction marked with propagation 'never'）

### 3.7、**Propagation.NESTED** ###

**说明**

PROPAGATION\_NESTED 启动的事务内嵌于外部事务中（如果存在外部事务的话）。嵌套子事务是JDBC 的保存点（SavePoint）的一个应用，它是具有可回滚到多个保存点的单个物理事务。被调用者使用PROPAGATION\_NESTED时，需JDBC 3.0及以上和JDK1.4及以上，且实现者需要支持保存点事务机制。

**提交**

只有通过外部的事务提交，才能引起内部事务的提交。（内嵌事务不是一个独立的事务，它依赖于外部事务）

**回滚**

父事务回滚，子事务一定回滚  
子事务回滚到savepoint，父事务可选择性回滚或者不不滚

![aeb5ef41cb741bd558bc8b6fa4fc9782.png][]

**员工service**

@Override
        @Transactional(propagation = Propagation.REQUIRED)     //1
        public void addEmpByNested(String name) {
            Employee employee = new Employee();
            employee.setDeptId(7);
            employeeMapper.insertSelective(employee);          //2
            try {
                departmentService.addDeptByNested("jishubu");  //3
            }catch (Exception e){
                // 其他业务, 如 departmentService.methodC();    //5
            }
            employee.setDeptId(8);
            employeeMapper.update(employee);                   //6
                // int i = 1/0;
        }

**部门service**

@Override
        @Transactional(propagation = Propagation.NESTED)
        public void addDeptByNested(String name) {
            Department department = new Department();
            department.setName(name);
            departmentMapper.insertSelective(department);  //4
            // int i = 1/0;
        }

1. 将开起新事务A

2. 插入数据，事务A挂起，没有commit，

3. 新建一个savepoint保存2插入的数据，不提交。

4. 若addDeptByNested异常，回滚4的操作，不影响2，同时可处理后面的5,6逻辑，最后一起commit: 2,5,6, 若addDeptByNested无异常，最后一起commit: 2,4,6

假如methodB使用的PROPAGATION\_REQUIRES\_NEW，那么B异常，会commit: 2,5,6，和NESTED一致。  
如果methodB没有出现异常，那么会先commit4，再commit:6，那么事务将分离开，不能保持一致，假如执行6报错，2和6将回滚，而4却没有被回滚，不能达到预期效果。

并不是只有NESTED用于嵌套，只要理解上述7个传播机制的意思，都可以嵌套用。

![format_png][]

原文地址: [Spring(SpringBoot)--事务传播机制--应用/实例/详解\_IT利刃出鞘的博客-CSDN博客][Spring_SpringBoot_--_--_IT_-CSDN]

[91e46a48d8874a4b93b651629ec78451.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/dc30c3bfbd8f48f8985578259e0595d1.png
[d4b0009c303a14e4ef1599ad50f8b1e5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/9e01a589b1a7457fb5f6194d9047e23f.png
[8676b7809835cc5b03bed86b71d1cafb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/092e711861f1491eb8e4ab4ff1674411.png
[aeb5ef41cb741bd558bc8b6fa4fc9782.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/9aef4ce41af44457b4387fec5b456068.png
[format_png]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy8xMDQzNDQ5OC0wYmM5ZWJiYWJlZWVkMjlmLnBuZw?x-oss-process=image/format,png
[Spring_SpringBoot_--_--_IT_-CSDN]: https://knife.blog.csdn.net/article/details/121369030