Spring AOP 源码系列（一）解析 AOP 配置信息

妖狐艹你老母 2023-07-26 05:25 24阅读 0赞

在进行源码阅读之前建议先看一下这篇文章：[Spring AOP 源码分析系列文章导读][Spring AOP] by 田小波，写的非常好，推荐阅读。

关于 AOP 中常用的一些术语这里就不解释了，如果不清楚的建议先看一遍上面推荐的文章。

### 一、AOP 配置入口 ###

在分析源码之前，我们先来看一下 XML 中关于 AOP 的配置：

在以前的文章里有总结过，XML 文件的配置信息会被转化成 `BeanDefinition`，其中 AOP 相关的配置也不例外，从上面的例子中我们能看出一个明显的区别：普通的 bean 标签与 AOP 配置标签不一样，一个是 `<bean />` 一个是 `<aop />`，除此之外你要想配置 AOP，还需要在 XMl 中引入 `xmlns:aop="http://www.springframework.org/schema/aop"` 命名空间。

普通的 bean 标签与 AOP 标签处理逻辑通过命名空间区分，下面我们来看源码。

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) { 
            // 命名空间检查，默认的命名空间是 "http://www.springframework.org/schema/beans"
            if (delegate.isDefaultNamespace(root)) { 
                NodeList nl = root.getChildNodes();
                for (int i = 0; i < nl.getLength(); i++) { 
                    Node node = nl.item(i);
                    if (node instanceof Element) { 
                        Element ele = (Element) node;
                        // <bean /> 标签处理入口
                        if (delegate.isDefaultNamespace(ele)) { 
                            parseDefaultElement(ele, delegate);
                        }
                        else { 
                            // <aop /> 标签处理入口
                            delegate.parseCustomElement(ele);
                        }
                    }
                }
            }
            else { 
                delegate.parseCustomElement(root);
            }
        }

上面我们说过，AOP 的命名空间是 `http://www.springframework.org/schema/aop`，因此会执行到 `delegate.parseCustomElement(ele)`。

public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) { 
            String namespaceUri = getNamespaceURI(ele);
            if (namespaceUri == null) { 
                return null;
            }
            // 根据命名空间获取 handler
            NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
            if (handler == null) { 
                error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
                return null;
            }
            return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
        }
    
    
        public BeanDefinition parse(Element element, ParserContext parserContext) { 
            BeanDefinitionParser parser = findParserForElement(element, parserContext);
            return (parser != null ? parser.parse(element, parserContext) : null);
        }

上面的流程比较简单，根据命名空间 URI 获取命名空间 handler，这里对应的是 `AopNamespaceHandler`，通过 handler 去解析配置。handler 内部会根据标签配置信息得到 `ConfigBeanDefinitionParser`，最终调用 `parse` 方法。

public BeanDefinition parse(Element element, ParserContext parserContext) { 
            CompositeComponentDefinition compositeDef =
                    new CompositeComponentDefinition(element.getTagName(), parserContext.extractSource(element));
            parserContext.pushContainingComponent(compositeDef);
    
            // 注册 AspectJAwareAdvisorAutoProxyCreator 类型的beanDefinition，继承自 BeanPostProcessor
            configureAutoProxyCreator(parserContext, element);
    
            // 获取所有子标签
            List<Element> childElts = DomUtils.getChildElements(element);
            for (Element elt: childElts) { 
                String localName = parserContext.getDelegate().getLocalName(elt);
                // 解析 <aop:poincut />
                if (POINTCUT.equals(localName)) { 
                    parsePointcut(elt, parserContext);
                }
                // 解析 <aop:>advisor />
                else if (ADVISOR.equals(localName)) { 
                    parseAdvisor(elt, parserContext);
                }
                // 解析 <aop:aspect />
                else if (ASPECT.equals(localName)) { 
                    parseAspect(elt, parserContext);
                }
            }
    
            parserContext.popAndRegisterContainingComponent();
            return null;
        }

这里涉及到一个 `<aop:advisor />` 标签，大家可能不太清楚它的作用，advisor 与 advice（`<aop:before />`，`<aop:after />`…）功能类似，都可以用来增强目标方法，具体用法可以参考这篇文章：[Spring Aop（八）——advisor标签][Spring Aop_advisor] by 234390216

