Spring事务传播行为总结

已于 2023-03-15 10:56:05 修改
阅读量1.2k 收藏 6
点赞数
文章标签： spring 事务传播行为 事务特性 事务
于 2023-03-14 19:11:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44958006/article/details/128854811
版权

Spring事务传播行为总结

1、概念

事务传播行为（propagation behavior）：指的就是当一个事务方法被另一个事务方法调用时，这个事务与事务应该如何运行。
事务传播行为是Spring框架独有的事务增强特性。这是Spring为我们提供的强大的工具箱，使用事务传播行为可以为我们的开发工作提供许多便利。

2、Spring的七种事务传播行为类型

Spring在TransactionDefinition接口中规定了7种类型的事务传播行为：

事务注解源码枚举：
在这里插入图片描述

总结：

事务传播行为类型对应说明验证结果
PROPAGATION_REQUIRED如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。(spring 默认的类型)外围方法未开启事务：内部方法各自执行，走各自的事务，互不影响；在外围方法开启事务的情况下，内部方法会加入到外围方法的事务中，所有内部方法和外围方法均属于同一事务，只要一个方法回滚，整个事务均回滚。
PROPAGATION_SUPPORTS支持当前事务，如果当前没有事务，就以非事务方式执行。外围开启SUPPORTS，且内部也是SUPPORTS情况下，相当于没有事务；外围开启SUPPORTS，内部方法开启别的事务，内部方法按开启的事务类型执行，互不影响；
PROPAGATION_MANDATORY使用当前的事务，如果当前没有事务，就抛出异常。外围方法开启MANDATORY事务或者没有开启事务，不管内部方法任何事务类型或者内部方法均不开启事务，都会抛出异常；外围开启别的事务，内部方法会加入到外围方法的事务中一起执行
PROPAGATION_REQUIRES_NEW新建事务，如果当前存在事务，把当前事务挂起。内部方法声明REQUIRES_NEW类型后会新建独立事务执行，与外围方法不走同一个事务，内部方法之间事务互不影响
PROPAGATION_NOT_SUPPORTED以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。内部方法声明后就是以非事务执行，外围方法对其try catch的情况下，内部方法的异常不会导致外围方法回滚
PROPAGATION_NEVER以非事务方式执行，如果当前存在事务，则抛出异常。以非事务执行，如果加入到的外围方法中包含事务就会报错
PROPAGATION_NESTED如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与PROPAGATION_REQUIRED类似的操作。外围方法在对内部方法try catch的情况下，内部子事务可以单独回滚而不影响外围主事务和其他子事务

3、各种行为类型及对应的结果验证

声明：
user方法 person方法 为不同的两个表的方法，外围方法同时调用 user 和 person；

user方法：

    @Override
    public void addUser(User user) {
        userMapper.addUser(user);
    }

person方法：

    @Override
    public void addPerson(Person person) {
        personMapper.addPerson(person);
    }

person含异常方法：

    @Override
    public void addPersonException(Person person) {
        personMapper.addPerson(person);
        int i = 1/0;
    }

3.1、PROPAGATION_REQUIRED类型

@Transactional(propagation = Propagation.REQUIRED,rollbackFor = Exception.class)

场景3.1.1：外围方法不开启事务，User方法，Person方法均开启事务，且外围方法包含异常

外围方法：

    public void noTransactional() {

        User user = new User();
        user.setId(1);
        user.setName("addUser1");
        user.setPwd("123456");
        userService.addUser(user);

        Person person = new Person();
        person.setId(1);
        person.setName("addPerson1");
        personService.addPerson(person);
        
        //异常
        int i = 1/0;
    }

运行结果：

user表插入成功：
在这里插入图片描述

person表插入成功：
在这里插入图片描述

场景3.1.2：外围方法不开启事务，User方法，Person方法均开启事务，且Person方法包含异常

外围方法：

    public void noTransactional() {

        User user = new User();
        user.setId(1);
        user.setName("addUser1");
        user.setPwd("123456");
        userService.addUser(user);

        Person person = new Person();
        person.setId(1);
        person.setName("addPerson1");
        personService.addPersonException(person);
    }

运行结果：

user表插入成功：
在这里插入图片描述

person表插入失败：
在这里插入图片描述

