文章结构

  1. 增强的获取
  2. @Transactional注解属性的解析

在上一篇文章@EnableTransactionManagement注解解析中，我们搭建了源码阅读的环境，以及解析了开启Spring事务功能的注解@EnableTransactionManagement的实现逻辑

在进行接下来的源码解析之前我想大家应该知道，当我们使用传统的jdbc应用事务的时候是不是做了如下操作：

  1. 开启事务
  2. save、update、delete等操作
  3. 出现异常进行回滚
  4. 正常情况提交事务

而在Spring中我们好像只需要关心第三步，也就是我们的业务，而其他的操作都不需要关心。那么我想你应该猜到了Spring是如何实现的呢？
答案就是基于@Transactional注解的SpringAOP实现，在接着往下阅读本篇文章的时候希望您对于SpringAOP的源码有一定的了解，如果不了解可以参考如下文章：

基于注解的SpringAOP源码解析（一）
基于注解的SpringAOP源码解析（二）
基于注解的SpringAOP源码解析（三）

获取Advisor

在阅读完AOP的原理之后，我们知道，当一个bean实例化之后会尝试获取所有适用于此Bean的增强。而在上篇文章中，我们已经发现了，@EnableTransactionManagement注解会往Spring中注入一个增强BeanFactoryTransactionAttributeSourceAdvisor。经过一番代码调用以后，会进入这么一个方法，这里的第一个入参就是BeanFactoryTransactionAttributeSourceAdvisor增强

Aop调用链

  1. AbstractAutowireCapableBeanFactory
  2. -> createBean()
  3.     -> resolveBeforeInstantiation()
  4.         -> applyBeanPostProcessorsBeforeInstantiation()
  5.             -> postProcessBeforeInstantiation()
  6.                 -> getAdvicesAndAdvisorsForBean()(查找符合符合条件的Advisor)
  7.                     -> findEligibleAdvisors()
  8.                         -> findAdvisorsThatCanApply()
  9.                             -> AopUtils.findAdvisorsThatCanApply()
  10.                                 -> canApply()
  1. public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) {
  2.     if (advisor instanceof IntroductionAdvisor) {
  3.         return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
  4.     }
  5.     else if (advisor instanceof PointcutAdvisor) {
  6.         PointcutAdvisor pca = (PointcutAdvisor) advisor;
  7.         return canApply(pca.getPointcut(), targetClass, hasIntroductions);
  8.     }
  9.     else {
  10.         return true;
  11.     }
  12. }
  13. public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) {
  14.     Assert.notNull(pc, "Pointcut must not be null");
  15.     if (!pc.getClassFilter().matches(targetClass)) {
  16.         return false;
  17.     }
  18.     MethodMatcher methodMatcher = pc.getMethodMatcher();
  19.     if (methodMatcher == MethodMatcher.TRUE) {
  20.         return true;
  21.     }
  23.     IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;
  24.     if (methodMatcher instanceof IntroductionAwareMethodMatcher) {
  25.         introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;
  26.     }
  28.     Set<Class<?>> classes = new LinkedHashSet<>(ClassUtils.getAllInterfacesForClassAsSet(targetClass));
  29.     classes.add(targetClass);
  30.     for (Class<?> clazz : classes) {
  31.       //获取当前类的所有方法
  32.         Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
  33.         for (Method method : methods) {
  34.             if ((introductionAwareMethodMatcher != null &&
  35.                     introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions)) ||
  36.                     methodMatcher.matches(method, targetClass)) {
  37.                 return true;
  38.             }
  39.         }
  40.     }
  42.     return false;
  43. }

TransactionAttributeSourcePointcut

到这里的时候就进入事务相关的类TransactionAttributeSourcePointcut，看名字就能知道，这是个切点类.那么接下来的逻辑应该可以想象到，无非就是判断是否是个事务方法

  1. public boolean matches(Method method, @Nullable Class<?> targetClass) {
  2.         if (targetClass != null && TransactionalProxy.class.isAssignableFrom(targetClass)) {
  3.             return false;
  4.         }
  5.         TransactionAttributeSource tas = getTransactionAttributeSource();
  6.         return (tas == null || tas.getTransactionAttribute(method, targetClass) != null);
  7.     }

getTransactionAttribute()

