@Transactional生效和失效测试及传播机制

已于 2024-05-24 22:38:48 修改
阅读量678 收藏 3
点赞数
分类专栏： java 常识 文章标签： java spring
于 2021-09-12 17:32:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013078871/article/details/120252447
版权
java 同时被 2 个专栏收录
57 篇文章 0 订阅
订阅专栏
常识
12 篇文章 0 订阅
订阅专栏

spring事务（注解 @Transactional ）失效的12种场景
一.概念
@Transactional是springboot框架中的声明式事务管理注解，是现在编程中普遍使用的事务管理注解。
通过该标注spring可以知道在什么地方启用数据库事务功能。

但是关于这个注解，如果不明白其原理，是有很多坑的，会导致使用时失效。
很多文章也只是千篇一律把其概念列了一下，并没有告诉我们究竟怎么使用是对的，怎么使用是错的。
所以我先把 @Transactional使用的注意点和规范列出来，大家先明白其用法，再去追究原理。

二.用法
@Transactional注解可以标注在类或者方法上：

  • 如果是标注在方法上，该方法必须是public才会生效。如果标注的方法是private则不会生效,但编译时也不会报错，所以这点需要我们自己去规避；

  • 如果标注在类上，则代表该类的所有公共非静态的方法都将使用事务功能。

根据@Transactional标注的层级讲解：

  • 直接标注在Controller类的方法上，则该方法内所有的逻辑都开启事务。（不推荐）
    实际上在一个Controller方法里面，会包含很多非数据库操作的逻辑，比如校验逻辑，发第三方消息等。我们要尽量避免长事物，提升性能，所以一般很少会直接在Controller方法上标注@Transactional。

  • 一般推荐标注在Service层级

1.private和public本类测试1

package com.kaka.mysql.controller;

import com.kaka.mysql.dao.entity.Test;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalTime;
import java.util.Date;

@Slf4j
@RestController
@AllArgsConstructor
@RequestMapping("/tran")
public class TransactionalController {



    @GetMapping("/test")
    private boolean A() {
        Test test = new Test();
        test.setTestDate(LocalDate.now());
        test.setTestTime(LocalTime.now());
        test.setTestTimestap(new Date());
        test.setName("a");
        test.setMoney(BigDecimal.valueOf(10.999));
        test.setTotalMoney(test.getMoney().add(BigDecimal.valueOf(3)));
        boolean insert = test.insert();
        /**
         * B 插入字段为 3的数据
         */
        boolean insertb=insertB();

        Test test2 = new Test();
        test2.setTestDate(LocalDate.now());
        test2.setTestTime(LocalTime.now());
        test2.setTestTimestap(new Date());
        test2.setName("aa");
        test2.setMoney(BigDecimal.valueOf(10.999));
        test2.setTotalMoney(test2.getMoney().add(BigDecimal.valueOf(3)));
        boolean insert2 = test2.insert();


        return insert&&insertb;
    }

    @Transactional
    public boolean insertB() {
        Test test = new Test();
        test.setTestDate(LocalDate.now());
        test.setTestTime(LocalTime.now());
        test.setTestTimestap(new Date());
        test.setName("b");
        test.setMoney(BigDecimal.valueOf(10.999));
        test.setTotalMoney(test.getMoney().add(BigDecimal.valueOf(3)));
        boolean insert = test.insert();
        this.insertC();
        int bbb = 1/0;
        Test test2 = new Test();
        test2.setTestDate(LocalDate.now());
        test2.setTestTime(LocalTime.now());
        test2.setTestTimestap(new Date());
        test2.setName("bb");
        test2.setMoney(BigDecimal.valueOf(10.999));
        test2.setTotalMoney(test2.getMoney().add(BigDecimal.valueOf(3)));
        boolean insert1 = test2.insert();
        return insert&&insert1;
    }

