Spring事物的传播属性

最新推荐文章于 2022-08-20 09:34:02 发布
最新推荐文章于 2022-08-20 09:34:02 发布
阅读量147 收藏 1
点赞数
分类专栏： springmvc 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhumengguang/article/details/116073433
版权

事物：
是数据库操作的最小工作单元，是作为单个逻辑工作单元执行的一系列操作；
这些操作作为一个整体一起向系统提交，要么都执行，要么都不执行，事物时一组不可再分割的操作集合（工作逻辑单元）
在这里插入图片描述
在这里插入图片描述

Transactional

没有开启事物之前，运行代码，如果代码中出现异常，异常前进行的数据库操作会保存到
数据库中，异常后进行的数据库操作不会保存到数据库中

Propagation属性：

REQUIRED：
使用当前的事务，如果当前没有事务，则自己新建一个事务，子方法是必须运行在一个事务中的；
如果当前存在事务，则加入这个事务，成为一个整体。


// 父类service方法
    @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public void testPropagationTrans() {
         stuService.saveParent();
         stuService.saveChildren();
       
    }

// 子类service方法
     public void saveParent() {
        Stu stu = new Stu();
        stu.setName("parent");
        stu.setAge(19);
        stuMapper.insert(stu);
    }
     public void saveChildren() {
        saveChild1();
        int a = 1 / 0;
        saveChild2();
    }
    // 父类方法中添加 事物注解，子类方法中出现异常整体都会回滚

   // 父类service方法
    @Override
    public void testPropagationTrans() {
         stuService.saveParent();
         stuService.saveChildren();
       
    }

// 子类service方法
     public void saveParent() {
        Stu stu = new Stu();
        stu.setName("parent");
        stu.setAge(19);
        stuMapper.insert(stu);
    }
     @Transactional(propagation = Propagation.REQUIRED)
     public void saveChildren() {
        saveChild1();
        int a = 1 / 0;
        saveChild2();
    }
    // 子类方法添加事物注解，当前子类方法回滚，父类方法没有事物注解代码不会回滚

  // 父类service方法
   @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public void testPropagationTrans() {
         stuService.saveParent();
         stuService.saveChildren();
       
    }

// 子类service方法
     public void saveParent() {
        Stu stu = new Stu();
        stu.setName("parent");
        stu.setAge(19);
        stuMapper.insert(stu);
    }
     @Transactional(propagation = Propagation.REQUIRED)
     public void saveChildren() {
        saveChild1();
        int a = 1 / 0;
        saveChild2();
    }
    // 父类方法添加事物注解，当前父类方法回滚，子类方法也有事物注解同样回滚

SUPPORTS：
如果当前有事务，则使用事务；如果当前没有事务，则不使用事务。
主要使用查询

 // 父类service方法
    @Override
    public void testPropagationTrans() {
         stuService.saveParent();
         stuService.saveChildren();
       
    }

// 子类service方法
     public void saveParent() {
        Stu stu = new Stu();
        stu.setName("parent");
        stu.setAge(19);
        stuMapper.insert(stu);
    }
     @Transactional(propagation = Propagation.SUPPORTS)
     public void saveChildren() {
        saveChild1();
        int a = 1 / 0;
        saveChild2();
    }
    // 父类方法无事物，父类方法不回滚，子类方式使用SUPPORTS，异常前方法不回滚

// 父类service方法
    @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public void testPropagationTrans() {
         stuService.saveParent();
         stuService.saveChildren();
       
    }

// 子类service方法
     public void saveParent() {
        Stu stu = new Stu();
        stu.setName("parent");
        stu.setAge(19);
        stuMapper.insert(stu);
    }
     @Transactional(propagation = Propagation.SUPPORTS)
     public void saveChildren() {
        saveChild1();
        int a = 1 / 0;
        saveChild2();
    }
    // 父类方法使用REQUIRED，父类方法回滚，子类方式使用SUPPORTS，方法回滚