如果是事务方法则继续往下走。ProxyTransactionManagementConfiguration中注入的 AnnotationTransactionAttributeSource ，继承了 AbstractFallbackTransactionAttributeSource ，实际是调用了其中的 getTransactionAttribute() 

  1. public TransactionAttribute getTransactionAttribute(Method method,
  2.       @Nullable Class<?> targetClass) {
  3.     // 如果当前方法是Object类中的方法，则直接返回
  4.     if (method.getDeclaringClass() == Object.class) {
  5.         return null;
  6.     }
  8.     // 获取当前方法缓存使用的key
  9.     Object cacheKey = getCacheKey(method, targetClass);
  10.     Object cached = this.attributeCache.get(cacheKey);
  11.     // 从缓存中获取当前方法解析的事务属性，如果解析过，则将解析结果返回
  12.     if (cached != null) {
  13.         if (cached == NULL_TRANSACTION_ATTRIBUTE) {
  14.             return null;
  15.         } else {
  16.             return (TransactionAttribute) cached;
  17.         }
  18.     } else {
  19.         // 解析当前方法的事务属性，这里很重要，下面说
  20.         TransactionAttribute txAttr = computeTransactionAttribute(method, targetClass);
  21.         if (txAttr == null) {
  22.             // 如果当前方法上没有事务属性，则缓存一个表示空事务属性的对象
  23.             this.attributeCache.put(cacheKey, NULL_TRANSACTION_ATTRIBUTE);
  24.         } else {
  25.             // 获取方法的签名
  26.             String methodIdentification =
  27.                 ClassUtils.getQualifiedMethodName(method, targetClass);
  28.             // 如果生成的事务属性是DefaultTransactionAttribute类型的，则将方法签名设置到其descriptor属性中
  29.             if (txAttr instanceof DefaultTransactionAttribute) {
  30.                 ((DefaultTransactionAttribute) txAttr)
  31.                     .setDescriptor(methodIdentification);
  32.             }
  33.             if (logger.isDebugEnabled()) {
  34.                 logger.debug("Adding transactional method '" + methodIdentification
  35.                              + "' with attribute: " + txAttr);
  36.             }
  37.             // 缓存当前方法的解析结果
  38.             this.attributeCache.put(cacheKey, txAttr);
  39.         }
  40.         return txAttr;
  41.     }
  42. }

computeTransactionAttribute()

接着看一下方法的事务属性是如何解析的。AnnotationTransactionAttributeSource 的构造方法默认设置了allowPublicMethodsOnly为ture，只对public方法生效

  1. protected TransactionAttribute computeTransactionAttribute(Method method,
  2.        @Nullable Class<?> targetClass) {
  3.     // 如果设置了只对public方法进行事务代理，并且当前方法不是public的，则返回null
  4.     if (allowPublicMethodsOnly() && !Modifier.isPublic(method.getModifiers())) {
  5.         return null;
  6.     }
  8.     Class<?> userClass = (targetClass != null ?
  9.         ClassUtils.getUserClass(targetClass) : null);
  10.     // 获取最为准确的方法，即如果传入的method只是一个接口方法，则会去找其实现类的同一方法进行解析
  11.     Method specificMethod = ClassUtils.getMostSpecificMethod(method, userClass);
  12.     // 如果当前方法是一个泛型方法，则会找Class文件中实际实现的方法
  13.     specificMethod = BridgeMethodResolver.findBridgedMethod(specificMethod);
  14.     // 解析目标方法，获取其是否存在事务属性，如果存在则直接返回
  15.     TransactionAttribute txAttr = findTransactionAttribute(specificMethod);
  16.     if (txAttr != null) {
  17.         return txAttr;
  18.     }
  20.     // 解析目标方法所在的类，判断其是否标注有事务属性，如果存在，并且目标方法是用户实现的方法，则直接返回
  21.     txAttr = findTransactionAttribute(specificMethod.getDeclaringClass());
  22.     if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
  23.         return txAttr;
  24.     }
  26.     // 如果通过解析到的方法无法找到事务属性，则判断解析得到的方法与传入的目标方法是否为同一个方法，
  27.     // 如果不是同一个方法，则尝试对传入的方法及其所在的类进行事务属性解析
  28.     if (specificMethod != method) {
  29.         // 对传入方法解析事务属性，如果存在，则直接返回
  30.         txAttr = findTransactionAttribute(method);
  31.         if (txAttr != null) {
  32.             return txAttr;
  33.         }
  35.         // 对传入方法所在类进行事务属性解析，如果存在，则直接返回
  36.         txAttr = findTransactionAttribute(method.getDeclaringClass());
  37.         if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
  38.             return txAttr;
  39.         }
  40.     }
  42.     return null;
  43. }