    @Transactional
    public boolean insertC() {
        Test test = new Test();
        test.setTestDate(LocalDate.now());
        test.setTestTime(LocalTime.now());
        test.setTestTimestap(new Date());
        test.setName("c");
        test.setMoney(BigDecimal.valueOf(10.999));
        test.setTotalMoney(test.getMoney().add(BigDecimal.valueOf(3)));
        boolean insert = test.insert();
        int bbb = 1/0;
        Test test2 = new Test();
        test2.setTestDate(LocalDate.now());
        test2.setTestTime(LocalTime.now());
        test2.setTestTimestap(new Date());
        test2.setName("cc");
        test2.setMoney(BigDecimal.valueOf(10.999));
        test2.setTotalMoney(test2.getMoney().add(BigDecimal.valueOf(3)));
        boolean insert1 = test2.insert();
        return insert&&insert1;
    }
}

测试结果：
1.当A为private修饰时，B和C的事务生效，当A为public时，B和C事务失效
2.加事务注解的方法A必须为public否则事务不生效，A内调用的方法，不管是private还是public，只要A加了就都生效
2.private和public本类测试2
测试代码：

package com.kaka.mysql.controller;

import com.kaka.mysql.dao.entity.Test;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalTime;
import java.util.Date;

@Slf4j
@RestController
@AllArgsConstructor
@RequestMapping("/tran")
public class TransactionalController {



    @GetMapping("/test")
    private boolean A() {
        Test test = new Test();
        test.setTestDate(LocalDate.now());
        test.setTestTime(LocalTime.now());
        test.setTestTimestap(new Date());
        test.setName("a");
        test.setMoney(BigDecimal.valueOf(10.999));
        test.setTotalMoney(test.getMoney().add(BigDecimal.valueOf(3)));
        boolean insert = test.insert();
        /**
         * B 插入字段为 3的数据
         */
        boolean insertb=insertB();

        Test test2 = new Test();
        test2.setTestDate(LocalDate.now());
        test2.setTestTime(LocalTime.now());
        test2.setTestTimestap(new Date());
        test2.setName("aa");
        test2.setMoney(BigDecimal.valueOf(10.999));
        test2.setTotalMoney(test2.getMoney().add(BigDecimal.valueOf(3)));
        boolean insert2 = test2.insert();


        return insert&&insertb;
    }

    @Transactional
    public boolean insertB() {
        Test test = new Test();
        test.setTestDate(LocalDate.now());
        test.setTestTime(LocalTime.now());
        test.setTestTimestap(new Date());
        test.setName("b");
        test.setMoney(BigDecimal.valueOf(10.999));
        test.setTotalMoney(test.getMoney().add(BigDecimal.valueOf(3)));
        boolean insert = test.insert();
        this.insertC();
        int bbb = 1/0;
        Test test2 = new Test();
        test2.setTestDate(LocalDate.now());
        test2.setTestTime(LocalTime.now());
        test2.setTestTimestap(new Date());
        test2.setName("bb");
        test2.setMoney(BigDecimal.valueOf(10.999));
        test2.setTotalMoney(test2.getMoney().add(BigDecimal.valueOf(3)));
        boolean insert1 = test2.insert();
        return insert&&insert1;
    }


    private boolean insertC() {
        Test test = new Test();
        test.setTestDate(LocalDate.now());
        test.setTestTime(LocalTime.now());
        test.setTestTimestap(new Date());
        test.setName("c");
        test.setMoney(BigDecimal.valueOf(10.999));
        test.setTotalMoney(test.getMoney().add(BigDecimal.valueOf(3)));
        boolean insert = test.insert();
//        int bbb = 1/0;
        Test test2 = new Test();
        test2.setTestDate(LocalDate.now());
        test2.setTestTime(LocalTime.now());
        test2.setTestTimestap(new Date());
        test2.setName("cc");
        test2.setMoney(BigDecimal.valueOf(10.999));
        test2.setTotalMoney(test2.getMoney().add(BigDecimal.valueOf(3)));
        boolean insert1 = test2.insert();
        return insert&&insert1;
    }
}

测试结果：
当A被private修饰时，B和C方法事务生效，当A被public修饰时，B和C事务都不生效
3.private和public不同类测试
TransactionalController

package com.kaka.mysql.controller;

import com.kaka.mysql.dao.entity.Test;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalTime;
import java.util.Date;

@Slf4j
@RestController
@AllArgsConstructor
@RequestMapping("/tran")
public class TransactionalController {

    private final Transactional2Controller transactional2Controller;

