@Transactional事务提交后触发异步方法

一、问题复现

1.场景

2个service方法, 方法A中调用方法B。

方法A 是核心业务方法，涉及多张表数据变更，为了保持数据一致，用spring事务注解：@Transactional(rollbackFor = Exception.class)

方法B 比较耗时，为了不影响核心业务，方法B 用@Async注解，单独开启一个线程去异步执行。（方法B在另外一个类里边，不能和A在同一个类）。

2.出错原因

方法B是异步方法，导致方法A事务还没提交时（不一定出错，具体就看哪个线程执行的快了）方法B就执行了。

3.期望

期望方法A上的大事务commit后再执行方法B。

二、解决方案

1 // 注册事务同步处理
2 TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
3 @Override
4 public void afterCommit() {
5     // 事务提交完毕时，触发：funcB
6     funB()；
7 }

三、原理

提交一个事务同步处理，在事务commit之后执行，具体存放在threadLocal（线程本地变量）中，事务commit时会去threadLocal里边取。源码afterCommit是空的，没有任何操作，可见是spring专门预留给大家使用的。

源码：

TransactionSynchronizationAdapter是一个接口适配器，这样不用实现接口的全部方法，按需Override即可。类图如下图所示：

TransactionSynchronizationAdapter实现了2个接口：

• TransactionSynchronization事务同步接口,
• Ordered执行优先级

我们这里就是实现了TransactionSynchronization接口的afterCommit()方法，最终在事务commit提交后执行。
关于spring事务执行过程图：

四、总结

遇到问题后，很快就想到了处理方式，因为我提前储备了相关知识：

1.spring事务系列（具体在第三章 事务源码，里边有链接）

spring事务详解（一）初探事务

2.@Async实现异步

异步任务spring @Async注解源码解析

3.threadLocal线程本地变量

ThreadLocal终极源码剖析-一篇足矣！

@Transactional方法中的LazyInitializationException

在执行以下操作org.hibernate.LazyInitializationException时，当我尝试访问延迟加载的异常时遇到错误：

