【spring入门】 事务 传播详解

最新推荐文章于 2024-03-10 11:52:30 发布
最新推荐文章于 2024-03-10 11:52:30 发布
阅读量186 收藏
点赞数
分类专栏： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33553218/article/details/105150005
版权

配置方法

基于XML的配置

    <!--    配置事务管理器-->
    <bean id="myTracnsactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--    配置事务属性-->
    <tx:advice id="myTx" transaction-manager="myTracnsactionManager">
        <tx:attributes>
            <tx:method name="add" propagation="REQUIRED"/>  <!--具体方法-->
            <tx:method name="*" propagation="NEVER"/>       <!--剩下的方法-->
        </tx:attributes>
    </tx:advice>

    <!--    配置事务切入点，关联事务属性-->
    <aop:config>
        <aop:pointcut expression="execution(* org.example.service.ProductService.*(..))" id="txPointCut"/>
        
        <aop:advisor advice-ref="myTx" pointcut-ref="txPointCut"/>
    </aop:config>

基于注解的配置
XML

    <bean id="myTracnsactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <tx:annotation-driven transaction-manager="myTracnsactionManager"/>

@Transactional()
  public void add(String name){}

@Transactional可选属性：

  Propagation propagation() default Propagation.REQUIRED; //传播方法

  Isolation isolation() default Isolation.DEFAULT; //隔离级别

  int timeout() default -1; //超时：单位秒，超过报错

  boolean readOnly() default false; //设置只读，事务优化

  Class<? extends Throwable>[] rollbackFor() default {}; //可回滚异常类（默认运行时异常回滚）

  String[] rollbackForClassName() default {}; //可回滚异常类名

  Class<? extends Throwable>[] noRollbackFor() default {};//不回滚异常类（默认checked异常）

  String[] noRollbackForClassName() default {}; //不回滚异常类名

传播详解

实验用到的几个类
Product

package org.example.pojo;

@Component("p")
public class Product {

  String name;

  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
}

ProductDao

package org.example.dao;

@Repository
public class ProductDao extends JdbcDaoSupport {
  @Autowired
  public ProductDao(DataSource dataSource) {
    super();
    setDataSource(dataSource);
  }

  @Transactional(propagation = Propagation.REQUIRED)
  public void addProduct(String name){
    String sql = "insert into product(name) values(?)";
    this.getJdbcTemplate().update(sql,name);
  }
}

ProductService

package org.example.service;

@Service
public class ProductService {
  @Autowired
  private ProductDao pd;

  @Transactional(propagation = Propagation.REQUIRED)
  public void add(String name){
    pd.addProduct(name);
    int a = 1/0;
  }
}

传播原理
在介绍七种传播行为前先看一个例子，稍微理解一下传播的原理。

@Repository
public class ProductDao extends JdbcDaoSupport {
  @Autowired
  public ProductDao(DataSource dataSource) {
    super();
    setDataSource(dataSource);
  }

  @Transactional
  public void addProduct(String name) throws Exception{
    String sql = "insert into product(name) values(?)";
    this.getJdbcTemplate().update(sql,name);
    int a = 1/0;
  }

  public void addProductWrapper(String name) throws Exception {
    addProduct(name);
  }
}
-----------------------------------------------------------------------------------
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class ProductTest {
  @Autowired
  private ProductDao p;
  @Test
  public void testTx() throws Exception {
    p.addProduct("nihaoaa"); //情况1
    P.addProductWrapper("nihaoaa");  //情况2
  }
} 

 p.addProduct("nihaoaa");
 P.addProductWrapper("nihaoaa");

这两个结果一样吗？？？

结果：第二行代码没有回滚，在数据库中加了nihaoaa，第一行代码回滚了，没有在数据库中加东西。

原因：看起来addProductWrapper除了调用addProduct之外没有任何其他的行为，应该和直接执行addProduct是一样的。但是实际上，Spring通过AOP实现事务，Spring帮我们实现了一个ProductDao的代理Proxy，并在里面定义了新的addProduct，这个方法除了包括ProductDao.addProduct的所有功能外，还加上了事务。p.addProduct执行的是代理对象proxy中的addProduct，所以有回滚操作。而p.addProductWrapper在类内调用addProduct，实际调用的就是ProductDao.addProduct，即原始的addProduct。

