详解事务传播特性

最新推荐文章于 2024-09-23 09:14:28 发布
最新推荐文章于 2024-09-23 09:14:28 发布
阅读量3.1k 收藏 22
点赞数 4
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43434182/article/details/108303960
版权

事务传播特性汇总：

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

supports:如果当前有事务，则使用事务，如果当前没有事务，则不使用事务

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

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

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

never:如果当前事务存在，则抛出异常

nested：  如果当前有事务，则开启子事务（嵌套事务），嵌套事务是独立提交或者回滚；如果当前没有事务，则同required

但是如果父事务提交，则会携带子事务一起提交。如果父事务回滚，则子事务会一起回滚。相反，子事务异常，则父事务可以不会滚（捕获子事务的异常），也可以回滚。

有异常才会回滚事务，如果异常被捕获，也就是try，catch，就不会回滚事务了，

发生异常，或者抛出异常都会回滚事务

准备工作

演示required

每次测试之前都会清空数据库

导入test依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

编写test类

import com.imooc.Application;
import com.imooc.service.impl.TestTransService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)
public class TransTest {
    @Autowired
    private TestTransService testTransService;
    /*
    * 事务传播特性
    *   required：
    *   supports：
    *   mandatory：
    *   required_new:
    *   not_supported:
    *   never:
    *   nested:
    * */
    @Test
    public void demo(){
        testTransService.saveParent();
        testTransService.saveChildren();
    }
}

编写需要的测试方法

package com.imooc.service.impl;

import com.imooc.mapper.StuMapper;
import com.imooc.pojo.Stu;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class TestTransService {
    @Autowired
    private StuMapper stuMapper;
    public void saveParent(){
        Stu stu=new Stu();
        stu.setName("parent");
        stu.setAge(55);
        stuMapper.insert(stu);
    }
    public void saveChildren(){
        saveChild1();
        int a=1/0;
        saveChild2();
    }
    public void saveChild1(){
        Stu stu1=new Stu();
        stu1.setName("child-1");
        stu1.setAge(11);
        stuMapper.insert(stu1);
    }
    public void saveChild2(){
        Stu stu2=new Stu();
        stu2.setName("child-2");
        stu2.setAge(22);
        stuMapper.insert(stu2);
    }
}

没有开启事务，直接测试

报错：java.lang.ArithmeticException: / by zero

结论：在报错之前，已经执行的代码会进行数据库操作，之后代码没有执行，也就没有操作数据库

在demo()方法上开启事务，进行测试

import com.imooc.Application;
import com.imooc.service.impl.TestTransService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)
public class TransTest {
    @Autowired
    private TestTransService testTransService;
    /*
    * 事务传播特性
    *   required：
    *   supports：
    *   mandatory：
    *   required_new:
    *   not_supported:
    *   never:
    *   nested:
    * */
    @Transactional(propagation = Propagation.REQUIRED)
    @Test
    public void demo(){
        testTransService.saveParent();
        testTransService.saveChildren();
    }
}

报错：java.lang.ArithmeticException: / by zero

结论：事务具有传播特性，demo()方法开启事务，方体体里面的方法也具有事务，所以报错后数据库进行了回滚操作

如果demo方法没有开启事务，在saveChildren()上开启了事务（  @Transactional(propagation = Propagation.REQUIRED)）

，则会保存saveParent()方法插入的数据。

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

================================================================================================

演示required_new

spring boot测试环境会自动回滚，不适合测试事务，直接使用开发环境，然后用postman调用

controller

package com.imooc.controller;

import com.imooc.service.impl.TestTransService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TestTransController {
    @Autowired
    private TestTransService testTransService;
    @PostMapping("/demo")
    @Transactional(propagation = Propagation.REQUIRED)
    public void demo()throws Exception{
        testTransService.saveParent();
        testTransService.saveChildren();
    }
}

demo()方法上面加@Transactional(propagation = Propagation.REQUIRED)

saveChildren()方法上面加@Transactional(propagation = Propagation.REQUIRES_NEW)

调用postman运行

报错：java.lang.NullPointerException: null

结论：由于抛出空指针异常，所以saveChildren()这个新事物会回滚，而抛出的异常会传递给父方法，父方法的事务也会回滚，所有没有一条记录

另外一种情况

saveChildren()

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void saveChildren(){
        saveChild1();
        /*String demon=null;
        System.out.println(demon.charAt(0));*/
        saveChild2();
    }