`parse` 方法会处理 `<aop:config />` 标签下的子标签，具体的处理逻辑后面会分析到。在解析标签之前先调用了 `configureAutoProxyCreator` 方法，这个方法比较重要。

### 二、注册 AspectJAwareAdvisorAutoProxyCreator beanDefinition ###

private void configureAutoProxyCreator(ParserContext parserContext, Element element) { 
            AopNamespaceUtils.registerAspectJAutoProxyCreatorIfNecessary(parserContext, element);
        }
    
        public static void registerAspectJAutoProxyCreatorIfNecessary(
                ParserContext parserContext, Element sourceElement) { 
            BeanDefinition beanDefinition = AopConfigUtils.registerAspectJAutoProxyCreatorIfNecessary(
                    parserContext.getRegistry(), parserContext.extractSource(sourceElement));
    
            useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);
    
            registerComponentIfNecessary(beanDefinition, parserContext);
        }

`registerAspectJAutoProxyCreatorIfNecessary`方法中有三个处理逻辑，下面一一来看下。

@Nullable
        public static BeanDefinition registerAspectJAutoProxyCreatorIfNecessary(
                BeanDefinitionRegistry registry, @Nullable Object source) { 
            // 注意这里传的是 AspectJAwareAdvisorAutoProxyCreator 类型
            return registerOrEscalateApcAsRequired(AspectJAwareAdvisorAutoProxyCreator.class, registry, source);
        }
    
        private static BeanDefinition registerOrEscalateApcAsRequired(
                Class<?> cls, BeanDefinitionRegistry registry, @Nullable Object source) { 
    
            Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
    
            // AUTO_PROXY_CREATOR_BEAN_NAME = "org.springframework.aop.config.internalAutoProxyCreator"
            if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) { 
                BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
                if (!cls.getName().equals(apcDefinition.getBeanClassName())) { 
                    int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
                    int requiredPriority = findPriorityForClass(cls);
                    if (currentPriority < requiredPriority) { 
                        apcDefinition.setBeanClassName(cls.getName());
                    }
                }
                return null;
            }
    
            RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
            beanDefinition.setSource(source);
            beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
            beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
            // 注册一个类型为 AspectJAwareAdvisorAutoProxyCreator 的 beanDefinition
            registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
            return beanDefinition;
        }

注册一个类型为 `AspectJAwareAdvisorAutoProxyCreator` 的 beanDefinition，注意此时还没有创建 bean，`AspectJAwareAdvisorAutoProxyCreator` 其实是一个 `BeanPostProcessor`，后面在对方法增强的时候会用到，具体细节会在后面的文章里总结。

private static void useClassProxyingIfNecessary(BeanDefinitionRegistry registry, @Nullable Element sourceElement) { 
            if (sourceElement != null) { 
                boolean proxyTargetClass = Boolean.parseBoolean(sourceElement.getAttribute(PROXY_TARGET_CLASS_ATTRIBUTE));
                if (proxyTargetClass) { 
                    AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
                }
                boolean exposeProxy = Boolean.parseBoolean(sourceElement.getAttribute(EXPOSE_PROXY_ATTRIBUTE));
                if (exposeProxy) { 
                    AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
                }
            }
        }

检查 `<aop:config />`是否配置了 `proxy-target-class` 与 `expose-proxy`，如果有配置，则为 beanDefinition 添加 `exposeProxy` 与 `proxyTargetClass` 属性，这两个配置标签后面还会遇到，这里先简单介绍下作用。

`proxy-target-class`：默认为 false，如果设置为 true，会使用 CGLIB 创建代理对象  
`expose-proxy`：默认为 false，作用：假设 A，B 方法都被增强，A 方法调用 B 方法，A 方法会被切面拦截，A 里的 B 方法是否会被切面拦截增强，默认不会

private static void registerComponentIfNecessary(@Nullable BeanDefinition beanDefinition, ParserContext parserContext) { 
            if (beanDefinition != null) { 
                parserContext.registerComponent(
                        new BeanComponentDefinition(beanDefinition, AopConfigUtils.AUTO_PROXY_CREATOR_BEAN_NAME));
            }
        }

注册组件。

### 三、解析 <aop:aspect ref="" id="" /> ###