接下来介绍七种传播行为。

传播属性当前有事务当前没有事务
propagation_requierd加入到当前事务中新建一个事务
propagation_required_new新建一个事务新建一个事务
propagation_supports加入到当前事务中以非事务方法执行
propagation_not_supported把当前事务挂起，以非事务方法执行以非事务方法执行
propagation_mandatory加入到当前事务中抛出异常
propagation_never抛出异常以非事务方法执行
propagation_nested在嵌套事务内执行新建一个事务

下面的测试都用这个代码

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class ProductTest {
  @Autowired
  private ProductService ps;
  @Test
  public void testTx() throws Exception {
    ps.add("nihaoaa");
  }
}
1.propagation_requierd
//  service
  @Transactional(propagation = Propagation.REQUIRED)
  public void add(String name){
    pd.addProduct(name);
    int a = 1/0;
  }
// ProductDao
  @Transactional(propagation = Propagation.REQUIRED)
  public void addProduct(String name){
    String sql = "insert into product(name) values(?)";
    this.getJdbcTemplate().update(sql,name);
  }

结果：加入数据库失败。
service的add新建一个事务，ProductDao中的addProduct看到当前有事务了，就加入当前事务，所以尽管addProduct中没有异常，但因为add中有异常，也被回滚了。

//  service
  @Transactional(propagation = Propagation.REQUIRED)
  public void add(String name){
    pd.addProduct2(name+2);
    try{pd.addProduct(name);}
    catch (Exception e){
      System.out.println(Arrays.toString(e.getStackTrace()));
    }
    pd.addProduct2(name+3);
  }
// ProductDao
  @Transactional(propagation = Propagation.REQUIRED)
  public void addProduct(String name) throws Exception{
    String sql = "insert into product(name) values(?)";
    this.getJdbcTemplate().update(sql,name);
    int a = 1/0;
  }
  @Transactional(propagation = Propagation.REQUIRED)
  public void addProduct2(String name){
    String sql = "insert into product(name) values(?)";
    this.getJdbcTemplate().update(sql,name);
  }

结果：加入数据库失败
addProduct内的异常也会导致add中正常代码的回滚。

2.propagation_required_new
//  service
  @Transactional(propagation = Propagation.REQUIRED)
  public void add(String name){
    pd.addProduct(name);
    int a = 1/0;
  }
// ProductDao
  @Transactional(propagation = Propagation.REQUIRES_NEW)
  public void addProduct(String name){
    String sql = "insert into product(name) values(?)";
    this.getJdbcTemplate().update(sql,name);
  }

结果：加入数据库成功
add的行为和REQUIRED的情况一样，addProduct看到当前事务存在了，仍然会创建一个新的事务，然后就在这个新事务里面运行，所以add事务里面的异常就和addProduct没有关系了。

//  service
  @Transactional(propagation = Propagation.REQUIRED)
  public void add(String name){
    pd.addProduct2(name+2);
    try{pd.addProduct(name);}
    catch (Exception e){
      System.out.println(Arrays.toString(e.getStackTrace()));
    }
    pd.addProduct2(name+3);
  }
//  ProductDao
  @Transactional(propagation = Propagation.REQUIRES_NEW)
  public void addProduct(String name) throws Exception{
    String sql = "insert into product(name) values(?)";
    this.getJdbcTemplate().update(sql,name);
    int a = 1/0;
  }
  @Transactional(propagation = Propagation.REQUIRED)
  public void addProduct2(String name){
    String sql = "insert into product(name) values(?)";
    this.getJdbcTemplate().update(sql,name);
  }

结果：加入了nihaoaa2和nihaoaa3，没有加入nihaoaa。
因为addProduct和add是在两个不同的事务里面的，所以互相不会影响。

