[Spring]事务的七个传播行为

最新推荐文章于 2025-10-30 13:35:40 发布
原创 最新推荐文章于 2025-10-30 13:35:40 发布 · 5.9k 阅读 · 26 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#事务 #spring #java #mysql #传播行为

本文详细解析了Spring中的事务传播行为，包括PROPAGATION_REQUIRED、PROPAGATION_SUPPORTS、PROPAGATION_REQUIRES_NEW、PROPAGATION_NOT_SUPPORTED、PROPAGATION_MANDATORY、PROPAGATION_NEVER和PROPAGATION_NESTED。每个传播行为的特点和应用场景通过实例进行了说明，尤其重点讨论了嵌套事务和异常处理对事务的影响。

前言

当我们调用一个基于Spring的Service接口方法时，它将运行于Spring管理的事务环境中，Service接口方法可能会在内部调用其它的Service接口方法以共同完成一个完整的业务操作，因此就会产生服务接口方法嵌套调用的情况， Spring通过事务传播行为控制当前的事务如何传播到被嵌套调用的目标服务接口方法中。
事务传播是Spring进行事务管理的重要概念，其重要性怎么强调都不为过。但是事务传播行为也是被误解最多的地方，在本文里，我们将详细分析不同事务传播行为的表现形式，掌握它们之间的区别。

注:本文可以与上篇文章一同参考
MySQL事务的四个隔离级别详解

Spring的事务传播行为

  1. PROPAGATION_REQUIRED:如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。这是最常见的选择。
  2. PROPAGATION_SUPPORTS:支持当前事务，如果当前没有事务，就以非事务方式执行。
  3. PROPAGATION_MANDATORY:使用当前的事务，如果当前没有事务，就抛出异常。
  4. PROPAGATION_REQUIRES_NEW:新建事务，如果当前存在事务，把当前事务挂起。
  5. PROPAGATION_NOT_SUPPORTED:以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
  6. PROPAGATION_NEVER:以非事务方式执行，如果当前存在事务，则抛出异常。
  7. PROPAGATION_NESTED:如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与PROPAGATION_REQUIRED类似的操作。

注意:

1、开启PROPAGATION_NESTED传播行为时,需要开启nestedTransactionAllowed属性为true。
   即支持事务的savepoint操作。
2、nestedTransactionAllowed默认为false。
3、JDK要在1.4+
<bean id="transactionManager" 
        class="org.springframework.orm.hibernate4.HibernateTransactionManager">  
        <property name="sessionFactory" ref="sessionFactory"/> 
        <!-- 开启 PROPAGATION_NESTED 事务传播行为  -->
        <property name="nestedTransactionAllowed" value="true"/> 
</bean>

下面提一些基本知识

  1. 事务传播机制只适用于不同bean之间方法的调用，如果一个bean中的两个方法互相调用并不会使用到事务传播。
  2. 事务方法里如果抛RuntimeException，则会导致所有相关事务回滚，个别事务传播机制有点特殊，我们下面会讲到。
  3. 事务方法里如果抛Throwable或者Exception，默认不会导致相关事务回滚，一般都会在出异常的地方提交，就有可能出现部分提交的问题。但可以配置rollback-for属性来控制。

下面我们来详细看一下七个Spring事务传播行为

@Service
public class BaseServiceImpl implements BaseService {

    @Autowired
    private BaseHibernateDao baseHibernateDao;

    @Autowired
    private LoginService loginService;

    //外部事务
    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public Serializable save1(LoginUser entity) throws Exception {
        Serializable save = null;
        loginService.save2(new LoginUser());
        return save;
    }
}
@Service
public class LoginServiceImpl implements LoginService {

    @Autowired
    private BaseHibernateDao baseHibernateDao;

    //内部事务
    @Override
    @Transactional 
    public Serializable save2(LoginUser entity) throws Exception {
        Serializable save = null;
        entity.setUsername("save2");
        save = baseHibernateDao.save(entity);
        return save;
    }
}

①
@Transactional(propagation = Propagation.SUPPORTS)
支持当前事务，如果当前没有事务，就以非事务方式执行。

