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

关注

原创最新推荐文章于 2026-06-07 15:26:25 发布 803 阅读 AI 写同款· GEO 优化 ›

Spring之aop源码解析 aop就是面向切面编程，是为了解耦而生。aop是不仅工作常用而且面试也经常问，所以看aop源码是非常有必要的。在看源码之前，我们先要带着结论去看源码，而不是一上来看的一脸懵逼，一定要先总后分。aop的流程就是在spring的生命周期过程中，会缓存所有的切面，然后在bean初始化的时候，它会找当前bean的所有方法是否跟缓存中的切面有匹配的，如果匹配，说明需要代理并创建代理对象，当调用被增强方法时，执行代理逻辑。本文基于springboot2.3.5.RELEASE，如果有错，欢迎指出。阅读详情

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

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

一、AOP 配置入口

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

    <bean id="userServiceImpl" class="com.jas.mess.aop.UserServiceImpl"/>
    <bean id="ownerAspect" class="com.jas.mess.aop.spring.OwnerAspect"/>

    <aop:config>
        <aop:aspect ref="ownerAspect">
            <aop:pointcut id="ownerPointcut" expression="execution(* com.jas.mess.aop.*.*(..))"/>
            <aop:before method="recordLog" pointcut-ref="ownerPointcut"/>
        </aop:aspect>
    </aop:config>

在以前的文章里有总结过，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标签 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();
        }
    }

主要流程如下：

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

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