Spring的七种事务

最新推荐文章于 2024-05-22 10:00:08 发布
最新推荐文章于 2024-05-22 10:00:08 发布
阅读量2.4k 收藏 7
点赞数 1
分类专栏： MySQL 文章标签： java 数据库 mysql spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42313773/article/details/118606908
版权

官方文档注释说明七种事务

PROPAGATION_REQUIRED

image-20210709144540449

支持当前事务，如果不存在则创建一个新事务。最常用的选择

场景一：外部不开启事务
@Service
public class User1ServiceImpl implements User1Service {
    //省略其他...
    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void addRequired(User1 user){
        user1Mapper.insert(user);
    }
}
@Service
public class User2ServiceImpl implements User2Service {
    //省略其他...
    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void addRequired(User2 user){
        user2Mapper.insert(user);
    }
    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void addRequiredException(User2 user){
        user2Mapper.insert(user);
        throw new RuntimeException();
    }

}

验证方法一、

@Override
public void notransaction_exception_required_required(){
    User1 user1=new User1();
    user1.setName("张三");
    user1Service.addRequired(user1);

    User2 user2=new User2();
    user2.setName("李四");
    user2Service.addRequired(user2);

    throw new RuntimeException();
}

验证方法二、

    @Override
    public void notransaction_required_required_exception(){
        User1 user1=new User1();
        user1.setName("张三");
        user1Service.addRequired(user1);

        User2 user2=new User2();
        user2.setName("李四");
        user2Service.addRequiredException(user2);
    }

方法1、2的抛出异常位置不同

output

一：张三、李四均插入成功。各自进行事务，异常在外抛出，不影响单独事务。

二：张三成功，李四不成功，李四自己方法抛出异常回滚。

结论：在外围方法未开启事务的情况下，PROPAGATION_REQUIRED修饰的内部方法会新开启自己的事务，且开启的事务相互独立，互不干扰。

PROPAGATION_REQUIRED

场景2：外部开启事务

开发中使用较高的场景（默认情况）

   @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void transaction_exception_required_required(){
        User1 user1=new User1();
        user1.setName("张三");
        user1Service.addRequired(user1);

        User2 user2=new User2();
        user2.setName("李四");
        user2Service.addRequired(user2);

        throw new RuntimeException();
    }

output

结论：外围开启事务，出现异常均回滚。原因是外围开启事务，PROPAGATION_REQUIRED修饰的所有内部方法会加入到外围方法的事务中，内部事务和外部事务均属于同一个事务。

PROPAGATION_REQUIRES_NEW

image-20210708212446958

创建一个新事务，如果当前事务存在，则暂停当前事务

场景一：外部不开启事务

Service1

@Service
public class User1ServiceImpl implements User1Service {
    //省略其他...
    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void addRequiresNew(User1 user){
        user1Mapper.insert(user);
    }
    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void addRequired(User1 user){
        user1Mapper.insert(user);
    }
}

Service2

@Service
public class User2ServiceImpl implements User2Service {
    //省略其他...
    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void addRequiresNew(User2 user){
        user2Mapper.insert(user);
    }
    
    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void addRequiresNewException(User2 user){
        user2Mapper.insert(user);
        throw new RuntimeException();
    }
}

验证方法一、

    @Override
    public void notransaction_exception_requiresNew_requiresNew(){
        User1 user1=new User1();
        user1.setName("张三");
        user1Service.addRequiresNew(user1);
        
        User2 user2=new User2();
        user2.setName("李四");
        user2Service.addRequiresNew(user2);
        throw new RuntimeException();
    }

验证方法二、

    @Override
    public void notransaction_requiresNew_requiresNew_exception(){
        User1 user1=new User1();
        user1.setName("张三");
        user1Service.addRequiresNew(user1);
        
        User2 user2=new User2();
        user2.setName("李四");
        user2Service.addRequiresNewException(user2);
    }

验证方法1：外围方法没有事务，插入“张三”、“李四”方法都在自己的事务中独立运行,外围方法抛出异常回滚不会影响内部方法。

验证方法2：张三正常插入，李四无法插入，李四在自己的方法中开启新事务，但是抛出异常回滚。

场景2：外部开启事务

验证方法1：

    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void transaction_exception_required_requiresNew_requiresNew(){
        User1 user1=new User1();
        user1.setName("张三");
        user1Service.addRequired(user1);
        
        User2 user2=new User2();
        user2.setName("李四");
        user2Service.addRequiresNew(user2);
        
        User2 user3=new User2();
        user3.setName("王五");
        user2Service.addRequiresNew(user3);
        throw new RuntimeException();
    }

验证方法2：

    @Override
    @Transactional(propagation = Propagation.REQUIRED)
    public void transaction_required_requiresNew_requiresNew_exception(){
        User1 user1=new User1();
        user1.setName("张三");
        user1Service.addRequired(user1);
        
        User2 user2=new User2();
        user2.setName("李四");
        user2Service.addRequiresNew(user2);
        
        User2 user3=new User2();
        user3.setName("王五");
        user2Service.addRequiresNewException(user3);
    }

验证方法3：

