面试官：@Transactional 注解是如何实现的？面试必问！

谁践踏了优雅 2022-09-11 13:20 287阅读 0赞

**点击关注公众号，Java干货****及时送达**![189ef7016cae029d4969e8d0f4126957.png][]

## @Transactional注解简介 ##

`@Transactional`是spring中声明式事务管理的注解配置方式，相信这个注解的作用大家都很清楚。`@Transactional`注解可以帮助我们把事务开启、提交或者回滚的操作，通过aop的方式进行管理。

通过`@Transactional`注解就能让spring为我们管理事务，免去了重复的事务管理逻辑，减少对业务代码的侵入，使我们开发人员能够专注于业务层面开发。

![7d3d23c14a69b9544db4058c13d37cb4.png][]

我们知道实现@Transactional原理是基于spring aop，aop又是动态代理模式的实现，通过对源码的阅读，总结出下面的步骤来了解实际中，在spring 是如何利用aop来实现@Transactional的功能的。

## spring中声明式事务实现原理猜想 ##

首先，对于spring中aop实现原理有了解的话，应该知道想要对一个方法进行代理的话，肯定需要定义切点。在@Transactional的实现中，同样如此，spring为我们定义了以 @Transactional 注解为植入点的切点，这样才能知道@Transactional注解标注的方法需要被代理。

有了切面定义之后，在spring的bean的初始化过程中，就需要对实例化的bean进行代理，并且生成代理对象。

生成代理对象的代理逻辑中，进行方法调用时，需要先获取切面逻辑，@Transactional注解的切面逻辑类似于@Around，在spring中是实现一种类似代理逻辑。

![5d742a177c7a7b0d193c9de479ae7357.png][]

## @Transactional作用 ##

根据上面的原理猜想，下面简单介绍每个步骤的源码以进行验证。推荐一个 Spring Boot 基础教程及实战示例：https://github.com/javastacks/spring-boot-best-practice

首先是@Transactional，作用是定义代理植入点。我们知道代理对象创建的通过`BeanPostProcessor`的实现类`AnnotationAwareAspectJAutoProxyCreator`的`postProcessAfterInstantiation`方法来实现个，如果需要进行代理，那么在这个方法就会返回一个代理对象给容器，同时判断植入点也是在这个方法中。

那么下面开始分析，在配置好注解驱动方式的事务管理之后，spring会在ioc容器创建一个`BeanFactoryTransactionAttributeSourceAdvisor`实例，这个实例可以看作是一个切点，在判断一个bean在初始化过程中是否需要创建代理对象，都需要验证一次`BeanFactoryTransactionAttributeSourceAdvisor`是否是适用这个bean的切点。如果是，就需要创建代理对象，并且把`BeanFactoryTransactionAttributeSourceAdvisor`实例注入到代理对象中。

前文我们知道在`AopUtils#findAdvisorsThatCanApply`中判断切面是否适用当前bean，可以在这个地方断点分析调用堆栈，`AopUtils#findAdvisorsThatCanApply`一致调用，最终通过以下代码判断是否适用切点。

*  `AbstractFallbackTransactionAttributeSource#computeTransactionAttribute(Method method, Class<?> targetClass)` 这里可以根据参数打上条件断点进行调试分析调用栈，targetClass就是目标class …一系列调用
 *  最终`SpringTransactionAnnotationParser#parseTransactionAnnotation(java.lang.reflect.AnnotatedElement)`

@Override
    public TransactionAttribute parseTransactionAnnotation(AnnotatedElement ae) {
        //这里就是分析Method是否被@Transactional注解标注，有的话，不用说BeanFactoryTransactionAttributeSourceAdvisor适配当前bean，进行代理，并且注入切点
        //BeanFactoryTransactionAttributeSourceAdvisor
       AnnotationAttributes attributes = AnnotatedElementUtils.getMergedAnnotationAttributes(ae, Transactional.class);
       if (attributes != null) {
          return parseTransactionAnnotation(attributes);
       }
       else {
          return null;
       }
    }

上面就是判断是否需要根据@Transactional进行代理对象创建的判断过程。@Transactional的作用一个就是标识方法需要被代理，一个就是携带事务管理需要的一些属性信息。

**点击关注公众号，Java干货****及时送达**![331b1f2be02d8765a26b08d5752823b4.png][]

## 动态代理逻辑实现 ##

【aop实现原理分析】中知道，aop最终的代理对象的代理方法是

*  `DynamicAdvisedInterceptor#intercept`

[所以我们可以在这个方法断点分析代理逻辑。][Link 1]