场景3.1.3 外围方法开启事务，User方法，Person方法均开启事务，且外围方法包含异常

外围方法：

    @Transactional(propagation = Propagation.REQUIRED,rollbackFor = Exception.class)
    @Override
    public void transactional() {
        
        User user = new User();
        user.setId(1);
        user.setName("addUser1");
        user.setPwd("123456");
        userService.addUser(user);

        Person person = new Person();
        person.setId(1);
        person.setName("addPerson1");
        personService.addPerson(person);
        
        //异常
        int i = 1/0;
    }

运行结果：

user表插入失败：
在这里插入图片描述
person表插入失败：
在这里插入图片描述

场景3.1.4 外围方法开启事务，User方法，Person方法均开启事务，且Person方法包含异常

外围方法：

    @Transactional(propagation = Propagation.REQUIRED,rollbackFor = Exception.class)
    @Override
    public void transactional() {

        User user = new User();
        user.setId(1);
        user.setName("addUser1");
        user.setPwd("123456");
        userService.addUser(user);

        Person person = new Person();
        person.setId(1);
        person.setName("addPerson1");
        personService.addPersonException(person);
    }

运行结果：

user表插入失败：
在这里插入图片描述

person表插入失败：
在这里插入图片描述

场景3.1.5 外围方法开启事务，User方法，Person方法均开启事务，且Person方法包含的异常被try catch捕获

外围方法：

    @Transactional(propagation = Propagation.REQUIRED,rollbackFor = Exception.class)
    @Override
    public void transactional() {

        User user = new User();
        user.setId(1);
        user.setName("addUser1");
        user.setPwd("123456");
        userService.addUser(user);

        Person person = new Person();
        person.setId(1);
        person.setName("addPerson1");
        
        try{
            personService.addPersonException(person);
        }catch (Exception e){
            System.out.println("捕获person异常方法！");
        }
    }

运行结果：

user表插入失败：
在这里插入图片描述

person表插入失败：
在这里插入图片描述

PROPAGATION_REQUIRED类型事务总结：

对应场景外围是否开启事务外围方法是否包含异常外围是否捕获异常person方法是否包含异常最终执行结果
3.1.1×√××均成功
3.1.2×××√user成功，person失败
3.1.3√√××均失败
3.1.4√××√均失败
3.1.5√√捕获person的异常√均失败

PROPAGATION_REQUIRED类型事务结论：
在外围方法开启事务的情况下，内部方法会加入到外围方法的事务中，所有内部方法和外围方法均属于同一事务，只要一个方法回滚，整个事务均回滚。

3.2 PROPAGATION_SUPPORTS类型

@Transactional(propagation = Propagation.SUPPORTS,rollbackFor = Exception.class)

PROPAGATION_SUPPORTS类型事务总结：

经验证：
外围开启SUPPORTS，且内部也是SUPPORTS情况下，相当于没有事务；
外围开启SUPPORTS，内部方法开启别的事务，内部方法按开启的事务类型执行，互不影响；

3.3 PROPAGATION_MANDATORY类型

@Transactional(propagation = Propagation.MANDATORY,rollbackFor = Exception.class)

  1. 如果外围方法和内部方法，均开启MANDATORY，则会报以下异常；
  2. 外围开启MANDATORY，内部其中一个开启SUPPORTS类型，另一个开启REQUIRED类型也会报以下异常，因为SUPPORTS默认就是无事务；
  3. 外围开启MANDATORY，内部均开启REQUIRED类型，也会抛如下异常；
  4. 外围开启MANDATORY，内部均不开启事务，也是抛如下异常；
  5. 外围开启别的事务，则内部方法都会加入到外围的事务中一起执行；
org.springframework.transaction.IllegalTransactionStateException: No existing transaction found for transaction marked with propagation 'mandatory'
	at org.springframework.transaction.support.AbstractPlatformTransactionManager.getTransaction(AbstractPlatformTransactionManager.java:362) ~[spring-tx-5.2.6.RELEASE.jar:5.2.6.RELEASE]
	at org.springframework.transaction.interceptor.TransactionAspectSupport.createTransactionIfNecessary(TransactionAspectSupport.java:572) ~[spring-tx-5.2.6.RELEASE.jar:5.2.6.RELEASE]
	at org.springframework.transaction.interceptor.TransactionAspectSupport.invokeWithinTransaction(TransactionAspectSupport.java:360) ~[spring-tx-5.2.6.RELEASE.jar:5.2.6.RELEASE]
	at org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:118) ~[spring-tx-5.2.6.RELEASE.jar:5.2.6.RELEASE]
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186) ~[spring-aop-5.2.6.RELEASE.jar:5.2.6.RELEASE]
	at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.proceed(CglibAopProxy.java:749) ~[spring-aop-5.2.6.RELEASE.jar:5.2.6.RELEASE]
	at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:691) ~[spring-aop-5.2.6.RELEASE.jar:5.2.6.RELEASE]

