天天看点

Springboot 跟着我了解下 事务 @Transactional 默认方式 Propagation.REQUIRED

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

如果稍微对spring事务有过了解的,会知道关于事务传播机制,存在7种,

也就是:

Springboot 跟着我了解下 事务 @Transactional 默认方式 Propagation.REQUIRED

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

Springboot 跟着我了解下 事务 @Transactional 默认方式 Propagation.REQUIRED
Springboot 跟着我了解下 事务 @Transactional 默认方式 Propagation.REQUIRED

为什么该篇文章,7种,我只介绍一种呢?而且是介绍的是 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同理。

继续阅读