spring事务的三个坑

简介: spring事务的三个坑

回顾


spring源码系列11:事务代理对象的执行那一节,得出的结论

事务执行:通过TransactionInterceptor增强器对

目标方法进行环绕增强。

  1. 调用目标方法前,创建事务。
  2. 执行目标方法
  3. 调用目标方法后,提交事务。

TransactionInterceptor功能增强功能的是实现在父类TransactionAspectSupportinvokeWithinTransaction方法

关键代码:

//创建事务
      TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
      Object retVal = null;
      try {
        //执行目标方法
        retVal = invocation.proceedWithInvocation();
      }
      catch (Throwable ex) {
        //异常回滚
        completeTransactionAfterThrowing(txInfo, ex);
        throw ex;
      }
      finally {
        cleanupTransactionInfo(txInfo);
      }
      //提交事务
      commitTransactionAfterReturning(txInfo);
      return retVal;

最近遇到事务方面的问题。在看了源码后,才对这些问题的出现豁然开朗


事务存在的三个问题


假如有这么一个类

@Service
public class TransactionalService {
    @Autowired
    UserDao userDao;
  public String noTransactionalSave(){
        System.out.println("非事务方法");
        return  save1();
    }
    @Transactional
    public String save1(){
        User user = new User("主动方事务方法",0);
        save2();
        userDao.save(user);
        return "save1";
    }
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public String save2(){
        User user = new User("被事务方法",1);
        userDao.save(user);
        return "save2";
    }
    @Transactional
    public synchronized String syncSave(){
        System.out.println("锁方法");
        User user = new User("锁方法",0);
        userDao.save(user);
        return "锁";
    }
}

记得在事务代理的创建那一节说过,不管是方法上,还是类上使用 @Transactional。都会对此类进行代理的创建。 创建代理后,调用目标方法首先调用的是代理的方法。

以CGLB为例,执行链

调用方法-->动态代理类.方法-->MethodInterceptor.intercept方法-->MethodInvocation.proceed执行增强器链-->Adivce.invoke方法-->目标方法

我们再看看MethodInterceptor.intercept()方法

@Override
    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
      Object oldProxy = null;
      boolean setProxyContext = false;
      Class<?> targetClass = null;
      Object target = null;
      try {
        //是否暴露出代理对象。
        if (this.advised.exposeProxy) {
          //将代理对象放到事务上下文中。
          oldProxy = AopContext.setCurrentProxy(proxy);
          setProxyContext = true;
        }
        // May be null. Get as late as possible to minimize the time we
        // "own" the target, in case it comes from a pool...
        target = getTarget();
        if (target != null) {
          targetClass = target.getClass();
        }
        List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
        Object retVal;
        //没事增强,则使用反射调用目标类方法方法
        //也就是处理非事务方法
        if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
          Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
          retVal = methodProxy.invoke(target, argsToUse);
        }
        else {
          //处理事务方法
          retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
        }
        retVal = processReturnType(proxy, target, method, retVal);
        return retVal;
      }
      finally {
        if (target != null) {
          releaseTarget(target);
        }
        if (setProxyContext) {
          // Restore old proxy.
          AopContext.setCurrentProxy(oldProxy);
        }
      }
    }


1.同类中非事务方法调事务方法

首先因为有事务注解,所以会生成代理对象。

因为首先调用的是非事务方法,所以chain.isEmpty()条件成立,走反射执行目标方法。

执行链代理类noTransactionalSave()-->MethodInterceptor.intercept方法-->methodProxy.invoke方法--->目标类.noTransactionalSave()-->目标.save1()方法。

我们看出事务方法save1()虽然有事务注解,但是因为其被非事务方法调用。在本次调用链中,没有走事务增强分支,所以导致了事务的失效。

结论:同类中非事务方法调用事务方法,因为执行链不会走事务增强,导致此次调用中事务方法的事务失效。