//外部事务
@Override
@Transactional(propagation = Propagation.SUPPORTS)  
//支持当前事务，如果当前没有事务，就以非事务方式执行。
public Serializable save1(LoginUser entity) throws Exception {
    Serializable save = null;
    loginService.save2(new LoginUser());
    return save;
}

//内部事务
@Override
public Serializable save2(LoginUser entity) throws Exception {
    Serializable save = null;
    entity.setUsername("save2");
    save = baseHibernateDao.save(entity);
    //空指针异常
    Object obj = null;
    obj.equals("");
    entity =  new LoginUser();
    entity.setUsername("save3");
    save = baseHibernateDao.save(entity);
    return save;
}

以上在内部事务中我们使用了SUPPORTS事务传播行为,以非事务方式执行(可执行增删改操作,但是不受事务控制),虽然中间抛出了空指针异常,但是不会导致第一次save回滚,第二次save失败

1

②
@Transactional(propagation = Propagation.REQUIRES_NEW)
新建事务，如果当前存在事务，把当前事务挂起。

//外部事务
@Override
@Transactional(propagation = Propagation.REQUIRED)
public Serializable save1(LoginUser entity) throws Exception {
    Serializable save = null;
    loginService.save2(new LoginUser());
    //空指针异常
    Object obj = null;
    obj.equals("");
    return save;
}

//内部事务
@Override
@Transactional(propagation = Propagation.REQUIRES_NEW)  
//开启内部事务,执行完毕后会立即提交内部事务
public Serializable save2(LoginUser entity) throws Exception {
    Serializable save = null;
    entity.setUsername("save2");
    save = baseHibernateDao.save(entity);
    return save;
}

外部事务中我们先执行了内部事务,随后外部事务抛出异常,但并不影响内部事务的提交。

3

如果内部事务传播行为为:REQUIRES_NEW,外部事务传播行为为:REQUIRED,若内部事务抛出异常,会影响外部事务吗?

//外部事务
@Override
@Transactional(propagation = Propagation.REQUIRED)
public Serializable save1(LoginUser entity) throws Exception {
    Serializable save = null;
    this.save(new LoginUser("save1"));
    loginService.save2(new LoginUser());
    return save;
}

//内部事务
@Override
@Transactional(propagation = Propagation.REQUIRES_NEW)  
public Serializable save2(LoginUser entity) throws Exception {
    Serializable save = null;
    entity.setUsername("save2");
    save = baseHibernateDao.save(entity);
    //空指针异常
    Object obj = null;
    obj.equals("");
    return save;
}

我们来看下执行结果

4

1、若内部事务抛出异常,并且没有处理的话,异常会跑到外部事务中,导致整个事务回滚,不做数据操作
2、若要想让内部事务不影响外部事务,需要在 [内部事务] 中做异常处理,若在外部事务中单独对引用的内部事务做事务回滚,将导致整个事务回滚(包括外部事务)

以下将导致整个事务回滚