3.propagation_supports
//  service
  @Transactional(propagation = Propagation.REQUIRED)
  public void add(String name){
    pd.addProduct(name);
    int a = 1/0;
  }
// ProductDao
  @Transactional(propagation = Propagation.SUPPORTS)
  public void addProduct(String name){
    String sql = "insert into product(name) values(?)";
    this.getJdbcTemplate().update(sql,name);
  }

结果：加入数据库失败
原因和REQUIRED情况一样。

//  service
//  @Transactional(propagation = Propagation.REQUIRED)
  public void add(String name){
    pd.addProduct(name);
    int a = 1/0;
  }
// ProductDao
  @Transactional(propagation = Propagation.SUPPORTS)
  public void addProduct(String name){
    String sql = "insert into product(name) values(?)";
    this.getJdbcTemplate().update(sql,name);
    int a = 1/0;
  }

结果：加入数据库成功
此时add上没有事务了，addProduct看到没有当前事务，就以非事务方法执行了，所以尽管addProduct本身抛异常了，也不影响前面的数据库行为。

4.propagation_not_supported
//  service
  @Transactional(propagation = Propagation.REQUIRED)
  public void add(String name){
    pd.addProduct(name);
    int a = 1/0;
  }
// ProductDao
  @Transactional(propagation = Propagation.NOT_SUPPORTED)
  public void addProduct(String name){
    String sql = "insert into product(name) values(?)";
    this.getJdbcTemplate().update(sql,name);
    int a = 1/0;
  }

结果：加入数据库成功

//  service
  @Transactional(propagation = Propagation.REQUIRED)
  public void add(String name){
    pd.addProduct2(name+2);
    try{pd.addProduct(name);}
    catch (Exception e){
      System.out.println(Arrays.toString(e.getStackTrace()));
    }
    pd.addProduct2(name+3);
    int a = 1/0;
  }
// ProductDao
  @Transactional(propagation = Propagation.NOT_SUPPORTED)
  public void addProduct(String name) throws Exception{
    String sql = "insert into product(name) values(?)";
    this.getJdbcTemplate().update(sql,name);
    int a = 1/0;
  }
  @Transactional(propagation = Propagation.REQUIRED)
  public void addProduct2(String name){
    String sql = "insert into product(name) values(?)";
    this.getJdbcTemplate().update(sql,name);
  }

结果：加入了nihaoaa。
当事务存在时，把当前事务挂起，然后执行addProduct里面的非事务操作，所以加入了nihaoaa。然后add里面抛出异常之后回滚，但不会影响到addProduct里面的行为。

5.propagation_mandatory

这个很简单如果在add上定义，那就会报错，因为它被调用的时候没看到创建好的事务。
No existing transaction found for transaction marked with propagation ‘mandatory’。

6.propagation_never

这个也很简单，如果在addProduct上定义，并且add上定义了事务，报错。

7.propagation_nested

这个叫做嵌套事件，注意和propagation_required_new以及propagation_required的区别。

//  service
  @Transactional(propagation = Propagation.REQUIRED)
  public void add(String name){
    pd.addProduct2(name+2);
    try{pd.addProduct(name);}
    catch (Exception e){
      System.out.println(Arrays.toString(e.getStackTrace()));
    }
    pd.addProduct2(name+3);
    int a = 1/0;
  }
// ProductDao
  @Transactional(propagation = Propagation.NESTED)
  public void addProduct(String name) throws Exception{
    String sql = "insert into product(name) values(?)";
    this.getJdbcTemplate().update(sql,name);
  }
  @Transactional(propagation = Propagation.REQUIRED)
  public void addProduct2(String name){
    String sql = "insert into product(name) values(?)";
    this.getJdbcTemplate().update(sql,name);
  }

结果：什么都没有加入。
add创建了一个事务，addProduct在这个事务里面嵌套执行，因为add最后抛了个异常，所以整个事务回滚了，导致addProduct的行为也被回滚。

//  service
  @Transactional(propagation = Propagation.REQUIRED)
  public void add(String name){
    pd.addProduct2(name+2);
    try{pd.addProduct(name);}
    catch (Exception e){
      System.out.println(Arrays.toString(e.getStackTrace()));
    }
    pd.addProduct2(name+3);
  }
