SpringAop源码（六）- 标签aspectj-autoproxy实现分析

目录

1、自定义标签、解析器的加载和调用时机

2、AspectJAutoProxyBeanDefinitionParser

3、总结

---

1、自定义标签、解析器的加载和调用时机

    之前分析过EnableAspectJAutoProxy方式启动Spring Aop的整个代理过程，当前在这之前基本都是使用Xml启动方式，配置如下：

<aop:aspectj-autoproxy proxy-target-class="true" expose-proxy="true" />

全局查找发现是NamespaceHandler的子类AopNamespaceHandler（Spring-aop.jar）实现了父类的init方法，

@Override
public void init() {
    // In 2.0 XSD as well as in 2.1 XSD.
    registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());
    registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());
    registerBeanDefinitionDecorator("scoped-proxy", new ScopedProxyBeanDefinitionDecorator());

    // Only in 2.0 XSD: moved to context namespace as of 2.1
    registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
}

注册方法如下：

protected final void registerBeanDefinitionParser(String elementName, 
    BeanDefinitionParser parser) {

    this.parsers.put(elementName, parser);
}

往NamespaceHandlerSupport的成员变量

private final Map<String, BeanDefinitionParser> parsers = new HashMap<>();

中添加了解析某一字符串标签的解析器。那么是在什么时候进行调用的呢，当Spring容器 ApplicationContext启动的时候，refresh模板方法的第二步骤就会先去初始化BeanFactory。

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

那么会进行Spring xml配置的加载、验证、解析、组装成BeanDefinition放入BeanFactory容器中。

。。。。。。

/**
 * Parse the elements at the root level in the document:
 * "import", "alias", "bean".
 * @param root the DOM root element of the document
 */
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
    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;
                if (delegate.isDefaultNamespace(ele)) {
                    parseDefaultElement(ele, delegate);
                }
                else {
                    delegate.parseCustomElement(ele);
                }
            }
        }
    }
    else {
        delegate.parseCustomElement(root);
    }
}

会根据委派的解析器解析xml标签，如果isDefaultNamespace（如<bean>等），那么就是自定义的标签，就走自定义标签解析流程。

public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
    String namespaceUri = getNamespaceURI(ele);
    if (namespaceUri == null) {
        return null;
    }
    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));
}

最好交给NamespaceHandlerSupport进行解析

@Override
@Nullable
public BeanDefinition parse(Element element, ParserContext parserContext) {
    BeanDefinitionParser parser = findParserForElement(element, parserContext);
    return (parser != null ? parser.parse(element, parserContext) : null);
}

再看一下查找解析器的过程就是知道了，就是根据标签的名称（aspectj-autoproxy）获取解析器

@Nullable
private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {
    String localName = parserContext.getDelegate().getLocalName(element);
    BeanDefinitionParser parser = this.parsers.get(localName);
    if (parser == null) {
        parserContext.getReaderContext().fatal(
                "Cannot locate BeanDefinitionParser for element [" + localName + "]", element);
    }
    return parser;
}

这样就获取到了之前放入Map中的解析器 AspectJAutoProxyBeanDefinitionParser

2、AspectJAutoProxyBeanDefinitionParser

parse方法：

@Override
@Nullable
public BeanDefinition parse(Element element, ParserContext parserContext) {
    AopNamespaceUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(parserContext, element);
    extendBeanDefinition(element, parserContext);
    return null;
}

主要的方法是第一步，第二步是解析子标签，但是当前标签是没有子标签的。

public static void registerAspectJAnnotationAutoProxyCreatorIfNecessary(
        ParserContext parserContext, Element sourceElement) {

    BeanDefinition beanDefinition = AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(
            parserContext.getRegistry(), parserContext.extractSource(sourceElement));
    useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);
    registerComponentIfNecessary(beanDefinition, parserContext);
}

当前是

AopConfigUtils.registerAspectJAutoProxyCreatorIfNecessary( parserContext.getRegistry(),        parserContext.extractSource(sourceElement));

与@EnableAspectJAutoProxy方式的

AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);

比较相似，继续往下看：

@Nullable
public static BeanDefinition registerAspectJAutoProxyCreatorIfNecessary(
    BeanDefinitionRegistry registry, @Nullable Object source) {

    return registerOrEscalateApcAsRequired(AspectJAwareAdvisorAutoProxyCreator.class, 
        registry, source);
}

    看到了注入的BeanDefinition为AspectJAwareAdvisorAutoProxyCreator，是AnnotationAwareAspectJAutoProxyCreator的父类。之前分析Aop带来实现的时候，其实大部分的处理逻辑都是在父类中进行完成的。

再看看

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

同样是对 proxy-target-class="true" expose-proxy="true"属性的处理，往上面初始化的BeanDefinition中添加属性。

registerComponentIfNecessary(beanDefinition, parserContext);

接着是注册组件并通知，便于监听器做进一步处理，先不进行分析。

3、总结

    基于自定义标签方式的Aop是早于注解的，所以当前注入的BeanDefinition，AspectJAwareAdvisorAutoProxyCreator，是AnnotationAwareAspectJAutoProxyCreator的父类。只是触发Aop代理开关方式不同其他的都是一样的。

    只是还需要注意，AnnotationAwareAspectJAutoProxyCreator实现了父类的findCandidateAdvisors方法，首先是先执行了super的方法，也就是AspectJAwareAdvisorAutoProxyCreator的解析方式。之前分析过该过程，详见：SpringAop源码-EnableAspectJAutoProxy实现原理（中）- getAdvicesAndAdvisorsForBean。那么也就是说，通过标签启动的Spring Aop没有解析@Aspect方式的能力。