demo()
    @PostMapping("/demo")
    @Transactional(propagation = Propagation.REQUIRED)
    public void demo(){
        testTransService.saveParent();
        testTransService.saveChildren();
        String demon=null;
        System.out.println(demon.charAt(0));
    }

调用postman

报错：java.lang.NullPointerException: null

结论：可以证明required_new创建的时新事务

================================================================================================

演示nested

saveChildren
    @Transactional(propagation = Propagation.NESTED)
    public void saveChildren(){
        saveChild1();
        saveChild2();
    }
demo
    @PostMapping("/demo")
    @Transactional(propagation = Propagation.REQUIRED)
    public void demo(){
        testTransService.saveParent();
        testTransService.saveChildren();
        String demon=null;
        System.out.println(demon.charAt(0));
    }

调用postman

报错是一定的：java.lang.NullPointerException: null

结论：父事务回滚，子事务也一起回滚

另外一种情况

demo
    @PostMapping("/demo")
    @Transactional(propagation = Propagation.REQUIRED)
    public void demo(){
        testTransService.saveParent();
        testTransService.saveChildren();

    }
saveChildren
    @Transactional(propagation = Propagation.NESTED)
    public void saveChildren(){
        saveChild1();
        String demon=null;
        System.out.println(demon.charAt(0));
        saveChild2();
    }

万年不变报错：java.lang.NullPointerException: null

结论：子事务异常，父事务没有捕获异常，则一起回滚

另外一种情况

saveChildren
    @Transactional(propagation = Propagation.NESTED)
    public void saveChildren(){
        saveChild1();
        String demon=null;
        System.out.println(demon.charAt(0));
        saveChild2();
    }