@Transactionalpublic void displayAddresses(){     Person person = getPersonByID(1234);     List<Address> addresses = person.getAddresses(); // Exception Thrown Here     for(Address address : addresses)          System.out.println(address.getFullAddress());}

我的实体看起来像这样：

@Entity@Table("PERSON_TBL")public class Person{     ...     @OneToMany(cascade=CascadeType.ALL, targetEntity=Address.class, mappedBy="person")     private List<Address> addresses;     ...}@Entity@Table("ADDRESS_TBL")public class Address{     ...     @ManyToOne(targetEntity=Person.class)     @JoinColumn(name="PERSON_ID", referencedColumnName="PERSON_ID")     Person person;     ...}

我的印象是，通过在我的displayAddresses()方法中使用@Transactional批注，它将使会话保持活动状态，直到该方法完成为止，从而使我可以访问延迟加载的Address集合。

我想念什么吗？

编辑

按照Tomasz的建议：在我的displayAddresses()方法中，状态TransactionSynchronizationManager.isActualTransactionActive(),变为false。

这确实可以缩小问题的范围，但是为什么此时我的“交易”不能处于活动状态？

答案1

有<tx:annotation-driven/>在我的配置文件，然后使用我的服务类的Spring管理的版本（调用（）方法displayAddresses）并获得成功。

@Transactional方法调用没有@Transactional注释的另一个方法？

我在Service类中看到了一种被标记为的方法@Transactional，但是它也在同一类中调用了其他未标为的方法@Transactional。

这是否意味着对单独方法的调用导致应用程序打开与DB的单独连接或暂停父事务等？

不带任何注释的方法的默认行为是什么，而另一个带有@Transactional注释的方法调用该方法的默认行为是什么？

答案1

当你调用没有@Transactional事务块之内的方法时，父事务将继续使用新方法。它将使用与父方法（with @Transactional）相同的连接，以及在调用的方法中@Transactional导致的任何异常（不使用该异常将导致事务按照事务定义中的配置回滚。

如果@Transactional从具有@Transactional相同实例的方法中调用带有注释的方法，则被调用方法的事务行为将不会对事务产生任何影响。但是，如果从具有事务定义的另一个方法中调用具有事务定义的方法，并且它们处于不同的实例中，则被调用方法中的代码将遵循被调用方法中给出的事务定义。

你可以发现在部分中详细声明式事务管理的spring交易文件。

Spring声明式事务模型使用AOP代理。因此，AOP代理负责创建交易。仅当从实例外部调用实例中包含的方法时，AOP代理才会处于活动状态。

@Transactional注解加不加 rollbackFor = Exception.class 的区别和@Transactional 注解失效的3种原因及解决办法

目录

1、首先我在Mysql中准备了一条数据

2、简单粗暴的开始测试了

2.1 我们的目的是需要把delflag修改为0 简单的准备一下sql

2.2、我们先来测试一下@Transactional 代码如下 大家都知道2/0必会抛出异常

2.3、执行测试 i=1说明更新成功 别着急咱们继续断点往下面走

2.4、果然不出所料 执行到第54行的时候报错了 出现了java.lang.ArithmeticException: /by zero

2.5、细心的同学会发现ArithmeticException这个异常类是继承了RuntimeException的

2.6、我们在点进去RuntimeException这个类里面一探究竟 我们发现RuntimeException又是继承Exception的

2.7、这个时候我们去看一下数据库的值到底有没有修改成功 很显然数据是被回滚了 并没有修改成0

3、下面我们在试试@Transactional不能过滚的异常 代码如下

3.1 用try catch来捕获异常

3.2、ok直接 抛出的异常是我们指定的java.lang.Exception异常 我们去看看数据库

3.3、数据库被更新成0了  说明@Transactional并不能回滚Exception异常

4.Transactional失效场景介绍

4.1 第一种

4.2 第二种

4.3 第三种

5.@Transactional注解不起作用原理分析

第一种

第二种

第三种

1、首先我在MysqL中准备了一条数据

2、简单粗暴的开始测试了

2.1 我们的目的是需要把delflag修改为0 简单的准备一下sql

 <update id="test">
        UPDATE tbl_users set delflag='0' where account='admin'
 </update>

2.2、我们先来测试一下@Transactional 代码如下 大家都知道2/0必会抛出异常

  @Override
  @Transactional
    public Ret test(){
        int i = articleMapper.test();
        int a = 2/0;
        if(i > 0){
            ResultUtil.success();
        }
        return ResultUtil.error();
    }

2.3、执行测试 i=1说明更新成功 别着急咱们继续断点往下面走

2.4、果然不出所料 执行到第54行的时候报错了 出现了java.lang.ArithmeticException: /by zero

2.5、细心的同学会发现ArithmeticException这个异常类是继承了RuntimeException的

而@Transactional默认回滚的的异常就是RuntimeException

2.6、我们在点进去RuntimeException这个类里面一探究竟 我们发现RuntimeException又是继承Exception的

而所有的异常类基本都是继承RuntimeException包括刚才上面的java.lang.ArithmeticException异常

所以只要是RuntimeException和RuntimeException下面的子类抛出的异常 @Transactional都可以回滚的

2.7、这个时候我们去看一下数据库的值到底有没有修改成功 很显然数据是被回滚了 并没有修改成0

3、下面我们在试试@Transactional不能过滚的异常 代码如下

3.1 用try catch来捕获异常

我们直接先用try catch来捕获异常 然后在catch里面自定义抛出Exception异常

@Override
@Transactional
public Ret test() throws Exception {
    int i = articleMapper.test();

    try {
        int a = 2 / 0;
    } catch (Exception e) {
        throw new Exception();
    }
    if (i > 0) {
        ResultUtil.success();
    }
    return ResultUtil.error();
}

3.2、ok直接 抛出的异常是我们指定的java.lang.Exception异常 我们去看看数据库

3.3、数据库被更新成0了  说明@Transactional并不能回滚Exception异常

总结一下：

@Transactional只能回滚RuntimeException和RuntimeException下面的子类抛出的异常 不能回滚Exception异常

如果需要支持回滚Exception异常请用@Transactional(rollbackFor = Exception.class)

这里如果是增删改的时候我建议大家都使用@Transactional(rollbackFor = Exception.class)

4.Transactional失效场景介绍

4.1 第一种

Transactional注解标注方法修饰符为非public时，@Transactional注解将会不起作用。例如以下代码。

定义一个错误的@Transactional标注实现，修饰一个默认访问符的方法

/**  
 * @author zhoujy  
 **/  
@Component  
public class TestServiceImpl {  
    @Resource  
    TestMapper testMapper;  
      
    @Transactional  
    void insertTestWrongModifier() {  
        int re = testMapper.insert(new Test(10,20,30));  
        if (re > 0) {  
            throw new NeedToInterceptException("need intercept");  
        }  
        testMapper.insert(new Test(210,20,30));  
    }  
  
}  

在同一个包内，新建调用对象，进行访问。

@Component  
public class InvokcationService {  
    @Resource  
    private TestServiceImpl testService;  
    public void invokeInsertTestWrongModifier(){  
        //调用@Transactional标注的默认访问符方法  
        testService.insertTestWrongModifier();  
    }  
}  

测试用例

@RunWith(springrunner.class)  
@SpringBoottest  
public class DemoApplicationTests {  
   @Resource  
   InvokcationService invokcationService;  
  
   @Test  
   public void  testInvoke(){  
      invokcationService.invokeInsertTestWrongModifier();  
   }  
}  

以上的访问方式，导致事务没开启，因此在方法抛出异常时，testMapper.insert(new Test(10,20,30));操作不会进行回滚。如果TestServiceImpl#insertTestWrongModifier方法改为public的话将会正常开启事务，testMapper.insert(new Test(10,20,30));将会进行回滚。

4.2 第二种

在类内部调用调用类内部@Transactional标注的方法。这种情况下也会导致事务不开启。示例代码如下。

设置一个内部调用

/**  
 * @author zhoujy  
 **/  
@Component  
public class TestServiceImpl implements TestService {  
    @Resource  
    TestMapper testMapper;  
  
    @Transactional  
    public void insertTestInnerInvoke() {  
        //正常public修饰符的事务方法  
        int re = testMapper.insert(new Test(10,20,30));  
        if (re > 0) {  
            throw new NeedToInterceptException("need intercept");  
        }  
        testMapper.insert(new Test(210,20,30));  
    }  
  
  
    public void testInnerInvoke(){  
        //类内部调用@Transactional标注的方法。  
        insertTestInnerInvoke();  
    }  
  
}  

测试用例。

@RunWith(springrunner.class)  
@SpringBoottest  
public class DemoApplicationTests {  
  
   @Resource  
   TestServiceImpl testService;  
  
   /**  
    * 测试内部调用@Transactional标注方法  
    */  
   @Test  
   public void  testInnerInvoke(){  
       //测试外部调用事务方法是否正常  
      //testService.insertTestInnerInvoke();  
       //测试内部调用事务方法是否正常  
      testService.testInnerInvoke();  
   }  
}  

上面就是使用的测试代码，运行测试知道，外部调用事务方法能够征程开启事务，testMapper.insert(new Test(10,20,30))操作将会被回滚；

然后运行另外一个测试用例，调用一个方法在类内部调用内部被@Transactional标注的事务方法，运行结果是事务不会正常开启，testMapper.insert(new Test(10,20,30))操作将会保存到数据库不会进行回滚。推荐：Java面试练题宝典

4.3 第三种

事务方法内部捕捉了异常，没有抛出新的异常，导致事务操作不会进行回滚。示例代码如下。

/**  
 * @author zhoujy  
 **/  
@Component  
public class TestServiceImpl implements TestService {  
    @Resource  
    TestMapper testMapper;  
  
    @Transactional  
    public void insertTestCatchException() {  
        try {  
            int re = testMapper.insert(new Test(10,20,30));  
            if (re > 0) {  
                //运行期间抛异常  
                throw new NeedToInterceptException("need intercept");  
            }  
            testMapper.insert(new Test(210,20,30));  
        }catch (Exception e){  
            System.out.println("i catch exception");  
        }  
    }  
      
}  

测试用例代码如下。

@RunWith(springrunner.class)  
@SpringBoottest  
public class DemoApplicationTests {  
  
   @Resource  
   TestServiceImpl testService;  
  
   @Test  
   public void testCatchException(){  
      testService.insertTestCatchException();  
   }  
}  

运行测试用例发现，虽然抛出异常，但是异常被捕捉了，没有抛出到方法 外， testMapper.insert(new Test(210,20,30))操作并没有回滚。

以上三种就是@Transactional注解不起作用，@Transactional注解失效的主要原因。下面结合spring中对于@Transactional的注解实现源码分析为何导致@Transactional注解不起作用。

5.@Transactional注解不起作用原理分析

5.1 第一种

@Transactional注解标注方法修饰符为非public时，@Transactional注解将会不起作用。这里分析 的原因是，@Transactional是基于动态代理实现的，@Transactional注解实现原理中分析了实现方法，在bean初始化过程中，对含有@Transactional标注的bean实例创建代理对象，这里就存在一个spring扫描@Transactional注解信息的过程，不幸的是源码中体现，标注@Transactional的方法如果修饰符不是public，那么就默认方法的@Transactional信息为空，那么将不会对bean进行代理对象创建或者不会对方法进行代理调用

@Transactional注解实现原理中，介绍了如何判定一个bean是否创建代理对象，大概逻辑是。根据spring创建好一个aop切点beanfactoryTransactionAttributeSourceAdvisor实例，遍历当前bean的class的方法对象，判断方法上面的注解信息是否包含@Transactional，如果bean任何一个方法包含@Transactional注解信息，那么就是适配这个beanfactoryTransactionAttributeSourceAdvisor切点。则需要创建代理对象，然后代理逻辑为我们管理事务开闭逻辑。

spring源码中，在拦截bean的创建过程，寻找bean适配的切点时，运用到下面的方法，目的就是寻找方法上面的@Transactional信息，如果有，就表示切点beanfactoryTransactionAttributeSourceAdvisor能够应用（canApply）到bean中，

AopUtils#canApply(org.springframework.aop.pointcut, java.lang.class<?>, boolean)

public static boolean canApply(pointcut pc, Class<?> targetClass, boolean hasIntroductions) {  
   Assert.notNull(pc, "pointcut must not be null");  
   if (!pc.getClassFilter().matches(targetClass)) {  
      return false;  
   }  
  
   MethodMatcher methodMatcher = pc.getmethodMatcher();  
   if (methodMatcher == MethodMatcher.TRUE) {  
      // No need to iterate the methods if we're matching any method anyway...  
      return true;  
   }  
  
   IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;  
   if (methodMatcher instanceof IntroductionAwareMethodMatcher) {  
      introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;  
   }  
  
    //遍历class的方法对象  
   Set<Class<?>> classes = new LinkedHashSet<Class<?>>(ClassUtils.getAllInterfacesForClassAsSet(targetClass));  
   classes.add(targetClass);  
   for (Class<?> clazz : classes) {  
      Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);  
      for (Method method : methods) {  
         if ((introductionAwareMethodMatcher != null &&  
               introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions)) ||  
             //适配查询方法上的@Transactional注解信息    
             methodMatcher.matches(method, targetClass)) {  
            return true;  
         }  
      }  
   }  
  
   return false;  
}  