3.4 PROPAGATION_REQUIRES_NEW类型

3.4.1 外围不开启事务，user，person方法均开启REQUIRES_NEW类型事务，且外围方法有异常

外围方法：

    @Override
    public void noTransactional() {

        User user = new User();
        user.setId(1);
        user.setName("addUser1");
        user.setPwd("123456");
        userService.addUser(user);

        Person person = new Person();
        person.setId(1);
        person.setName("addPerson1");
        personService.addPerson(person);
        
        //异常
        int i = 1/0;
    }

运行结果：

user表插入成功：
在这里插入图片描述
person表插入成功：

在这里插入图片描述

3.4.2 外围不开启事务，user，person方法均开启REQUIRES_NEW类型事务，且person方法有异常

外围方法：

    @Override
    public void noTransactional() {

        User user = new User();
        user.setId(1);
        user.setName("addUser1");
        user.setPwd("123456");
        userService.addUser(user);

        Person person = new Person();
        person.setId(1);
        person.setName("addPerson1");
        personService.addPersonException(person);
    }

运行结果：

user表插入成功：
在这里插入图片描述
person表插入失败：

在这里插入图片描述

3.4.3 外围开启REQUIRED事务，user，person方法均开启REQUIRES_NEW类型事务，且外围方法有异常

外围代码：

    @Transactional(propagation = Propagation.REQUIRED,rollbackFor = Exception.class)
    @Override
    public void transactional() {

        User user = new User();
        user.setId(1);
        user.setName("addUser1");
        user.setPwd("123456");
        userService.addUser(user);

        Person person = new Person();
        person.setId(1);
        person.setName("addPerson1");
        personService.addPerson(person);
        
        //异常
        int i = 1/0;
    }

运行结果：

user表插入成功：
在这里插入图片描述
person表插入成功：
在这里插入图片描述

3.4.4 外围开启REQUIRED事务，addPersonRequired方法开启REQUIRED事务，addPersonRequiredNew开启REQUIRES_NEW事务，且外围方法有异常

外围方法：

    @Transactional(propagation = Propagation.REQUIRED,rollbackFor = Exception.class)
    @Override
    public void transactional() {

        Person person1 = new Person();
        person1.setId(1);
        person1.setName("第一人");
        personService.addPersonRequired(person1);

        Person person2 = new Person();
        person2.setId(2);
        person2.setName("第二人");
        personService.addPersonRequiredNew(person2);

        Person person3 = new Person();
        person3.setId(3);
        person3.setName("第三人");
        personService.addPersonRequiredNew(person3);

        //异常
        int i= 1/0;
    }

运行结果：

第一条插入失败，其他成功

在这里插入图片描述

3.4.5 外围开启REQUIRED事务，addPersonRequired方法开启REQUIRED事务，addPersonRequiredNew开启REQUIRES_NEW事务，addPersonExceptionRequiredNew方法开启REQUIRES_NEW事务且有异常

外围代码：

    @Transactional(propagation = Propagation.REQUIRED,rollbackFor = Exception.class)
    @Override
    public void transactional() {

        Person person1 = new Person();
        person1.setId(1);
        person1.setName("第一人");
        personService.addPersonRequired(person1);

        Person person2 = new Person();
        person2.setId(2);
        person2.setName("第二人");
        personService.addPersonRequiredNew(person2);

        Person person3 = new Person();
        person3.setId(3);
        person3.setName("第三人");
        personService.addPersonExceptionRequiredNew(person3);

    }

运行结果：

第二条成功，其他失败

在这里插入图片描述

