| 版本 | 内容 | 时间 | | ---- | ---- | ------------------- | | V1 | 新增 | 2023-03-08 13:45:37 | ## 引入前面我们已经分析过解析 `` 标签，主要是做了下面几件事情： - 注册 InfrastructureAdvisorAutoProxyCreator，AOP 相关后处理器； - 注册 AnnotationTransactionAttributeSource，主要作用是解析 @Transaction 注解的信息； - 注册 TransactionInterceptor，是一个 Advice，声明式事务的核心入了； - 注册 BeanFactoryTransactionAttributeSourceAdvisor，是一个 Advisor，用于找到 @Transaction 位置，给对应的方法增强；本篇就基于前面的来分析如何定位 @Transaction，已经如何解析它并生成代理对象。 ## 回忆 AOP 的入口和匹配逻辑 InfrastructureAdvisorAutoProxyCreator 是 AbstractAutoProxyCreator 的子类，Spring AOP 的没有入口是在 AbstractAutoProxyCreator#wrapIfNecessary。（注意：下面的代码做了省略） ```java protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) { // 省略部分校验代码...... // Create proxy if we have advice. // 获取适合当前 bean 实例 Class 的通知的列表 Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null); // 条件成立，说明上面方法有查询到适合当前 class 的通知 if (specificInterceptors != DO_NOT_PROXY) { this.advisedBeans.put(cacheKey, Boolean.TRUE); // 根据查询到的通知，创建代理对象 Object proxy = createProxy( bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean)); // 保存代理对象的类型，返回代理对象 this.proxyTypes.put(cacheKey, proxy.getClass()); return proxy; } this.advisedBeans.put(cacheKey, Boolean.FALSE); return bean; } ``` 我们主要关注 AbstractAutoProxyCreator#getAdvicesAndAdvisorsForBean 方法，这就是去找到适合当前 bean 的所有增强了，前面在 AOP 的时候已经分析过，本次只是分析核心代码。沿着调用链，最终会调用到AopUtils#canApply(Pointcut, Class, boolean)，这里面就是判断某个增强是否匹配当前类的某个方法。前面我们分析过在解析 `` 标签的时候会注册一个 BeanFactoryTransactionAttributeSourceAdvisor 的通知，这里传入的参数 Pointcut pc 就是 BeanFactoryTransactionAttributeSourceAdvisor 的 TransactionAttributeSourcePointcut 属性。 ```java public static boolean canApply(Pointcut pc, Class targetClass, boolean hasIntroductions) { Assert.notNull(pc, "Pointcut must not be null"); // 整个条件成立，说明当前 class 不满足切点定义 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> classes = new LinkedHashSet<>(); // 这个 if 确保 classes Set 内存储的数据包括目标对象的 clazz，而不是代理类的 clazz if (!Proxy.isProxyClass(targetClass)) { classes.add(ClassUtils.getUserClass(targetClass)); } classes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetClass)); // 整个 for 循环会检查当前目标 clazz 的上级接口的所有方法，看看是否能被方法匹配器匹配，如果有一个方法匹配成功，就说明目标 clazz 就需要被 aop 代理 for (Class clazz : classes) { // 获取当前 clazz 内定义的 method Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz); for (Method method : methods) { if (introductionAwareMethodMatcher != null ? introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions) : methodMatcher.matches(method, targetClass)) { // 方法匹配 return true; } } } // 执行到这里，说明当前 clazz 内的方法没有匹配成功，就不需要代理了 return false; } ``` 关键点就是上面的代码中最下面的两个 for 循环，最核心的判断就是 ```java methodMatcher.matches(method, targetClass)) ``` 所以接下来就是要看 BeanFactoryTransactionAttributeSourceAdvisor 是如何校验方法是否匹配的。 ## 判断方法是否需要被事务增强 BeanFactoryTransactionAttributeSourceAdvisor 类中有个 Pointcut 类型的属性。 ```java public class BeanFactoryTransactionAttributeSourceAdvisor extends AbstractBeanFactoryPointcutAdvisor { /** * 声明式注解xml配置时，这里是 AnnotationTransactionAttributeSource */ @Nullable private TransactionAttributeSource transactionAttributeSource; private final TransactionAttributeSourcePointcut pointcut = new TransactionAttributeSourcePointcut() { @Override @Nullable protected TransactionAttributeSource getTransactionAttributeSource() { return transactionAttributeSource; } }; // 省略部分代码... } ``` 匹配方法是否需要被事务增强的入口就是 TransactionAttributeSourcePointcut#matches ```java @Override public boolean matches(Method method, Class targetClass) { // 声明式事务注解这里是 AnnotationTransactionAttributeSource 类 TransactionAttributeSource tas = getTransactionAttributeSource(); // getTransactionAttribute 方法返回值不是 null，说明当前方法需要声明式事务，在方法或它的类（包括接口，接口方法）上面找到的 @Transaction 注解 return (tas == null || tas.getTransactionAttribute(method, targetClass) != null); } ``` 可以看到又绕回来调用 AnnotationTransactionAttributeSource 的方法了。核心方法 AbstractFallbackTransactionAttributeSource#computeTransactionAttribute ```java @Nullable protected TransactionAttribute computeTransactionAttribute(Method method, @Nullable Class targetClass) { // Don't allow no-public methods as required. // 不是 public 的方法不允许动态带啦 if (allowPublicMethodsOnly() && !Modifier.isPublic(method.getModifiers())) { return null; } // The method may be on an interface, but we need attributes from the target class. // If the target class is null, the method will be unchanged. // 该方法可能位于接口上，但我们需要目标类的属性。 // 如果目标类为空，则方法将保持不变。 Method specificMethod = AopUtils.getMostSpecificMethod(method, targetClass); // First try is the method in the target class. // ① 尝试去目标类的当前方法上面去找 @Transaction 注解 TransactionAttribute txAttr = findTransactionAttribute(specificMethod); if (txAttr != null) { return txAttr; } // Second try is the transaction attribute on the target class. // ② 前面去目标类的方法上面没找到，就去类上面找 @Transaction 注解 txAttr = findTransactionAttribute(specificMethod.getDeclaringClass()); if (txAttr != null && ClassUtils.isUserLevelMethod(method)) { // 找到了，且是用户定义的方法 return txAttr; } // specificMethod != method 不相等，说明可能是接口上面的方法，去查看原始方法上是否有注解 if (specificMethod != method) { // Fallback is to look at the original method. // ③ 可能是接口上面的方法，去查看原始方法上是否有注解 txAttr = findTransactionAttribute(method); if (txAttr != null) { return txAttr; } // Last fallback is the class of the original method. // ④ 可能是接口上面的方法，去查看原始方法的接口上是否有注解 txAttr = findTransactionAttribute(method.getDeclaringClass()); if (txAttr != null && ClassUtils.isUserLevelMethod(method)) { return txAttr; } } return null; } ``` 上面判断的流程很简单： 1. 先尝试去目标类的当前方法上面去找 @Transaction 注解； 2. 假如前面去目标类的方法上面没找到，就去类上面找 @Transaction 注解； 3. 假如前面还是没找到，如果有接口的话，可能是接口上面的方法，去查看原始方法上是否有注解； 4. 假如还是没找到，可能是接口上面的方法，去查看原始方法的接口上是否有注解；那么核心就是 AbstractFallbackTransactionAttributeSource#findTransactionAttribute(Class) 方法了。最终会走到 SpringTransactionAnnotationParser#parseTransactionAnnotation(AnnotatedElement) 方法，可以看到最终就是将 @Transaction 注解的信息转换成 TransactionAttribute 对象了。 ```java @Override @Nullable public TransactionAttribute parseTransactionAnnotation(AnnotatedElement element) { // 查看是否有 @Transactional 注解 AnnotationAttributes attributes = AnnotatedElementUtils.findMergedAnnotationAttributes( element, Transactional.class, false, false); if (attributes != null) { // 找到了 @Transactional 注解，解析注解的属性 return parseTransactionAnnotation(attributes); } else { return null; } } protected TransactionAttribute parseTransactionAnnotation(AnnotationAttributes attributes) { RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute(); Propagation propagation = attributes.getEnum("propagation"); rbta.setPropagationBehavior(propagation.value()); Isolation isolation = attributes.getEnum("isolation"); rbta.setIsolationLevel(isolation.value()); rbta.setTimeout(attributes.getNumber("timeout").intValue()); rbta.setReadOnly(attributes.getBoolean("readOnly")); rbta.setQualifier(attributes.getString("value")); List rollbackRules = new ArrayList<>(); for (Class rbRule : attributes.getClassArray("rollbackFor")) { rollbackRules.add(new RollbackRuleAttribute(rbRule)); } for (String rbRule : attributes.getStringArray("rollbackForClassName")) { rollbackRules.add(new RollbackRuleAttribute(rbRule)); } for (Class rbRule : attributes.getClassArray("noRollbackFor")) { rollbackRules.add(new NoRollbackRuleAttribute(rbRule)); } for (String rbRule : attributes.getStringArray("noRollbackForClassName")) { rollbackRules.add(new NoRollbackRuleAttribute(rbRule)); } rbta.setRollbackRules(rollbackRules); return rbta; } ``` 思绪回到 TransactionAttributeSourcePointcut#matches 方法，假如我们解析出来的 TransactionAttribute 不是 null，就说明当前方法需要增强了，就会把 BeanFactoryTransactionAttributeSourceAdvisor 作为方法的一个增强器，拿去创建代理对象。 ```java @Override public boolean matches(Method method, Class targetClass) { // 声明式事务注解这里是 AnnotationTransactionAttributeSource 类 TransactionAttributeSource tas = getTransactionAttributeSource(); // getTransactionAttribute 方法返回值不是 null，说明当前方法需要声明式事务，在方法或它的类（包括接口，接口方法）上面找到的 @Transaction 注解 return (tas == null || tas.getTransactionAttribute(method, targetClass) != null); } ``` ## 事务方法增强逻辑假如某个方法需要被事务增强，前面我们说了就会拿 BeanFactoryTransactionAttributeSourceAdvisor 作为一个增强去创建代理对象。那么目前来看和 TransactionInterceptor 是没关系的，接下来分析 TransactionInterceptor 是如何起作用的。假如是使用的 JDK 动态代理，我们来看 JdkDynamicAopProxy#invoke 方法，这个方法就是每次目标方法调用时会调用的方法，在这个方法中我们要找到适合当前方法的增强，关键就是下面这行代码： ```java // Get the interception chain for this method. // 查找适合该方法的增强 List

17-Spring5核心源码-事务-解析@Transaction生成代理对象.

Dylan Kwok

17-Spring5核心源码-事务-解析@Transaction生成代理对象