@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) {
             // Make invocation available if necessary.
             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();
          }
           //follow
          List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
          Object retVal;
          // Check whether we only have one InvokerInterceptor: that is,
          // no real advice, but just reflective invocation of the target.
          if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
             // We can skip creating a MethodInvocation: just invoke the target directly.
             // Note that the final invoker must be an InvokerInterceptor, so we know
             // it does nothing but a reflective operation on the target, and no hot
             // swapping or fancy proxying.
             Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
             retVal = methodProxy.invoke(target, argsToUse);
          }
          else {
             // We need to create a method invocation...
             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);
          }
       }
    }

[通过分析][Link 1] `List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass)`返回的是TransactionInterceptor,利用TransactionInterceptor是如何实现代理逻辑调用的？

跟踪`new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();`

发现最终是调用`TransactionInterceptor#invoke`方法，并且把CglibMethodInvocation注入到invoke方法中，从上面可以看到`CglibMethodInvocation`是包装了目标对象的方法调用的所有必须信息，因此，在`TransactionInterceptor#invoke`里面也是可以调用目标方法的，并且还可以实现类似@Around的逻辑，在目标方法调用前后继续注入一些其他逻辑，比如事务管理逻辑。

另外，Spring 系列面试题和答案全部整理好了，微信搜索Java技术栈，在后台发送：面试，可以在线阅读。

## TransactionInterceptor–最终事务管理者 ##

下面看代码。

*  `TransactionInterceptor#invoke`

@Override
    public Object invoke(final MethodInvocation invocation) throws Throwable {
     // Work out the target class: may be {@code null}.
     // The TransactionAttributeSource should be passed the target class
     // as well as the method, which may be from an interface.
     Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);
    
     // Adapt to TransactionAspectSupport's invokeWithinTransaction...
     return invokeWithinTransaction(invocation.getMethod(), targetClass, new InvocationCallback() {
      @Override
      public Object proceedWithInvocation() throws Throwable {
       return invocation.proceed();
      }
     });
    }

继续跟踪invokeWithinTransaction，下面的代码中其实就可以看出一些逻辑端倪，就是我们猜想的实现方式，[事务管理。][Link 1]

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
         //回滚事务
             completeTransactionAfterThrowing(txInfo, ex);
             throw ex;
          }
          finally {
             cleanupTransactionInfo(txInfo);
          }
           //提交事务
          commitTransactionAfterReturning(txInfo);
          return retVal;
       }
    
       else {
          // It's a CallbackPreferringPlatformTransactionManager: pass a TransactionCallback in.
          try {
             Object result = ((CallbackPreferringPlatformTransactionManager) tm).execute(txAttr,
                   new TransactionCallback<Object>() {
                      @Override
                      public Object doInTransaction(TransactionStatus status) {
                         TransactionInfo txInfo = prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
                         try {
                            return invocation.proceedWithInvocation();
                         }
                         catch (Throwable ex) {
                            if (txAttr.rollbackOn(ex)) {
                               // A RuntimeException: will lead to a rollback.
                               if (ex instanceof RuntimeException) {
                                  throw (RuntimeException) ex;
                               }
                               else {
                                  throw new ThrowableHolderException(ex);
                               }
                            }
                            else {
                               // A normal return value: will lead to a commit.
                               return new ThrowableHolder(ex);
                            }
                         }
                         finally {
                            cleanupTransactionInfo(txInfo);
                         }
                      }
                   });
    
             // Check result: It might indicate a Throwable to rethrow.
             if (result instanceof ThrowableHolder) {
                throw ((ThrowableHolder) result).getThrowable();
             }
             else {
                return result;
             }
          }
          catch (ThrowableHolderException ex) {
             throw ex.getCause();
          }
       }
    }

## 总结 ##

最终可以总结一下整个流程，跟开始的猜想对照。另外，关注公众号Java技术栈，在后台回复：面试，可以获取我整理的 Spring 系列面试题和答案，非常齐全。

![0e7653e7969a72497d0870c1291cc8e1.png][]

分析源码后对照

![56c2d394050703bdf42bc582e125830c.png][]

原文链接：https://blog.csdn.net/qq\_20597727/article/details/84868035

![34ab79668e2f4ac85ac4878c47251eee.gif][]

![b547331f26800f533b554c1e2c14a99e.png][]

[![aceeea0420986759ce559fdf745512ff.png][]][aceeea0420986759ce559fdf745512ff.png 1]

[![a412f5325ef39ed45ef1359bb3ee5676.png][]][a412f5325ef39ed45ef1359bb3ee5676.png 1]