我们可以在上面的方法打断点，一步一步调试跟踪代码，最终上面的代码还会调用如下方法来判断。在下面的方法上断点，回头看看方法调用堆栈也是不错的方式跟踪。推荐：Java面试练题宝典

AbstractFallbackTransactionAttributeSource#getTransactionAttribute

• AbstractFallbackTransactionAttributeSource#computeTransactionAttribute

protected TransactionAttribute computeTransactionAttribute(Method method, Class<?> targetClass) {  
   // Don't allow no-public methods as required.  
   //非public 方法，返回@Transactional信息一律是null  
   if (allowPublicmethodsOnly() && !Modifier.isPublic(method.getModifiers())) {  
      return null;  
   }  
   //后面省略.......  
 }  

不创建代理对象

所以，如果所有方法上的修饰符都是非public的时候，那么将不会创建代理对象。以一开始的测试代码为例，如果正常的修饰符的testService是下面图片中的，经过cglib创建的代理对象。

如果class中的方法都是非public的那么将不是代理对象。

不进行代理调用

考虑一种情况，如下面代码所示。两个方法都被@Transactional注解标注，但是一个有public修饰符一个没有，那么这种情况我们可以预见的话，一定会创建代理对象，因为至少有一个public修饰符的@Transactional注解标注方法。

