Spring的7种事务传播行为类型

最新推荐文章于 2024-01-04 10:34:48 发布
最新推荐文章于 2024-01-04 10:34:48 发布
阅读量624 收藏
点赞数
分类专栏： Database 文章标签： 事务传播行为

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类似的操作。

罗列了7种spring的事务传播行为，我们具体来看看它的实现。在这里，我们使用spring annotation注解实现事务。

实现事务的类BusinessServiceImpl

package com.aop;
 
import org.springframework.aop.support.AopUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
 
import com.entity.Student;
 
@Service("businessSerivce")
public class BusinessServiceImpl implements IBaseService {
 
    @Autowired
    IStudentDao studentDao;
 
    @Autowired
    IBaseServiceB baseServiceb;
 
    @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT, rollbackFor = Exception.class)
    public String doA() throws Exception {
        Student st = new Student();
        st.setId(1);
        st.setSex("girl");
        st.setUsername("zx");
        studentDao.insertStudent(st);
 
        System.out.println(baseServiceb);
        System.out.println("是否是代理调用，AopUtils.isAopProxy(baseServiceb) : " + AopUtils.isAopProxy(baseServiceb));
        System.out
                .println("是否是cglib类代理调用，AopUtils.isCglibProxy(baseServiceb) : " + AopUtils.isCglibProxy(baseServiceb));
        System.out.println("是否是jdk动态接口代理调用，AopUtils.isJdkDynamicProxy(baseServiceb) : "
                + AopUtils.isJdkDynamicProxy(baseServiceb));
        
        //使用代理调用方法doB()
        baseServiceb.doB();
        int i = 1 / 0;// 抛出异常，doB()的事务事务回滚
        return "success";
    }
 
    // @Transactional(propagation = Propagation.REQUIRES_NEW, isolation =
    // Isolation.DEFAULT, rollbackFor = Exception.class)
    // public String doB() throws Exception {
    // Student st = new Student();
    // st.setId(2);
    // st.setSex("girl");
    // st.setUsername("zx2");
    // studentDao.insertStudent(st);
    //
    // return "success";
    // }
 
}

实现事务的类BusinessServiceImpl

package com.aop;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
 
import com.entity.Student;
 
@Service("businessSerivceB")
public class BusinessServiceImplB implements IBaseServiceB {
  
    @Autowired
    IStudentDao studentDao;
    
    @Transactional(propagation = Propagation.REQUIRES_NEW,isolation=Isolation.DEFAULT,rollbackFor=Exception.class)  
    public String doB() throws Exception {
        Student st = new Student();
        st.setId(2);
        st.setSex("girl");
        st.setUsername("zx2");
        studentDao.insertStudent(st);
        return "success";
    }
     
}

测试类：

package com.aop;
 
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
import com.thread.service.IBaseFacadeService;
 
 
//@RunWith(SpringJUnit4ClassRunner.class)
//@ContextConfiguration(locations = { "classpath:/spring-ibatis.xml", "classpath:/spring-jdbctemplate.xml" })
public class TestStudentDao {
 