[![c2ab6b2a66ebb0bc28dea4af8b7221c3.png][]][c2ab6b2a66ebb0bc28dea4af8b7221c3.png 1]

[![18bd49b0b24dde7f1c14e124ed2d1395.png][]][18bd49b0b24dde7f1c14e124ed2d1395.png 1]

[![46d2d51ceeea8e52b603d4c09f615a8e.png][]][46d2d51ceeea8e52b603d4c09f615a8e.png 1]

**关注Java技术栈看更多干货**

![03c359009009dbaa83b7eb56944d1291.png][]

![5220baf8d4299402e345852346a023dd.gif][]

获取 Spring Boot 实战笔记！

[189ef7016cae029d4969e8d0f4126957.png]: /images/20220828/c7bead350c9b41de9e8b3b94cdc3586f.png
[7d3d23c14a69b9544db4058c13d37cb4.png]: /images/20220828/579564ecc4d245568002f519a1763412.png
[5d742a177c7a7b0d193c9de479ae7357.png]: /images/20220828/8de99d3088eb48d18c84bea8126526b7.png
[331b1f2be02d8765a26b08d5752823b4.png]: /images/20220828/e988cbf6d7bb499882471b55535c510c.png
[Link 1]: http://mp.weixin.qq.com/s?__biz=MzI3ODcxMzQzMw==&mid=2247539795&idx=2&sn=42fec97b57d339b55c1e3c66d1624eff&chksm=eb50d965dc275073becd2ebffe18b70960f347a3ee83a070933fb8ee8776f21b7a250ba2a398&scene=21#wechat_redirect
[0e7653e7969a72497d0870c1291cc8e1.png]: /images/20220828/bc6bb01ad2a642648dac606df2773b16.png
[56c2d394050703bdf42bc582e125830c.png]: /images/20220828/acb39d7709364ef3a1c3bb3f4e4a2c98.png
[34ab79668e2f4ac85ac4878c47251eee.gif]: /images/20220828/f749f942113141cb9567eb2ada971c4f.png
[b547331f26800f533b554c1e2c14a99e.png]: /images/20220828/a2b2d25d1fe2437b8089270d557b37b5.png
[aceeea0420986759ce559fdf745512ff.png]: /images/20220828/fef7af822d7641bcaedbb187b60a6fb4.png
[aceeea0420986759ce559fdf745512ff.png 1]: https://mp.weixin.qq.com/s?__biz=MzI3ODcxMzQzMw==&mid=2247539795&idx=1&sn=1efca511169265e8146e90db220159d5&scene=21#wechat_redirect
[a412f5325ef39ed45ef1359bb3ee5676.png]: /images/20220828/40a926f2696d435bb3f2bbeebd47121f.png
[a412f5325ef39ed45ef1359bb3ee5676.png 1]: https://mp.weixin.qq.com/s?__biz=MzI3ODcxMzQzMw==&mid=2247542231&idx=1&sn=75ab147414255cc18c26b03746833be8&scene=21#wechat_redirect
[c2ab6b2a66ebb0bc28dea4af8b7221c3.png]: /images/20220828/762ed0852a9f44e9b54cfa30d69b9585.png
[c2ab6b2a66ebb0bc28dea4af8b7221c3.png 1]: https://mp.weixin.qq.com/s?__biz=MzI3ODcxMzQzMw==&mid=2247540613&idx=2&sn=acbe3189c3e5d11419b8f383f36b145f&scene=21#wechat_redirect
[18bd49b0b24dde7f1c14e124ed2d1395.png]: /images/20220828/75a7fde807ea4ca2bb858eb711c907c4.png
[18bd49b0b24dde7f1c14e124ed2d1395.png 1]: https://mp.weixin.qq.com/s?__biz=MzI3ODcxMzQzMw==&mid=2247537730&idx=1&sn=3869e164e482b838671fa8896cb33cdb&scene=21#wechat_redirect
[46d2d51ceeea8e52b603d4c09f615a8e.png]: /images/20220828/ee75eff80d664c5798b6a04092acf7c2.png
[46d2d51ceeea8e52b603d4c09f615a8e.png 1]: https://mp.weixin.qq.com/s?__biz=MzI3ODcxMzQzMw==&mid=2247540947&idx=1&sn=a4941f93acb4ee551534a4a1f57d9376&scene=21#wechat_redirect
[03c359009009dbaa83b7eb56944d1291.png]: /images/20220828/231ae0087c1c41668caf381056670c77.png
[5220baf8d4299402e345852346a023dd.gif]: /images/20220828/9a3a59af81374c61b0aa27da81557813.png