spring 中事务注解@Transactional与trycatch的使用

spring事务注解@Transactional与trycatch

在项目中 @service层中 我们会经常在做一些增删改操作的方法上看到 spring 的事务注解 @transaction 已知@transaction 是让spring 帮我们实现事务的控制。

但是在项目中会经常看到 有的方法中 会存在trycatch块包括的方法上注解着@transaction

eg:

 @Override
    @Transactional
    public Json addOrder(TOrderAddReq tOrderAddReq) {
  try{
    //增删改方法
        } catch (Exception e) {
            .....
            e.printStackTrace();}
//        }
        return json;
    }

上述的方法执行后可以看到事务并没有执行,接下来再看一个例子eg:

 @Override
    @Transactional
    public Json addOrder(TOrderAddReq tOrderAddReq) {
  try{
    //增删改方法
        } catch (Exception e) {
         // 手动硬编码开启spring事务管理
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            e.printStackTrace();}
//        }
        return json;
    }

上述方法执行后我们可以看到事务最后执行了,但实际上 事务 执行只是因为手动硬编码开启spring事务管理起了作用 而方法上的注解并没有起作用

接下来再看一个例子eg

 @Override
    @Transactional
    public Json addOrder(TOrderAddReq tOrderAddReq) {
  try{
    //增删改方法
        } catch (Exception e) {

            throw new RuntimeException();
            }
//        }
        return json;
    }

上述方法执行后我们可以看到事务是执行了的,但这里有个小细节:@Transactional不做任何配置 默认是对抛出的unchecked异常回滚,checked异常不会回滚,为了让所有异常都会让事务启动可以将 @Transactional配置为 @Transactional(rollbackFor = Exception.class)

解释:

spring的事务边界是在调用业务方法之前开始的,业务方法执行完毕之后来执行commit or rollback(spring默认取决于是否抛出runtime异常).

如果抛出runtime exception 并在你的业务方法中没有catch到的话,事务会回滚。

一般不需要在业务方法中catch异常,如果非要catch,在做完你想做的工作后(比如关闭文件等)一定要抛出runtime exception,否则spring会将你的操作commit,这样就会产生脏数据.所以你的catch代码是画蛇添足。

@Transactional回滚问题(try catch、嵌套)

Spring 事务注解 @Transactional 本来可以保证原子性,如果事务内有报错的话,整个事务可以保证回滚,但是加上try catch或者事务嵌套,可能会导致事务回滚失败。测试一波。

准备

建两张表,模拟两个数据操作

CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(20) DEFAULT NULL,
  `age` smallint(3) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
CREATE TABLE `role` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `role_name` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;

测试

根据排列组合原理,我们进行四种测试:1、无try catch、无嵌套;2、有try catch、无嵌套;3、无try catch、有嵌套;4、都有。

最简单测试

如果我们单纯@Transactional,事务可以正常回滚吗?

    @GetMapping("/saveNormal0")
    @Transactional
    public void saveNormal0() throws Exception {
        int age = random.nextInt(100);
        User user = new User().setAge(age).setName("name:"+age);
        userService.save(user);
        throw new RuntimeException();
    }

如果事务内报了RuntimeException错误,事务可以回滚。

    @GetMapping("/saveNormal0")
    @Transactional
    public void saveNormal0() throws Exception {
        int age = random.nextInt(100);
        User user = new User().setAge(age).setName("name:"+age);
        userService.save(user);
        throw new Exception();
    }

如果事务内报了Exception错误(非RuntimeException错误),事务不可以回滚。

    @GetMapping("/saveNormal0")
    @Transactional( rollbackFor = Exception.class)
    public void saveNormal0() throws Exception {
        int age = random.nextInt(100);
        User user = new User().setAge(age).setName("name:"+age);
        userService.save(user);
        throw new Exception();
    }

如果是Exception错误(非RuntimeException),加上 rollbackFor = Exception.class 参数也可以实现回滚。

结论一:对于@Transactional可以保证RuntimeException错误的回滚,如果想保证非RuntimeException错误的回滚,需要加上rollbackFor = Exception.class 参数。

try catch 影响