3.4.6 外围开启REQUIRED事务，addPersonRequired方法开启REQUIRED事务，addPersonRequiredNew开启REQUIRES_NEW事务，addPersonExceptionRequiredNew方法开启REQUIRES_NEW事务且有异常,被try catch

外围代码：

    @Transactional(propagation = Propagation.REQUIRED,rollbackFor = Exception.class)
    @Override
    public void transactional() {

        Person person1 = new Person();
        person1.setId(1);
        person1.setName("第一人");
        personService.addPersonRequired(person1);

        Person person2 = new Person();
        person2.setId(2);
        person2.setName("第二人");
        personService.addPersonRequiredNew(person2);

        Person person3 = new Person();
        person3.setId(3);
        person3.setName("第三人");
        try{
            personService.addPersonExceptionRequiredNew(person3);
        }catch (Exception e){
            System.out.println("存入第三人异常！");
        }

    }

运行结果：

第三条失败，其他成功

在这里插入图片描述

PROPAGATION_REQUIRES_NEW类型事务总结：

对应场景外围方法是否开启事务及事务类型内部方法事务类型是否有异常最终执行结果
3.4.1×均为REQUIRES_NEW外围方法包含异常均成功
3.4.2×均为REQUIRES_NEW内部person方法包含异常user成功，person失败
3.4.3REQUIRED均为REQUIRES_NEW外围方法包含异常均成功
3.4.4REQUIRED1为REQUIRED, 2 3为REQUIRES_NEW外围方法包含异常1失败，2 3成功
3.4.5REQUIRED1为REQUIRED, 2 3为REQUIRES_NEW3方法包含异常2成功，1 3失败
3.4.6REQUIRED1为REQUIRED, 2 3为REQUIRES_NEW3方法包含异常且在外围方法中被try catch3失败，1 2成功

PROPAGATION_REQUIRES_NEW类型事务结论：

(1) 3.4.1，3.4.2和3.4.3说明：
REQUIRES_NEW类型修复的方法会新建事务，内部方法的事务各自执行，互不影响，且内部方法事务不会加入到外围方法事务；

(2) 3.4.4说明：
外围REQUIRED 1为REQUIRED ，所以1和外围方法会在同一个事务，外围方法有异常，所以1必然会回滚，2 3为REQUIRES_NEW，所以2 3会各自建立新的事务，不加入到外围方法事务，所以2 3成功；

(3) 3.4.5说明：
2 3为REQUIRES_NEW会新建事务，虽然不加到外围事务，但是外围是REQUIRED，内部的事务执行异常会传导到外围方法，外围方法发现异常直接回滚，3本身又包含异常，所以3失败，导致外围失败，1方法加入外围事务，所以1也失败，2是内部新建的独立事务，所以成功；

(4) 3.4.6说明：
2 3是独立新建事务，而3有异常，所以2会成功，3失败；而3的异常被外围方法捕获，所以外围不会回滚，正常执行，所以加入到外围事务的1也会成功；

3.5 PROPAGATION_NOT_SUPPORTED类型事务

略

3.6 PROPAGATION_NEVER类型事务

略

3.7 PROPAGATION_NESTED类型事务

3.7.1 外围不开启事务，user，person方法均开启NESTED类型事务，且外围方法有异常

外围代码：

    @Override
    public void noTransactional() {

        User user = new User();
        user.setId(1);
        user.setName("addUser1");
        user.setPwd("123456");
        userService.addUser(user);

        Person person = new Person();
        person.setId(1);
        person.setName("person");
        personService.addPerson(person);

        int i = 1/0;
    }

执行结果：

user表插入成功：

在这里插入图片描述
person表插入成功：

在这里插入图片描述

3.7.2 外围不开启事务，user，person方法均开启NESTED类型事务，且person方法有异常

外围方法：

    @Override
    public void noTransactional() {

        User user = new User();
        user.setId(1);
        user.setName("addUser1");
        user.setPwd("123456");
        userService.addUser(user);

        Person person = new Person();
        person.setId(1);
        person.setName("person");
        personService.addPersonException(person);
    }

执行结果：
user表插入成功：

在这里插入图片描述
person表插入失败：

在这里插入图片描述

3.7.3 外围开启REQUIRED类型事务，user，person方法均开启NESTED类型事务，且外围方法有异常

