事务（二）：spring事务传播行为

落日映苍穹つ 2022-02-16 03:15 363阅读 0赞

## 一、什么是spring事务传播行为？ ##

事务的传播行为就是在一个方法中嵌套一个或者多个事务，这个（些）嵌套的事务就涉及到了事务的传播行为，**对于事务传播行为类型的设置是在被调用的方法上进行**。例如：

public void methodParentA() {
        methodA();
        methodB();
    }
    
    @Transactional(propagation = Propagation.REQUIRED)
    public void methodParentB() {
        methodA();
        methodB();
    }
    
    @Transactional(propagation = Propagation.REQUIRED)
    public void methodA() {
        System.out.println("methodA");
    }
    
    @Transactional(propagation = Propagation.REQUIRED)
    public void methodB() {
        System.out.println("methodB");
    }

如上代码，无论是在methodParentA还是在methodParentB中，都涉及到了事务的传播行为，其中propagation设置的类型不一样，会是不同的事务传播行为。

## 二、七种事务传播行为 ##

在spring中有七种事务传播行为类型，分别是

<table> 
 <tbody> 
  <tr> 
   <td style="width:221px;">PROPAGATION_REQUIRED</td> 
   <td style="width:532px;">如果一个事务已开启，使用当前事务；如果没有事务开启，则开启自己的事务</td> 
  </tr> 
  <tr> 
   <td style="width:221px;">PROPAGATION_SUPPORTS</td> 
   <td style="width:532px;">支持当前事务，如果当前没有事务，就以非事务方式执行</td> 
  </tr> 
  <tr> 
   <td style="width:221px;">PROPAGATION_MANDATORY</td> 
   <td style="width:532px;">使用当前事务，如果没有当前事务则抛出异常</td> 
  </tr> 
  <tr> 
   <td style="width:221px;">PROPAGATION_REQUIRES_NEW</td> 
   <td style="width:532px;">新建事务，如果当前存在事务，把当前事务挂起</td> 
  </tr> 
  <tr> 
   <td style="width:221px;">PROPAGATION_NOT_SUPPORTED</td> 
   <td style="width:532px;">以非事务方式执行，如果当前存在事务，将当前事务挂起</td> 
  </tr> 
  <tr> 
   <td style="width:221px;">PROPAGATION_NEVER</td> 
   <td style="width:532px;">以非事务方式执行，如果当前存在事务，则抛出异常</td> 
  </tr> 
  <tr> 
   <td style="width:221px;">PROPAGATION_NESTED</td> 
   <td style="width:532px;">如果当前存在事务，在嵌套事务内执行；如果当前没有事务，则执行与PROPAGATION_REQUIRED类似的操作</td> 
  </tr> 
 </tbody> 
</table>

## 三、以PROPAGATION\_REQUIRED类型为例详解事务传播行为 ##

1.在这里用到了两张测试表，两张表结构完全一样，仅名字不同。

CREATE TABLE `animal1` (
      `id` int(11) NOT NULL AUTO_INCREMENT,
      `name` varchar(25) DEFAULT NULL,
      PRIMARY KEY (`id`)
    )
    
    CREATE TABLE `animal2` (
      `id` int(11) NOT NULL DEFAULT '0',
      `name` varchar(25) DEFAULT NULL,
      PRIMARY KEY (`id`)
    )

2.两张表所对应的各自的业务层代码

@Service
    public class Animal1ServiceImpl implements Animal1Service {
        @Autowired
        private Animal1Mapper animal1Mapper;
    
        @Override
        @Transactional(propagation = Propagation.REQUIRED)
        public void add(Animal1 animal1) {
            animal1Mapper.insert(animal1);
        }
    
        @Override
        @Transactional(propagation = Propagation.REQUIRED)
        public void addWithException(Animal1 animal1) {
            animal1Mapper.insert(animal1);
            throw new RuntimeException();
        }
    }

