Spring AOP XML配置 源码学习

上两篇文章已经介绍了AOP的使用方法以及AOP注解原理，如果有疑问，可以看看Spring AOP学习 和 Spring AOP 注解配置 源码学习 。
现在来学习XML配置的操作原理。

XML配置解析

根据<aop:config>直接定位到其命名空间的解析器ConfigBeanDefinitionParser

public BeanDefinition parse(Element element, ParserContext parserContext) {
    CompositeComponentDefinition compositeDef =
            new CompositeComponentDefinition(element.getTagName(), parserContext.extractSource(element));
    parserContext.pushContainingComponent(compositeDef);

    configureAutoProxyCreator(parserContext, element);
    // 直接创建了一个代理对象，AspectJAwareAdvisorAutoProxyCreator类
    // 这个类和注解实现的类不一样！

    List<Element> childElts = DomUtils.getChildElements(element);
    // 扫描叶子节点的信息，包含了pointCut、adivsor、aspect等信息
    for (Element elt: childElts) {
        String localName = parserContext.getDelegate().getLocalName(elt);
        if (POINTCUT.equals(localName)) {
            parsePointcut(elt, parserContext);
        }
        else if (ADVISOR.equals(localName)) {
            parseAdvisor(elt, parserContext);
        }
        else if (ASPECT.equals(localName)) {
            parseAspect(elt, parserContext);
        }
    }

    parserContext.popAndRegisterContainingComponent();
    return null;
}

image.png

如上图就是在xml文件解析完成之后在IOC的map中保存的数据，其中pc这个pointCut被当做一个新的beandefinition插入到map中，此外所有的advisor也被插入到map中。

接下来就需要进行实例化beandefinition操作，在beanFactory.preInstantiateSingletons()操作会依次遍历所有已经存储好的beandefinition列表。如下图

image.png

在Spring AOP 注解配置 源码学习 中有说过在实例化org.springframework.context.event.internalEventListenerProcessor时才会进行AOP操作，原因是什么呢，很简单，因为列表的前面几个beandefinition也是postbeanprocessor，已经在invokebeanpostprocessor的时候进行实例化了，所有也就轮流到了internalEventListenerProcessor的实例化而已。

AbstractAutowireCapableBeanFactory 类

try {
    Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
    if (bean != null) {
        return bean;
    }
}

需要注意到AspectJAwareAdvisorAutoProxyCreator这个需要实例化的bean是beanPostProcessors类也是InstantiationAwareBeanPostProcessor类。所有会进入到上面的resolveBeforeInstantiation方法

image.png

如上述代码会遍历所有的Advisor类，并实例化。

实例化操作

在对People类的实例化操作时，肯定会获取到上述已经实例化好的advisor，并利用cglib或者动态代理的方式生成具体对象。

AbstractAutowireCapableBeanFactory 类

public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException {
    Object result = existingBean;
    for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
       // 重点关注AspectJAwareAdvisorAutoProxyCreator对象的方法
       // 会调用 AbstractAutoProxyCreator 类的方法
        result = beanProcessor.postProcessAfterInitialization(result, beanName);
        if (result == null) {
            return result;
        }
    }
    return result;
}

AbstractAutoProxyCreator 类

// 这里的bean已经完成了实例化
// 例如本demo的People对象，已经完成了实例化，然后添加代理proxy操作
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    if (bean != null) {
        Object cacheKey = getCacheKey(bean.getClass(), beanName);
        if (!this.earlyProxyReferences.contains(cacheKey)) {
           // 还没有处理的bean，调用wrapIfNecessary
            return wrapIfNecessary(bean, beanName, cacheKey);
        }
    }
    return bean;
}