findTransactionAttribute()

这里对事务属性的解析主要分为对目标方法进行解析和对传入方法进行解析，接着看findTransactionAttribute方法，SpringTransactionAnnotationParser的解析器，判断是否有@Transactional注解，这里方法和方法对应的类上都进行了查找

  1. protected TransactionAttribute findTransactionAttribute(Method method) {
  2.         return determineTransactionAttribute(method);
  3.     }
  4.     protected TransactionAttribute determineTransactionAttribute(AnnotatedElement ae) {
  5.         for (TransactionAnnotationParser annotationParser : this.annotationParsers) {
  6.             TransactionAttribute attr = annotationParser.parseTransactionAnnotation(ae);
  7.             if (attr != null) {
  8.                 return attr;
  9.             }
  10.         }
  11.         return null;
  12.     }
  13.     public TransactionAttribute parseTransactionAnnotation(AnnotatedElement ae) {
  14.         AnnotationAttributes attributes = AnnotatedElementUtils.findMergedAnnotationAttributes(
  15.                 ae, Transactional.class, false, false);
  16.         if (attributes != null) {
  17.             return parseTransactionAnnotation(attributes);
  18.         }
  19.         else {
  20.             return null;
  21.         }
  22.     }
  23. public TransactionAttribute parseTransactionAnnotation(AnnotatedElement ae) {
  24.     // 判断目标方法上是否存在@Transactional注解，如果不存在，则直接返回
  25.     AnnotationAttributes attributes = AnnotatedElementUtils
  26.         .findMergedAnnotationAttributes(ae, Transactional.class, false, false);
  27.     if (attributes != null) {
  28.         // 如果目标方法上存在@Transactional注解，则获取注解值，并且封装为TransactionAttribute返回
  29.         return parseTransactionAnnotation(attributes);
  30.     } else {
  31.         return null;
  32.     }
  33. }
  35. protected TransactionAttribute parseTransactionAnnotation(
  36.         AnnotationAttributes attributes) {
  37.     RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();
  38.     // 获取注解上的propagation值
  39.     Propagation propagation = attributes.getEnum("propagation");
  40.     rbta.setPropagationBehavior(propagation.value());
  41.     // 获取注解上的isolation属性值
  42.     Isolation isolation = attributes.getEnum("isolation");
  43.     rbta.setIsolationLevel(isolation.value());
  44.     // 获取注解上的timeout属性值
  45.     rbta.setTimeout(attributes.getNumber("timeout").intValue());
  46.     // 获取注解上的readOnly属性值
  47.     rbta.setReadOnly(attributes.getBoolean("readOnly"));
  48.     // 获取注解上的value属性值
  49.     rbta.setQualifier(attributes.getString("value"));
  50.     ArrayList<RollbackRuleAttribute> rollBackRules = new ArrayList<>();
  51.     // 获取注解上的rollbackFor属性列表
  52.     Class<?>[] rbf = attributes.getClassArray("rollbackFor");
  53.     for (Class<?> rbRule : rbf) {
  54.         RollbackRuleAttribute rule = new RollbackRuleAttribute(rbRule);
  55.         rollBackRules.add(rule);
  56.     }
  57.     // 获取注解上的rollbackForClassName属性列表
  58.     String[] rbfc = attributes.getStringArray("rollbackForClassName");
  59.     for (String rbRule : rbfc) {
  60.         RollbackRuleAttribute rule = new RollbackRuleAttribute(rbRule);
  61.         rollBackRules.add(rule);
  62.     }
  63.     // 获取注解上的noRollbackFor属性列表
  64.     Class<?>[] nrbf = attributes.getClassArray("noRollbackFor");
  65.     for (Class<?> rbRule : nrbf) {
  66.         NoRollbackRuleAttribute rule = new NoRollbackRuleAttribute(rbRule);
  67.         rollBackRules.add(rule);
  68.     }
  69.     // 获取注解上的noRollbackForClassName属性列表
  70.     String[] nrbfc = attributes.getStringArray("noRollbackForClassName");
  71.     for (String rbRule : nrbfc) {
  72.         NoRollbackRuleAttribute rule = new NoRollbackRuleAttribute(rbRule);
  73.         rollBackRules.add(rule);
  74.     }
  75.     rbta.getRollbackRules().addAll(rollBackRules);
  76.     return rbta;
  77. }

可以看到这里已经把方法上或者类上的@Transactional注解的属性封装成TransactionAttribute返回了，关于@Transactional注解的更多知识可参考Spring分类的@Transactional