经过博主多种情况测试,发现try catch对回滚这个事本身没有什么影响,结论一照样成立。try catch只是对异常是否可以被@Transactional 感知 到有影响。如果错误抛到切面可以感知到的地步,那就可以起作用。

    @GetMapping("/saveTryCatch")
    @Transactional( rollbackFor = Exception.class)
    public void saveTryCatch() throws Exception{
        try{
            int age = random.nextInt(100);
            User user = new User().setAge(age).setName("name:"+age);
            userService.save(user);
            throw new Exception();
        }catch (Exception e){
            throw e;
        }
    }

比如上面一段代码就回滚了。

    @GetMapping("/saveTryCatch")
    @Transactional( rollbackFor = Exception.class)
    public void saveTryCatch() throws Exception{
        try{
            int age = random.nextInt(100);
            User user = new User().setAge(age).setName("name:"+age);
            userService.save(user);
            throw new Exception();
        }catch (Exception e){
        }
    }

然而,将catch中的错误不继续网上抛,切面无法感知到错误,无法进行处理,那么事务就无法回滚了。

结论二:try catch只是对异常是否可以被@Transactional 感知 到有影响。如果错误抛到切面可以感知到的地步,那就可以起作用。

事务嵌套 影响

首先经过实验,结论一仍然成立,即,当不加上rollbackFor = Exception.class 的时候,无论内外报RuntimeException,都会回滚;无论内外报 非RuntimeException 错误,都不会回滚。如果加上rollbackFor = Exception.class,无论内外怎么报错,都会回滚。这些代码就不给出了。接下来,试下下面两种情况:

    @GetMapping("/out")
    @Transactional( rollbackFor = Exception.class)
    public void out() throws Exception{
        innerService.inner();
        int age = random.nextInt(100);
        User user = new User().setAge(age).setName("name:" + age);
        userService.save(user);
        throw new Exception();
    }
    @Transactional
    public void inner() throws Exception{
        Role role = new Role();
        role.setRoleName("roleName:"+new Random().nextInt(100));
        roleService.save(role);
//        throw new Exception();
    }

情况一,外面事务加上rollbackFor = Exception.class,里面事务不加,测试内外分别报错的情况(为了简化代码量,只给出了外面报错的代码),都可以回滚。因为,无论如何,错误都抛给了外面那个事务进行处理,而外面那个加上了rollbackFor = Exception.class,具备处理非RuntimeException错误的能力,所以都可以让事务进行正常回滚。

下面看情况二,里面的事务加上rollbackFor = Exception.class,外面不加,外面报错。

    @GetMapping("/out")
    @Transactional
    public void out() throws Exception{
        innerService.inner();
        int age = random.nextInt(100);
        User user = new User().setAge(age).setName("name:" + age);
        userService.save(user);
        throw new Exception();
    }

    @Transactional( rollbackFor = Exception.class)
    public void inner() throws Exception{
        Role role = new Role();
        role.setRoleName("roleName:"+new Random().nextInt(100));
        roleService.save(role);
    }

事务都无法回滚,这是我们有个疑问,里面的事务明明有很强的处理能力啊,为什么和外面一起回滚失败呢,别着急,等等聊这个。

然后试下里面报错:

    @GetMapping("/out")
    @Transactional
    public void out() throws Exception{
        innerService.inner();
        int age = random.nextInt(100);
        User user = new User().setAge(age).setName("name:" + age);
        userService.save(user);
    }
     @Transactional( rollbackFor = Exception.class)
    public void inner() throws Exception{
        Role role = new Role();
        role.setRoleName("roleName:"+new Random().nextInt(100));
        roleService.save(role);
        throw new Exception();
    }

咦,这回都进行了正常的回滚。我的天,这回外面没有处理能力,为什么接受里面抛出来的错误,也进行了回滚!!!看上去,就好像里外事务总是同生共死的对不对?原来,@Transactional还有个参数,看下源码,这个注解还有默认值:

Propagation propagation() default Propagation.REQUIRED;

REQUIRED的意思是说,事务嵌套的时候,如果发现已经有事务存在了,就加入这个事务,而不是新建一个事务,所以根本就不存在两个事务,一直只有一个!至于,此参数其他值,本文不进行测试。回到上面的问题,当外面报错的时候,此时查看事务,没有增加rollbackFor = Exception.class参数,即没有处理非RuntimeException能力,所以代码走完,貌似“两个事务”,都回滚失败了。当里面报错的时候,事务已经添加上了处理非RuntimeException能力,所以,代码走完就回滚成功了。

