Spring学习10-- AOP实现原理

AOP的原理不需要多讲，动态代理。那么，Spring在bean对象实例化的时候，是如何动态代理一个类的呢？又是如何完成方法织入的呢，来看一看源码。

1、AbstractAutowireCapableBeanFactory的applyBeanPostProcessorsBeforeInstantiation
翻开Spring学习08的内容，里面有讲到后置处理器BeanPostProcessor的实现原理，在给Bean实例化的过程中，调用了该类中的ceaterBean方法，里面有处理后置处理器的入口函数的调用

// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
if (beanClass != null && !mergedBeanDefinition.isSynthetic()) {
//bean对象初始化之前的处理入口
Object bean = applyBeanPostProcessorsBeforeInstantiation(beanClass, beanName);
    if (bean != null) {
    //bean对象初始化之后的处理入口
        bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
        return bean;
    }
}

以applyBeanPostProcessorsAfterInitialization为例子，进入该方法

public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)  
           throws BeansException {  
       Object result = existingBean;  
       //遍历容器为所创建的Bean添加的所有BeanPostProcessor后置处理器  
       for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {  
           //调用Bean实例所有的后置处理中的初始化后处理方法，为Bean实例对象在  
           //初始化之后做一些自定义的处理操作  
           result = beanProcessor.postProcessAfterInitialization(result, beanName);  
           if (result == null) {  
               return result;  
           }  
       }  
       return result;  
    }

真正处理的方法是postProcessAfterInitialization，继续进去看看，AbstractAutowireCapableBeanFactory类中并没有实现这个方法，查看一下子类，真正实现的地方在AbstractAutoProxyCreator

public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (isInfrastructureClass(bean.getClass(), beanName) || shouldSkip(bean.getClass(), beanName)) {
            return bean;
        }

        // Create proxy if we have advice.
        Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
        if (specificInterceptors != DO_NOT_PROXY) {
            //创建代理
            return createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
        }

        return bean;
    }

真正创建代理的地方入口就在这里，进入createProxy

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

        // handle prototypes correctly
        //获取所有的advisor, Advisor：充当Advice和Pointcut的适配器，类似使用Aspect的@Aspect注解的类（前一章节所//述）。一般有advice和pointcut属性
        Advisor[] commonInterceptors = resolveInterceptorNames();

        List allInterceptors = new ArrayList();
        if (specificInterceptors != null) {
            allInterceptors.addAll(Arrays.asList(specificInterceptors));
            if (commonInterceptors != null) {
                if (this.applyCommonInterceptorsFirst) {
                    allInterceptors.addAll(0, Arrays.asList(commonInterceptors));
                }
                else {
                    allInterceptors.addAll(Arrays.asList(commonInterceptors));
                }
            }
        }
        if (logger.isDebugEnabled()) {
            int nrOfCommonInterceptors = commonInterceptors != null ? commonInterceptors.length : 0;
            int nrOfSpecificInterceptors = specificInterceptors != null ? specificInterceptors.length : 0;
            logger.debug(
                    "Creating implicit proxy for bean '" + beanName + "' with " + nrOfCommonInterceptors +
                    " common interceptors and " + nrOfSpecificInterceptors + " specific interceptors");
        }

        ProxyFactory proxyFactory = new ProxyFactory();
        // Copy our properties (proxyTargetClass) inherited from ProxyConfig.
        proxyFactory.copyFrom(this);

        if (!isProxyTargetClass()) {
            // Must allow for introductions; can't just set interfaces to
            // the target's interfaces only.
            Class[] targetsInterfaces = ClassUtils.getAllInterfacesForClass(beanClass);
            for (int i = 0; i < targetsInterfaces.length; i++) {
                proxyFactory.addInterface(targetsInterfaces[i]);
            }
        }

        for (Iterator it = allInterceptors.iterator(); it.hasNext();) {
            Advisor advisor = this.advisorAdapterRegistry.wrap(it.next());
            proxyFactory.addAdvisor(advisor);
        }
        proxyFactory.setTargetSource(targetSource);
        customizeProxyFactory(proxyFactory);

        proxyFactory.setFrozen(this.freezeProxy);
        //返回代理对象
        return proxyFactory.getProxy();
    }

正在返回代理的地方就是最后的getProxy()方法，进入，但是类中没有实现，在子类JdkDynamicAopProxy中有了实现