MANDATORY：
该传播属性强制必须存在一个事务，如果不存在，则抛出异常

 
    @Override
    public void testPropagationTrans() {
         stuService.saveParent();
         stuService.saveChildren();
       
    }

// 子类service方法
     public void saveParent() {
        Stu stu = new Stu();
        stu.setName("parent");
        stu.setAge(19);
        stuMapper.insert(stu);
    }
     @Transactional(propagation = Propagation.MANDATORY)
     public void saveChildren() {
        saveChild1();
        int a = 1 / 0;
        saveChild2();
    }
    // 父类方法无事物，子类方式使用MANDATORY，直接抛出无事物异常


  @Transactional(propagation = Propagation.REQUIRED)
  @Override
    public void testPropagationTrans() {
         stuService.saveParent();
         stuService.saveChildren();
       
    }

// 子类service方法
     public void saveParent() {
        Stu stu = new Stu();
        stu.setName("parent");
        stu.setAge(19);
        stuMapper.insert(stu);
    }
     @Transactional(propagation = Propagation.MANDATORY)
     public void saveChildren() {
        saveChild1();
        int a = 1 / 0;
        saveChild2();
    }
    // 父类方法有事物，子类方式使用MANDATORY，直接抛出无事物异常

REQUIRES_NEW：
如果当前有事务，则挂起该事务，并且自己创建一个新的事务给自己使用；
如果当前没有事务，则同 REQUIRED

  @Override
    public void testPropagationTrans() {
         stuService.saveParent();
         stuService.saveChildren();
       
    }

// 子类service方法
     public void saveParent() {
        Stu stu = new Stu();
        stu.setName("parent");
        stu.setAge(19);
        stuMapper.insert(stu);
    }
     @Transactional(propagation = Propagation.REQUIRES_NEW)
     public void saveChildren() {
        saveChild1();
        int a = 1 / 0;
        saveChild2();
    }
    // 父类方法无事物，子类方式使用REQUIRES_NEW，saveParent()保存到数据库 saveChildren() 回滚

  @Transactional(propagation = Propagation.REQUIRED)
  @Override
    public void testPropagationTrans() {
         stuService.saveParent();
         stuService.saveChildren();
       
    }

// 子类service方法
     public void saveParent() {
        Stu stu = new Stu();
        stu.setName("parent");
        stu.setAge(19);
        stuMapper.insert(stu);
    }
     @Transactional(propagation = Propagation.REQUIRES_NEW)
     public void saveChildren() {
        saveChild1();
        int a = 1 / 0;
        saveChild2();
    }
    // 父类方法有自己事物，子类方式使用REQUIRES_NEW新建事物，两个事物saveParent()回滚 saveChildren() 回滚

 @Transactional(propagation = Propagation.REQUIRED)
  @Override
    public void testPropagationTrans() {
         stuService.saveParent();
         stuService.saveChildren();
       int a = 1 / 0;
    }

// 子类service方法
     public void saveParent() {
        Stu stu = new Stu();
        stu.setName("parent");
        stu.setAge(19);
        stuMapper.insert(stu);
    }
     @Transactional(propagation = Propagation.REQUIRES_NEW)
     public void saveChildren() {
        saveChild1();
        
        saveChild2();
    }
    // 父类方法有自己事物，子类方式使用REQUIRES_NEW新建事物，两个事物saveParent()回滚 saveChildren()保存到数据库

 @Transactional(propagation = Propagation.REQUIRED)
  @Override
    public void testPropagationTrans() {
         stuService.saveParent();
         stuService.saveChildren();
       int a = 1 / 0;
    }

// 子类service方法
     public void saveParent() {
        Stu stu = new Stu();
        stu.setName("parent");
        stu.setAge(19);
        stuMapper.insert(stu);
    }
     @Transactional(propagation = Propagation.REQUIRED)
     public void saveChildren() {
        saveChild1();
        
        saveChild2();
    }
    // 父类方法有自己事物，子类方式使用REQUIRES 公用一个事物 saveParent()回滚 saveChildren()回滚 都不能保存到数据库