创建了代理对象，insertTestWrongModifier就会开启事务吗？答案是不会。

/**  
 * @author zhoujy  
 **/  
@Component  
public class TestServiceImpl implements TestService {  
    @Resource  
    TestMapper testMapper;  
  
    @Override  
    @Transactional  
    public void inserttest() {  
        int re = testMapper.insert(new Test(10,20,30));  
        if (re > 0) {  
            throw new NeedToInterceptException("need intercept");  
        }  
        testMapper.insert(new Test(210,20,30));  
    }  
      
    @Transactional  
    void insertTestWrongModifier() {  
        int re = testMapper.insert(new Test(10,20,30));  
        if (re > 0) {  
            throw new NeedToInterceptException("need intercept");  
        }  
        testMapper.insert(new Test(210,20,30));  
    }  
}  

原因是在动态代理对象进行代理逻辑调用时，在cglib创建的代理对象的拦截函数中cglibAopProxy.DynamicAdvisedInterceptor#intercept，有一个逻辑如下，目的是获取当前被代理对象的当前需要执行的method适配的aop逻辑。

List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);  

而针对@Transactional注解查找aop逻辑过程，相似地，也是执行一次

AbstractFallbackTransactionAttributeSource#getTransactionAttribute

• AbstractFallbackTransactionAttributeSource#computeTransactionAttribute

