Spring Boot项目业务代码中使用@Transactional事务失效踩坑点总结自然就没有事务控制了

2024-06-30 16:15:27 [百科] 来源：避面尹邢网

Spring Boot项目业务代码中使用@Transactional事务失效踩坑点总结

作者：Shepherd 2023-08-29 10:51:44开发项目管理 Spring 是项目通过 AOP 技术对方法进行增强实现事务控制的，要调用增强过的业务用方法必然是调用代理后的对象，而这里this是代码点总原生对象，并不是中使代理，自然就没有事务控制了。事务失效

1.概述

接着之前我们对Spring AOP以及基于AOP实现事务控制的踩坑上文，今天我们来看看平时在项目业务开发中使用声明式事务@Transactional的项目失效场景，并分析其失效原因，业务用从而帮助开发人员尽量避免踩坑。代码点总

我们知道 Spring 声明式事务功能提供了极其方便的中使事务配置方式，配合 Spring Boot 的事务失效自动配置，大多数 Spring Boot 项目只需要在方法上标记 @Transactional 注解，踩坑即可一键开启方法的项目事务性配置。当然后端开发人员对数据库事务这个概念并不陌生，业务用也知道如果整体考虑多个数据库操作要么成功要么失败时，代码点总需要通过数据库事务来实现多个操作的一致性和原子性。如下所示：

Spring Boot项目业务代码中使用@Transactional事务失效踩坑点总结自然就没有事务控制了

@Override    @Transactional(rollbackFor = Exception.class)    public void addUser(UserParam param) {         User user = PtcBeanUtils.copy(param, User.class);        userDAO.insert(user);        if (!CollectionUtils.isEmpty(param.getRoleIds())) {             userRoleService.addUserRole(user.getId(), param.getRoleIds());        }    }

新增用户的同时还添加了用户角色，这里就是使用@Transactional来控制事务保证一致性的。但大多数开发仅限于为方法标记 @Transactional来开启声明式事务，认为就可以高枕无忧了，不会去关注事务是否有效、出错后事务是否正确回滚，也不会考虑复杂的业务代码中涉及多个子业务逻辑时，怎么正确处理事务。事务没有被正确处理，一般来说不会过于影响正常流程，也不容易在测试阶段被发现。但当系统越来越复杂、压力越来越大之后，就会带来大量的数据不一致问题，随后就是大量的人工介入查看和修复数据。

Spring Boot项目业务代码中使用@Transactional事务失效踩坑点总结自然就没有事务控制了

正是因为声明式事务@Transactional使用简单，所以很多开发人员不注重细节点，但是@Transactional条条框框还蛮多的，可谓是细节点拉满，如果不注意也不小心就会掉进坑里，今天就让我们一起来了解使用细节，把坑填平咯。

Spring Boot项目业务代码中使用@Transactional事务失效踩坑点总结自然就没有事务控制了

2.@Transactional

话不多说，先看看该注解定义

@Target({ ElementType.TYPE, ElementType.METHOD})@Retention(RetentionPolicy.RUNTIME)@Inherited@Documentedpublic @interface Transactional {  @AliasFor("transactionManager") String value() default ""; @AliasFor("value") String transactionManager() default ""; Propagation propagation() default Propagation.REQUIRED; Isolation isolation() default Isolation.DEFAULT; int timeout() default TransactionDefinition.TIMEOUT_DEFAULT; boolean readOnly() default false; Class<? extends Throwable>[] rollbackFor() default { }; String[] rollbackForClassName() default { }; Class<? extends Throwable>[] noRollbackFor() default { }; String[] noRollbackForClassName() default { };}

从上面看出@Transactional既可以作用于类上，也可以作用于方法上，作用于类：表示所有该类的**public**方法都配置相同的事务属性信息。接下来再看看其属性：

propagation：设置事务的传播行为，主要解决是A方法调用B方法时，事务的传播方式问题的，默认值为 **Propagation.REQUIRED**，其他属性值信息如下：

事务传播行为	解释
REQUIRED（默认值）	A调用B，B需要事务，如果A有事务B就加入A的事务中，如果A没有事务，B就自己创建一个事务
REQUIRED_NEW	A调用B，B需要新事务，如果A有事务就挂起，B自己创建一个新的事务
SUPPORTS	A调用B，B有无事务无所谓，A有事务就加入到A事务中，A无事务B就以非事务方式执行
NOT_SUPPORTS	A调用B，B以无事务方式执行，A如有事务则挂起
NEVER	A调用B，B以无事务方式执行，A如有事务则抛出异常
MANDATORY	A调用B，B要加入A的事务中，如果A无事务就抛出异常
NESTED	A调用B，B创建一个新事务，A有事务就作为嵌套事务存在，A没事务就以创建的新事务执行