    public static void main(String[] args) {
          try {
          BeanFactory factory = new ClassPathXmlApplicationContext("spring-jdbctemplate.xml");
          IBaseService service = (IBaseService) factory.getBean("businessSerivce");
        
              service.doA();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

测试结果：
om.aop.BusinessServiceImplB@14b75fd9
是否是代理调用，AopUtils.isAopProxy(baseServiceb) : true
是否是cglib类代理调用，AopUtils.isCglibProxy(baseServiceb) : true
是否是jdk动态接口代理调用，AopUtils.isJdkDynamicProxy(baseServiceb) : false
java.lang.ArithmeticException: / by zero

从测试结果可以看到，我们在数据库中成功插入了doB()方法中要插入的数据，而doA()中插入的数据被回滚了，这是因为我们在doB()方法中加入ROPAGATION_REQUIRES_NEW传播行为，doB()创建了属于自己的事务，挂起了doA()中的事务，所以事务B提交了，而事务A因为执行异常插入的数据被回滚了。

如果我们将BusinessServiceImplB做下修改，改为第一种传播行为ROPAGATION_REQUIRED


package com.aop;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
 
import com.entity.Student;
 
@Service("businessSerivceB")
public class BusinessServiceImplB implements IBaseServiceB {
  
    @Autowired
    IStudentDao studentDao;
    
    @Transactional(propagation = Propagation.REQUIRED,isolation=Isolation.DEFAULT,rollbackFor=Exception.class)  
    public String doB() throws Exception {
        Student st = new Student();
        st.setId(2);
        st.setSex("girl");
        st.setUsername("zx2");
        studentDao.insertStudent(st);
        return "success";
    }
     
}

测试结果：
com.aop.BusinessServiceImplB@97c87a4
是否是代理调用，AopUtils.isAopProxy(baseServiceb) : true
是否是cglib类代理调用，AopUtils.isCglibProxy(baseServiceb) : true
是否是jdk动态接口代理调用，AopUtils.isJdkDynamicProxy(baseServiceb) : false
java.lang.ArithmeticException: / by zero

从结果可以看到，我们没有成功插入数据，这是为什么呢？因为我们使用的是第一种传播行为PROPAGATION_REQUIRED ，doB()方法被加入到doA()的事务中，doA()执行时抛出了异常，因为doB()和doA()同属于一个事务，则执行操作被一起回滚了。其实在doB()中我们不加入注解，也等同PROPAGATION_REQUIRED的效果。

接下来我们再来看看第五种传播行为PROPAGATION_NOT_SUPPORTED，我们同样修改B类，如下


package com.aop;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
 
import com.entity.Student;
 
@Service("businessSerivceB")
public class BusinessServiceImplB implements IBaseServiceB {
  
    @Autowired
    IStudentDao studentDao;
    
    @Transactional(propagation = Propagation.NOT_SUPPORTED,isolation=Isolation.DEFAULT,rollbackFor=Exception.class)  
    public String doB() throws Exception {
        Student st = new Student();
        st.setId(2);
        st.setSex("girl");
        st.setUsername("zx2");
        studentDao.insertStudent(st);
        return "success";
    }
     
}
测试结果：

可以看到doB()方法成功插入了数据。doA()方法中插入的数据被回滚了。这是因为传播行为PROPAGATION_NOT_SUPPORTED是doB()以非事务执行的，并且提交了。所以当doA()的事务被回滚时，doB()的操作没有被回滚。

其他的传播行为就不一一列举了，机制是差不多的。

注意：在上面的实例中，我没有把doB()方法放在类BusinessServiceImpl，而是放在BusinessServiceImplB中，这是因为spring通过扫描所有含有注解的@Trasation的方法，使用aop形成事务增强advise。但是加入增强时是通过代理对象调用方法的形式加入的，如果将doB()方法放在doA()方法直接调用时，在调用doB()方法的时候是通过当前对象来调用doB()方法的，而不是通过代理来调用的doB()方法，这个时候doB()方法上加的事务注解就失效了不起作用。在Spring事务传播行为在内部方法不起作用讲到。

spring配置文件：


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    xmlns:tx="http://www.springframework.org/schema/tx" xmlns:jdbc="http://www.springframework.org/schema/jdbc"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd 
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
            http://www.springframework.org/schema/tx  http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
            http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd"
            default-lazy-init="false">
 
    <context:component-scan base-package="com.aop"/>
    <aop:aspectj-autoproxy proxy-target-class="true"/>
    <!-- 数据 -->
    <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/lpWeb"/>
        <property name="username" value="root"/>
        <property name="password" value="root123"/>
    </bean>
    
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
         <property name = "dataSource" ref="dataSource"/>  
    </bean>
  
     <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean> 
    
    <tx:annotation-driven transaction-manager="transactionManager" />  
</beans>

--------------------- 
作者：hsgao_water 
from：https://blog.csdn.net/hsgao_water/article/details/52860380?utm_source=copy 
 

GarfieldEr007
关注
专栏目录
Spring传播行为
qq_40927385的博客
05-22 272
###Spring事务的传播行为 当方法存在事务，然后调用其他方法的时候事务是怎么传播的，spring提供了七种传播行为，每次看过几天后就忘记了，这一次进行整理记录一下，不然每次寻找资料很麻烦。 Spring有七大传播行为如下图所示，光看以下描述可能不是很好理解，遇见自己无法理解的东西最好的办法就是自己通过代码去实践探索。 ####REQUIRED spring中默认的传播行为，如果拥有事务的A方法调用拥有事务的B方法，B方法将会在A方法的事务中运行，如果A方法没有事务，将会运行在B方法的事务中。下
Spring中事务传播行为的介绍
08-26
Spring 中事务传播行为的介绍 Spring 中事务传播行为是指在分布式事务系统中，事务的边界定义和传播规则。在 Spring 框架中，定义了 7 种不同的传播行为，每种行为都有其特点和应用场景。 1. PROPAGATION_...
【Spring学习34】Spring事务(4)：事务属性之7种传播行为
热门推荐
程序老兵的博客
04-20 1万+
事务传播行为什么叫事务传播行为？听起来挺高端的，其实很简单。 即然是传播，那么至少有两个东西，才可以发生传播。单体不存在传播这个行为。事务传播行为（propagation behavior）指的就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行。 例如：methodA事务方法调用methodB事务方法时，methodB是继续在调用者methodA的事务中运行呢，还是为自己开启一个
spring事物的七种事物传播属性行为及五种隔离级别
denglu2912的博客
12-19 308
首先,说说什么事务（Transaction）。 事务，就是一组操作数据库的动作集合。事务是现代数据库理论中的核心概念之一。如果一组处理步骤或者全部发生或者一步也不执行，我们称该组处理步骤为一个事务。当所有的步骤像一个操作一样被完整地执行，我们称该事务被提交。由于其中的一部分或多步执行失败，导致没有步骤被提交，则事务必须回滚到最初的系统状态。 其中spring七个事物传播属性： ...
Spring事务传播行为7种类型 --- 看一遍就能记住！
愿我如星君如月 ... 夜夜流光相皎洁 ...
03-16 1031
一、Spring 事务传播行为一共有7种类型，主要分为3类： 1）支持当前事物、 2）不支持当前事务、 3）奇葩类型。 二、支持当前事物： 1）支持当前事物 —— PROPAGATION_REQUIRED：如果当前没有事物，就新建一个事务；如果有事物，就直接使用当前前事物、 2）支持当前事物 —— PROPAGATION_SUPPORTS ：如果当前没有事务
Spring七种事务传播特性
qq_34999633的博客
09-22 484
Spring七种事务传播特性： REQUIRED 如果不存在外层事务就主动开启事务，否则使用外层事务。 SUPPORTS 如果不存在外层事务就不开启事务，否则使用外层事务。 MANDATORY 如果不存在外层事务就抛出异常，否则使用外层事务。 REQUIRES_NEW 总是主动开启事务，如果存在外层事务，就将外层事务挂起。 NOT_SUPPORTED 总是不开启事务，如果...
Spring的7 种事务传播行为.pdf
10-24
【Spring的7种事务传播行为】在Spring框架中，事务管理是核心功能之一，而事务传播行为则是控制事务如何在不同方法调用之间传播的重要机制。理解这些行为有助于确保应用程序的事务一致性，尤其是在多线程和分布式...
Spring的7 种事务传播行为.docx
10-25
Spring提供了七种不同的事务传播行为，这些行为定义了在一个事务方法被另一个事务方法调用时应该如何处理事务边界。以下是这七种事务传播行为的详细解释： 1. **PROPAGATION_REQUIRED**：这是默认的行为，如果当前...
Spring事务的7种传播属性
WLQ0621的博客
04-05 986
Spring在TransactionDefinition接口中规定了7种事务传播行为，他们规定了事务方法和事务方法发生嵌套时事务如何进行传播。 所谓事务的传播行为是指，如果在开始当前事务之前，一个事务上下文已经存在，此时有若干选项可以指定一个事务性方法的执行行为。 PROPAGATION_REQUIRED 默认事务类型，如果没有，就新建一个事务；如果有，就加入当前事务。适合绝大多数情况。 如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。 PROPAGATION_REQUIRES
Spring中的7大事务传播特性
qq_36311757的博客
04-13 941
Spring中的7大事务传播特性
spring七种事务传播属性说明
qq_35939148的博客
03-18 286
事务概念 事务是访问数据库的一个操作序列，数据库应用系统通过事务集来完成对数据库的存取。事务的正确执行使得数据库从一种状态转换为另一种状态。 事务必须服从ACID原则即：原子性（atomicity）、一致性（consistency）、隔离性（isolation）、持久性（durability） spring七个事务传播属性(前两种常用)： PROPAGATION_REQUIRED【prop...
聊一聊Spring事务中的7种传播特性
竹林幽深
08-12 626
methodA和methodB，如果methodA调用methodB，那么将采用什么样的事务形式，这就叫做事务的传播特性，传播特性是作用于内层方法。目前，Spring在/*** PROPAGATION_REQUIRED：如果不存在外层事务，就主动创建事务；否则使用外层事务* PROPAGATION_REQUIRES_NEW：总是主动开启事务；如果存在外层事务，就将外层事务挂起* PROPAGATION_NESTED：如果不存在外层事务，就主动创建事务；否则创建嵌套的子事务。
spring总结(三十一)--事务七种传播属性
秋天的猿
12-07 197
来自：https://blog.csdn.net/z69183787/article/details/17136639 事务传播行为种类 Spring在TransactionDefinition接口中规定了7种类型的事务传播行为， 它们规定了事务方法和事务方法发生嵌套调用时事务如何进行传播： 表1事务传播行为类型   事务传播行为类型 说明 ...
Spring 七种事务传播性介绍
最新发布
vivo互联网技术
01-04 1326
本文主要介绍了Spring事务传播性的相关知识。在Spring环境中，含有事务的方法嵌套调用，事务是如何传递的规则，以及每种规则是如何开展工作的。文章还提到每种事务传播性是如何使用的，方便读者依据实际的场景，使用不同的事务规则。
Spring七种事务传播行为
荡漾
04-24 655
Spring七种事务传播行为 propagation_required： 如果有事务在运行，当前的方法就在这个事务内运行，否则就开启一个新的事务，并在自己的事务内运行（常用） propagation_required_new： 当前的方法必须启动新事务，并在它自己的事务内运行。如果有事务在运行，应该将其挂起。（常用） propagation_supports： 如果有事务在运行，当前这个方法...
spring 事务的4中隔离级别，7种传播属性
Dachuan
12-06 296
 事务的5种隔离级别           隔离级别：default 是数据库默认的隔离级别           |--read uncommitted 级别最低，没有什么作用           |--read committed   解决脏读的问题           |--reaptable read   解决重复读的问题，           |--serial  系列化 ，解决幻读的问...
Spring中事务传播行为种类
iteye_4734的博客
04-30 135
Spring在TransactionDefinition接口中规定了7种类型的事务传播行为，它们规定了事务方法和事务方法发生嵌套调用时事务如何进行传播： 　　PROPAGATION_REQUIRED 　　如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。这是最常见的选择。 　　PROPAGATION_SUPPORTS 　　支持当前事务，如果当前没有...
理解Spring事务的7种传播行为
"Spring事务之7种传播行为" 在Spring框架中，事务管理是核心功能之一，它确保了数据操作的原子性和一致性。事务的传播行为是Spring事务管理中的一个重要概念，它定义了在一个事务方法被另一个事务方法调用时，如何...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值