也就是说还需要找一个方法上的@Transactional注解信息，没有的话就不执行代理@Transactional对应的代理逻辑，直接执行方法。没有了@Transactional注解代理逻辑，就无法开启事务，这也是上一篇已经讲到的。

5.2 第二种

在类内部调用调用类内部@Transactional标注的方法。这种情况下也会导致事务不开启。

经过对第一种的详细分析，对这种情况为何不开启事务管理，原因应该也能猜到；

既然事务管理是基于动态代理对象的代理逻辑实现的，那么如果在类内部调用类内部的事务方法，这个调用事务方法的过程并不是通过代理对象来调用的，而是直接通过this对象来调用方法，绕过的代理对象，肯定就是没有代理逻辑了。

其实我们可以这样玩，内部调用也能实现开启事务，代码如下。

/**  
 * @author zhoujy  
 **/  
@Component  
public class TestServiceImpl implements TestService {  
    @Resource  
    TestMapper testMapper;  
  
    @Resource  
    TestServiceImpl testServiceImpl;  
  
  
    @Transactional  
    public void insertTestInnerInvoke() {  
        int re = testMapper.insert(new Test(10,20,30));  
        if (re > 0) {  
            throw new NeedToInterceptException("need intercept");  
        }  
        testMapper.insert(new Test(210,20,30));  
    }  
  
  
    public void testInnerInvoke(){  
        //内部调用事务方法  
        testServiceImpl.insertTestInnerInvoke();  
    }  
  
}  

上面就是使用了代理对象进行事务调用，所以能够开启事务管理，但是实际操作中，没人会闲的蛋疼这样子玩~

5.3 第三种

事务方法内部捕捉了异常，没有抛出新的异常，导致事务操作不会进行回滚。

这种的话，可能我们比较常见，问题就出在代理逻辑中，我们先看看源码里卖弄动态代理逻辑是如何为我们管理事务的。

TransactionAspectSupport#invokeWithinTransaction

代码如下。

protected Object invokeWithinTransaction(Method method, Class<?> targetClass, final InvocationCallback invocation)  
      throws Throwable {  
  
   // If the transaction attribute is null, the method is non-transactional.  
   final TransactionAttribute txAttr = getTransactionAttributeSource().getTransactionAttribute(method, targetClass);  
   final PlatformTransactionManager tm = determineTransactionManager(txAttr);  
   final String joinpointIdentification = methodIdentification(method, targetClass);  
  
   if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {  
      // Standard transaction demarcation with getTransaction and commit/rollback calls.  
       //开启事务  
      TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);  
      Object retVal = null;  
      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  
          //异常时，在catch逻辑中回滚事务  
         completeTransactionAfterThrowing(txInfo, ex);  
         throw ex;  
      }  
      finally {  
         cleanupTransactionInfo(txInfo);  
      }  
       //提交事务  
      commitTransactionAfterReturning(txInfo);  
      return retVal;  
   }  
  
   else {  
     //....................  
   }  
}  

所以看了上面的代码就一目了然了，事务想要回滚，必须能够在这里捕捉到异常才行，如果异常中途被捕捉掉，那么事务将不会回滚。

关于如何手动强制@Transactional方法中的提交？和强制方法是什么意思的介绍已经告一段落，感谢您的耐心阅读，如果想了解更多关于@Transactional事务提交后触发异步方法、@Transactional方法中的LazyInitializationException、@Transactional方法调用没有@Transactional注释的另一个方法？、@Transactional注解加不加 rollbackFor = Exception.class 的区别和@Transactional 注解失效的3种原因及解决办法的相关信息，请在本站寻找。