`<aop:aspect />` 标签下可以配置多种类型的子标签，比如 `<aop:before />`、`<aop:after` />、`<aop:pointcut />`、`<aop:declare-parents />` 等，不同类型的标签处理逻辑也是不一样的。

private void parseAspect(Element aspectElement, ParserContext parserContext) { 
            String aspectId = aspectElement.getAttribute(ID);
            // 切面 beanName
            String aspectName = aspectElement.getAttribute(REF);
    
            try { 
                // 添加进 LinkedList
                this.parseState.push(new AspectEntry(aspectId, aspectName));
                List<BeanDefinition> beanDefinitions = new ArrayList<>();
                List<BeanReference> beanReferences = new ArrayList<>();
    
                // 获取 <aop:declare-parents /> 子标签
                List<Element> declareParents = DomUtils.getChildElementsByTagName(aspectElement, DECLARE_PARENTS);
                for (Element declareParentsElement : declareParents) { 
                    beanDefinitions.add(parseDeclareParents(declareParentsElement, parserContext));
                }
    
                NodeList nodeList = aspectElement.getChildNodes();
                boolean adviceFoundAlready = false;
                for (int i = 0; i < nodeList.getLength(); i++) { 
                    Node node = nodeList.item(i);
                    // 处理通知节点 <aop:before,after, around ... />
                    if (isAdviceNode(node, parserContext)) { 
                        if (!adviceFoundAlready) { 
                            adviceFoundAlready = true;
                            if (!StringUtils.hasText(aspectName)) { 
                                parserContext.getReaderContext().error(
                                        "<aspect> tag needs aspect bean reference via 'ref' attribute when declaring advices.",
                                        aspectElement, this.parseState.snapshot());
                                return;
                            }
                            beanReferences.add(new RuntimeBeanReference(aspectName));
                        }
                        // 处理通知
                        AbstractBeanDefinition advisorDefinition = parseAdvice(
                                aspectName, i, aspectElement, (Element) node, parserContext, beanDefinitions, beanReferences);
                        beanDefinitions.add(advisorDefinition);
                    }
                }
    
                // 创建 AspectComponentDefinition
                AspectComponentDefinition aspectComponentDefinition = createAspectComponentDefinition(
                        aspectElement, aspectId, beanDefinitions, beanReferences, parserContext);
                parserContext.pushContainingComponent(aspectComponentDefinition);
    
                // 获取所有切点 element
                List<Element> pointcuts = DomUtils.getChildElementsByTagName(aspectElement, POINTCUT);
                for (Element pointcutElement : pointcuts) { 
                    parsePointcut(pointcutElement, parserContext);
                }
    
                parserContext.popAndRegisterContainingComponent();
            }
            finally { 
                this.parseState.pop();
            }
        }

主要流程如下：

1.  获取 `<aop:aspect >` 的 id 与 ref 属性，封装成 `AspectEntry` 添加到 `parseState` 集合中，流程处理完后，出栈
2.  获取 `<aop:declare-parents />` 子标签，如果有配置则封装成 beanDefinition
3.  解析 `<aop:aspect >` 下所有子标签，循环处理通知配置
4.  解析切点配置

