29--aspectj-autoproxy解析及Spring解析自定义标签

版权声明：如有转载，请标明出处，谢谢合作！ https://blog.csdn.net/lyc_liyanchao/article/details/83246275

前两个小节已经介绍了AOP的一些基础知识回顾并对静态代理、JDK动态代理、CGLIB动态代理做了一些简单的介绍，本节介绍AOP标签的解析过程。

1.aspectj-autoproxy标签简介

使用注解方式应用aop需要在配置文件中配置<aop:aspectj-autoproxy/>, 而该标签有两个属性，proxy-target-class he expose-proxy

• proxy-target-class
  如果被代理的目标对象至少实现了一个接口，则会使用JDK动态代理，所有实现该目标类实现的接口都将被代理；如果该目标对象没有实现任何接口，则创建CGLIB动态代理。但是可以通过proxy-target-class属性强制指定使用CGLIB代理。所以如果指定了proxy-target-class="true"则将强制开启CGLIB动态代理。
• expose-proxy
  解决目标对象内部的自我调用无法实施切面增强的问题。

2.aspectj-autoproxy标签解析

在第十七小节，讲解了Spring对默认标签的解析过程，但是没有对默认标签解析进行分析，今天就来分析一下Spring是如何解析自定义标签aspectj-autoproxy的。顺便通过对该标签的解析，补充十七节欠缺的分析。

• 自定义标签解析入口
  打开DefaultBeanDefinitionDocumentReader类的parseBeanDefinitions方法

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
    // 1、解析默认命名空间
    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);
                }
            }
        }
    }
    // 2、解析自定义命名空间
    else {
        delegate.parseCustomElement(root);
    }
}

通过parseCustomElement解析自定义标签

• 自定义标签解析过程

/**
 * 解析自定义标签
 * @param ele
 * @param containingBd
 * @return
 */
@Nullable
public BeanDefinition parseCustomElement(Element ele, @Nullable BeanDefinition containingBd) {
    // 1、获取namespaceUri
    String namespaceUri = getNamespaceURI(ele);
    if (namespaceUri == null) {
        return null;
    }
    // 2、根据namespaceUri得到命名空间解析器
    NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
    if (handler == null) {
        error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
        return null;
    }
    // 2、使用命名空间解析器解析自定义标签
    return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
}

对自定义标签的解析交给了NamespaceHandler接口，通过这个我们就可以知道，如果我们想在Spring中实现自己的自定义标签，那么就需要实现NamespaceHandler接口，并通过重写其中的方法，来完成对自定义标签的解析。

• 获取NamespaceHandler

public NamespaceHandler resolve(String namespaceUri) {
    // 1.获取所有的namespaceUri，NamespaceHandler键值对map集合并得到
    // 当前namespaceUri对应的NamespaceHandler类
    Map<String, Object> handlerMappings = getHandlerMappings();
    Object handlerOrClassName = handlerMappings.get(namespaceUri);
    if (handlerOrClassName == null) {
        return null;
    }
    else if (handlerOrClassName instanceof NamespaceHandler) {
        return (NamespaceHandler) handlerOrClassName;
    }
    else {
        // 2、通过BeanUtils实例化NamespaceHandler并调用其init方法进行初始化操作
        String className = (String) handlerOrClassName;
        try {
            Class<?> handlerClass = ClassUtils.forName(className, this.classLoader);
            if (!NamespaceHandler.class.isAssignableFrom(handlerClass)) {
                throw new FatalBeanException("Class [" + className + "] for namespace [" + namespaceUri +
                        "] does not implement the [" + NamespaceHandler.class.getName() + "] interface");
            }
            NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass);
            namespaceHandler.init();
            handlerMappings.put(namespaceUri, namespaceHandler);
            return namespaceHandler;
        }
        catch (ClassNotFoundException ex) {
            throw new FatalBeanException("Could not find NamespaceHandler class [" + className +
                    "] for namespace [" + namespaceUri + "]", ex);
        }
        catch (LinkageError err) {
            throw new FatalBeanException("Unresolvable class definition for NamespaceHandler class [" +
                    className + "] for namespace [" + namespaceUri + "]", err);
        }
    }
}

该方法非常简单，首先根据namespaceUri从所有的Map<namespaceUri,NamespaceHandler>中获取对应的NamespaceHandler实现类，然后通过BeanUtils.instantiateClass实例化该类，最后调用NamespaceHandler实例的init方法。

• AopNamespaceHandler的init方法

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

在该方法中我们已经看到了aspectj-autoproxy标签，该方法也很简单，不做过多的分析。接下来分析aspectj-autoproxy解析的过程。

3.通过NamespaceHandler的parse方法解析aspectj-autoproxy标签

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

具体的转换工作委托给了BeanDefinitionParser实例：

public BeanDefinition parse(Element element, ParserContext parserContext) {
    // 1、注册AnnotationAwareAspectJAutoProxyCreator
    AopNamespaceUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(parserContext, element);
    // 2、处理子标签<aop:include/>， 指定@Aspect类，支持正则表达式，符合该表达式的切面类才会被应用
    extendBeanDefinition(element, parserContext);
    return null;
}