结论三:由于REQUIRED属性,“两个事务”其实是一个事务,处理能力看报错时刻,是否添加了处理非RuntimeException的能力。

try catch和事务嵌套 共同影响

在结论一二三成立的条件下,探索共同影响的问题就简单多了,由于情况太多,就不进行过多的代码展示了。

结论

结论一:

对于@Transactional可以保证RuntimeException错误的回滚,如果想保证非RuntimeException错误的回滚,需要加上rollbackFor = Exception.class 参数。

结论二:

try catch只是对异常是否可以被@Transactional 感知 到有影响。如果错误抛到切面可以感知到的地步,那就可以起作用。

结论三:

由于REQUIRED属性,“两个事务”其实是一个事务,处理能力看报错时刻,是否添加了处理非RuntimeException的能力。

以上为个人经验,希望能给大家一个参考,也希望大家多多支持我们。

(0)

相关推荐

  • 解决@Transactional注解事务不回滚不起作用的问题

    这几天在项目里面发现我使用@Transactional注解事务之后,抛了异常居然不回滚.后来终于找到了原因. 如果你也出现了这种情况,可以从下面开始排查. 一.特性 先来了解一下@Transactional注解事务的特性吧,可以更好排查问题 1.service类标签(一般不建议在接口上)上添加@Transactional,可以将整个类纳入spring事务管理,在每个业务方法执行时都会开启一个事务,不过这些事务采用相同的管理方式. 2.@Transactional 注解只能应用到 public 可

  • springboot中事务管理@Transactional的注意事项与使用场景

    前言:在service层的方法上使用@Transactional 即可实现处理数据库发生错误时触发事务回滚机制. 注意: Spring 基于注解的声明式事物 @Transactional 默认情况下只会对运行期异常(java.lang.RuntimeException及其子类)和 Error 进行回滚. 数据库引擎要支持事物,使用InnoDB. @Transactional 只能被应用到public方法上, 对于其它非public的方法,如果标记了@Transactional也不会报错,但方法没

  • 关于Spring的@Transaction导致数据库回滚全部生效问题(又删库跑路)

    1 前言 很多需要使用事务的场景,都只是在方法上直接添加个@Transactional注解 但是,你以为这真的够了吗? 事务如果未达到完美效果,在开发和测试阶段都难以被发现,因为你难以考虑到太多意外场景.但当业务数据量发展,就可能导致大量数据不一致的问题,就会造成前人栽树后人踩坑,需要大量人力排查解决问题和修复数据. 2 如何确认Spring事务生效了? 使用@Transactional一键开启声明式事务, 这就真的事务生效了?过于信任框架总有"意外惊喜".来看如下案例 领域层 实体

  • 浅谈Spring中@Transactional事务回滚及示例(附源码)

    一.使用场景举例 在了解@Transactional怎么用之前我们必须要先知道@Transactional有什么用.下面举个栗子:比如一个部门里面有很多成员,这两者分别保存在部门表和成员表里面,在删除某个部门的时候,假设我们默认删除对应的成员.但是在执行的时候可能会出现这种情况,我们先删除部门,再删除成员,但是部门删除成功了,删除成员的时候出异常了.这时候我们希望如果成员删除失败了,之前删除的部门也取消删除.这种场景就可以使用@Transactional事物回滚. 二.checked异常和unc

  • spring 中事务注解@Transactional与trycatch的使用

    spring事务注解@Transactional与trycatch 在项目中 @service层中 我们会经常在做一些增删改操作的方法上看到 spring 的事务注解 @transaction 已知@transaction 是让spring 帮我们实现事务的控制. 但是在项目中会经常看到 有的方法中 会存在trycatch块包括的方法上注解着@transaction eg: @Override @Transactional public Json addOrder(TOrderAddReq tO

  • Spring事务注解@Transactional失效的八种场景分析

    首先说一下最近自己遇到的一个坑: @Transactional service A(){ try{ insert(); serviceB.update(); }catch(){ throw new RunTimeException(); } } serviceB(){ @Transactional update(){ try{ mapperB.update(); }catch(){ throw new RunTimeException(); } } } mapperB (){ try{ //do

  • spring中的注解事务演示和添加步骤详情

    目录 添加注解效果事务演示 基于注解的事务添加步骤 添加不回滚属性设置 @Transactional注解参数详解 添加注解效果事务演示 注解我们经常会用到,或者在jdk源码中也会看到,例如: @Deprecated以及我们在spring或者springboot中经常用到@Controller.@Service.@Repository.@Entity等注解. 基于注解的事务添加步骤 1)在applicationContext_service.xml文件中添加事务管理器 <bean id="t

  • Spring中@Async注解实现异步调详解

    异步调用 在解释异步调用之前,我们先来看同步调用的定义:同步就是整个处理过程顺序执行,当各个过程都执行完毕,并返回结果. 异步调用则是只是发送了调用的指令,调用者无需等待被调用的方法完全执行完毕,继续执行下面的流程.例如, 在某个调用中,需要顺序调用 A, B, C三个过程方法:如他们都是同步调用,则需要将他们都顺序执行完毕之后,过程才执行完毕: 如B为一个异步的调用方法,则在执行完A之后,调用B,并不等待B完成,而是执行开始调用C,待C执行完毕之后,就意味着这个过程执行完毕了. 概述说明 Sp

  • spring中12种@Transactional的失效场景(小结)

    目录 一.失效场景集一:代理不生效 二.失效场景集二:框架或底层不支持的功能 三.失效场景集三:错误使用@Transactional 四.总结 数据库事务是后端开发中不可缺少的一块知识点.Spring为了更好的支撑我们进行数据库操作,在框架中支持了两种事务管理的方式: 编程式事务声明式事务 日常我们进行业务开发时,基本上使用的都是声明式事务,即为使用@Transactional注解的方式. 常规使用时,Spring能帮我们很好的实现数据库的ACID (这里需要注意哦,Spring只是进行了编程上

  • Spring中事务几个常见的问题解决

    目录 前言 Spring如何处理事务 1.编程式事务,可以使用TransactionTemplate 2.声明式事务 Spring事务传播机制 Spring事务隔离级别 前言 首先,事务这个概念是数据库层面的,Spring只是基于数据库中的事务进行扩展,以及提供了一些能让程序员更新方便操作事务的方式 Spring如何处理事务 Spring中支持编程式事务和声明式事务管理两种方式 1.编程式事务,可以使用TransactionTemplate public class B { @Autowired

  • Java 事务注解@Transactional回滚(try catch、嵌套)问题

    目录 前言 准备 测试 最简单测试 try catch 影响 事务嵌套 影响 try catch和事务嵌套 共同影响 结论 前言 Spring 事务注解 @Transactional 本来可以保证原子性,如果事务内有报错的话,整个事务可以保证回滚,但是加上try catch或者事务嵌套,可能会导致事务回滚失败.测试一波. 准备 建两张表,模拟两个数据操作 CREATE TABLE `user` ( `id` int(11) NOT NULL AUTO_INCREMENT, `name` varc

  • Spring中异步注解@Async的使用、原理及使用时可能导致的问题及解决方法

    前言 其实最近都在研究事务相关的内容,之所以写这么一篇文章是因为前面写了一篇关于循环依赖的文章: <Spring循环依赖的解决办法,你真的懂了吗> 然后,很多同学碰到了下面这个问题,添加了Spring提供的一个异步注解@Async循环依赖无法被解决了,下面是一些读者的留言跟群里同学碰到的问题: 本着讲一个知识点就要讲明白.讲透彻的原则,我决定单独写一篇这样的文章对@Async这个注解做一下详细的介绍,这个注解带来的问题远远不止循环依赖这么简单,如果对它不够熟悉的话建议慎用. 文章要点 @Asy

  • 浅谈Spring 中 @EnableXXX 注解的套路

    目录 前言 设计目标 @EnableScheduling (导入一个 @Configuration 类) @EnableTransactionManagement(导入一个 ImportSelector) @EnableAspectJAutoProxy (在 Bean 定义层导入) 结论 前言 在 Spring 框架中有很多实用的功能,不需要写大量的配置代码,只需添加几个注解即可开启. 其中一个重要原因是那些 @EnableXXX 注解,它可以让你通过在配置类加上简单的注解来快速地开启诸如事务管

  • Spring中常用注解的详细介绍

    spring中使用注解时配置文件的写法: <?xml version="1.0" encoding="UTF-8"?> <span style="font-size:18px;"><beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-in

随机推荐