isolation ：事务的隔离级别，默认值为 Isolation.DEFAULT。指定事务的隔离级别，事务并发存在三大问题：脏读、不可重复读、幻读/虚读。可以通过设置事务的隔离级别来保证并发问题的出现，常用的是READ_COMMITTED 和REPEATABLE_READ

isolation属性	解释
DEFAULT	默认隔离级别，取决于当前数据库隔离级别，例如MySQL默认隔离级别是REPEATABLE_READ
READ_UNCOMMITTED	A事务可以读取到B事务尚未提交的事务记录，不能解决任何并发问题，安全性最低，性能最高
READ_COMMITTED	A事务只能读取到其他事务已经提交的记录，不能读取到未提交的记录。可以解决脏读问题，但是不能解决不可重复读和幻读
REPEATABLE_READ	A事务多次从数据库读取某条记录结果一致，可以解决不可重复读，不可以解决幻读
SERIALIZABLE	串行化，可以解决任何并发问题，安全性最高，但是性能最低

timeout ：事务的超时时间，默认值为 -1。如果超过该时间限制但事务还没有完成，则自动回滚事务。

readOnly：指定事务是否为只读事务，默认值为 false；为了忽略那些不需要事务的方法，比如读取数据，可以设置 read-only 为 true。

rollbackFor：用于指定能够触发事务回滚的异常类型，可以指定多个异常类型。

noRollbackFor：抛出指定的异常类型，不回滚事务，也可以指定多个异常类型。

项目推荐：基于SpringBoot2.x、SpringCloud和SpringCloudAlibaba企业级系统架构底层框架封装，解决业务开发时常见的非功能性需求，防止重复造轮子，方便业务快速开发和企业技术栈框架统一管理。引入组件化的思想实现高内聚低耦合并且高度可配置化，做到可插拔。严格控制包依赖和统一版本管理，做到最少化依赖。注重代码规范和注释，非常适合个人学习和企业使用
Github地址：https://github.com/plasticene/plasticene-boot-starter-parent
Gitee地址：https://gitee.com/plasticene3/plasticene-boot-starter-parent
微信公众号：Shepherd进阶笔记
交流探讨qun：Shepherd_126

3.@Transactional失效场景、原因及修正方式

3.1 同一个类中的方法通过this调用导致失效