// 需要进行proxy的包装处理
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    if (beanName != null && this.targetSourcedBeans.contains(beanName)) {
       // 已经处理过了，直接返回
       // 这个this就是AspectJAwareAdvisorAutoProxyCreator 对象
        return bean;
    }
    if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
       // 这个false表示了没有合适的advisor需要被包装处理
        return bean;
    }
    if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
       // isInfrastructureClass 是检测类是否属于Advice、Pointcut、Advisor、AopInfrastructureBean 类中的一种 如果是则不应该被处理
       // skip函数在上一篇已经介绍过了，就是确认是否存在合适的advisor对象
       // skip返回true表示了没有合适的advisor需要被处理，则当前该bean没有合适的proxy
       // 设置adviseBean为false，并且直接返回
        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }

    // Create proxy if we have advice.
    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
    // 很关键的一个操作，找出合适的advisor对象
    // 并且其中就有规则的判断逻辑，等下再细细介绍【1、匹配execution逻辑规则】
    if (specificInterceptors != DO_NOT_PROXY) {
       // 存在合适的advisor对象信息
        this.advisedBeans.put(cacheKey, Boolean.TRUE);
        // 设置为true，免得下次再计算
        Object proxy = createProxy(
                bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
        // 创建包装的对象信息，并返回，其中就有是使用动态代理还是cglib产生对象的判断存在【2、代理对象生成原理】
        this.proxyTypes.put(cacheKey, proxy.getClass());
        return proxy;
    }
   // 否则，设置其值为false，返回返回
    this.advisedBeans.put(cacheKey, Boolean.FALSE);
    return bean;
}

1、【匹配execution逻辑规则】

AbstractAdvisorAutoProxyCreator 类

protected Object[] getAdvicesAndAdvisorsForBean(Class<?> beanClass, String beanName, TargetSource targetSource) {
    List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
    if (advisors.isEmpty()) {
        return DO_NOT_PROXY;
    }
    return advisors.toArray();
}

protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
    List<Advisor> candidateAdvisors = findCandidateAdvisors();
    // 所有合适的advisor对象列表
    List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
    // 找出所有可以使用的advisor
    extendAdvisors(eligibleAdvisors);
    if (!eligibleAdvisors.isEmpty()) {
       // 这个sort操作 注解方式和XML配置方式是一致的
        eligibleAdvisors = sortAdvisors(eligibleAdvisors);
    }
    return eligibleAdvisors;
}

AopUtils 类

如下截图，运行到该代码的参数细节

image.png

public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz) {
    if (candidateAdvisors.isEmpty()) {
       // 列表为空，直接返回
        return candidateAdvisors;
    }
    List<Advisor> eligibleAdvisors = new LinkedList<Advisor>();
    for (Advisor candidate : candidateAdvisors) {
        if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {
           // 是IntroductionAdvisor 类而且 通过expression 的规则校验
            eligibleAdvisors.add(candidate);
        }
    }
    boolean hasIntroductions = !eligibleAdvisors.isEmpty();
    for (Advisor candidate : candidateAdvisors) {
        if (candidate instanceof IntroductionAdvisor) {
            // 已经处理了不再处理
            continue;
        }
        if (canApply(candidate, clazz, hasIntroductions)) {
           // 这里的canApply和上面就差距一个hasIntroductions的参数
           // 如果包含了advisor对象且通过校验位true参数
            eligibleAdvisors.add(candidate);
        }
    }
    return eligibleAdvisors;
}

public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) {
    if (advisor instanceof IntroductionAdvisor) {
       // 可看出hasIntroductions只对PointCut才有用，所以才有了上面的多次canApply操作
        return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
    }
    else if (advisor instanceof PointcutAdvisor) {
        PointcutAdvisor pca = (PointcutAdvisor) advisor;
        // 又是被封装了一层的canApply方法
        // 通过getPointCut方法获取具体的pointCut信息
        return canApply(pca.getPointcut(), targetClass, hasIntroductions);
    }
    else {
        // 没有pointCut，假定为可以应用，返回true
        return true;
    }
}