解决办法: (1:出现此中业务场景时,可将非事务方法与事务方法抽象到不同的类中。事务方法所在类会创建事务代理,调用事务方法,走事务增强。 (2:看MethodInterceptor.intercept()中开头有一个if(this.advised.exposeProxy)的判断,如果为真,就会把事务代理对象放到事务上下文中,我们可以在非事务方法中,使用AopContext.currentProxy()获取代理对象,强制save1方法走代理执行。

项目中,我们遇到最多的应该就是事务失效问题,以前总是对事务失效问题模模糊糊,最近看了AOP源码,才对此有了深刻理解。


2.同类中事务方法调用事务方法

同类中事务方法调用事务方法,虽然不会出现事务失效问题。但是却会出现事务传播失效问题。

执行链代理方法.save1()--->MethodInterceptor.intercept方法--->methodProxy.invoke方法--->MethodInvocation.proceed执行增强器链-->Adivce.invoke增强方法--->目标方法.save1--->目标方法.save2

可以看出save1是事务方法,会走事务增强,但是save2的调用,是在save1方法增强调用链中,也就是说save2是依靠save1的事务。save2的事务配置,因为没有走Adivce(TransactionInterceptor).invoke增强方法,他的事务传播属性不会被解析。

结论:同类中事务方法调用事务方法,传播属性失效。

解决办法:同1中解决


3.调用同步事务方法

最近同事就遇到了这个问题呢。他在事务方法上加了synchronized关键词,让对此方法的调用强制串行化。

  • 第一个线程查询数据库,没有对应的实例数据,则创建一个数据
  • 第二个线程进入方法查询数据库,有了对应的值,则不用创建。 以此来达到幂等性问题。

想法是好的,但是结果确是有时还是会创建两条。

问题出在哪里呢?

首先: 在动态代理一节讲过,所谓的代理是在内存中生成了新的字节码文件。 在CGLB情况下,TransactionalService类生成的代理类TransactionalService?EnhancerBySpringCGLIB?cdcbf2e8中的syncSave()并没有synchronized修饰的。

public final String syncSave() {
        try {
            MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
            if (var10000 == null) {
                CGLIB$BIND_CALLBACKS(this);
                var10000 = this.CGLIB$CALLBACK_0;
            }
            return var10000 != null ? (String)var10000.intercept(this, CGLIB$syncSave$1$Method, CGLIB$emptyArgs, CGLIB$syncSave$1$Proxy) : super.syncSave();
        } catch (Error | RuntimeException var1) {
            throw var1;
        } catch (Throwable var2) {
            throw new UndeclaredThrowableException(var2);
        }
    }

其次: 再看看TransactionInterceptor对事务的增强那一段关键代码。事务的增强逻辑是在TransactionInterceptor中的。

//创建事务
      TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
      Object retVal = null;
      try {
        //执行目标方法
        retVal = invocation.proceedWithInvocation();
      }
      catch (Throwable ex) {
        //异常回滚
        completeTransactionAfterThrowing(txInfo, ex);
        throw ex;
      }
      finally {
        cleanupTransactionInfo(txInfo);
      }
      //提交事务
      commitTransactionAfterReturning(txInfo);
      return retVal;

也就是说:两个线程都阻塞到目标方法上,当第一个线程离开目标方法时,他的调用回到了TransactionInterceptor中,做提交事务动作。但是此时第二个线程进入目标方法去执行数据库查询操作,但第一个线程的提交事务动作可能为完成,此时数据库中并没有,所以第二个线程也会创建一个实例数据。这样就可能出现创建两条的情况。

可以看出加锁的范围没有包括到整个事务,把synchronized加到方法上出发点时好的。但是真实的调用确实从代理类开始的,生成的代理类中并没有加synchronized,结合事务的增强。导致了synchronized同步的失效。

结论:@Transcational注解和synchronized锁一起使用会导致同步失效。加锁的范围没有包括到整个事务

解决办法:既然两个在一起,不能使用锁范围覆盖整个事务。那就创造一个覆盖整个事务的调用。锁方法与事务方法分离到不同的类中,在锁方法中调用事务方法,不就完成了锁范围覆盖整个事务了吗


总结


透过表象看本质。

事务虽然给我带来了方便,但是因为代理类的生成,有一些隐形的调用存在,导致了我们错误的判断了调用链,带来一些错误。

所以看到本质,才能正确的使用。


相关文章
|
24天前
|
SQL Java 关系型数据库
Spring事务传播机制:7种姿势教你玩转"事务接力赛"
事务传播机制是Spring框架中用于管理事务行为的重要概念,它决定了在方法调用时事务如何传递与执行。通过7种传播行为,开发者可以灵活控制事务边界,适应不同业务场景。例如:REQUIRED默认加入或新建事务,REQUIRES_NEW独立开启新事务,NESTED支持嵌套回滚等。合理使用传播机制不仅能保障数据一致性,还能提升系统性能与健壮性。掌握这“七种人格”,才能在复杂业务中游刃有余。
|
2月前
|
Java 关系型数据库 数据库
深度剖析【Spring】事务:万字详解,彻底掌握传播机制与事务原理
在Java开发中,Spring框架通过事务管理机制,帮我们轻松实现了这种“承诺”。它不仅封装了底层复杂的事务控制逻辑(比如手动开启、提交、回滚事务),还提供了灵活的配置方式,让开发者能专注于业务逻辑,而不用纠结于事务细节。
|
7月前
|
Java Spring
Spring中事务失效的场景
因为Spring事务是基于代理来实现的,所以某个加了@Transactional的⽅法只有是被代理对象调⽤时, 那么这个注解才会⽣效 , 如果使用的是被代理对象调用, 那么@Transactional会失效 同时如果某个⽅法是private的,那么@Transactional也会失效,因为底层cglib是基于⽗⼦类来实现 的,⼦类是不能重载⽗类的private⽅法的,所以⽆法很好的利⽤代理,也会导致@Transactianal失效 如果在业务中对异常进行了捕获处理 , 出现异常后Spring框架无法感知到异常, @Transactional也会失效
|
7月前
|
Java 关系型数据库 数据库
微服务——SpringBoot使用归纳——Spring Boot事务配置管理——常见问题总结
本文总结了Spring Boot中使用事务的常见问题,虽然通过`@Transactional`注解可以轻松实现事务管理,但在实际项目中仍有许多潜在坑点。文章详细分析了三个典型问题:1) 异常未被捕获导致事务未回滚,需明确指定`rollbackFor`属性;2) 异常被try-catch“吃掉”,应避免在事务方法中直接处理异常;3) 事务范围与锁范围不一致引发并发问题,建议调整锁策略以覆盖事务范围。这些问题看似简单,但一旦发生,排查难度较大,因此开发时需格外留意。最后,文章提供了课程源代码下载地址,供读者实践参考。
143 0
|
7月前
|
Java 关系型数据库 数据库
微服务——SpringBoot使用归纳——Spring Boot事务配置管理——Spring Boot 事务配置
本文介绍了 Spring Boot 中的事务配置与使用方法。首先需要导入 MySQL 依赖,Spring Boot 会自动注入 `DataSourceTransactionManager`,无需额外配置即可通过 `@Transactional` 注解实现事务管理。接着通过创建一个用户插入功能的示例,展示了如何在 Service 层手动抛出异常以测试事务回滚机制。测试结果表明,数据库中未新增记录,证明事务已成功回滚。此过程简单高效,适合日常开发需求。
936 0
|
7月前
|
Java 数据库 微服务
微服务——SpringBoot使用归纳——Spring Boot事务配置管理——事务相关
本文介绍Spring Boot事务配置管理,阐述事务在企业应用开发中的重要性。事务确保数据操作可靠,任一异常均可回滚至初始状态,如转账、购票等场景需全流程执行成功才算完成。同时,事务管理在Spring Boot的service层广泛应用,但根据实际需求也可能存在无需事务的情况,例如独立数据插入操作。
153 0
|
5月前
|
人工智能 Java 数据库连接
Spring事务失效场景
本文深入探讨了Spring框架中事务管理可能失效的几种常见场景及解决方案,包括事务方法访问级别不当、方法内部自调用、错误的异常处理、事务管理器或数据源配置错误、数据库不支持事务以及不合理的事务传播行为或隔离级别。通过合理配置和正确使用`@Transactional`注解,开发者可以有效避免这些问题,确保应用的数据一致性和完整性。
241 10
|
4月前
|
Java 关系型数据库 MySQL
【Spring】【事务】初学者直呼学会了的Spring事务入门
本文深入解析了Spring事务的核心概念与使用方法。Spring事务是一种数据库事务管理机制,通过确保操作的原子性、一致性、隔离性和持久性(ACID),维护数据完整性。文章详细讲解了声明式事务(@Transactional注解)和编程式事务(TransactionTemplate、PlatformTransactionManager)的区别与用法,并探讨了事务传播行为(如REQUIRED、REQUIRES_NEW等)及隔离级别(如READ_COMMITTED、REPEATABLE_READ)。
306 1
|
7月前
|
SQL Java 数据库连接
Spring中的事务是如何实现的
1. Spring事务底层是基于数据库事务和AOP机制的 2. ⾸先对于使⽤了@Transactional注解的Bean,Spring会创建⼀个代理对象作为Bean 3. 当调⽤代理对象的⽅法时,会先判断该⽅法上是否加了@Transactional注解 4. 如果加了,那么则利⽤事务管理器创建⼀个数据库连接 5. 并且修改数据库连接的autocommit属性为false,禁⽌此连接的⾃动提交,这是实现Spring事务⾮ 常重要的⼀步 6. 然后执⾏当前⽅法,⽅法中会执⾏sql 7. 执⾏完当前⽅法后,如果没有出现异常就直接提交事务 8. 如果出现了异常,并且这个异常是需要回滚的就会回滚事务
|
7月前
|
JavaScript Java 开发者
Spring事务失效,常见的情况有哪些?
本文总结了Spring事务失效的7种常见情况,包括未启用事务管理功能、方法非public类型、数据源未配置事务管理器、自身调用问题、异常类型错误、异常被吞以及业务和事务代码不在同一线程中。同时提供了两种快速定位事务相关Bug的方法:通过查看日志(设置为debug模式)或调试代码(在TransactionInterceptor的invoke方法中设置断点)。文章帮助开发者更好地理解和解决Spring事务中的问题。
232 7