事务注解 @Transactional 失效的3种场景及解决办法

点击蓝色字免费订阅，天天收到这样的好信息

私活接单qq群：716817407
java

做者：向北web

blog.csdn.net/qq_20597727/article/details/84900994面试

Transactional失效场景介绍

第一种

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

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

/**
 * @author zhoujy
 * @date 2018年12月06日
 **/
@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));将会进行回滚。mybatis

第二种

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

设置一个内部调用less

/**
 * @author zhoujy
 * @date 2018年12月06日
 **/
@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))操做将会保存到数据库不会进行回滚。

第三种

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

/**
 * @author zhoujy
 * @date 2018年12月06日
 **/
@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注解不起做用。

@Transactional注解不起做用原理分析

首先不了解@Transactional注解实现原理，而后下面开始结合源码分析下面三种状况。

第一种

@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;
}

咱们能够在上面的方法打断点，一步一步调试跟踪代码，最终上面的代码还会调用以下方法来判断。在下面的方法上断点，回头看看方法调用堆栈也是不错的方式跟踪。

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
 * @date 2018年12月06日
 **/
@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注解代理逻辑，就没法开启事务，这也是上一篇已经讲到的。

第二种

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

通过对第一种的详细分析，对这种状况为什么不开启事务管理，缘由应该也能猜到；

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

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

/**
 * @author zhoujy
 * @date 2018年12月06日
 **/
@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();
    }

}

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

第三种

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

这种的话，可能咱们比较常见，问题就出在代理逻辑中，咱们先看看源码里卖弄动态代理逻辑是如何为咱们管理事务的，这个过程在个人另外一篇文章有提到。

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 {
     //....................
   }
}

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

总结了以上几种状况

打油诗

我不在意个人做品文章是被如今的人读仍是由子孙后代来读。既然上帝花了六千年来等一位观察者，我能够花上一个世纪来等待读者。

私活接单qq群：716817407

永久激活方案~

2020-07-29

spring 状态机

2020-05-12

mybatis用到的设计模式

2020-07-02

jvm高级面试题(必须看)

2020-07-23

MySQL索引实现原理分析

2020-05-19

Spring中的用到的设计模式

2020-04-23

Spring 和 SpringBoot 之间到底有啥区别？

2020-05-29

如何快速搭建一个免费的鉴黄平台

2020-08-15

美国也就那么回事吧

2020-08-15

5T的Java视频教程所有免费获取

2020-08-14

本文分享自微信公众号 - Java小白学心理（gh_9a909fa2fb55）。
若有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一块儿分享。