public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) {
    Assert.notNull(pc, "Pointcut must not be null");
    // 对类名称进行一个基础的（maybe）的判断操作，如果返回false，则认为不可用，返回false
    if (!pc.getClassFilter().matches(targetClass)) {
        return false;
    }

    MethodMatcher methodMatcher = pc.getMethodMatcher();
    if (methodMatcher == MethodMatcher.TRUE) {
        // 该方法正好匹配为true，则直接返回true
        return true;
    }

    IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;
    if (methodMatcher instanceof IntroductionAwareMethodMatcher) {
        introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;
    }

    Set<Class<?>> classes = new LinkedHashSet<Class<?>>(ClassUtils.getAllInterfacesForClassAsSet(targetClass));
    classes.add(targetClass);
    for (Class<?> clazz : classes) {
        Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
        // 获取该类所有的方法形成一个列表，进行遍历匹配操作
        // 看到这个函数已经就很清楚了，简而言之就是通过函数名称进行匹配操作
        for (Method method : methods) {
            if ((introductionAwareMethodMatcher != null &&
                    introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions)) ||
                    methodMatcher.matches(method, targetClass)) {
                return true;
            }
        }
    }
    return false;
}

expression="execution(* com.demo.Aop..(..))" 在execution中的参数就是函数的匹配

第一个* 表示为 private、public
com.demo.Aop.* 表示为 Aop文件夹下面所有的class文件
第二个* 表示为 类文件下的具体函数名称
(..) 表示为 参数的情况

image.png

如上图中所示，原本存在6个advisor，经过canApply操作，只剩下了5个，其中的* com.demo.Aop1.*就被过滤掉了。

所有匹配execution的逻辑规则是先对类名称进行基础的判断，然后获取被匹配的类名称的所有函数精准匹配

sort操作

此外在findEligibleAdvisors函数中的sort操作前后对比

image.png image.png

2、【代理对象生成原理】

在wrapIfNecessary方法中获取到合适的advisor列表之后，肯定需要需要ProxyFactory根据advisor列表信息等产生具体对象

AbstractAutoProxyCreator 类

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

    if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
       // 给当前的类加上属性ORIGINAL_TARGET_CLASS_ATTRIBUTE
        AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
    }

    ProxyFactory proxyFactory = new ProxyFactory();
    // spring所有的套路都是这样的，大量利用工厂模式产生具体对象
    proxyFactory.copyFrom(this);
    // 拷贝了当前的数据到当前的工厂中

    if (!proxyFactory.isProxyTargetClass()) {
       // 如果该bean存在PRESERVE_TARGET_CLASS_ATTRIBUTE属性，设置ProxyTargetClass为true
        if (shouldProxyTargetClass(beanClass, beanName)) {
            proxyFactory.setProxyTargetClass(true);
        }
        else {
           // 检查是否存在接口，能否正常使用
           // 不过有毒的是，在发现没有合适的接口时，又设置ProxyTargetClass为true
            evaluateProxyInterfaces(beanClass, proxyFactory);
        }
    }

    Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
    // 再包装一层advisor
    for (Advisor advisor : advisors) {
        proxyFactory.addAdvisor(advisor);
    }

    proxyFactory.setTargetSource(targetSource);
    customizeProxyFactory(proxyFactory);
  // spring依旧的套路很多custom方法都是接口
    proxyFactory.setFrozen(this.freezeProxy);
    if (advisorsPreFiltered()) {
        proxyFactory.setPreFiltered(true);
    }
  // 真正创建对象的步骤
    return proxyFactory.getProxy(getProxyClassLoader());
}

DefaultAopProxyFactory 类

ProxyFactory包含的默认的代理工厂DefaultAopProxyFactory

public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
    if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
        Class<?> targetClass = config.getTargetClass();
        // 没有设置目标targetClass,抛出异常
        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() || Proxy.isProxyClass(targetClass)) {
           // 如果是继承自接口或者ProxyClass值为true（为代理类）
           // 则使用java的动态代理产生对象
            return new JdkDynamicAopProxy(config);
        }
        // 没有继承自接口而且不是proxy类
        // 则使用cglib 产生对象
        // 这里有点需要注意到的是 cglib 同样可以使用接口实现对象，只是在spring中如此设置而已
        return new ObjenesisCglibAopProxy(config);
    }
    else {
        return new JdkDynamicAopProxy(config);
    }
}

现在就介绍了spring中AOP的代理对象实现细节，同时使用其他工厂产生对象也是采用同样的模式。

现在整个的XML配置的学习就结束了，后续还会再总结一下xml配置和注解方式的差异和一些未曾注意到的细节，具体梳理其中的细节信息。