Spring 切面解析过程

当使用Spring事务时，需要在Spring的配置文件中添加命名空间aop

xmlns:aop="http://www.springframework.org/schema/aop"

aop命名空间的处理类可在Spring-aop-XXXXX.jar中找到。

AOP命名空间处理类配置

http\://www.springframework.org/schema/aop=org.springframework.aop.config.AopNamespaceHandler

AopNamespaceHandler的代码如下

    public class AopNamespaceHandler extends NamespaceHandlerSupport {

        /**
         * Register the {@link BeanDefinitionParser BeanDefinitionParsers} for the
         * '{@code config}', '{@code spring-configured}', '{@code aspectj-autoproxy}'
         * and '{@code scoped-proxy}' tags.
         */
        @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());
        }

    }

上面的代码标识了不同标签的处理类。

aspectj-autoproxy的处理类为

org.springframework.aop.config.AspectJAutoProxyBeanDefinitionParser

AspectJAutoProxyBeanDefinitionParser的解析过程如下：

    class AspectJAutoProxyBeanDefinitionParser implements BeanDefinitionParser {

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

AopNamespaceUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary函数主要向Spring注入AnnotationAwareAspectJAutoProxyCreator类

    public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, Object source) {
        return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
    }

下面来看AnnotationAwareAspectJAutoProxyCreator类。

欲观察AnnotationAwareAspectJAutoProxyCreator如何起作用的，一般而言观察AnnotationAwareAspectJAutoProxyCreator实现了Spring的那些Aware或者回到函数。

Spring bean的实例化过程

通过观察可发现AnnotationAwareAspectJAutoProxyCreator实现了BeanPostProcessor接口。

    public interface BeanPostProcessor {

        Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;

        Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;

    }

下面来看AnnotationAwareAspectJAutoProxyCreator的postProcessBeforeInitialization做了什么事

    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        return bean;
    }

Nothing。

postProcessAfterInitialization呢？

    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (bean != null) {
            Object cacheKey = getCacheKey(bean.getClass(), beanName);
            if (!this.earlyProxyReferences.contains(cacheKey)) {
                return wrapIfNecessary(bean, beanName, cacheKey);
            }
        }
        return bean;
    }

下面来看wrapIfNeccessary函数

    protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
        //部分代码略
        //1.找到当前对象的advisors
        Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
        if (specificInterceptors != DO_NOT_PROXY) {
            this.advisedBeans.put(cacheKey, Boolean.TRUE);
            //2.代理当前对象
            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;
    }

主要做两件事：

• 找到当前对象的Advisor。
• 对当前对象进行代理。

getAdvicesAndAdvisorsForBean会调用到

    protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
        List<Advisor> candidateAdvisors = findCandidateAdvisors();
        List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
        extendAdvisors(eligibleAdvisors);
        if (!eligibleAdvisors.isEmpty()) {
            eligibleAdvisors = sortAdvisors(eligibleAdvisors);
        }
        return eligibleAdvisors;
    }

findEligibleAdvisors处理两件事：

• findCandidateAdvisors找到Spring中所有的Advisor.
• findAdvisorsThatCanApply过滤出适合当前对象的advisors.

    protected List<Advisor> findCandidateAdvisors() {
        // Add all the Spring advisors found according to superclass rules.
        List<Advisor> advisors = super.findCandidateAdvisors();
        // Build Advisors for all AspectJ aspects in the bean factory.
        advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
        return advisors;
    }

findEligibleAdvisors处理两件事

• 找到Spring中Advisor的实现类（findCandidateAdvisors）
• 将所有拥有@Aspect注解的类转换为advisors（aspectJAdvisorsBuilder.buildAspectJAdvisors）

注：
通过aspect注解生成Advisor时，如果同一个函数上有多个aspect注解，比如同时有@After @Before注解，只有@Before注解起作用。（为毛如此设计？）

findAdvisorsThatCanApply
找到当前对象适合的所有Advisor。整个过程比较简单：
遍历所有的advisor。
查看当前advisor的pointCut是否适用于当前对象，如果是，假如候选队列，否则跳过。

createProxy

    protected Object createProxy(
            Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {

        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.copyFrom(this);

        if (!proxyFactory.isProxyTargetClass()) {
            if (shouldProxyTargetClass(beanClass, beanName)) {
                proxyFactory.setProxyTargetClass(true);
            }
            else {
                evaluateProxyInterfaces(beanClass, proxyFactory);
            }
        }

        Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
        for (Advisor advisor : advisors) {
            proxyFactory.addAdvisor(advisor);
        }

        proxyFactory.setTargetSource(targetSource);
        customizeProxyFactory(proxyFactory);

        proxyFactory.setFrozen(this.freezeProxy);
        if (advisorsPreFiltered()) {
            proxyFactory.setPreFiltered(true);
        }

        return proxyFactory.getProxy(getProxyClassLoader());
    }

该函数的逻辑

• 初始化ProxyFactory
• 调用proxyFactory.getProxy生成代理对象

初始化ProxyFactory时需要注意ProxyTargetClass的初始化，proxyTargetClass的值决定了代理模式是cglib还是jdk动态代理。
proxyTargetClass的值：

  if  设置了proxy-target-class=“true”
    then proxyTargetClass=true，使用cglib代理。
else if(当前对象实现了用户自定义的接口)
    then proxyTargetClass=false，使用JDK动态代理
else
    proxyTargetClass=true，使用cglib代理。

getProxy

    public Object getProxy(ClassLoader classLoader) {
        return createAopProxy().getProxy(classLoader);
    }

createAopProxy根据proxyTargetClass等内容决定使用cglib还是jdk动态代理。

    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
        if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
            Class<?> targetClass = config.getTargetClass();
            if (targetClass == null) {
                throw new AopConfigException("TargetSource cannot determine target class: " +
                        "Either an interface or a target is required for proxy creation.");
            }
            if (targetClass.isInterface()) {
                return new JdkDynamicAopProxy(config);
            }
            return new ObjenesisCglibAopProxy(config);
        }
        else {
            return new JdkDynamicAopProxy(config);
        }
    }

getProxy函数就是使用cglib还是jdk动态代理 生成代理对象过程。

具体代理过程可查看

• cglib

Object org.springframework.aop.framework.CglibAopProxy.getProxy(ClassLoader classLoader)

• JDK动态代理

Object org.springframework.aop.framework.JdkDynamicAopProxy.getProxy(ClassLoader classLoader)