Spring中的事务传播机制和嵌套事务

桃扇骨 2023-06-12 09:22 22阅读 0赞

## 一、序言 ##

Spring中声明式事务确实给我们带来了很大的便利，在Service层方法上带上@Transactional注解即可实现事务，首先看看@Transactional的默认配置：

1、默认使用的事务管理器名字为"transactionManager"。

2、默认事务隔离传播为Propagation.REQUIRED。

3、默认超时时长为底层事务系统的时长。

4、默认事务隔离级别为数据库的隔离级别。

5、默认事务类型为读写事务。

6、默认发生RuntimeExeption异常会触发事务回滚，而受检异常不会。

@Target({ElementType.TYPE, ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @Inherited
    @Documented
    public @interface Transactional {
    
    	
    	@AliasFor("transactionManager")
    	String value() default "";
    	
    	@AliasFor("value")
    	String transactionManager() default "";
    
    	Propagation propagation() default Propagation.REQUIRED;
    
    	Isolation isolation() default Isolation.DEFAULT;
    
    	int timeout() default TransactionDefinition.TIMEOUT_DEFAULT;
    
    	boolean readOnly() default false;
    	
    	Class<? extends Throwable>[] rollbackFor() default {};
    
    	String[] rollbackForClassName() default {};
    
    	Class<? extends Throwable>[] noRollbackFor() default {};
    
    	String[] noRollbackForClassName() default {};
    
    }

## 二、事务传播机制介绍 ##

public enum Propagation {
    
    	
            /**
             * 如果当前线程执行的方法如果没有事务则创建新事务，否则在已存在事务中执行
             * /   
    	REQUIRED(TransactionDefinition.PROPAGATION_REQUIRED),
    
            /**
             * 如果当前线程执行的方法如果有事务，则在事务中执行，否则无事务执行 
             * / 
    	SUPPORTS(TransactionDefinition.PROPAGATION_SUPPORTS),
    
            /**
             * 当前线程执行的方法必须有事务，否则抛出异常
             * /
    	MANDATORY(TransactionDefinition.PROPAGATION_MANDATORY),
    	
            /**
             * 当前线程执行方法每次都会创建新的事务，如果当前方法已在事务中执行，则会挂起外部事务
             * /
    	REQUIRES_NEW(TransactionDefinition.PROPAGATION_REQUIRES_NEW),
    	
            /**
             * 当前线程所执行的方法在无事务环境中执行，如果已有外部事务，则会挂起外部事务
             * /
    	NOT_SUPPORTED(TransactionDefinition.PROPAGATION_NOT_SUPPORTED),
    
            /**
             * 当前线程所执行的方法在无事务环境中执行，如果已有外部事务，则会抛出异常
             * /
    	NEVER(TransactionDefinition.PROPAGATION_NEVER),
    
            /**
             * 如果外部事务存在，则当前线程所在方法会在嵌套事务中执行。
             * 如果外部事务不存在，则和REQUIRED效果一样。
             * /
    	NESTED(TransactionDefinition.PROPAGATION_NESTED);
    }

## 三、嵌套事务实例 ##

### 1、Propagation.REQUIRED ###

@Service
    public class TransactionServiceB {
    
      @Autowired
      private OperationLogMapper operationLogMapper;
    
      @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
      public void methodB() {
        OperationLogDo operationLog = new OperationLogDo();
        operationLog.setOpType(1);
        operationLog.setOpContent("新增操作");
        operationLog.setUserId(1);
        operationLog.setCreateTime(new Date());
        operationLogMapper.saveOperationLog(operationLog);
      }
    }
    
    
    @Service
    public class TransactionServiceA {
    
      @Autowired
      private TransactionServiceB serviceB;
    
      @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
      public void methodA() {
        serviceB.methodB();
        throw new RuntimeException("发生异常了!");
      }
    }

由于methodA和methodB事务的传播机制都是Propagation.REQUIRED，因此methodB会和methodA在同一个事务中执行，当methodA执行发生异常时，methodB会回滚，因此methodB中的插入操作不会生效。

### 2、Propagation.REQUIRES\_NEW ###

@Service
    public class TransactionServiceA {
    
      @Autowired
      private TransactionServiceB serviceB;
    
      @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
      public void methodA() {
        serviceB.methodB();
        throw new RuntimeException("发生异常了!");
      }
    }
    
    @Service
    public class TransactionServiceB {
    
      @Autowired
      private OperationLogMapper operationLogMapper;
    
      @Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)
      public void methodB() {
        OperationLogDo operationLog = new OperationLogDo();
        operationLog.setOpType(1);
        operationLog.setOpContent("新增操作");
        operationLog.setUserId(1);
        operationLog.setCreateTime(new Date());
        operationLogMapper.saveOperationLog(operationLog);
      }
    }

methodA方法上的事务传播机制是Propagation.REQUIRED，而methodB方法上的事务传播机制Propagation.REQUIRES\_NEW，因此methodB方法会在一个新的事务中执行，同时外部事务(即methodA所在事务)会被挂起。这里我们看到的效果是数据库中仍然插入了一条记录，说明不受外部事务影响。

### 3、Propagation.NESTED ###

@Service
    public class TransactionServiceA {
    
      @Autowired
      private OperationLogMapper operationLogMapper;
      @Autowired
      private TransactionServiceB serviceB;
    
      @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
      public void methodA() {
        serviceB.methodB();
        
        OperationLogDo operationLog = new OperationLogDo();
        operationLog.setOpType(1);
        operationLog.setOpContent("修改操作");
        operationLog.setUserId(1);
        operationLog.setCreateTime(new Date());
        operationLogMapper.saveOperationLog(operationLog);
        
        throw new RuntimeException("发生异常了!");
      }
    }
    
    @Service
    public class TransactionServiceB {
    
      @Autowired
      private OperationLogMapper operationLogMapper;
    
      @Transactional(propagation = Propagation.NESTED, rollbackFor = Exception.class)
      public void methodB() {
        OperationLogDo operationLog = new OperationLogDo();
        operationLog.setOpType(1);
        operationLog.setOpContent("新增操作");
        operationLog.setUserId(1);
        operationLog.setCreateTime(new Date());
        operationLogMapper.saveOperationLog(operationLog);
      }
    }

此时methodA方法在methodB方法执行完后抛出了异常，最后的结果是methodB中的插入操作回滚了。为什么呢？我们可以把嵌套事务看做是外部事务的一个子事务，既然外部事务发生异常回滚了，那么子事务也会回滚，但要注意子事务不会影响外部事务。而如果methodB上的隔离级别设为REQUIRES\_NEW，那么methodB中的插入操作会生效,因为methodB方法执行会在一个新的事务环境中，不受其它事务影响。

有同学会发现，上面的例子即使methodB方法上的事务传播机制为Propagation.REQUIRED，methodB方法中的插入操作也会回滚，那我们再看看Propagation.NESTED和Propagation.REQUIRED的区别，下面再进行改写：

@Service
    public class TransactionServiceA {
    
      @Autowired
      private OperationLogMapper operationLogMapper;
      @Autowired
      private TransactionServiceB serviceB;
    
      @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
      public void methodA() {
        try {
          serviceB.methodB();
        } catch (Exception e) {
          e.printStackTrace();
        }
        
        OperationLogDo operationLog = new OperationLogDo();
        operationLog.setOpType(1);
        operationLog.setOpContent("修改操作");
        operationLog.setUserId(1);
        operationLog.setCreateTime(new Date());
        operationLogMapper.saveOperationLog(operationLog);
      }
    }
    
    @Service
    public class TransactionServiceB {
    
      @Autowired
      private OperationLogMapper operationLogMapper;
    
      @Transactional(propagation = Propagation.NESTED, rollbackFor = Exception.class)
      public void methodB() {
        OperationLogDo operationLog = new OperationLogDo();
        operationLog.setOpType(1);
        operationLog.setOpContent("新增操作");
        operationLog.setUserId(1);
        operationLog.setCreateTime(new Date());
        operationLogMapper.saveOperationLog(operationLog);
        throw new RuntimeException("发生异常了!");
      }
    }

上面这个例子看到的效果是methodB方法中的插入操作会回滚，而methodA方法在捕获methodB方法抛出的异常后执行插入操作，因此数据库会新增一条记录。这也说明当methodB方法的传播机制为Propagation.NESTED时，methodB方法所在的事务为外部事务的一个子事务，子事务不会影响外部事务。当然如果methodA方法不捕获异常，那么methodA方法中的插入操作同样也会回滚。

发表评论取消回复

表情：

评论列表（有 0 条评论，22人围观）

还没有评论，来说两句吧...

相关阅读

相关【Spring】Spring事务和事务传播机制

Spring事务的传播机制和隔离级别

﹏ヽ暗。殇╰゛Y/ 2024年04月20日 12:05/ 0 赞/ 73 阅读

相关 Spring中的事务和事务的传播机制

事务是一组操作的集合，不可以被分割。事务会把所有的操作作为一个整体，这组操作要么全部成功，要么全部失败。事务有三种操作： 1. 开启事务； 2. 提交事务； 3.

客官°小女子只卖身不卖艺/ 2024年04月06日 15:28/ 0 赞/ 51 阅读

相关 Spring事务及事务传播机制

一.事务回顾 1.什么是事务事务定义 :将一组操作封装成⼀个执行单元（封装到一起），要么全部成功，要么全部失败。 2.为什么要使用事务还是用一个老生常谈

r囧r小猫/ 2024年03月22日 22:26/ 0 赞/ 65 阅读

相关 Spring 事务和事务的传播机制

文章目录 1. 回顾复习事务定义为什么要用事务 MySQL 中事务的使用 2

Myth丶恋晨/ 2024年03月17日 23:51/ 0 赞/ 71 阅读

相关 Spring事务与事务传播机制

文章目录 Spring事务与事务传播机制前言 1. Spring中事务的实现 1.1 编程式事务（手动编写代码操作事

末蓝、/ 2024年03月17日 22:56/ 0 赞/ 42 阅读

相关 Spring中的事务传播机制和嵌套事务

一、序言 Spring中声明式事务确实给我们带来了很大的便利，在Service层方法上带上@Transactional注解即可实现事务，首先看看@Transactiona

桃扇骨/ 2023年06月12日 09:22/ 0 赞/ 23 阅读

相关 Spring中事务的传播机制

Spring的事务其实就是数据库的事务操作，符合ACID标准，也具有标准的事务隔离级别。传统JDBC事务先来看下传统的JDBC事务的用法： package

傷城~/ 2022年11月14日 11:54/ 0 赞/ 109 阅读

相关 Spring、Springboot中事务传播机制（事物嵌套）

Spring、Springboot中事务传播机制（事物嵌套）事务传播机制： `事务的传播行为是针对嵌套事务而言。即是针对（需要事务的业务方法）调用（需要事务的业务

r囧r小猫/ 2022年08月30日 04:08/ 0 赞/ 284 阅读

相关 spring事务传播机制

spring定义了7中事务传播机制 <table> spring事务传播机制 <tbody> <tr> <td style="width:461px;"

布满荆棘的人生/ 2022年03月18日 09:46/ 0 赞/ 251 阅读

相关 spring事务传播机制

概述当我们调用一个基于Spring的Service接口方法（如UserService\addUser()）时，它将运行于Spring管理的事务环境中，Service接口方

﹏ヽ暗。殇╰゛Y/ 2021年09月28日 00:44/ 0 赞/ 380 阅读