外围方法：

    @Transactional(propagation = Propagation.REQUIRED,rollbackFor = Exception.class)
    @Override
    public void transactional() {

        User user = new User();
        user.setId(1);
        user.setName("addUser1");
        user.setPwd("123456");
        userService.addUser(user);

        Person person = new Person();
        person.setId(1);
        person.setName("person");
        personService.addPerson(person);

        int i = 1/0;
    }

运行结果：

user表插入失败：

在这里插入图片描述
person表插入失败：

在这里插入图片描述

3.7.4 外围开启REQUIRED类型事务，user，person方法均开启NESTED类型事务，且person方法有异常

外围方法：

    @Transactional(propagation = Propagation.REQUIRED,rollbackFor = Exception.class)
    @Override
    public void transactional() {

        User user = new User();
        user.setId(1);
        user.setName("addUser1");
        user.setPwd("123456");
        userService.addUser(user);

        Person person = new Person();
        person.setId(1);
        person.setName("person");
        personService.addPersonException(person);

    }

运行结果：

user表插入失败：

在这里插入图片描述
person表插入失败：

在这里插入图片描述

3.7.5 外围开启REQUIRED类型事务，user，person方法均开启NESTED类型事务，且person方法有异常在外围方法中捕获

外围方法：

    @Transactional(propagation = Propagation.REQUIRED,rollbackFor = Exception.class)
    @Override
    public void transactional() {

        User user = new User();
        user.setId(1);
        user.setName("addUser1");
        user.setPwd("123456");
        userService.addUser(user);

        Person person = new Person();
        person.setId(1);
        person.setName("person");
        try{
            personService.addPersonException(person);
        }catch (Exception e){
            System.out.println("异常捕获！");
        }
    }

运行结果：

user表插入成功：

在这里插入图片描述
person表插入失败：

在这里插入图片描述

PROPAGATION_NESTED类型事务总结：

对应场景外围方法是否开启事务内部方法事务类型是否包含异常最终执行结果
3.7.1×NESTED类型外围方法包含异常均成功
3.7.2×NESTED类型person包含异常user成功，person失败
3.7.3REQUIREDNESTED类型外围方法包含异常均失败
3.7.4REQUIREDNESTED类型person包含异常均失败
3.7.5REQUIREDNESTED类型person包含异常且在外围方法捕获user成功，person失败

结论：
（1）在外围方法未开启事务的情况下NESTED和REQUIRED作用相同，修饰的内部方法都会新开启自己的事务，且开启的事务相互独立，互不干扰。
（2）在外围方法开启REQUIRED事务的情况下，NESTED修饰的内部方法属于外部事务的子事务，外围主事务回滚，子事务一定回滚，而内部子事务可以单独回滚而不影响外围主事务和其他子事务，这是与REQUIRED的区别；

4. 关于REQUIRED,REQUIRES_NEW,NESTED异同

  1. NESTED 和 REQUIRED 修饰的内部方法都属于外围方法事务，如果外围方法抛出异常，这两种方法的事务都会被回

滚。但是REQUIRED是加入外围方法事务，所以和外围事务同属于一个事务，一旦REQUIRED事务抛出异常被回滚，外围方法

事务也将被回滚。而NESTED是外围方法的子事务，有单独的保存点，所以NESTED方法抛出异常被回滚，不会影响到外围方

法的事务。

  1. NESTED 和 REQUIRES_NEW 都可以做到内部方法事务回滚而不影响外围方法事务。但是因为NESTED是嵌套事

务，所以外围方法回滚之后，作为外围方法事务的子事务也会被回滚。而REQUIRES_NEW是通过开启新的事务实现的，内部

事务和外围事务是两个事务，外围事务回滚不会影响内部事务。

5. 事务传播特性的应用场景

如： 系统在用户注册账号会赠送积分。

那我们是期望注册成功，才会赠送积分，注册失败的话，赠送的积分也要回滚；但是积分赠送失败，不能影响注册的执行流程；另外，假设我们要记录日志，那我们期望不管注册，还是赠送积分是否有异常，都不要回滚日志；

那结合事务传播特性，我们可以这样写：

注册方法：

        @Transactional(propagation = Propagation.REQUIRED,rollbackFor = Exception.class)
        public void register(User user){
            //省略...       
            try {
                //添加积分
                pointService.addPoint(Point point);
            } catch (Exception e) {
               //省略...
            }
            //省略...
        }