//外部事务
@Override
@Transactional(propagation = Propagation.REQUIRED)
public Serializable save1(LoginUser entity) throws Exception {
    Serializable save = null;
    this.save(new LoginUser("save1"));
    try {
        //引用内部事务方法
        loginService.save2(new LoginUser());
    } catch (Exception e) {
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
    return save;
}

以下会单独将内部事务回滚

//内部事务
@Override
@Transactional(propagation = Propagation.REQUIRES_NEW)
public Serializable save2(LoginUser entity) throws Exception {
    Serializable save = null;
    try {
        entity.setUsername("save2");
        save = baseHibernateDao.save(entity);
        //空指针异常
        Object obj = null;
        obj.equals("");
    } catch (Exception e) {
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
    return save;
}

③
@Transactional(propagation = Propagation.NESTED)
它是已经存在事务的一个真正的子事务。嵌套事务开始执行时,它将取得一个 savepoint。如果这个嵌套事务失败, 我们将回滚到此 savepoint。嵌套事务是外部事务的一部分, 只有外部事务结束后它才会被提交。

//外部事务
@Override
@Transactional(propagation = Propagation.REQUIRED)
public Serializable save1(LoginUser entity) throws Exception {
    Serializable save = null;
    this.save(new LoginUser("save1"));
    loginService.save2(new LoginUser());
    //空指针异常
    Object obj = null;
    obj.equals("");
    return save;
}

//内部事务
@Override
@Transactional(propagation = Propagation.NESTED)    
//开启内部事务,内部事务"嵌套"在外部事务中
public Serializable save2(LoginUser entity) throws Exception {
    Serializable save = null;
    entity.setUsername("save2");
    save = baseHibernateDao.save(entity);
    return save;
}

5

NESTED:虽然开启了一个新的事务,实质是”嵌套”在外部事务中,它的原理是通过savepoint实现的。所以当外部事务发生异常时,会导致整个内外部事务回滚。

注:
与REQUIRES_NEW不同的是,REQUIRES_NEW外部事务异常,内部事务执行正常操作时,外部事务回滚,内部事务提交不回滚

问题:若内部事务发生了异常,并且在内部事务中做了事务回滚,会影响外部事务吗?

//外部事务
@Override
@Transactional(propagation = Propagation.REQUIRED)
public Serializable save1(LoginUser entity) throws Exception {
  Serializable save = null;
  this.save(new LoginUser("save1"));
  loginService.save2(new LoginUser());
  return save;
}

//内部事务
@Transactional(propagation = Propagation.NESTED)
public Serializable save2(LoginUser entity) throws Exception {
    Serializable save = null;
    try {
        entity.setUsername("save2");
        save = baseHibernateDao.save(entity);
        //空指针异常
        Object obj = null;
        obj.equals("");
    } catch (Exception e) {
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
    return save;
}

7

当内部事务发生异常,并且做了事务回滚,不会影响到外部事务,原因为该事务是通过savepoint控制的，不会影响外部事务。

④
@Transactional(propagation = Propagation.NOT_SUPPORTED)
//以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

//外部事务
@Override
@Transactional(propagation = Propagation.REQUIRED)
public Serializable save1(LoginUser entity) throws Exception {
    Serializable save = null;
    this.save(new LoginUser("save1"));
    loginService.save2(new LoginUser());
    return save;
}

//内部事务
@Override
@Transactional(propagation = Propagation.NOT_SUPPORTED) 
//以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
public Serializable save2(LoginUser entity) throws Exception {
    Serializable save = null;
    entity.setUsername("save2");
    save = baseHibernateDao.save(entity);
    //空指针异常
    Object obj = null;
    obj.equals("");
    return save;
}

5

以非事务方式执行(可执行增删改操作,但是不受事务控制),所以当内部事务抛出异常后,导致外部事务回滚,但是内部事务能过成功插入一条,并且内部事务没有回滚操作。

注:内部事务能手动将事务回滚吗?

//内部事务
@Override
@Transactional(propagation = Propagation.NOT_SUPPORTED) 
//以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
public Serializable save2(LoginUser entity) throws Exception {
    Serializable save = null;
    try {
        entity.setUsername("save2");
        save = baseHibernateDao.save(entity);
        //空指针异常
        Object obj = null;
        obj.equals("");
    } catch (Exception e) {
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
    return save;
}

6

我们在内部事务中做了异常处理并且手动启动事务回滚,发现内部事务并不能回滚,所以这种情况下内部事务是不能回滚的。

以上我们详细说明了Spring的四个事务传播行为,其他三个较为简单,这里就不做详细说明了。

上面我们提到了,若在两个不同的Bean之间调用是存在事务的传播行为的,那么在同一个Bean之间调用两个方法,事务是怎样的呢?请看如下示例

@Service
public class BaseServiceImpl implements BaseService {

    public BaseServiceImpl () {

    }

    @Autowired
    private BaseHibernateDao baseHibernateDao;

    @Autowired
    private LoginService loginService;


    @Override
    public Serializable save(Object entity) throws Exception {
        return baseHibernateDao.save(entity);
    }

    //外部事务
    @Override
    @Transactional(propagation = Propagation.SUPPORTS)
    public Serializable save1(LoginUser entity) throws Exception {
      Serializable save = null;
      try {
          this.save2(new LoginUser());
          this.save(new LoginUser("save1"));
          //空指针异常
          Object obj = null;
          obj.equals("");
      } catch (Exception e) {
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
      }
      return save;
    }

    //内部事务
    @Override
    @Transactional(propagation = Propagation.REQUIRED)  
    public Serializable save2(LoginUser entity) throws Exception {
        Serializable save = null;
        try {
            entity.setUsername("save2");
            save = baseHibernateDao.save(entity);
            //空指针异常
            Object obj = null;
            obj.equals("");
        } catch (Exception e) {
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
        return save;
    }
}

当我们执行了save1方法后,我们来看下数据库

8

当save1调用save2了之后,虽然save2的事务传播行为为REQUIRED,但是我们发现save2并没有执行回滚操作,显然save2的事务传播行为依然为SUPPORTS。

结论:若在同一个Bean之间方法相互调用,以第一个被调用的方法的事务传播行为为基准。

Spring 事务传播机制源码浅析——PROPAGATION_REQUIRES_NEW
龚小帅的博客
08-24 2932
两个方法都使用 PROPAGATION_REQUIRES_NEW 传播机制进行演示，并分析源码：示例如下： 还是要进入 TransactionInterceptor 类，这各类是入口，这里截取出核心源码如下：进入 createTransactionIfNecessary() 方法，可以分成六个核心步骤，源码如下：源码如下：可以发现第一步骤有两行非常重要的代码，第一行代码主要是从 ThreadLocal 类型的变量中去获取值，源码如下：第一次也就是现在过来的 add() 方法，现在从这个 ThreadLoc
Transaction事务传播行为
Vector丶
07-31 1371
事务传播行为Spring的7种事务传播行为代码演示PROPAGATION_REQUIREDPROPAGATION_SUPPORTSPROPAGATION_MANDATORYPROPAGATION_REQUIRES_NEWPROPAGATION_NOT_SUPPORTEDPROPAGATION_NEVERPROPAGATION_NESTED实际场景PROPAGATION_REQUIREDPROPAGATION_NESTEDPROPAGATION_NOT_SUPPORTEDPROPAGATION_REQUIRE
【Spring学习34】Spring事务(4)：事务属性之7种传播行为
程序老兵的博客
04-20 1万+
事务传播行为什么叫事务传播行为？听起来挺高端的，其实很简单。 即然是传播，那么至少有两个东西，才可以发生传播。单体不存在传播这个行为。事务传播行为（propagation behavior）指的就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行。 例如：methodA事务方法调用methodB事务方法时，methodB是继续在调用者methodA的事务中运行呢，还是为自己开启一个
Spring事务传播机制Propagation.REQUIRES_NEW详解及测试
热门推荐
墨迹程序员
10-30 10万+
REQUIRES_NEW官方文档解释： Create a new transaction, and suspend the current transaction if one exists. 意思是，创建一个新事务，如果当前存在事务，将这个事务挂起。也就是说如果当前存在事务，那么将当前的事务挂起，并开启一个新事务去执行REQUIRES_NEW标志的方法。 先来总结一下结果： 1.标志REQUIR...
Spring 事务（详解）
最新发布
2509_93951834的博客
10-30 543
将组操作封装成个执单元，要么全部成功要么全部失败。为什么要事务？如转账分为两个操作：第步操作：A 账户 -100 元，第步操作：B 账户 +100 元。如果没有事务，第步执成功了，第步执失败了，那么 A 账户平故的 100 元就“间蒸发”了。如果使事务就可以解决这个问题，让这组操作要么起成功，要么起失败。
Spring事务的7种传播行为
keehom的博客
03-04 509
本文主要介绍下Spring事务中的传播行为。 事务传播行为介绍 Spring中的7个事务传播行为: 事务行为 说明 PROPAGATION_REQUIRED 支持当前事务，假设当前没有事务。就新建一个事务 PROPAGATION_SUPPORTS 支持当前事务，假设当前没有事务，就以非事务方式运行 PROPAGATION_MANDATORY 支持当前事务，假设当前没有事务，就抛出异常 PROPAGATION_REQUIRES_NEW 新建事务，假设当前存在事务。把当前事务挂...
Spring事务传播行为
bigliu123的专栏
07-03 402
事务传播行为 什么叫事务传播行为？听起来挺高端的，其实很简单。 即然是传播，那么至少有两个东西，才可以发生传播。单体不存在传播这个行为。 事务传播行为（propagation behavior）指的就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行。 例如：methodA事务方法调用methodB事务方法时，methodB是继续在调用者methodA的事务中运行呢，还是为自...
Spring中事务传播行为的介绍
08-26
Spring 中事务传播行为的介绍 Spring 中事务传播行为是指在分布式事务系统中，事务的边界定义和传播规则。在 Spring 框架中，定义了 7 种不同的传播行为，每种行为都有其特点和应用场景。 1. PROPAGATION_...
浅谈Spring事务传播行为实战
08-25
浅谈Spring事务传播行为实战 Spring框架提供了事务管理的标准实现，通过注解或者XML文件的方式声明和配置事务。事务管理是指按照给定的事务规则来执行事务的提交或者回滚操作。事务的机制实现很大一部依赖事务日志...
Spring中的事务传播行为示例详解
08-25
Spring 框架中事务传播行为是指在多个方法之间的调用关系中，如何处理事务的传播和rollback的机制。事务传播行为是 Spring 框架提供的一种事务管理方式，用于控制事务的传播范围和回滚机制。 一、背景介绍 ...
Spring事务传播行为问题解决
08-25
Spring事务传播行为问题解决 Spring事务传播行为问题解决是指在Spring框架中，事务传播行为的配置和使用问题。事务传播行为是指在多个事务方法之间的调用关系，如何去管理和控制事务的传播和回滚。 一、 Spring...
Spring事务传播行为的理解
simpleGq的专栏
11-20 485
关于Spring事务传播行为的理解
事务的7种传播行为
weixin_50989637的博客
02-22 671
事务的7种传播行为
Spring的事务传播机制(通俗易懂)
Samdom的博客
06-05 1万+
概述 Spring的传播机制有7种，在枚举Propagation中有定义。 1.REQUIRED PROPAGATION_REQUIRED：如果当前没有事务，就创建一个新事务，如果当前存在事务，就加入该事务，该设置是最常用的默认设置。 @Transactional(propagation= Propagation.REQUIRED) public void methodA(){ methodB(); // do something } @Transactional(propagation= P
详解事务的7种传播行为
卓越无关环境，保持空杯心态——靡不有初，鲜克有终
04-11 5万+
什么是Spring事务的传播行为？事务传播行为的七种类型有哪些？将异常try-catch捕获，事务是否还会回滚？
事务的七个传播行为
心有猛虎,细嗅蔷薇
07-03 606
PROPAGATION_REQUIRED 如果存在一个事务，则支持当前事务。如果没有事务则开启一个新的事务。 PROPAGATION_SUPPORTS 如果存在一个事务，支持当前事务。如果没有事务，则非事务的执行。但是对于事务同步的事务管理器，PROPAGATION_SUPPORTS与不使用事务有少许不同。 PROPAGATION_MANDATORY 如果已经存在一个事务，支持当前事务。...
Spring之事务传播行为
猎户星座
01-26 754
Spring事务传播行为： spring特有的事务传播行为，spring支持7种事务传播行为，确定客户端和被调用端的事务边界（说得通俗一点就是多个具有事务控制的service的相互调用时所形成的复杂的事务边界控制）下图所示为7钟事务传播机制 传播行为 含义 PROPAGATION_REQUIRED（XML文件中为REQUIRED) 表示当前方法必须在一个具有事务的上下文中运行，如有客户端有事务在进行，那么被调用端将在该事务中运行，否
spring事务传播行为
qq_27818157的博客
03-08 581
在Spring中，我们可以通过声明式事务，实现对数据库操作的事务管理。其中，在声明式事务时，有一个事务的属性为propagation，即事务的传播行为。今天，就来讨论该属性的作用。什么是事务的传播行为？首先，事务的传播行为，可以拆成两部分理解，即事务的传播，和事务的行为。指的是，当有两个或以上的方法同时声明为事务方法(事务方法：即加了事务管理的增删改方法)时，如果在一次程序执行过程中，这些事务方法彼此间相互调用，那么这些事务方法的事务，应该如何来进行管理？
Spring事务传播行为实战解析与案例分析
"本文主要探讨了Spring框架中的事务传播行为，并通过一个电商平台包裹出库的业务场景进行实战解析。文章详细介绍了Spring的事务管理机制，包括事务的定义、事务管理的核心以及事务日志的重要性。在实际案例中，由于...
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值