/** 
    * <ol> 
    * <li>获取代理类要实现的接口,除了Advised对象中配置的,还会加上SpringProxy, Advised(opaque=false) 
    * <li>检查上面得到的接口中有没有定义 equals或者hashcode的接口 
    * <li>调用Proxy.newProxyInstance创建代理对象 
    * </ol> 
    */  
   public Object getProxy(ClassLoader classLoader) {  
       if (logger.isDebugEnabled()) {  
           logger.debug("Creating JDK dynamic proxy: target source is " +this.advised.getTargetSource());  
       }  
       Class[] proxiedInterfaces =AopProxyUtils.completeProxiedInterfaces(this.advised);  
       findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);  
       return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);  
}  

这样一个过程下来，一个代理对象就产生了，但是问题又来了，这个对象是如何工作的，也就是说，是如何织入的呢？

2、织入过程
上面说到类JdkDynamicAopProxy中geyProxy方法产生了一个代理对象，我们在动态代理中说过，动态代理最重要的地方就是实现InvocationHandler接口，其中invoke函数是代理生效的方法，正好，类JdkDynamicAopProxy就实现了这个接口，来找一下invoke方法，看里面做了写什么。

//AOP代理对象的回调方法  
publicObject invoke(Object proxy, Method method, Object[] args) throws Throwable {  
MethodInvocationinvocation;  
ObjectoldProxy = null;  
booleansetProxyContext = false;  
//获取通知的目标源  
TargetSourcetargetSource = this.advised.targetSource;  
ClasstargetClass = null;  
Objecttarget = null;  
try{  
//如果代理目标对象的接口中没有定义equals()方法，且当前调用的方法  
//是equals()方法，即目标对象没有自己实现equals()方法  
if(!this.equalsDefined && AopUtils.isEqualsMethod(method)) {  
returnequals(args[0]);  
}  
//如果代理目标对象的接口中没有定义hashCode()方法，且当前调用的方法  
//是hashCode()方法，即目标对象没有自己实现hashCode()方法  
if(!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {  
returnhashCode();  
}  
//如果AOP配置了通知，使用反射机制调用通知的同名方法  
if(!this.advised.opaque && method.getDeclaringClass().isInterface()&&                                method.getDeclaringClass().isAssignableFrom(Advised.class)){  
returnAopUtils.invokeJoinpointUsingReflection(this.advised, method, args);  
}  
ObjectretVal;  
//如果当前通知暴露了代理，则将当前代理使用currentProxy()方法变为可用代理  
if(this.advised.exposeProxy) {  
oldProxy= AopContext.setCurrentProxy(proxy);  
setProxyContext= true;  
}  
//获取目标对象  
target= targetSource.getTarget();  
if(target != null) {  
targetClass= target.getClass();  
}  
//获取目标对象方法配置的拦截器(通知器)链  
List<Object>chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method,targetClass);  
//如果没有配置任何通知  
if(chain.isEmpty()) {  
//没有配置通知，使用反射直接调用目标对象的方法，并获取方法返回值  
retVal= AopUtils.invokeJoinpointUsingReflection(target, method, args);  
}  
//如果配置了通知  
else{  
//为目标对象创建方法回调对象，需要在调用通知之后才调用目标对象的方法  
invocation= new ReflectiveMethodInvocation(proxy, target, method, args, targetClass,chain);  
//调用通知链，沿着通知器链调用所有配置的通知  
retVal= invocation.proceed();  
}  
//如果方法有返回值，则将代理对象最为方法返回  
if(retVal != null && retVal == target &&method.getReturnType().isInstance(proxy) &&  
!RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())){  
retVal= proxy;  
}  
returnretVal;  
}  
finally{  
if(target != null && !targetSource.isStatic()) {  
//释放目标对象  
targetSource.releaseTarget(target);  
}  
if(setProxyContext) {  
//存储代理对象  
AopContext.setCurrentProxy(oldProxy);  
}  
}  
}

过程如下：
1、Advised接口或者其父接口中定义的方法,直接反射调用,不应用通知
2、获取可以应用到此方法上的通知链（Interceptor Chain）,如果有,则应用通知,并执行joinpoint; 如果没有,则直接反射执行joinpoint

获取通知链的过程getInterceptorsAndDynamicInterceptionAdvice，进入查看一下。这个方法在子类中实现。

    public List getInterceptorsAndDynamicInterceptionAdvice(
            Advised config, Object proxy, Method method, Class targetClass) {

        List cached = (List) this.methodCache.get(method);
        if (cached == null) {
            // recalculate
            cached = AdvisorChainFactoryUtils.calculateInterceptorsAndDynamicInterceptionAdvice(
                    config, proxy, method, targetClass);
            this.methodCache.put(method, cached);
        }
        return cached;
    }

实际调用的是calculateInterceptorsAndDynamicInterceptionAdvice，进入查看