    @GetMapping("/test")
    public boolean A() {
        Test test = new Test();
        test.setTestDate(LocalDate.now());
        test.setTestTime(LocalTime.now());
        test.setTestTimestap(new Date());
        test.setName("a");
        test.setMoney(BigDecimal.valueOf(10.999));
        test.setTotalMoney(test.getMoney().add(BigDecimal.valueOf(3)));
        boolean insert = test.insert();
//        boolean insertb=insertB();
        transactional2Controller.insertB();

        Test test2 = new Test();
        test2.setTestDate(LocalDate.now());
        test2.setTestTime(LocalTime.now());
        test2.setTestTimestap(new Date());
        test2.setName("aa");
        test2.setMoney(BigDecimal.valueOf(10.999));
        test2.setTotalMoney(test2.getMoney().add(BigDecimal.valueOf(3)));
        boolean insert2 = test2.insert();


        return insert;
    }
}

Transactional2Controller

package com.kaka.mysql.controller;

import com.kaka.mysql.dao.entity.Test;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalTime;
import java.util.Date;

@Component
public class Transactional2Controller {


    @Transactional
    public boolean insertB() {
        Test test = new Test();
        test.setTestDate(LocalDate.now());
        test.setTestTime(LocalTime.now());
        test.setTestTimestap(new Date());
        test.setName("b");
        test.setMoney(BigDecimal.valueOf(10.999));
        test.setTotalMoney(test.getMoney().add(BigDecimal.valueOf(3)));
        boolean insert = test.insert();
        this.insertC();
        int bbb = 1/0;
        Test test2 = new Test();
        test2.setTestDate(LocalDate.now());
        test2.setTestTime(LocalTime.now());
        test2.setTestTimestap(new Date());
        test2.setName("bb");
        test2.setMoney(BigDecimal.valueOf(10.999));
        test2.setTotalMoney(test2.getMoney().add(BigDecimal.valueOf(3)));
        boolean insert1 = test2.insert();
        return insert&&insert1;
    }


    private boolean insertC() {
        Test test = new Test();
        test.setTestDate(LocalDate.now());
        test.setTestTime(LocalTime.now());
        test.setTestTimestap(new Date());
        test.setName("c");
        test.setMoney(BigDecimal.valueOf(10.999));
        test.setTotalMoney(test.getMoney().add(BigDecimal.valueOf(3)));
        boolean insert = test.insert();
//        int bbb = 1/0;
        Test test2 = new Test();
        test2.setTestDate(LocalDate.now());
        test2.setTestTime(LocalTime.now());
        test2.setTestTimestap(new Date());
        test2.setName("cc");
        test2.setMoney(BigDecimal.valueOf(10.999));
        test2.setTotalMoney(test2.getMoney().add(BigDecimal.valueOf(3)));
        boolean insert1 = test2.insert();
        return insert&&insert1;
    }
}

测试结果：
无论A被private还是被public修饰，B的事务都会生效
参考博客：
@Transactional生效场景和自调用失效场景
Spring 的事务实现原理和传播机制
spring 事务传播机制
spring 事务传播机制
spring 事务 传播机制 描述的 事务方法直接相互调用，父子事物开启，挂起，回滚 等的处理方式。 绿色的 那几个 我认为比较重要。