// ProductDao
  @Transactional(propagation = Propagation.NESTED)
  public void addProduct(String name) throws Exception{
    String sql = "insert into product(name) values(?)";
    this.getJdbcTemplate().update(sql,name);
    int a = 1/0;
  }
  @Transactional(propagation = Propagation.REQUIRED)
  public void addProduct2(String name){
    String sql = "insert into product(name) values(?)";
    this.getJdbcTemplate().update(sql,name);
  }

结果：加入了nihaoaa2和nihaoaa3。
addProduct里面的异常导致这段嵌入的行为被回滚，回滚到嵌入点（add调用addProduct的地方），然后add从嵌入点继续往下执行。

haikuc
关注
专栏目录
Spring Boot入门(24)：实现优雅的事务管理：Spring Boot事务全解析
**My Coding Family**
08-28 1699
一文讲透Spring Boot 中的事务，等你来学！
Spring-全面详解（学习总结---从入门到深化）
11-29 1308
接下来我们通过一段代码模拟IOC思想。创建一个集合容器，先将 对象创建出来放到容器中，需要使用对象时，只需要从容器中获取 对象即可，而不需要重新创建，此时容器就是对象的管理者。创建实体类// 省略getter/setter/构造方法/tostring}创建Dao接口和实现类// 根据id查询学生}@Override// 模拟从数据库查找出学生return new Student(1,"程序员","北京");}}@Override// 模拟根据id查询学生。
spring事务传播之NESTED
bearman的博客
11-23 6520
下面是官方的解释/** * Execute within a nested transaction if a current transaction exists, * behave like PROPAGATION_REQUIRED else. There is no analogous feature in EJB. * <p>Note: Actual creation of a nest
Spring 事务传播属性以及PROPAGATION_NESTED 和PROPAGATION_REQUIRES_NEW
Big_Blogger的博客
04-15 4373
spring的六种事务传播属性 PROPAGATION_REQUIRED -- 支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。 PROPAGATION_SUPPORTS -- 支持当前事务，如果当前没有事务，就以非事务方式执行。 PROPAGATION_MANDATORY -- 支持当前事务，如果当前没有事务，就抛出异常。 PROPAGATION_REQUIRES_NE
spring 事件传播
m0_38123177的博客
03-27 183
源于：https://blog.csdn.net/it_man/article/details/8440737 spring提供事件传播机制。 ApplicationContext基于Observer(观察者)模式（Java.util有实现）。通过使用Application.publishEvent方法，可以将事件通知给所有的ApplicationListener. 作用：借助事件机制，可以...
spring 事务的传播Propagation.NESTED Propagation.REQUIRED Propagation.REQUIRES_NEW
weixin_39314170的博客
08-20 505
Propagation.NESTED Propagation.REQUIRED Propagation.REQUIRES_NEW 主要说这三种传播类型 场景1 ： 事务方法a   调用事务方法b和c void a（）{   otherClass.b(); try{   otherClass.c(); }catch(Exception c) }   void c(){ th...
spring事务PROPAGATION_NESTED 与PROPAGATION_REQUIRES_NEW
qq_33271461的博客
02-08 755
spring事务PROPAGATION_NESTED 与PROPAGATION_REQUIRES_NEW
Spring V4.2入门详解
JYplute的博客
04-21 380
文章目录震惊！原来Spring框架入门仅需这么几步老营销号了????教学开始1.Spring的概述1.1介绍1.2下载1.3引入Spring核心jar包1.4原始Dao存在的问题1.5IOC和DI2.Spring的配置2.1头配置2.2标签的配置2.3Spring的工厂类2.4Spring的实例化方式和属性注入2.5分模块开发2.6Spring整合Junit3.IOC的注解3.1添加约束3.2配置注解扫...
Spring学习详解（1）——Spring入门详解
科技D人生
12-30 6341
一：spring的基本用法： 1，关于spring容器： spring容器是Spring的核心，该 容器负责管理spring中的java组件， ApplicationContext ctx  = new ClassPathXmlApplicationContext("bean.xml");//这种方式实例化容器，容器会自动预初始化所有Bean实例 ctx.getBean("beanName
spring入门
lxb_10323的博客
03-12 963
springIOC、springAOP、spring事务控制
【业务功能篇138】SpringBoot中的事务传播属性运用REQUIRED、REQUIRES_NEW、NESTED 只读属性运用readOnly
最新发布
studyday1的博客
03-10 1223
假如当前正要运行的事务不在另外一个事务里，那么就起一个新的事务 比方说，ServiceB.methodB的事务级别定义PROPAGATION_REQUIRED, 那么因为执行ServiceA.methodA的时候，ServiceA.methodA已经起了事务。此外，只读事务不能保证数据的一致性，因为在只读事务中，数据可能已经被其他事务修改了，因此在使用只读事务时需要注意这一点。此外，只读事务不能保证数据的一致性，因为在只读事务中，数据可能已经被其他事务修改了，因此在使用只读事务时需要注意这一点。
Spring事务传播行为实战
程序员Forlan的博客
10-28 2961
简单示例小实验，悟透各种事务传播行为的使用和作用
Spring事务
Javaer`s blog
02-29 330
Spring事务管理（详解+实例） 事务的传播行为 Spring事务传播行为详解 默认情况下，事务只有遇到运行期异常时才会回滚，而在遇到检查型异常时不会回滚（这一行为与EJB的回滚行为是一致的，但是你自己把运行期异常catch住了自然也不会回滚 1 核心接口 Spring并不直接管理事务，而是提供了多种事务管理器，他们将事务管理的职责委托给Hibernate或者JTA等持久化机制所提供的相关平台...
事务的传播机制（案例演示）
热门推荐
易柏州的博客
08-08 1万+
事务的传播机制（案例演示）     案例介绍： 数据库表：user表，两条数据： Mapper逻辑： 两条sql update1：修改张三的pass字段为2。 update2：修改李四的pass字段为2。 @Update("Update user set pass = 2 where id = 1") void update1(); @Update("Update user set pass = 2 where id = 2") void update2(); Se
事务的传播级别（行为）
weixin_68472181的博客
03-06 823
事务的传播级别（行为）
spring中事务的传播行为详解+业务场景示例
qq_41717518的博客
09-19 1780
这里我先来给大家规整一下代码，涉及事务传播行为要点的是UserServiceImpl的register方法，这里为了后续方便指认，我就称UserServiceImpl的register方法为外围方法。
Spring事务传播行为Propagation及原理
侠客小虎的博客
10-13 596
Spring事务传播行为Propagation及原理
spring 事务传播REQUIRED 与 NESTED的区别
FREEDOM
05-12 4821
NESTED 似乎与REQUIRED 是一样的，但是他们是不同的。 若 关于spring事务传播机制的解释 播行为 意义 PROPAGATION_REQUIRES 表示当前方法必须在一个事务中运行。如果一个现有事务正在进行中，该方法将在那个事务中运行，否则就要开始一个新事务。 PROPAGATION_SUPPORTS 表示当前方法不需要事务性上下文，但是如果有一个事务已经在运行的话，它也可以在这个事务里运行。 PROPAGATION_MANDATORY ...
Spring事务传播机制详细讲解
qq_39939541的博客
08-01 2228
事务传播机制允许开发者根据实际需求来控制事务的行为。通过合理选择事务传播机制，可以保证事务的一致性和可靠性，提高系统的稳定性和性能。需要注意的是，事务传播机制只对方法级别的事务起作用，对注解方式的事务不适用。在使用注解方式时，可以通过@Transactional注解的propagation属性来指定事务的传播行为。
Spring事务管理详解：入门指南与配置详解
- 对于事务代理，可以在Service或DAO层的类上添加`@Transactional`注解，或在XML配置中指定事务属性，如隔离级别、传播行为等。 Spring事务配置的核心是通过合理配置DataSource和TransactionManager，结合AOP代理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值