/**
     * Return the static interceptors and dynamic interception advice that may apply
     * to this method invocation.
     * @return list of MethodInterceptor and InterceptionAdvice (if there's a dynamic
     * method matcher that needs evaluation at runtime)
     */
    public static List calculateInterceptorsAndDynamicInterceptionAdvice(
            Advised config, Object proxy, Method method, Class targetClass) {

        // this is somewhat tricky... we have to process introductions first,
        // but we need to preserve order in the ultimate list.
        List interceptorList = new ArrayList(config.getAdvisors().length);
        boolean hasIntroductions = hasMatchingIntroductions(config,targetClass);
        AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();
        for (int i = 0; i < config.getAdvisors().length; i++) {
            Advisor advisor = config.getAdvisors()[i];
            if (advisor instanceof PointcutAdvisor) {
                // add it conditionally
                PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;
                if (pointcutAdvisor.getPointcut().getClassFilter().matches(targetClass)) {
                    Interceptor[] interceptors = registry.getInterceptors(advisor);
                    MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
                    if (methodMatches(mm,method, targetClass,hasIntroductions)) {
                        if (mm.isRuntime()) {
                            // Creating a new object instance in the getInterceptors() method
                            // isn't a problem as we normally cache created chains.
                            for (int j = 0; j < interceptors.length; j++) {
                                interceptorList.add(new InterceptorAndDynamicMethodMatcher((MethodInterceptor) interceptors[j], mm));
                            }
                        }
                        else {
                            interceptorList.addAll(Arrays.asList(interceptors));
                        }
                    }
                }
            }
            else if (advisor instanceof IntroductionAdvisor) {
                IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
                if (ia.getClassFilter().matches(targetClass)) {
                    Interceptor[] interceptors = registry.getInterceptors(advisor);
                    interceptorList.addAll(Arrays.asList(interceptors));
                }
            }
        }
        return interceptorList;
    }

这个方法的作用就是
* 从提供的配置实例config中获取advisor列表,遍历处理这些advisor.如果是IntroductionAdvisor,
* 则判断此Advisor能否应用到目标类targetClass上.如果是PointcutAdvisor,则判断
* 此Advisor能否应用到目标方法method上.将满足条件的Advisor通过AdvisorAdaptor转化成Interceptor列表返回.
调用此方法获取目标对象方法配置的拦截器(通知器)链 。

返回上一层代码，查看一下拦截器链是怎么起作用的

JdkDynamicAopProxy 和CglibAopProxy创建AOPProxy代理对象，以及对目标对象的通知器回调我们了解到，当目标对象配置了通知器时，在对目标对象方法调用前首先需要回调通知器链，JdkDynamicAopProxy和CglibAopProxy都是通过将目标对象方法、方法参数、和通知器链、代理对象等封装为ReflectiveMethodInvocation类，然后通过ReflectiveMethodInvocation.proceed()方法调用通知器链
proceed方法源码如下

//通用通知器链
public Object proceed() throws Throwable {
//如果拦截器链中通知已经调用完毕
if(this.currentInterceptorIndex ==this.interceptorsAndDynamicMethodMatchers.size() - 1) {
//这个方法调用AopUtils.invokeJoinpointUsingReflection方法，
//通过反射机制直接调用目标对象方法
returninvokeJoinpoint();
}
//获取拦截器链中的通知器或通知
ObjectinterceptorOrInterceptionAdvice=           this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
//如果获取的通知器或通知是动态匹配方法拦截器类型
if(interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher){
//动态匹配方法拦截器
InterceptorAndDynamicMethodMatcherdm =
    (InterceptorAndDynamicMethodMatcher)interceptorOrInterceptionAdvice;
if(dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
//如果匹配，调用拦截器的方法
returndm.interceptor.invoke(this);
}
else{
//如果不匹配，递归调用proceed()方法，知道拦截器链被全部调用为止
returnproceed();
}
}
else{
//如果不是动态匹配方法拦截器，则切入点在构造对象之前进行静态匹配，调用
//拦截器的方法
return((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
}
}

总结一下
1、AOP创建代理对象通过ProxyFactory创建的。
2、JdkDynamicAopProxy通过JDK提供的动态代理创建代理类，实现方式有两种一种是jdk的动态代理，如果没有实现接口，则使用CGLIB字节码技术生成代理类。
3、代理类创建通过invoke方法调用，主要是获取目标对象方法、方法参数、和通知器链、代理对象等。
4、将上述获取到的目标对象数据封装为ReflectiveMethodInvocation类，然后通过ReflectiveMethodInvocation.proceed()方法调用通知器链。