添加积分方法：

        @Transactional(propagation = Propagation.NESTED,rollbackFor = Exception.class)
        public void addPoint(Point point){
            //省略...     
            try {
                recordService.addLog(Record record);
            } catch (Exception e) {
               //省略...
            }
            //省略...
        }
        //省略...

记录日志方法：

        @Transactional(propagation = Propagation.NOT_SUPPORTED,rollbackFor = Exception.class)
        public void addLog(Record record){
            //省略...
        }

。
。
。

Java牛马
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring 事务的传播行为
TStana的博客
05-01 607
Spring 事务的传播行为和隔离级别前提： 该事物是同一数据源事务，非分布式事务； 事务的传播行为和隔离级别书针对当前事务设置的； 事务的回滚条件，发生RuntimeException。所以，如果程序有自定义的exception的时候，必须集成RuntimeExcepion ，这样事务才能回滚。 事务的传播行为Spring中事务的定义： 一、Propagation ： 　　key属性确定代理应
Spring事务传播行为详解
刘树之的博客
08-17 586
前言 Spring在TransactionDefinition接口中规定了7种类型的事务传播行为。事务传播行为是Spring框架独有的事务增强(通知)特性，是Spring为我们提供的强大的工具箱，使用事务传播行可以为我们的开发工作提供许多便利。但是人们对他的误解也颇多，你一定也听过“service方法事务最好不要嵌套”的传言。要想正确的使用工具首先需要了解工具。本文对七种事务传播行为做详细介绍，内容主要代码示例的方式呈现。 基础概念 1.什么是事务传播行为？ 事务传播行为用来描述由某一个事务传播行为修饰的方
【Spring学习34】Spring事务(4)：事务属性之7种传播行为
程序老兵的博客
04-20 1万+
事务传播行为什么叫事务传播行为？听起来挺高端的，其实很简单。 即然是传播，那么至少有两个东西，才可以发生传播。单体不存在传播这个行为。事务传播行为（propagation behavior）指的就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行。 例如：methodA事务方法调用methodB事务方法时，methodB是继续在调用者methodA的事务中运行呢，还是为自己开启一个
spring中事务的传播行为详解+业务场景示例
qq_41717518的博客
09-19 1419
这里我先来给大家规整一下代码，涉及事务传播行为要点的是UserServiceImpl的register方法，这里为了后续方便指认，我就称UserServiceImpl的register方法为外围方法。
事务的传播行为
最新发布
qq_47438404的博客
04-25 401
NESTED：子事务出异常，父事务catch住情况下，父事务不会回滚。NESTED：子事务出异常，父事务catch住情况下，父事务不会回滚。NEVER：不支持事务，A方法调用B方法，如果A方法有事务，则B方法会抛出异常。NEVER：不支持事务，A方法调用B方法，如果A方法有事务，则B方法会抛出异常。NOT_SUPPORTED：b方法总是非事务地执行，a方法有事务则会挂起。同一个类中，a方法没有事务，b方法有事务，则b方法事务失效。a方法捕获b方法的异常，a方法不会回滚，而b方法发生回滚。
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种传播行为
glenshappy的专栏
10-14 4263
另一方面, PROPAGATION_NESTED 开始一个 “嵌套的” 事务, 它是已经存在事务的一个真正的子事务. 潜套事务开始执行时, 它将取得一个 savepoint. 如果这个嵌套事务失败, 我们将回滚到此 savepoint. 潜套事务是外部事务的一部分, 只有外部事务结束后它才会被提交。两个事务不是一个真正的嵌套事务。举例说明：有两个事务方法，一个是方法A，一个是方法B，方法A中调用了方法B，那方法B是开启一个事务运行还是在方法A中的事务中运行，是由方法B的事务传播行为控制的。
Spring事务传播行为
m0_73687324的博客
12-09 7778
addUser的事务内嵌addTest的事务，如果addUser异常回滚，那么addTest也会回滚。2.requires_new：如果当前有事务，其他不会加入当前事务，会新增事务。2.requires_new：如果当前有事务，其他不会加入当前事务，会新增事务。addUser没有回滚。当前没有事务抛出异常，当前有事务则支持当前事务。1.required：(默认传播行为)，如果当前有事务，其他就用当前事务，不会新增事务。1.required：(默认传播行为)，如果当前有事务，其他就用当前事务，不会新增事务。
浅谈Spring事务传播行为实战
08-25
浅谈Spring事务传播行为实战 Spring框架提供了事务管理的标准实现，通过注解或者XML文件的方式声明和配置事务。事务管理是指按照给定的事务规则来执行事务的提交或者回滚操作。事务的机制实现很大一部依赖事务日志...
Spring事务传播行为问题解决
08-25
Spring事务传播行为问题解决 Spring事务传播行为问题解决是指在Spring框架中，事务传播行为的配置和使用问题。事务传播行为是指在多个事务方法之间的调用关系，如何去管理和控制事务的传播和回滚。 一、 Spring...
Spring中事务传播行为的介绍
08-26
Spring 中事务传播行为的介绍 Spring 中事务传播行为是指在分布式事务系统中，事务的边界定义和传播规则。在 Spring 框架中，定义了 7 种不同的传播行为，每种行为都有其特点和应用场景。 1. PROPAGATION_...
spring 事务传播 demo
06-05
本示例“spring 事务传播 demo”将聚焦于Spring的事务传播行为，这是在多个方法调用中控制事务边界的关键概念。下面我们将详细讨论相关知识点。 首先，事务传播行为是指当一个被@Transactional注解的方法被另一个@...
Spring中的事务传播行为示例详解
08-25
Spring中的事务传播行为示例详解 Spring 框架中事务传播行为是指在多个方法之间的调用关系中，如何处理事务的传播和rollback的机制。事务传播行为是 Spring 框架提供的一种事务管理方式，用于控制事务的传播范围和...
Spring(1) Spring的7种事务传播行为
ACGkaka的博客
03-07 2306
Spring（一）Spring的7种事务传播行为
详解事务的7种传播行为
热门推荐
卓越无关环境，保持空杯心态——靡不有初，鲜克有终
04-11 5万+
什么是Spring事务的传播行为？事务传播行为的七种类型有哪些？将异常try-catch捕获，事务是否还会回滚？
案例挑战——事务传播行为
理想主义的花最终会盛开在浪漫主义的土壤里，我的热情永远不会熄灭在现实的平凡之中，我们终将上岸，阳光万里。
07-05 500
此前在项目开发过程中，使用到了事务的传播行为。但是大多数情况下都是使用的事务默认的传播行为required。但是其实还有其他的传播行为。所以特地的回顾和学习了事务的多种传播行为。本篇博客从5w2h的角度来对事务的传播行为进行学习和实践。事务的传播行为其实指的是事务在多个方法之间的传播方式和规则。例如：当一个方法调用另一个方法时，如果这两个方法都涉及事务操作，事务的传播行为定义了如何处理这些嵌套的事物，以及事务如何在方法调用之间传播和管理。
Spring 事务传播行为
weixin_42278603的博客
05-10 3889
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 随着spring框架的不断发展，spring框架也越来越重要，很多人都开启了spring框架学习，本文就介绍了spring框架中的一个基础内容------spring事务传播行为。 一、spring事务传播行为是什么？ 事务传播行为指的就是当一个事务方法（当前事务）被另一个事务方法（调用者）调用时，...
spring的事务传播行为有哪些？
06-01
Spring中的事务传播行为指的是在一个事务方法调用另一个事务方法时，如何处理这两个事务的关系。常见的事务传播行为有以下几种： 1. REQUIRED：如果当前没有事务，则创建一个新事务；如果当前存在事务，则加入该事务。 2. SUPPORTS：如果当前存在事务，则加入该事务；如果当前不存在事务，则以非事务执行。 3. MANDATORY：如果当前存在事务，则加入该事务；如果当前不存在事务，则抛出异常。 4. REQUIRES_NEW：创建一个新事务，并且暂停当前事务（如果存在）。 5. NOT_SUPPORTED：以非事务执行，并且暂停当前事务（如果存在）。 6. NEVER：以非事务执行，如果当前存在事务，则抛出异常。 7. NESTED：如果当前存在事务，则在该事务中开启一个嵌套事务；如果当前不存在事务，则创建一个新事务。嵌套事务可以独立提交或回滚，但必须在外部事务的提交或回滚时一起提交或回滚。 以上就是常用的Spring事务传播行为。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值