demo
    @PostMapping("/demo")
    @Transactional(propagation = Propagation.REQUIRED)
    public void demo(){
        testTransService.saveParent();
        try {
            //相当于数据库中的savepoint 捕获异常之后，不影响其他事务操作
            testTransService.saveChildren();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

调用postman：

报错：java.lang.NullPointerException

结论：捕获子事务异常之后，父事务不需要回滚，子事务进行回滚

 

解密Java事务传播行为与隔离级别：案例详解与解决方案
weixin_44976692的博客
02-26 2万+
在实际开发中，根据具体业务需求和数据库环境，选择合适的事务传播行为和隔离级别非常重要，以确保事务的正确性和可靠性。在这个示例中，由于事务隔离级别是READ_COMMITTED，可能会导致读取和更新之间其他事务的影响，解决方案是在更新数据之前重新读取一次，确保数据的一致性。在这个示例中，设置了事务的超时时间为30秒，如果更新操作的执行时间超过了30秒，事务将会被回滚，可以避免长时间占用数据库连接。下面是针对事务传播行为和隔离级别的更丰富的代码示例，包括了多种不同情况下的使用方法和解决方案。
Spring事务传播行为详解
刘树之的博客
08-17 637
前言 Spring在TransactionDefinition接口中规定了7种类型的事务传播行为。事务传播行为是Spring框架独有的事务增强(通知)特性，是Spring为我们提供的强大的工具箱，使用事务传播行可以为我们的开发工作提供许多便利。但是人们对他的误解也颇多，你一定也听过“service方法事务最好不要嵌套”的传言。要想正确的使用工具首先需要了解工具。本文对七种事务传播行为做详细介绍，内容主要代码示例的方式呈现。 基础概念 1.什么是事务传播行为？ 事务传播行为用来描述由某一个事务传播行为修饰的方
事务传播特性了解事务的几种传播特性
09-21
事务传播特性了解事务的几种传播特性 总共有七种propagation——required propagation——support propagation——mandatory propagation——not——supported propagation_required_new propagation_never propagation_nested propagation_
事务的传播特性
thomas0yang的专栏
11-23 805
事务的6种传播特性     1.    PROPAGATION_REQUIRED: 如果存在一个事务，则支持当前事务。如果没有事务则开启     2.    PROPAGATION_SUPPORTS: 如果存在一个事务，支持当前事务。如果没有事务，则非事务的执行     3.    PROPAGATION_MANDATORY: 如果已经存在一个事务，支持当前事务。如果没有一个活动的事务，则抛出异常。     4.    PROPAGATION_REQUIRES_NEW: 总是开启一个新的事务。如果一
为了不再被事务坑，我读透了Spring的事务传播性。
最新发布
编码人生
09-23 674
所以作者对Spring的事务深恶痛绝，这次我们来再次对spring的事务发起进攻，还是用用户中奖这个例子去解释这个Spring的事务（用户：麻烦给一下出场费），防止以后再次出现这样的情况，这次我们的攻击点就是spring的事务的七种传播性。Spring框架中的事务传播性是指当一个事务方法被另一个事务方法调用时，如何处理这种嵌套调用的情况。，但是这里大家不要把Spring的事务和mysql的隔离级别搞混了。这里面是他的实现类，在这里，除了往user表中插入了一条数据，还往中奖记录表中添加了一条数据。
事务传播性
漫天雪_昆仑巅
02-15 1044
事务传播性说明： 事务传播行为就是多个事务方法相互调用时，事务如何在这些方法间传播。spring支持7种事务传播行为： 1、propagation_requierd：如果当前没有事务，就新建一个事务，如果已存在一个事务中，加入到这个事务中，这是最常见的选择。 2、propagation_supports：支持当前事务，如果没有当前事务，就以非事务方法执行。 3、propagation_mand...
事务的7中传播特性
u011861874的博客
08-09 6328
一、传播特性的产生        在项目开发中，一般将事务设置在service层，当调用这个service方法时，这个service保证了所有的操作在同一个事务中，所有对数据库的操作要么一起成功，要么一起失败。        如果service方法除了调用DAO，还调用了其他的service方法，如何通过事务控制，保证数据的一致，这个时候就需要事务的传播特性。 二、传播特性种类      ...
SPRING事务传播特性&事务隔离级别
10-28
### Spring 事务传播特性和事务隔离级别详解 #### 一、Spring 事务传播特性 在进行多层服务架构设计时，事务的管理尤其重要。为了确保数据的一致性，Spring 提供了一种灵活的方式来控制事务的传播行为。下面详细...
Spring中事务的传播属性详解
03-11
本文将详细介绍Spring中的事务传播属性，并通过具体的例子来解释每种传播行为的特点。 #### 二、事务传播属性概述 事务传播行为（Propagation）定义了当一个事务方法被另一个事务方法调用时的行为。在Spring中，...
Spring事务的传播特性
Q
07-23 1万+
Spring中通过Propagation来设置事务的传播属性的，在这个属性中提供了我们其中关于事务传播的特性：        1.     PROPAGATION_REQUIRED：支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。        2.     PROPAGATION_SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行。         3.
浅谈事务的传播特性
jay_888的博客
07-04 205
参考博客：https://www.cnblogs.com/yixianyixian/p/8372832.html
事务的传播性
^_^-Beluga, ^_^-Stefli
06-13 801
1.Required：共享型若1处在一个事务中调用了2，则2直接和1在同一个事务中。若1没有任何事务，则系统会默认给2创建一个新事务。此策略适合大多数情况。2.RequiredNew：独立型若1在一个事务中调用了2，则系统先将1的事务挂起，不管、之后为2设置一个新事务，执行完毕后恢复1的事务。若1没有事务，则会为2新开一个事务。3.Mandatory：强制共享型若1处在一个
什么是事务的传播特性
热门推荐
jim_007的博客
09-03 1万+
看到一个词“事务的传播特性”，在网上查找半天没理解是啥，看了一个网友列举的实例才有点明白，此处用其实例整理下思路： 上图方法1对应的事务叫事务1，方法2对应的事务叫事务2；其中事务1调用了事务2； 期望：想要让事务2发生异常时回滚，而事务1不回滚（catch后继续循环下一个）； 实际：事务2回滚时事务1也回滚了，不符合期许； 原因：当调用方法1时会创建事务1，当调用方法2时准备创建事务...
事务的传播属性
weixin_50576371的博客
04-03 710
因此，在处理业务日志时，需要注意确保日志记录代码的执行不受业务方法执行流程的影响，并确保在异常情况下也能够正确记录错误信息，以便后续排查和处理。，可以确保日志的记录不受业务方法的事务影响，即使业务方法发生异常，日志也能够成功保存。：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。：支持当前事务，如果当前没有事务，就以非事务方式执行。：以非事务方式执行操作，如果当前存在事务，则抛出异常。：新建一个事务，如果当前存在事务，就把当前事务挂起。：支持当前事务，如果当前没有事务，就抛出异常。
Spring事务：传播属性与隔离级别详解
"Spring事务的传播特性和事务隔离级别是理解Spring框架中事务管理的关键概念。" 在Spring框架中，事务管理是确保数据一致性的重要机制。事务的传播属性和事务隔离级别是两个核心概念，它们决定了如何处理事务边界...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值