@Override
@Transactional(propagation = Propagation.REQUIRED)
public void transaction_required_requiresNew_requiresNew_exception_try(){
    User1 user1=new User1();
    user1.setName("张三");
    user1Service.addRequired(user1);
    
    User2 user2=new User2();
    user2.setName("李四");
    user2Service.addRequiresNew(user2);
    User2 user3=new User2();
    user3.setName("王五");
    try {
        user2Service.addRequiresNewException(user3);
    } catch (Exception e) {
        System.out.println("回滚");
    }
}

结论：外围方法开启事务的情况下，**Propagation.REQUIRES_NEW**修饰的内部方法全部单独开启独立事务，不同的内部方法、外部事务间相互独立，互不干扰。

Propagation.NESTED

image-20210709135237991

如果当前事务存在，则在嵌套事务中执行。

@Service1

@Service
public class User1ServiceImpl implements User1Service {
    //省略其他...
    @Override
    @Transactional(propagation = Propagation.NESTED)
    public void addNested(User1 user){
        user1Mapper.insert(user);
    }
}

@Service2

@Service
public class User2ServiceImpl implements User2Service {
    //省略其他...
    @Override
    @Transactional(propagation = Propagation.NESTED)
    public void addNested(User2 user){
        user2Mapper.insert(user);
    }
    
    @Override
    @Transactional(propagation = Propagation.NESTED)
    public void addNestedException(User2 user){
        user2Mapper.insert(user);
        throw new RuntimeException();
    }
}
场景一：外围方法没有开启事务

验证方法一、

  @Override
  public void notransaction_exception_nested_nested(){
    User1 user1=new User1();
    user1.setName("张三");
    user1Service.addNested(user1);

    User2 user2=new User2();
    user2.setName("李四");
    user2Service.addNested(user2);
    throw new RuntimeException();
  }

验证方法二、

    @Override
    public void notransaction_required_required_exception(){
        User1 user1=new User1();
        user1.setName("张三");
        user1Service.addRequired(user1);

        User2 user2=new User2();
        user2.setName("李四");
        user2Service.addRequiredException(user2);
    }

方法一均插入，张三、李四是在各自的独立事务中运行。

方法二张三插入，李四未插入，李四报异常回滚。两者事务独立，不影响张三。

场景2：外围开启事务

验证方法一、

@Transactional
@Override
public void transaction_exception_nested_nested(){
    User1 user1=new User1();
    user1.setName("张三");
    user1Service.addNested(user1);
    
    User2 user2=new User2();
    user2.setName("李四");
    user2Service.addNested(user2);
    throw new RuntimeException();
}

验证方法二、

@Transactional
@Override
public void transaction_nested_nested_exception(){
    User1 user1=new User1();
    user1.setName("张三");
    user1Service.addNested(user1);
    
    User2 user2=new User2();
    user2.setName("李四");
    user2Service.addNestedException(user2);
}

验证方法三、

@Transactional
@Override
public void transaction_nested_nested_exception_try(){
    User1 user1=new User1();
    user1.setName("张三");
    user1Service.addNested(user1);
    
    User2 user2=new User2();
    user2.setName("李四");
    try {
        user2Service.addNestedException(user2);
    } catch (Exception e) {
        System.out.println("方法回滚");
    }
}

验证1，2由于外部开启事务，内部嵌套事务相当于外部事务的子事务，子事务回滚影响外部事务回滚。

验证方法3：张三插入，李四未插入，内部事务为外围事务的子事务，外围方法开启事务，插入“李四”内部方法抛出异常，可以单独对子事务回滚。

结论：外围方法开启事务的情况下**Propagation.NESTED**修饰的内部方法属于外部事务的子事务，外围主事务回滚，子事务一定回滚，而内部子事务可以单独回滚而不影响外围主事务和其他子事务。

Spring中七种事务传播行为

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

原文链接