该转换过程主要完成两个功能，注册AnnotationAwareAspectJAutoProxyCreator和解析子标签<aop:include/>，我们逐步分析一下：

3.1 注册AnnotationAwareAspectJAutoProxyCreator

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

    // 1、注册AnnotationAwareAspectJAutoProxyCreator
    BeanDefinition beanDefinition = AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(
            parserContext.getRegistry(),
            parserContext.extractSource(sourceElement));
    // 2、解析子标签 proxy-target-class 和 expose-proxy
    useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);
    // 3、注册组件并发送组件注册事件
    registerComponentIfNecessary(beanDefinition, parserContext);
}

• 注册AnnotationAwareAspectJAutoProxyCreator

private static BeanDefinition registerOrEscalateApcAsRequired(Class<?> cls, BeanDefinitionRegistry registry,
			@Nullable Object source) {
    // cls --> org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator
    // AUTO_PROXY_CREATOR_BEAN_NAME --> org.springframework.aop.config.internalAutoProxyCreator
    if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
        // 如果registry已经包含了internalAutoProxyCreator，
        BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
        // 如果已经注册的internalAutoProxyCreator不是AnnotationAwareAspectJAutoProxyCreator，则需要判断优先级并决定使用哪个
        if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
            int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
            int requiredPriority = findPriorityForClass(cls);
            if (currentPriority < requiredPriority) {
                apcDefinition.setBeanClassName(cls.getName());
            }
        }
        // 如果已经注册的internalAutoProxyCreator是AnnotationAwareAspectJAutoProxyCreator，则无需特殊处理
        return null;
    }

    RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
    beanDefinition.setSource(source);
    // HIGHEST_PRECEDENCE --> 指定最高优先级
    beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
    // ROLE_INFRASTRUCTURE --> 表示Spring的内部bean
    beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    // 注册BeanDefinition
    registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
    return beanDefinition;
}

• 解析子标签 proxy-target-class 和 expose-proxy

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

该过程最核心的作用就是注册AnnotationAwareAspectJAutoProxyCreator，关于该类的作用，我们会在下面的章节分析。

3.2 处理子标签<aop:include/>

<aop:include/>标签的作用：例如有下面的配置文件，并指定了<aop:include name="aspectJTest"></aop:include>，则aspectJTest切面类会被应用，且name支持正则表达式，如果配置文件中的切面类不符合name的表达式，则切面类不会被应用。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	   xmlns:aop="http://www.springframework.org/schema/aop"
	   xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

	<!--
		1、proxy-target-class
			如果被代理的目标对象至少实现了一个接口，则会使用JDK动态代理，所有实现该目标类实现的接口都将被代理
			如果该目标对象没有实现任何接口，则创建CGLIB动态代理。
			但是可以通过proxy-target-class属性强制指定使用CGLIB代理，
		2、expose-proxy
			解决目标对象内部的自我调用无法实施切面增强的问题
	-->
	<aop:aspectj-autoproxy proxy-target-class="true" expose-proxy="true">
		<!-- 指定@Aspect类，支持正则表达式，符合该表达式的切面类才会被应用-->
		<aop:include name="aspectJTest"></aop:include>
	</aop:aspectj-autoproxy>

	<bean id="aopTestBean" class="com.lyc.cn.v2.day04.AopTestBean"></bean>

	<bean name="aspectJTest" class="com.lyc.cn.v2.day04.AspectJTest"></bean>
</beans>

了解了标签的作用之后，我们来看其解析过程，比较简单就不附加注释了：

private void extendBeanDefinition(Element element, ParserContext parserContext) {
    BeanDefinition beanDef = parserContext.getRegistry().getBeanDefinition(AopConfigUtils.AUTO_PROXY_CREATOR_BEAN_NAME);
    if (element.hasChildNodes()) {
        addIncludePatterns(element, parserContext, beanDef);
    }
}

private void addIncludePatterns(Element element, ParserContext parserContext, BeanDefinition beanDef) {
    ManagedList<TypedStringValue> includePatterns = new ManagedList<>();
    NodeList childNodes = element.getChildNodes();
    for (int i = 0; i < childNodes.getLength(); i++) {
        Node node = childNodes.item(i);
        if (node instanceof Element) {
            Element includeElement = (Element) node;
            TypedStringValue valueHolder = new TypedStringValue(includeElement.getAttribute("name"));
            valueHolder.setSource(parserContext.extractSource(includeElement));
            includePatterns.add(valueHolder);
        }
    }
    if (!includePatterns.isEmpty()) {
        includePatterns.setSource(parserContext.extractSource(element));
        beanDef.getPropertyValues().add("includePatterns", includePatterns);
    }
}

那么到这里<aop:aspectj-autoproxy/>标签的解析工作也就完成了。

4.总结

本节主要分析了<aop:aspectj-autoproxy/>标签的解析，而该标签也是Spring的自定义标签，所以，如果大家有自己的自定义标签时，可以参考借鉴Spring的源码，写出自己的标签解析过程。通过继承NamespaceHandler实现自己的命名空间解析器即可。

在解析<aop:aspectj-autoproxy/>的过程中，除了对标签的解析工作之外，还注册了AnnotationAwareAspectJAutoProxyCreator，该类的作用是什么呢，我们留在下节分析。