public void addUser(UserParam param) {         User user = PtcBeanUtils.copy(param, User.class);        // 新增用户        userDAO.insert(user);        // 添加用户角色        this.addUserRole(user.getId(), param.getRoleIds());        log.info("执行结束了");    }    @Transactional(rollbackFor = Exception.class)    public void addUserRole(Long userId, List<Long> roleIds) {         if (CollectionUtils.isEmpty(roleIds)) {             return;        }        List<UserRole> userRoles = new ArrayList<>();        roleIds.forEach(roleId -> {             UserRole userRole = new UserRole();            userRole.setUserId(userId);            userRole.setRoleId(roleId);            userRoles.add(userRole);        });        userRoleDAO.insertBatch(userRoles);        throw new RuntimeException("发生异常咯");    }

执行#addUser()会发现事务控制失效，发生异常事务并没有回滚，用户和角色绑定都插入成功了。

这里，我给出@Transactional 生效原则 1，必须通过代理过的类从外部调用目标方法才能生效.

图片

Spring 是通过 AOP 技术对方法进行增强实现事务控制的，要调用增强过的方法必然是调用代理后的对象，而这里this是原生对象，并不是代理，自然就没有事务控制了。

修正方式：①：将this换成代理的userService, 可以自己注入自己@Resource private UserService userService，当然也可以不用注入，直接在Spring容器中获取userService这个bean ②将#addUser()方法开启事务即加上@Transactional(rollbackFor = Exception.class)，这里本就该开启，只是为了演示失效情况没加上，因为在#addUser()里面有插入用户的操作涉及到事务的所以本要开启。当然如果#addUser()只是做一些判断、逻辑处理不涉及到数据库事务操作，那么这样解决就显得有点不太合适，而且容易导致另一种事务失效的情况，即因为没有正确处理异常，导致事务即便生效也不一定能回滚。

3.2 异常被catch“吃掉了”导致@Transactional失效

如下所示：

@Transactional(rollbackFor = Exception.class)    public void addUser(UserParam param) {         try {             User user = PtcBeanUtils.copy(param, User.class);            // 完成一些逻辑处理                      .......                          // 添加用户角色            this.addUserRole(user.getId(), param.getRoleIds());            log.info("执行结束了");        } catch (Exception e) {             log.error(e.getMessage());        }    }    @Transactional(rollbackFor = Exception.class)    public void addUserRole(Long userId, List<Long> roleIds) {         if (CollectionUtils.isEmpty(roleIds)) {             return;        }        List<UserRole> userRoles = new ArrayList<>();        roleIds.forEach(roleId -> {             UserRole userRole = new UserRole();            userRole.setUserId(userId);            userRole.setRoleId(roleId);            userRoles.add(userRole);        });        userRoleDAO.insertBatch(userRoles);        throw new RuntimeException("发生异常咯");    }

@Transactional生效原则2：只有异常传播出了标记了 @Transactional 注解的方法，事务才能回滚。之前我们总结过基于AOP事务控制实现原理说过在 Spring的 TransactionAspectSupport 里有个 invokeWithinTransaction 方法，里面就是处理事务的逻辑。可以看到，只有捕获到异常才能进行后续事务处理：

protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,   final InvocationCallback invocation) throws Throwable {             ......              try {     // This is an around advice: Invoke the next interceptor in the chain.    // This will normally result in a target object being invoked.    retVal = invocation.proceedWithInvocation();   }   catch (Throwable ex) {     // target invocation exception        // 捕获到异常，进行回滚操作，如果我们在业务方法已经捕获掉异常，这里就捕获不到了，自然就不会回滚了    completeTransactionAfterThrowing(txInfo, ex);    throw ex;   }   finally {     cleanupTransactionInfo(txInfo);   }        ......           return result;  } }

可以看到，只有捕获到异常时才进行回滚操作，如果我们在业务方法已经捕获掉异常，这里就捕获不到了，自然就不会回滚了。

修正方式：就是对异常捕获尽量做到局部针对操作，不要笼统把整个方法的代码逻辑都包括进行，这样异常就抛出去了。

3.3 @Transactional 属性 rollbackFor 设置错误，导致异常不满足回滚条件

直接看代码：

@Transactional  public void addUser(UserParam param) {       User user = PtcBeanUtils.copy(param, User.class);             .......              // 添加用户角色      this.addUserRole(user.getId(), param.getRoleIds());      log.info("执行结束了");    }    public void addUserRole(Long userId, List<Long> roleIds) throws Exception {         if (CollectionUtils.isEmpty(roleIds)) {             return;        }        List<UserRole> userRoles = new ArrayList<>();        roleIds.forEach(roleId -> {             UserRole userRole = new UserRole();            userRole.setUserId(userId);            userRole.setRoleId(roleId);            userRoles.add(userRole);        });        userRoleDAO.insertBatch(userRoles);        throw new Exception("发生异常咯");    }

这里#addUser()使用@transactional，但没有设置rollbackFor属性，且#addUserRole()抛出的异常是exception，不是RuntimeException，这样事务也失效了，因为默认情况下，出现 RuntimeException（非受检异常）或 Error 的时候，Spring才会回滚事务

从上面3.2小节的completeTransactionAfterThrowing(txInfo, ex);进去完成回滚操作会判断异常类型是否满足规定，DefaultTransactionAttribute 类能看到如下代码块，可以发现相关证据，通过注释也能看到 Spring 这么做的原因，大概的意思是受检异常一般是业务异常，或者说是类似另一种方法的返回值，出现这样的异常可能业务还能完成，所以不会主动回滚；而Error 或 RuntimeException 代表了非预期的结果，应该回滚：

public boolean rollbackOn(Throwable ex) {   return (ex instanceof RuntimeException || ex instanceof Error); }

修正方法：设置rollbackFor：@Transactional(rollbackFor = Exception.class)

3.4 @Transactional 应用在非 public 修饰的方法上

@Transactional(rollbackFor = Exception.class)    private void addUserRole(Long userId, List<Long> roleIds) {         if (CollectionUtils.isEmpty(roleIds)) {             return;        }        List<UserRole> userRoles = new ArrayList<>();        roleIds.forEach(roleId -> {             UserRole userRole = new UserRole();            userRole.setUserId(userId);            userRole.setRoleId(roleId);            userRoles.add(userRole);        });        userRoleDAO.insertBatch(userRoles);        throw new RuntimeException("发生异常咯");    }

idea也会提示爆红：

图片

Spring通过CGLIB动态代理来增强生产代理对象，CGLIB 通过继承方式实现代理类，private 方法在子类不可见，自然也就无法进行事务增强。s在基于AOP事务控制实现原理一文中也分析过，会调用到AbstractFallbackTransactionAttributeSource的computeTransactionAttribute()方法

@Nullable protected TransactionAttribute computeTransactionAttribute(Method method, @Nullable Class<?> targetClass) {     // Don't allow no-public methods as required.    if (allowPublicMethodsOnly() && !Modifier.isPublic(method.getModifiers())) {      return null;    }        ...... }

修正方式：自然是改成public

3.5 @Transactional 注解传播属性 propagation 设置错误

如上面我们新增的用户的同时要添加用户角色，但是假如我们希望即使添加角色错误了，还可以正常新增用户。

public void addUser(UserParam param) {       String username = param.getUsername();      checkUsernameUnique(username);      User user = PtcBeanUtils.copy(param, User.class);      // 添加用户      userDAO.insert(user);      // 添加用户角色      userRoleService.addUserRole(user.getId(), param.getRoleIds());     }

#userRoleService.addUserRole()

@Transactional(rollbackFor = Exception.class)  private void addUserRole(Long userId, List<Long> roleIds) {       if (CollectionUtils.isEmpty(roleIds)) {           return;      }      List<UserRole> userRoles = new ArrayList<>();      roleIds.forEach(roleId -> {           UserRole userRole = new UserRole();          userRole.setUserId(userId);          userRole.setRoleId(roleId);          userRoles.add(userRole);      });      userRoleDAO.insertBatch(userRoles);      throw new RuntimeException("发生异常咯");  }

你会发现只会同时插入失败，无法实现上面所说的。这时候你可能会想到，既然addUserRole()抛出了异常不能插入用户角色，但是addUser()不想受影响，正常添加用户，那么何不在addUser()里面对userRoleService.addUserRole()进行异常捕获，不就可以解决问题了吗？真是如此吗，就让我们来验证一下：

@Transactional(rollbackFor = Exception.class)    public void addUser(UserParam param) {         User user = PtcBeanUtils.copy(param, User.class);        // 添加用户        userDAO.insert(user);        // 添加用户角色        try {             userRoleService.addUserRole(user.getId(), param.getRoleIds());        } catch (Exception e) {             log.error(e.getMessage());        }    }

执行会发现，用户同样没有添加成功，看日志报错：

[1689568520410750976] [ERROR] [2023-08-10 17:25:02.023] [http-nio-18888-exec-1@56682]  com.plasticene.fast.service.impl.UserServiceImpl addUser : 发生异常咯[1689568520410750976] [ERROR] [2023-08-10 17:25:02.097] [http-nio-18888-exec-1@56682]  com.plasticene.boot.web.core.global.GlobalExceptionHandler exceptionHandler : 【系统异常】org.springframework.transaction.UnexpectedRollbackException: Transaction rolled back because it has been marked as rollback-only at org.springframework.transaction.support.AbstractPlatformTransactionManager.processRollback(AbstractPlatformTransactionManager.java:870)

可以看到发生异常咯是我们在addUser()中捕获到输出的，但是紧接着下一行发现有报出一个异常UnexpectedRollbackException。

原因是，主方法添加用户的逻辑和子方法添加用户角色的逻辑是同一个事务，子逻辑标记了事务需要回滚，主逻辑自然也不能提交了。

修正方式：其实要想新增用户角色失败不影响添加用户，只需要让新增用户角色单独开启一个新事务即可。

@Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRES_NEW)    public void addUserRole(Long userId, List<Long> roleIds) {         List<UserRole> userRoles = new ArrayList<>();        roleIds.forEach(roleId -> {             UserRole userRole = new UserRole();            userRole.setUserId(userId);            userRole.setRoleId(roleId);            userRoles.add(userRole);        });        userRoleDAO.insertBatch(userRoles);        throw new RuntimeException("发生异常啦！");    }

3.6 @Transactional长事务导致生产事故

很多开发都觉得Spring的声明式事务使用非常简单，即@Transactional，所以从来不注重细节。当 Spring 遇到该注解时，会自动从数据库连接池中获取 connection，并开启事务然后绑定到 ThreadLocal 上，对于@Transactional注解包裹的整个方法都是使用同一个connection连接。如果我们出现了耗时的操作，比如第三方接口调用、业务逻辑复杂、大批量数据处理等就会导致我们我们占用这个connection的时间会很长，数据库连接一直被占用不释放。一旦类似操作过多，就会导致数据库连接池耗尽。这就是典型的长事务问题

长事务引发的常见危害有：