爱叨叨的程序狗
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
实战Spring中的八大事务
技术篮子
11-27 1278
一、测试前的准备 数据表结构： 1. StuService package com.ybqdren.service; import com.ybqdren.pojo.Stu; /** * Wen(Joan) Zhao <withzhaowen@126.com> * 2021/9/15 */ public interface StuService { public Stu getStuInfo(int id); public void saveStu();
Spring框架+Spring中的事务
03-22
Spring事务传播机制可以通过Propagation枚举类中的不同值来指定，共包括七种不同的传播行为。具体来说，Spring事务传播机制包括以下七种： REQUIRED：如果当前没有事务，则创建一个新的事务；如果当前已经存在事务，...
Spring中事务的种类
cathline1117的博客
08-13 5871
事务传播行为种类 Spring在TransactionDefinition接口中规定了7种类型的事务传播行为， 它们规定了事务方法和事务方法发生嵌套调用时事务如何进行传播： 事务传播行为类型 说明 PROPAGATION_REQUIRED： 如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。这是最常见的选择。 PROPAGATION_SUPPORTS： 支...
Spring 事务介绍
HelloiChen的博客
12-08 621
spring 事务
Spring事务
最新发布
2302_82270778的博客
05-22 884
事务就是一组操作的集合，是一个不可分割的操作，事务会把所有的操作作为一个整体，一起向数据库提交或者撤销操作请求，要么同时成功，要么同时失败。
Spring事务分类和传播特性
ChengZi~
10-08 475
Spring2事务分类和传播特性   
Spring事务类型祥解
热门推荐
陈建慧程序人生
12-30 1万+
 大家可能在spring中经常看到这样的定义： PROPAGATION_REQUIRED,readOnlyPROPAGATION_REQUIRED估计有好多朋友还没有弄清楚里面的值的意思，仔细看完下面应该知道自己什么情况下面应该使用什么样的声明。^_^ Spring中常用事务类型：PROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个
浅谈Spring的两种事务定义方式
08-29
浅谈Spring的两种事务定义方式 Spring框架提供了两种事务定义方式：声明式和注解式。下面我们将深入探讨这两种方式的实现和应用。 声明式事务 声明式事务是通过在XML文件中定义需要拦截方法的匹配来完成配置的。...
Spring事务处理原理步骤详解
08-19
Spring事务处理原理步骤详解 Spring事务处理原理步骤详解是指在Spring框架中实现事务处理的整个过程，它涉及到事务处理的实现、事务处理原理和事务管理器的配置等几个方面。下面是Spring事务处理原理步骤详解的知识...
深入理解Spring事务原理
09-02
Spring事务管理是Spring框架的核心特性之一，它使得开发者能够在应用层面上轻松地处理数据库事务，无需直接接触底层的事务控制。本文将深入探讨Spring事务原理，包括事务的基本概念、Spring事务的传播属性、数据库...
spring声明式事务解析
09-01
1.1 Spring事务管理器 Spring并不直接管理事务，而是利用JTA（Java Transaction API）或者特定持久层技术（如JDBC、JPA、Hibernate等）提供的事务实现。Spring通过AOP（面向切面编程）来实现事务管理，创建代理对象...
Spring事务的分类，原理以及注意事项
tabeWell的博客
04-21 1092
1.分类： a.声明事务 b.编程事务 2.原理 AOP技术 环绕通知进行拦截 3.注意事项 不要try，因为要将异常抛出给外层 springboot中添加事务的时候如下： 加上@Transactional的用处，会使得insertUser这个方法彻底执行完毕以后才会提交事务， 期间如果异常则会回滚，数据就不会插入到数据库了。 ...
Spring事务TransactionProxyFactoryBean属性-transactionAttributes的意义
走马观花
02-20 717
http://g.kehou.com/t1033026846.html PROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。  PROPAGATION_SUPPORTS--支持当前事务，如果当前没有事务，就以非事务方式执行。  PROPAGATION_MANDATORY--支持当前事务，如果当前没有事务，就抛出异常。  PROPAG
Spring中使用事务的常用几种方式
晨猫
08-27 4262
Spring中使用事务的常用几种方式1. 使用TransactionTemplate手动提交事务spring配置业务代码2. 使用TransactionProxyFactoryBean代理提交事务spring配置业务代码功能代码3. 使用AOP配置事务（常用）spring配置业务代码功能代码4. 注解方式（常用）spring配置业务代码功能代码案例代码 1. 使用TransactionTempla...
Spring事务分类
不认输的我
04-23 989
 Spring的事务传播规则：     Spring的事务传播分为以下几种：PROPAGATION_MANDATORY,PROPAGATION_NESTED,PROPAGATION_NEVER,PROPAGATION_NOT_SUPPORTED,PROPAGATION_REQUIRED,PROPAGATION_REQUIRES_NEW,PROPAGATION_SUPPORTS.    
spring的事务管理器有几种
lzf的博客
07-26 3533
接下来让我们学习一下如何在Spring配置文件中定义事务管理器： 声明对本地事务的支持： a)JDBC及iBATIS、MyBatis框架事务管理器 bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> property name="dataSource
在spring中有几种事务管理，分别是什么?
jardownload的博客
08-12 492
代码管理的事务处理 TransactonTemplate的execute方法中的内部类TransactionCallback中的doInTransaction方法中使用。 public void make()  {    TransactionTemplate jtm=new TransactionTemplate(this.getTransactionManager());   jtm.exec...
Spring事务管理的三种简单方法
mrzhangtufu2的专栏
09-12 119
如有一代表用户的域对象User:package com.domain;import java.io.Serializable;public class User implements Serializable{    private int user_id;    private String user_name;    private String user_password;    priva...
Spring事务的七种传播
07-27
Spring事务的七种传播行为是： 1. REQUIRED：如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。 2. SUPPORTS：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式执行。 3. MANDATORY：如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。 4. REQUIRES_NEW：创建一个新的事务，并挂起当前事务（如果存在）。 5. NOT_SUPPORTED：以非事务的方式执行操作，如果当前存在事务，则挂起该事务。 6. NEVER：以非事务的方式执行操作，如果当前存在事务，则抛出异常。 7. NESTED：如果当前存在事务，则在嵌套事务内执行；如果当前没有事务，则创建一个新的事务。 这些传播行为可以通过在方法上使用`@Transactional`注解来指定。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值