Springboot中事务 @Transactional 默认方式 Propagation.REQUIRED

在平常的项目里面，最常看到的就是使用注解  @Transactional   去操作事务。

事务传播机制，存在7种，

也就是：

 同样可以在注解@Transactional里面看到， 默认配置了的是  Propagation.REQUIRED （文章的主角）

 说明：

1.1 支持当前事务

支持当前事务的传播机制有三种，分别是
1 REQUIRED （必须有） 默认

含义：如果当前方法没有事务，新建一个事务，如果已经存在一个事务中，则加入到这个事务中。

2 SUPPORTS （可有可无）

含义：支持当前事务，如果当前没有事务，就以非事务方式执行

3 MANDATORY （强制）

含义：使用当前的事务，如果当前没有事务，就抛出异常。

1.2 不支持当前事务

4 REQUIRES_NEW

含义：新建事务，如果当前存在事务，把当前事务挂起。

5 NOT_SUPPORTED

含义：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

6 NEVER

含义： 以非事务方式执行，如果当前存在事务，则抛出异常。

1.3 NESTED

含义： 如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与PROPAGATION_REQUIRED类似的操作。

看代码，默认啥都不指定的时候，我们使用的就是PROPAGATION_REQUIRED这种方式。

往往很多小伙伴在使用声明式事物的时候，就顶多加上一个异常指定，都是使用的默认传播机制变量。

我们日常操作里，对于单个方法使用事物，经常是这样：

  @Transactional(rollbackFor = Exception.class)
    public Boolean add(UserInfo userInfo) {
        
        //... 业务处理
        //... 业务处理
        //... 业务处理
 
       //手动抛异常 触发回滚等
        retrun xxx;
  }

 或者说配合手动回滚使用，是这样：

 @Transactional(rollbackFor = Exception.class)
    public Boolean add(UserInfo userInfo) {
        
       try {
          
          //....业务逻辑处理
          
          if(XXXX){
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                return false;
          }
          //....业务逻辑处理
          
          if(xxxxx){
                 TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                 return false;
          }
          
 
        } catch (Exception e) {
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return false;
        }
    }

以上都是单个事物方法，理解起来很简单，相信大多数场景大家就这么用一下就没有过多去理会了。

那么接下来就是关于 这种默认的事物传播机制  PROPAGATION_REQUIRED 我们需要关心的东西了。

在结合代码介绍前，先把结论贴出来： 

1.如果外部方法没有开启事务的话，Propagation.REQUIRED（默认就是）修饰的内部方法会新开启自己的事务，且开启的事务相互独立，互不干扰。

2.如果外部方法开启事务并且指定为Propagation.REQUIRED(默认就是)，所有Propagation.REQUIRED修饰的内部方法和外部方法均属于同一事务 ，只要一个方法回滚，整个事务均回滚，因为大家都加入到了外部设置的这个事务里了。

第一种情形：
第一个业务类里面的方法，使用了声明式事务：

class testOne  
{
    @Transactional(rollbackFor = Exception.class)
    public Boolean addOne(UserInfo userInfo) {
        
        //... 业务处理
        //... 业务处理
        //... 业务处理
        retrun xxx;
    }
    
}

第二个业务类里面的方法，也使用了声明式事务：

class testTwo  
{
    @Transactional(rollbackFor = Exception.class)
    public Boolean addTwo(UserInfo userInfo) {
        
        //... 业务处理
        //... 业务处理
        //... 业务处理
        retrun xxx;
    }
    
}

然后第三个业务类里面的方法没有使用声明式事务，去调用第一个和第二个，如：

class testThree  
{
    
    public Boolean testThree(UserInfo userInfo) {
        
        addOne(xxxx);
        addTwo(xxxx);
        retrun xxx;
    }
    
}

这种情况下，addOne和addTwo两个方法的事务都是各自独立的， 也就是说，就算addOne成功了，在执行addTwo的时候出现了异常进行了回滚，并不会影响到addOne的数据。
 

那么，在默认addOne和addTwo都使用了事务，而且都是默认指定的传播机制PROPAGATION_REQUIRED的时候，我们想达到，只要这两个方法，或者testThree 方法，其中一个出现异常触发回滚，都可以将这三个方法一起进行回滚。那应该怎么做？

第二种情形：
让它们都加入到一个事务里面：

class testThree  
{
    @Transactional(rollbackFor = Exception.class)
    public Boolean testThree(UserInfo userInfo) {
        
        addOne(xxxx);
        addTwo(xxxx);
        retrun xxx;
    }
    
}

在testThree方法（对于addOne 和 addTwo 来说是个外部方法）上同样使用声明式事物，且也是默认指定传播机制PROPAGATION_REQUIRED。 

这样addOne事物开启时，发现外部存在指定传播机制PROPAGATION_REQUIRED的事物，那么就会加入该事物；

同样addTwo同理。