章
目
录
1.概述
本文将探讨在日常Java项目业务开发中,对于@Transactional声明式事务在何种情形下可能失效,同时分析导致其失效的根本原因,以此来协助开发者避免在实际应用中遭遇类似问题。
众所周知,Spring所提供的声明式事务功能为事务配置带来了极大的便利。在Spring Boot的智能配置的辅助下,许多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注解,以为这样就可以高枕无忧,不必过多关注事务是否真正有效,以及在出错情况下是否能够正确地回滚事务。他们也不会考虑在复杂的业务代码中,涉及多个子业务逻辑的情况下,应如何正确处理事务。
虽然事务没有得到适当处理通常不会过于影响正常流程,且很难在测试阶段被察觉。然而,一旦系统变得越来越复杂,承受的压力逐渐加大,就会导致大量数据不一致的问题。随之而来的,是大量人工干预以检查和修复数据。
正是由于声明式事务@Transactional使用起来简单,许多开发者常常忽略了其中的细节。然而,实际上@Transactional涉及的细节非常多,可以说是一个充满细节的领域。如果不慎忽略这些细节,就可能会掉入陷阱。在本文中,我们将深入了解@Transactional的使用细节,填平这些潜在的坑。
2.@Transactional
话不多说,先看看该注解定义
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @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
抛出指定的异常类型,不回滚事务,也可以指定多个异常类型。
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 roleIds) {
if (CollectionUtils.isEmpty(roleIds)) {
return;
}
ListuserRoles = 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生效的原则,即必须通过代理过的类从外部调用目标方法才能使事务生效。
Spring采用AOP技术对方法进行增强,以实现事务控制。在调用被增强过的方法时,必然是通过代理对象进行的调用。然而,在这里,使用了关键字”this”引用的是原生对象,而不是代理对象。因此,事务控制并不会生效。
要进行修正,有以下两种方式:
- 将”this”替换为代理的userService。你可以通过自己注入自己(使用@Resource注解),或者直接在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 roleIds) {
if (CollectionUtils.isEmpty(roleIds)) {
return;
}
List 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
第二个生效原则涉及到事务的回滚机制:只有在异常传播到标记了 @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 roleIds) throws Exception {
if (CollectionUtils.isEmpty(roleIds)) {
return;
}
List 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。这种设置导致事务失效,因为在默认情况下,Spring仅会在出现RuntimeException(非受检异常)或Error时才会触发事务回滚机制。
在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 roleIds) {
if (CollectionUtils.isEmpty(roleIds)) {
return;
}
ListuserRoles = 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通过继承的方式实现代理类,但是私有方法在子类中是不可见的,因此也无法进行事务增强
修正方式:直接是改成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 roleIds) {
if (CollectionUtils.isEmpty(roleIds)) {
return;
}
ListuserRoles = 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 roleIds) {
ListuserRoles = 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遇到这个注解时,它会自动从数据库连接池中获取连接,并启动事务,然后将连接绑定到ThreadLocal上。整个被@Transactional注解包裹的方法会使用同一个连接。然而,如果方法中存在耗时的操作,比如第三方接口调用、复杂的业务逻辑或大批量数据处理等,就可能导致连接被占用的时间过长,进而导致数据库连接一直处于占用状态。当这种操作过于频繁时,就会导致数据库连接池资源耗尽,形成典型的长事务问题。
长事务问题带来的常见危害有:
- 数据库连接池资源耗尽,导致应用无法获取连接资源。
- 容易引发数据库死锁问题。
- 数据库回滚时间变长,影响性能。
- 在主从架构中可能导致主从延时增大。
一旦长事务问题出现,服务系统可能会出现多种故障表现:数据库监控平台频繁报告连接不足,大量死锁问题;系统日志显示调用流程引擎接口超时现象频发;同时也可能不断出现CannotGetJdbcConnectionException错误,因为数据库连接池的连接被耗尽。
解决这个问题并不难,关键在于对方法进行拆分,将不需要事务管理的逻辑与需要事务操作的逻辑分开,从而有效控制事务的执行时长,避免长事务问题。虽然这种方法可能会导致一个方法的逻辑拆分成多个子方法,有时可能会引发事务不生效的问题,但结合你之前的总结,我相信你已经能够正确应对这些情况了。
4.总结
Spring的声明式事务利用@Transactional注解确实使开发变得十分便捷。然而,稍有不慎使用不当便可能引发事务失效、数据不一致甚至系统数据库性能问题。正因如此,上述充满干货的总结均源自实际工作中的实践,对于规避这些陷阱起到了积极的作用。这些经验能够有效地助你避免在开发过程中掉入坑中。