@Service
    public class Animal2ServiceImpl implements Animal2Service {
        @Autowired
        private Animal2Mapper animal2Mapper;
    
        @Override
        @Transactional(propagation = Propagation.REQUIRED)
        public void add(Animal2 animal2) {
            animal2Mapper.insert(animal2);
        }
    
        @Override
        @Transactional(propagation = Propagation.REQUIRED)
        public void addWithException(Animal2 animal2) {
            animal2Mapper.insert(animal2);
            throw new RuntimeException();
        }
    }

3.以PROPAGATION\_REQUIRED类型为例，在五种种情况下分别测试，并记录测试结果

/**
         * 1.外层没有开启事务，但最后一行抛出异常
         * 2.内层两个事务传播行为均为REQURED，其中一个有抛出异常
         * 3.结果为animal1表插入了“狮子1”，animal2表未插入成功
         */
        public  void testRequiredNoTransactionalThrowException() {
            Animal1 animal1 = new Animal1();
            animal1.setName("狮子1");
            animal1Service.add(animal1);
    
            Animal2 animal2 = new Animal2();
            animal2.setName("狮子2");
            animal2Service.addWithException(animal2);
    
            throw new RuntimeException();
        }
    
        /**
         * 1.外层没有开启事务，且没有抛出异常
         * 2.内层两个事务传播行为均为REQURED，其中一个有抛出异常
         * 3.结果为animal1表插入了“狮子1”，animal2表未插入成功
         */
        @Override
        public void testRequiredNoTransactional() {
            Animal1 animal1 = new Animal1();
            animal1.setName("狮子1");
            animal1Service.add(animal1);
    
            Animal2 animal2 = new Animal2();
            animal2.setName("狮子2");
            animal2Service.addWithException(animal2);
        }
    
        /**
         * 1.外层开启事务，且没有抛出异常
         * 2.内层两个事务传播行为均为REQURED，其中一个有抛出异常
         * 3.结果为内层两个事务都发生了回滚，没有插入成功
         */
        @Override
        @Transactional(propagation = Propagation.REQUIRED)
        public void testRequiredTransactional() {
            Animal1 animal1 = new Animal1();
            animal1.setName("狮子1");
            animal1Service.add(animal1);
    
            Animal2 animal2 = new Animal2();
            animal2.setName("狮子2");
            animal2Service.addWithException(animal2);
        }
    
        /**
         * 1.外层开启事务，且抛出异常
         * 2.内层两个事务传播行为均为REQURED，且都正常执行
         * 3.结果为内层两个事务都发生了回滚，没有插入成功
         */
        @Override
        @Transactional(propagation = Propagation.REQUIRED)
        public void testRequiredTransactionalThrowException() {
            Animal1 animal1 = new Animal1();
            animal1.setName("狮子1");
            animal1Service.add(animal1);
    
            Animal2 animal2 = new Animal2();
            animal2.setName("狮子2");
            animal2Service.add(animal2);
    
            throw new RuntimeException();
        }
    
        /**
         * 1.内层两个事务传播行为均为REQURED，其中一个有抛出异常
         * 2.外层捕获异常，不主动抛出异常
         * 3.结果为内层两个事务都发生了回滚，没有插入成功
         */
        @Override
        @Transactional(propagation = Propagation.REQUIRED)
        public void testRequiredTransactionalTryException() {
            Animal1 animal1 = new Animal1();
            animal1.setName("狮子1");
            animal1Service.add(animal1);
    
            Animal2 animal2 = new Animal2();
            animal2.setName("狮子2");
            try {
                animal2Service.addWithException(animal2);
            } catch (Exception e) {
                System.out.println("捕获异常，回滚");
            }
        }

4.结论

**（1）在外层方法中没有开启事务的情况下，内层事务传播类型为 Propagation.REQUIRED的事务会各自开启新的事务，并且相互之间独立，互不干扰；**

**（2）在外层方法中开启事务的情况下，在内层事务传播类型为Propagation.REQUIRED的事务会加入外层的事务，也就是它们同属于一个事务，只要有其中一个逻辑发生了回滚，则外层方法所包含的内容全部回滚。**

5.其他

在这里，我以事务传播类型Propagation.REQUIRED为例，测试了七种事务传播类型中的一种。本文的目的主要是在解释spring的事务传播类型是什么，而其他六种事务传播类型的测试结果就不在此赘述了。