NOT_SUPPORTED：
如果当前有事务，则把事务挂起，自己不使用事务去运行数据库操作

  @Override
    public void testPropagationTrans() {
         stuService.saveParent();
         stuService.saveChildren();
    
    }

// 子类service方法
     public void saveParent() {
        Stu stu = new Stu();
        stu.setName("parent");
        stu.setAge(19);
        stuMapper.insert(stu);
    }
     @Transactional(propagation = Propagation.NOT_SUPPORTED)
     public void saveChildren() {
        saveChild1();
           int a = 1 / 0;
        saveChild2();
    }
    // 父类方法无事物，子类方式使用NOT_SUPPORTED 相当于无事物   saveParent()不回滚 saveChild1()不回滚异常前保存到数据库


@Transactional(propagation = Propagation.REQUIRED)
 @Override
    public void testPropagationTrans() {
         stuService.saveParent();
         stuService.saveChildren();
    
    }

// 子类service方法
     public void saveParent() {
        Stu stu = new Stu();
        stu.setName("parent");
        stu.setAge(19);
        stuMapper.insert(stu);
    }
     @Transactional(propagation = Propagation.NOT_SUPPORTED)
     public void saveChildren() {
        saveChild1();
           int a = 1 / 0;
        saveChild2();
    }
    // 父类方法有事物，子类方式使用NOT_SUPPORTED 相当于无事物   saveParent()回滚 saveChild1()不回滚，saveChild1()保存到数据库

NEVER：
如果当前有事务存在，则抛出异常

@Transactional(propagation = Propagation.REQUIRED)
 @Override
    public void testPropagationTrans() {
         stuService.saveParent();
         stuService.saveChildren();
    
    }

// 子类service方法
     public void saveParent() {
        Stu stu = new Stu();
        stu.setName("parent");
        stu.setAge(19);
        stuMapper.insert(stu);
    }
     @Transactional(propagation = Propagation.NEVER)
     public void saveChildren() {
        saveChild1();
           int a = 1 / 0;
        saveChild2();
    }
    // 父类方法有事物，子类方式使用NEVER 报发现事物异常，不允许使用事物，不会保存到数据库

 @Override
    public void testPropagationTrans() {
         stuService.saveParent();
         stuService.saveChildren();
    }

// 子类service方法
     public void saveParent() {
        Stu stu = new Stu();
        stu.setName("parent");
        stu.setAge(19);
        stuMapper.insert(stu);
    }
     @Transactional(propagation = Propagation.NEVER)
     public void saveChildren() {
        saveChild1();
           int a = 1 / 0;
        saveChild2();
    }
    // 父类方法无事物，子类方式使用NEVER 报除数为0异常，异常前代码数据保存到数据库，无回滚

NESTED：
如果当前有事务，则开启子事务（嵌套事务），嵌套事务是独立提交或者回滚；
如果当前没有事务，则同 REQUIRED。
但是如果主事务提交，则会携带子事务一起提交。
如果主事务回滚，则子事务会一起回滚。相反，子事务异常，则父事务可以回滚或不回滚。

@Transactional(propagation = Propagation.REQUIRED)
@Override
    public void testPropagationTrans() {
         stuService.saveParent();
         stuService.saveChildren();
           int a = 1 / 0;
    }

// 子类service方法
     public void saveParent() {
        Stu stu = new Stu();
        stu.setName("parent");
        stu.setAge(19);
        stuMapper.insert(stu);
    }
     @Transactional(propagation = Propagation.NESTED)
     public void saveChildren() {
        saveChild1();
        saveChild2();
    }
    // 父类方法有事物，子类方式使用NESTED ，报除数为0异常，事物回滚，数据没保存到数据库