private AbstractBeanDefinition parseAdvice(
               String aspectName, int order, Element aspectElement, Element adviceElement, ParserContext parserContext,
               List<BeanDefinition> beanDefinitions, List<BeanReference> beanReferences) { 
    
           try { 
               this.parseState.push(new AdviceEntry(parserContext.getDelegate().getLocalName(adviceElement)));
    
               RootBeanDefinition methodDefinition = new RootBeanDefinition(MethodLocatingFactoryBean.class);
               // 切面 bean（类）
               methodDefinition.getPropertyValues().add("targetBeanName", aspectName);
               // 设置切面方法
               methodDefinition.getPropertyValues().add("methodName", adviceElement.getAttribute("method"));
               methodDefinition.setSynthetic(true);
    
               // 创建切面 BeanDefinition
               RootBeanDefinition aspectFactoryDef =
                       new RootBeanDefinition(SimpleBeanFactoryAwareAspectInstanceFactory.class);
               aspectFactoryDef.getPropertyValues().add("aspectBeanName", aspectName);
               aspectFactoryDef.setSynthetic(true);
    
               // 创建通知 BeanDefinition，此时已明确通知类型
               AbstractBeanDefinition adviceDef = createAdviceDefinition(
                       adviceElement, parserContext, aspectName, order, methodDefinition, aspectFactoryDef,
                       beanDefinitions, beanReferences);
    
               RootBeanDefinition advisorDefinition = new RootBeanDefinition(AspectJPointcutAdvisor.class);
               advisorDefinition.setSource(parserContext.extractSource(adviceElement));
               // 将上面创建的 adviceDef 注入到 advisorDefinition 中
               advisorDefinition.getConstructorArgumentValues().addGenericArgumentValue(adviceDef);
               // <aop:aspect ref="" order="" />，控制切面方法优先级
               if (aspectElement.hasAttribute(ORDER_PROPERTY)) { 
                   advisorDefinition.getPropertyValues().add(
                           ORDER_PROPERTY, aspectElement.getAttribute(ORDER_PROPERTY));
               }
    
               // 注册通知 BeanDefinition
               parserContext.getReaderContext().registerWithGeneratedName(advisorDefinition);
    
               return advisorDefinition;
           }
           finally { 
               this.parseState.pop();
           }
       }

上面逻辑主要是创建出 `advisorDefinition`，并注册到 beanFactory 中，由此可见，我们配置的每一个通知，最终都会被转化成 beanDefinition 并注册到 IoC 容器中。

上面这个方法深追下去知识点还挺多的，比如 `createAdviceDefinition` 方法，注册 beanDefinition 时 beanName 的生成规则等，有兴趣的自己可以研究下，这里就不介绍了，看不懂的地方可以通过 DEBUG 的方式帮助理解。

private AbstractBeanDefinition parsePointcut(Element pointcutElement, ParserContext parserContext) { 
            String id = pointcutElement.getAttribute(ID);
            // 获取切点表达式
            String expression = pointcutElement.getAttribute(EXPRESSION);
    
            AbstractBeanDefinition pointcutDefinition = null;
    
            try { 
                this.parseState.push(new PointcutEntry(id));
                // 创建切点 beanDefinition，类型为 ConfigurableBeanFactory.SCOPE_PROTOTYPE
                pointcutDefinition = createPointcutDefinition(expression);
                pointcutDefinition.setSource(parserContext.extractSource(pointcutElement));
    
                String pointcutBeanName = id;
                // 注册切点 BeanDefinition 到 beanFactory 中
                if (StringUtils.hasText(pointcutBeanName)) { 
                    parserContext.getRegistry().registerBeanDefinition(pointcutBeanName, pointcutDefinition);
                }
                else { 
                    // <aop:pointcut id="" expression=""/> 没有配置 id 先生成 beanName 在注册到 beanFactory 中
                    pointcutBeanName = parserContext.getReaderContext().registerWithGeneratedName(pointcutDefinition);
                }
    
                parserContext.registerComponent(
                        new PointcutComponentDefinition(pointcutBeanName, pointcutDefinition, expression));
            }
            finally { 
                this.parseState.pop();
            }
    
            return pointcutDefinition;
        }
    
        protected AbstractBeanDefinition createPointcutDefinition(String expression) { 
            RootBeanDefinition beanDefinition = new RootBeanDefinition(AspectJExpressionPointcut.class);
            // 切点作用域原型
            beanDefinition.setScope(BeanDefinition.SCOPE_PROTOTYPE);
            beanDefinition.setSynthetic(true);
            beanDefinition.getPropertyValues().add(EXPRESSION, expression);
            return beanDefinition;
        }

处理切点的逻辑与通知类似，注意切点 beanDefinition 的作用域并非单例而是原型，初始化 beanDefinition 后注册到 IoC 容器中。

### 参考 ###

[【Spring源码分析】AOP源码解析（上篇）][Spring_AOP] by 五月的仓颉

[Spring AOP]: http://www.tianxiaobo.com/2018/06/17/Spring-AOP-%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%E7%B3%BB%E5%88%97%E6%96%87%E7%AB%A0%E5%AF%BC%E8%AF%BB/
[Spring Aop_advisor]: https://www.iteye.com/blog/elim-2396274
[Spring_AOP]: https://www.cnblogs.com/xrq730/p/6753160.html