Spring源码分析（七）SpringAOP生成代理类及执行的过程

1、AOP的入口

上一节我们在分析解析AOP标签的时候，第一步就是注册了一个类AspectJAwareAdvisorAutoProxyCreator，我们说它是AOP的入口类。为什么这样说呢？
来看它父类的父类AbstractAutoProxyCreator，它继承了BeanPostProcessor接口。
那么，有两个方法肯定要被调用到postProcessBeforeInitialization、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;
}

wrapIfNecessary方法则是真正产生代理的地方，我们先看下它的内部实现。

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    // Create proxy if we have advice.
    //先看它的注释，大意说：如果有通知，就创建代理。
    //其实就是在bean.getClass()找到所有的通知和advisor
    //这里面其实又分为两个步骤:
    //第一，在Bean工厂找到所有的Advisor 第二，根据beanClass和Pointcut去做匹配
    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
    if (specificInterceptors != DO_NOT_PROXY) {
        this.advisedBeans.put(cacheKey, Boolean.TRUE);
        //真正创建代理并返回，这时候返回的就是代理类了，把真实的bean替换掉
        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，这个比较简单。因为我们知道，在解析的时候就把配置的通知封装成advisor注册了进去。首先拿到beanDefinitionNames容器所有beanName，循环判断bean的类型是不是advisor接口的类型，符合条件返回。

public List findAdvisorBeans() {
    // Determine list of advisor bean names, if not cached already.
    String[] advisorNames = null;
    
    //先拿到beanName
    advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
            this.beanFactory, Advisor.class, true, false);
        
    List advisors = new LinkedList();
    for (String name : advisorNames) {
        if (isEligibleBean(name)) {     
            try {
                //再从Bean工厂中拿bean的实例
                advisors.add(this.beanFactory.getBean(name, Advisor.class));
            }
        }
    }
    //返回的advisors就是配置文件中所有的advice和advisor
    return advisors;
}

找到advisors并未结束，还要跟pointcut做匹配，看这些advisor符不符合表达式条件。它最终调用到Pointcut的match方法。这个方法嵌套的太深，就不贴代码了，核心思想就是判断class和class对应的method是否与pointcut表达式匹配。

创建代理

经过上面查找匹配后，确定当前的bean确实需要代理，就调用createProxy方法。

• 设置代理工厂

protected Object createProxy(Class beanClass, 
        String beanName, Object[] specificInterceptors, TargetSource targetSource) {
    //创建代理工厂
    ProxyFactory proxyFactory = new ProxyFactory();
    // Copy our properties (proxyTargetClass etc) inherited from ProxyConfig.
    proxyFactory.copyFrom(this);

    //将beanClass上的接口设置到代理工厂
    evaluateProxyInterfaces(beanClass, proxyFactory);
        
    //设置Advisor到代理工厂
    Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
    for (Advisor advisor : advisors) {
        proxyFactory.addAdvisor(advisor);
    }
    //设置目标对象
    proxyFactory.setTargetSource(targetSource);
    return proxyFactory.getProxy(this.proxyClassLoader);
}

• 创建

创建代理分为JDK的代理和Cglib的代理，这里我们先关注JDK的代理。getProxy方法就调用到JdkDynamicAopProxy类的方法。这个类还实现了InvocationHandler接口，说明它同时还是调用处理程序。即在调用代理类的invoke方法时，实际上就会调用到JdkDynamicAopProxy.invoke()。

public Object getProxy(ClassLoader classLoader) {
    //这里又给代理工厂加了两个接口 SpringProxy和Advised
    Class[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised);
    
    //这个方法就比较熟悉了，正是JDK动态代理的方法
    //这里的this就是JdkDynamicAopProxy实例。
    return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}

2、代理类的调用

在实例化Bean和完成依赖注入后，会判断当前的Bean是否需要代理，如果需要，就生成代理类把原始类替换掉。在业务方法里面调用的时候，就会调用到JdkDynamicAopProxy.invoke()。

在执行invoke的时候，我们又可以分为两个步骤...-_-||，是不是跟二很有缘，每次都是两个步骤。。

1. 获取方法的拦截链

首先从代理工厂中拿到所有的advisor，然后判断是不是PointcutAdvisor类型，其次先matches一下targetClass，再matches一下method，证明这个类的方法在pointcut范围内，加入interceptorList，最后返回。

public List