@Transactional(propagation = Propagation.REQUIRED)
    @Override
    public void testPropagationTrans() {
        stuService.saveParent();

        try {
            // save point
            stuService.saveChildren();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
     public void saveParent() {
        Stu stu = new Stu();
        stu.setName("parent");
        stu.setAge(19);
        stuMapper.insert(stu);
    }
    @Transactional(propagation = Propagation.NESTED)
    public void saveChildren() {
        saveChild1();
        int a = 1 / 0;
        saveChild2();
    }
        // 父类方法有事物，子类方式使用NESTED ，父方法catch住异常，子事物回滚，父事物可以不回滚
散_步
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring事务传播属性和隔离级别详细介绍
08-29
主要介绍了Spring事务传播属性和隔离级别详细介绍，同时涉及传播行为介绍，超时设置等相关内容，需要的朋友可以参考下。
事务的传播属性、隔离级别等以及在Spring中的设置
qq_50313418的博客
03-07 1915
1. 事务的传播属性 # 事务传播属性 事务传播：就是在多个业务层之间相互调用时传递事务的过程称之为事务传播 将事务对象在业务层之间进行传递的过程 （本来不同的业务层是不同的事务对象，那么我们在一个业务层就不能调用其他业务层的方法了，但是spring框架提供了 事务传播属性，可以在一个事务层调用其他事务层的方法时将事务对象也传递过去，这样即使调用了别的事务层，但是由于 事务对象是一样的，那么这就成为了一个原子操作，这样这两个（多个）事务要么一起成功，要么有一
事物的传播属性
曾令胜的博客
04-16 432
一、事物的传播属性 传播属性 当前不存在事物 当前存在事物 REQUIRED 新建事物 使用当前事物 REQUIRES_NEW 新建事物 挂起当前事物，新建事物 SUPPORTS 不使用事物 使用当前事物 NOT_SUPPORTED 不使用事物 挂起当前事物 MANDATORY 抛出异常 使用当前事物 NEVER 不使用事物 抛出异常 NESTED 新建事物...
Spring 事务及传播属性
TianH_legend的博客
08-20 684
Spring 事务及传播属性
Spring事务传播属性
qq_21696621的博客
04-14 154
/** * 事务传播 - Propagation * REQUIRED: 使用当前的事务，如果当前没有事务，则自己新建一个事务，子方法是必须运行在 * 一个事务中，如果当前存在事务，则加入这个事务，成为一个整体 * SUPPORTS: * MANDATORY: * MEQUIRES_NEW: * NOT_SUPPORTED: * NEVER: * NESTED: */ REQUIRED例子： UserServiceImpl.java @Override...
spring的两种常用事务传播属性说明
qianxiaopeng的专栏
09-18 1万+
常用的两种传播属性： 1.REQUIRED 如果存在当前事务则用当前事务，如果不存在当前事务，则新建一个事务 2.REQUIRES_NEW 如果当前存在事务则挂起当前事务，开启一个新事务，新事务执行完毕后，唤醒之前挂起的事务，继续执行。如果不存在当前事务，则新建一个事务 第一种情况： 执行controller以后事务会回滚，两条数都插不进去。（propagation如果不写默认的是...
Spring中事务的传播属性详解
03-11
Spring中事务的传播属性详解,Spring中事务的传播属性详解
spring常用数据库事务传播属性和事务隔离级别1
08-08
事务的属性：1.Propagation：用来设置事务的传播行为事务的传播行为：一个方法运行在了一个开启了事务的方法中时，当前方法是使用原来的事务还是开启了一个新
spring 事务传播
02-27
系统理解spring事务传播属性，和隔离级别
spring事物的七种事物传播属性行为及五种隔离级别
denglu2912的博客
12-19 279
首先,说说什么事务（Transaction）。 事务，就是一组操作数据库的动作集合。事务是现代数据库理论中的核心概念之一。如果一组处理步骤或者全部发生或者一步也不执行，我们称该组处理步骤为一个事务。当所有的步骤像一个操作一样被完整地执行，我们称该事务被提交。由于其中的一部分或多步执行失败，导致没有步骤被提交，则事务必须回滚到最初的系统状态。 其中spring七个事物传播属性： ...
spring事务的七种传播属性和五种隔离级别
浮生一梦
07-06 5619
事务定义 事务，就是一组操作数据库的动作集合。事务是现代数据库理论中的核心概念之一。如果一组处理步骤或者全部发生或者一步也不执行，我们称该组处理步骤为一个事务。当所有的步骤像一个操作一样被完整地执行，我们称该事务被提交。由于其中的一部分或多步执行失败，导致没有步骤被提交，则事务必须回滚到最初的系统状态。 事务特点 1.原子性：一个事务中所有对数据库的操作是一个不可分割的操作序列，
Spring-事务的传播属性（六）
piaoslowly的专栏
08-16 1万+
Spring-事务的传播属性（六） 事务的传播属性概述 所谓spring事务的传播属性，就是定义在存在多个事务同时存在的时候，spring应该如何处理这些事务的行为。这些属性在TransactionDefinition中定义，具体常量的解释见下： Propagation.REQUIRED（required）：支持当前事务，如果当前有事务， 那么加入事务， 如果当前没有事务则新建一个(默...
习题4：Spring事物的隔离级别
小狮王的专栏
10-25 430
1 事务的传播属性（Propagation）1) REQUIRED ，这个是默认的属性 Support a current transaction, create a new one if none exists. 如果存在一个事务，则支持当前事务。如果没有事务则开启一个新的事务。 被设置成这个级别时，会为每一个被调用的方法创建一个逻辑事务域。如果前面的方法已经创建了事务，那么后面的方法
事务的7种传播特性
热门推荐
weixin_41313504的博客
12-11 2万+
Propagation （事务的传播属性） Propagation ：　　key属性确定代理应该给哪个方法增加事务行为。这样的属性最重要的部份是传播行为。有以下选项可供使用：PROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。 PROPAGATION_SUPPORTS--支持当前事务，如果当前没有事务，就以非事务方式执行。 PRO
Spring事务的传播特性
Q
07-23 1万+
Spring中通过Propagation来设置事务的传播属性的，在这个属性中提供了我们其中关于事务传播的特性：        1.     PROPAGATION_REQUIRED：支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。        2.     PROPAGATION_SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行。         3.
事务的传播属性
she_smiled的博客
04-20 321
在配置ssm的applicationContext-trans.xml文件的时候涉及到了事务的传播属性：<!-- 通知 --> <tx:advice id="txAdvice" transaction-manager="transactionManager"> <tx:attributes> <!-- 传播行为 --> <tx:met
sring 的事务管理
07-09 105
REQUIRED：业务方法需要在一个事务中运行。如果方法运行时，已经处在一个事务中，那么加入到该事务，否则为自己创建一个新的事务。 NOT_SUPPORTED：声明方法不需要事务。如果方法没有关联到一个事务，容器不会为它开启事务。如果方法在一个事务中被调用，该事务会被挂起，在方法调用结束后，原先的事务便会恢复执行。 REQUIRESNEW：属性表明不管是否存在事务，业务方法总会为自己发起一个新...
深入浅出事务之传播属性
caomiao2006的专栏
08-25 4508
本文参考《java Transaction design strategies》 大部分时候，我们都习惯了spring容器默认的配置，但有时候，我们需要知道更多…… 当使用声明式事务模型时，您必须告诉容器如何去管理事务，例如，何时开启一个事务？哪些方法需要事务？当前不存在事务的情况下，容器是否需要为其添加事务控制？事实上，Spring提供了一个bean ——Transactio
spring 事务传播机制
最新发布
10-09
Spring的事务传播机制用于定义在一个事务方法调用另一个事务方法时，如何处理事务的边界。事务传播机制可以通过设置`@Transactional`注解的`propagation`属性来指定。 常见的事务传播机制包括： 1. `REQUIRED`：...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值