1 , @Transactional(propagation=Propagation.REQUIRED） 默认值 等于 @Transactional

有父方法传递过来的 事务环境，就在使用父方法的事务环境，如果父方法没有事务环境，那么就用新开启一个事物。

备注：非事务执行的意思是单条sql就提交。

例子设置： A 方法调用 B，C两个子方法。C执行后在C的方法中抛出异常

情景1 条件：A 什么都不加，B 什么都不加，C，Propagation.REQUIRED ，

结果：C 执行以后抛出异常。结果 B能写入 ，C写入的被回滚。

解析：A，B都是非事物环境，C起了一个新的事务。

情景2 条件：A 加 @Transactional ，B 什么都不加，C，Propagation.REQUIRED ，

结论：B C 的操作都回滚了

解析：B，C都是用的 A开启的事务环境，C的时候抛出异常， 全部回滚。

关键字：有就用，没有就新建一个

2 ,@Transactional( propagation=Propagation.SUPPORTS）

如果父方法没有事物换机，那么当前方法就使用非事务环境执行，如果 有，就使用父方法的事务环境。 这个和只写一个@Transactional 几乎一样

例子设置： A 方法调用 B，C两个子方法。C执行后在C的方法中抛出异常

情景1 条件：A 什么都不加，B 什么都不加，C，Propagation.SUPPORTS，

结果：B，C 都能写入成功

解析：ABC，都是非事务环境

情景2 条件：A @Transactional ，B 什么都不加，C，Propagation.SUPPORTS，

结果：B，C 都能写入后都回滚了，

解析：ABC，都处于A开启的事务环境。

关键字：有就用，没有就不用

3 @Transactional(propagation=Propagation.MANDATORY)

当前方法必须处于事物环境才能执行。

例子设置： A 方法调用 B，C两个子方法。

情景1 条件：A 什么都不加，B 什么都不加，C，Propagation.MANDATORY，

结果：执行C的时候抛出异常（ No existing transaction found for transaction marked with propagation ‘mandatory’ ）

解析：C 需要事物环境才能执行

情景2 条件：A @Transactional ，B 什么都不加，C，Propagation.MANDATORY，

结果： 正常执行到

解析：C 需要事物环境才能执行

关键字：必须要父类给我一个事务环境

4 @Transactional(propagation=Propagation.REQUIRES_NEW)

必定要新开启一个事务。

例子设置： A 方法调用 B，C两个子方法。C执行后在C的方法中抛出异常

情景1 条件：A 什么都不加，B 什么都不加，C，Propagation.REQUIRES_NEW，

结果：B 能写入，C 写入后被回滚了。

解析：在父类没有事务环境的情况下，C启动了一个新的事务

情景2 条件：A @Transactional ，B 什么都不加，C，Propagation.REQUIRES_NEW，

结果： B，C都没有写入数据

解析： 明显C 让父类事务一起回滚了。C如果 回滚，父类事物也会回滚。

情景3 条件：A @Transactional ，B 什么都不加，C，Propagation.REQUIRES_NEW， 去掉 C执行后在C的方法中抛出异常，在A中 执行完C后抛出异常。

结果： B的数据没写进去，C的数据写进去；额

解析： B 使用的A开启的事物 ，C 开启了一个新事物。并且C执行完成以后就提交了，A 里面的异常让B一起回滚了。

关键字：新建一个，父回滚子不回滚，子回滚，父也会滚。 并且子事物是在 子方法完成的时候提交的。

5 @Transactional(propagation=Propagation.NOT_SUPPORTED)

当前方法一定不回用在事务环境执行，如果父类有事务，那么就先把它挂起。 和 REQUIRED 是相反的。

例子设置： A 方法调用 B，C两个子方法。C执行后在C的方法中抛出异常

情景1 条件：A @Transactional，B 什么都不加，C，Propagation.NOT_SUPPORTED，

结果：B没有写入，C能写入。

解析：B 写入了，然后被 C里面的 抛出的异常 给触发回退了，C 里面是非事执行，能够正常写入。

关键字：不会在事务环境执行

6 @Transactional(propagation=Propagation.NEVER)

和 MANDATORY 相反 ，这个方法只能执行在非事务环境，如果父类有事物，就抛出异常

例子设置： A 方法调用 B，C两个子方法

情景1 条件：@Transactional ，B 什么都不加，C，Propagation.NEVER，

结果：抛出异常（Existing transaction found for transaction marked with propagation ‘never’）

解析：NEVER 的父方法不能有 事物环境。

关键字：父层不能有事务

7 @Transactional(propagation=Propagation.NESTED)

内嵌事物，在没有外部事务 的时候 和 REQUIRED 一样， 这个和 Propagation.REQUIRES_NEW 容易混淆 ，Propagation.REQUIRES_NEW 是挂起父事物，然后新启动一个事物，新的事务完成后先提交，新事物回滚，父事物一起回滚，

Propagation.NESTED 是在 父环境有事物的时候，会做一个保存点，然后在 如果 当前方法抛出异常，就回滚到保存点，如果 父事物 回滚，当前方法里面的写操作也回滚，而且本质上只有一个事物，所以在父方法事物提交的时候提交。

例子设置： A 方法调用 B，C两个子方法,C方法内部执行完成以后抛出异常

情景1 条件：@Transactional ，B 什么都不加，C，Propagation.NEVER，

结果： B 没有写入成功，C也没有写入成功。

解析：.这个结果和 REQUIRES_NEW 类似，不做解释，后面进一步确认。

情景2 条件：@Transactional ，B 什么都不加，C，Propagation.NEVER， ，但是抛异常的位置改成A方法内部，C方法调用以后。

结果： B 没有写入成功，C也没有写入成功。

解析：综合和上面2个例子。NESTED 内层事物回滚，外层也会滚，外层回滚内层也会回滚。并且内层事物提交的 时间节点是和外层事务 一起提交。

关键字：父子同步回滚，父子一起提交

备注：sharding JDBC 不支持 @Transactional(propagation=Propagation.NESTED)

备注2：如果方法前面不写 @Transactional ，如果这个方法被有事务环境的 方法调用。 那么这个方法会使用 父类的 事务环境。如果父类没有就每条单独提交。

海光之蓝
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring声明式事务@Transactional传播行为
王者之峰
03-03 6514
propagation = Propagation.REQUIRED 默认的传播行为，该方法需要再事务环境下运行，被调用的方法有事务的话就和它在同一个事务下属于平级那一个异常都会回滚，没有就自己开启新的事务，调用别的没事务的方法会把它加到同一个事务中。下面会给出相应example 调用A方法 @Transactional(rollbackFor = Exception.class) @O...
Spring @Transactional工作原理详解
08-28
主要介绍了Spring @Transactional工作原理详解，具有一定借鉴价值，需要的朋友可以参考下。
Spring事务和事务传播机制（@Transactional）
最新发布
m0_74312445的博客
05-14 682
Spring事务，@Transactional注解使用细节
@Transactional的多情况测试
you_do_what的博客
03-23 175
1.在同一个类中一个方法调用其它方法，且错误被try-cache抓住的情况下，无论注解加在哪里都不会回滚 public void testIn(){ try{ test2(); int i =1/0; }catch (Exception e){ test3(); } Testa testa = new Testa(); testa.setName("张三"+
Spring的@Transactional的传播机制
Yong Ledo的博客
03-13 3171
@Transactional(propagation = Propagation.REQUIRED) 针对子方法：老板没饭吃（没有事务），我有钱我可以自己吃；老板有饭吃（有事务），我也有饭吃。 @Transactional(propagation = Propagation.SUPPORTS) 针对子方法：老板没饭吃，我也没饭吃；老板有饭吃，我也有饭吃。 @Transactional(propag......
spring中@transactional注解的测试
wgg062511的博客
01-11 453
@transacitonal注解的测试： 注解的定义 @Target({ElementType.TYPE, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @Inherited @Documented public @interface Transactional { ... } 根据元注解的定义，事务注解可以定义在类、接口、枚举、方法上 ，在日常的开发中一般写到service层（约定） 常见问题分析： 在springboot项
@Transctional事务传播机制（Propagation）
zhzh980的博客
04-05 5624
Transactional注解可以作用于接口、接口方法、类以及类方法上。当作用于类上时，该类的所有public方法将都具有该类型的事务属性。当作用在方法级别时，会覆盖类级别的定义。当作用在接口和接口方法时，则只有在使用基于接口的代理时它才会生效，也就是JDK代理。在Spring中，事务的传播类型对方法执行顺序和结果都有影响。调用者和被调用者方法所定义的事务传播类型共同决定了代码的结果。ps.两个问题：Q1:类内部方法调用时，避免@Transcational失效的获取代理类方法待验证。
Java注解@Transactional事务类内调用不生效问题及解决办法
08-19
Java注解@Transactional事务类内调用不生效问题及解决办法 Java注解@Transactional是Java中的一种注解，主要用于标记事务边界。然而，在某些情况下，@Transactional注解可能不会生效，例如在同一个类中的方法调用...
Spring @Transactional注解失效解决方案
08-25
本篇文章将详细介绍 @Transactional 注解失效解决方案，通过示例代码和详细的解释，帮助开发者解决 @Transactional 注解失效的问题。 一、了解 @Transactional 注解的特性 在了解解决方案之前，我们首先需要了解 @...
带有@Transactional和@Async的循环依赖问题的解决
08-19
解决带有@Transactional和@Async的循环依赖问题 在Spring框架中，使用@Transactional和@Async注解可以实现事务处理和异步调用。但是，在某些情况下，这两个注解的组合使用可能会导致循环依赖问题。本文将介绍这种...
Spring声明式事务@Transactional知识点分享
08-25
"Spring声明式事务@Transactional知识点分享" 在 Spring 框架中，@Transactional 注解是实现声明式...@Transactional 注解是 Spring 框架中实现声明式事务的关键，可以灵活地控制事务的传播行为、隔离级别和读写控制。
@Transactional的四种隔离级别测试
C18298182575的博客
11-14 482
@Transactional
Spring中，@Transactional 注解的失效测试以及传播行为测试
一个胖子IT男的博客
08-06 398
分别测试四种情况： 同一个service中，A方法调用B方法，B方法抛异常 同一个service中，A方法调用B方法，A方法抛异常 service1中A方法，调用service2中B方法，B方法抛异常 service1中A方法，调用service2中B方法，A方法抛异常 分别测试A、B方法加上@Transactional注解 Controller层： @RestController @Requ...
@Transactional里事务的隔离级别和事务的传播机制
qq_15654285的博客
07-25 350
spring事务
实践理解 Transactional 是否生效
一生编程，快乐编程
01-31 421
执行A方法，抛异常后，update_time 已更新为最新时间，更新成功，说明事务没有回滚。@Transactional 底层是通过 AOP 动态代理实现的，如果在同一个类中调用，就不是通过代理类调用了，事务不会生效。如果在 Service 服务层 catch异常，那么 @Transactional 会认为方法正常执行，没有异常，不会回滚。执行A方法，抛异常后，update_time 没有更新成功，说明事务回滚了。执行A方法，抛异常后，update_time 没有更新成功，说明事务回滚了。
@Transactional注解作用，不生效的场景，事务回滚
学Java，找哪吒
05-27 7609
目前已经800+订阅，CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
Spring 事务传播行为-测试代码+源码分析
wuhulala的休息室
04-15 974
spring事务有如下七种类型 REQUIRED 默认，需要事务，没有则新建 REQUIRED_NEW 需要新事务，每次都新建 SUPPORTS 支持事务但不强制有事务 NOT_SUPPORTS 不支持事务，有事务挂起事务，执行完方法再唤醒 MONDATORY 强制事务，没有事务抛出异常 NEVER 当前方法不能有事务，否则抛出异常 NESTED 嵌套事务，无论是否有事务都会创建一个内部事务事...
@Transactional注解生效机制
牧码人的博客
02-19 1301
前言 近期项目中遇到很多需要事务处理的逻辑，所以对@Transactional注解的作用条件测试了一番。 @Transactional注解是spring定义的一个注解，可以被子类继承，可以声明在类型、方法上，声明在类型时，可以看作给该类型下的所有方法都加了注解。 测试过程 具体测试流程过于繁琐，暂时就不记录了，有时间再补充。 思路就是在不同的调用方式下，给不同的方法加上@Transactional注解，在测试的方法中手动抛出一个运行时异常，看数据库中记录是否回滚。 结论 假定有一个对象类Object及其实例
Spring事务理解和配置
Student108的博客
09-07 2477
文章目录1 Spring事务1.1 事务简介1.1.1 什么是事务1.1.2 事物的特性1.1.3 不考虑事物会引发的安全问题1.1.4 事务隔离级别1.2 事务的传播行为1.3 编程式事务(需要手动写代码,了解)1.3.1 配置平台事务管理器1.3.2 Spring提供了事务管理的模板类1.3.3 在业务层注入事务管理的模板1.3.4 编写事务管理的代码1.4 声明式事务(xml配置)1.4.1 配置事务管理器1.4.2 配置增强1.4.3 AOP的配置1.5 声明式事务(注解)1.5.1 配置事务管理器
@Transactional原理以及失效的场景？
05-13
如果在一个方法中使用了多个@Transactional注解，并且它们的传播级别不同，那么可能会导致事务失效。这是因为Spring不支持嵌套事务的回滚。 了解这些场景可以帮助我们更好地使用@Transactional注解，从而保证数据的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值