AOP Proxy 对象创建过程

由《Spring的IOC的源码解析（三）》继续分析！

首先介绍一下容器命名空间句柄 ContextNamespaceHandler

位置：spring-context-*.jar的META-INF/spring-handlers

容器命名空间句柄： http\:// www.springframework.org/schema/context=org.springframework.context.config.ContextNamespaceHandler

ContextNamespaceHandler的init方法实现如下，

     registerBeanDefinitionParser("property-placeholder", new PropertyPlaceholderBeanDefinitionParser());

    registerBeanDefinitionParser("property-override", new PropertyOverrideBeanDefinitionParser());

    registerBeanDefinitionParser("annotation-config", new AnnotationConfigBeanDefinitionParser());

    registerBeanDefinitionParser("component-scan", new ComponentScanBeanDefinitionParser());

    registerBeanDefinitionParser("load-time-weaver", new LoadTimeWeaverBeanDefinitionParser());

    registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());

    registerBeanDefinitionParser("mbean-export", new MBeanExportBeanDefinitionParser());

    registerBeanDefinitionParser("mbean-server", new MBeanServerBeanDefinitionParser());

当 ContextNamespaceHandler在解析标签的时候，会调用每种标签的解析器，解析过程就会调用 AopNamespaceUtils为当前类型的标签 尝试 注册相应的BPP；下边给出一些示例，格式为： {标签-标签解析器-注册的BPP}

    config/ ConfigBeanDefinitionParser/ AspectJAwareAdvisorAutoProxyCreator

    aspectj-autoproxy/ AspectJAutoProxyBeanDefinitionParser/ AnnotationAwareAspectJAutoProxyCreator

    load-time-weaver/ LoadTimeWeaverBeanDefinitionParser/没有

    component-scan/ ComponentScanBeanDefinitionParser/没有

继续分析AOP Proxy对象的生成过程！

（1）获取能够处理目标类的advisor

首先是调用AbstractAdvisorAutoProxyCreator. getAdvicesAndAdvisorsForBean()方法，然后调用：

protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {

    List<Advisor> candidateAdvisors = findCandidateAdvisors(); //这个方法就是去beanFactory中查询全部Advisor类型的bean，然后初始化；参见(a)

    List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);//参看(b)

    extendAdvisors(eligibleAdvisors);

    if (!eligibleAdvisors.isEmpty()) {

    eligibleAdvisors = sortAdvisors(eligibleAdvisors);//排序

    }

    return eligibleAdvisors;

}

(a) 获取并初始化Advisor，实现逻辑在 BeanFactoryAdvisorRetrievalHelper.findAdvisorBeans()，其核心代码是：

advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this.beanFactory, Advisor.class, true, false); //查询所有注册在工厂中的Advisor的bean name or id

List<Advisor> advisors = new LinkedList<>();                        

advisors.add(this.beanFactory.getBean(name, Advisor.class)); //初始化Advisor，同时也会初始化Advisor中的advice，生成一个advice实例；

(b) 往后又调用 AopUtils.findAdvisorsThatCanApply()方法； findAdvisorsThatCanApply调用的核心函数就是：

public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) {

    if (advisor instanceof IntroductionAdvisor) {

        return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass); //advisor是 IntroductionAdvisor的匹配过程

    }

    else if (advisor instanceof PointcutAdvisor) {//正常使用AOP，都是这种advisor

        PointcutAdvisor pca = (PointcutAdvisor) advisor;

        return canApply(pca.getPointcut(), targetClass, hasIntroductions); //advisor是 PointcutAdvisor的匹配过程

    }

    else {

        // It doesn't have a pointcut so we assume it applies.

        return true; //其他的 advisor 默认要处理

    }

}

pointcut的匹配过程如下：

public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) {

    Assert.notNull(pc, "Pointcut must not be null");

    if (!pc.getClassFilter().matches(targetClass)) { //获取advisor中的pointcut对象，关于pointcut的使用，请参看《 spring中的pointcut 》；这里相当于把所有的advisor中的pointcut都拿来匹配一遍，看看是否满足

        return false;

    }

    MethodMatcher methodMatcher = pc.getMethodMatcher();

    if (methodMatcher == MethodMatcher.TRUE) {

        // No need to iterate the methods if we're matching any method anyway...

        return true;

    }

    IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;

    if (methodMatcher instanceof IntroductionAwareMethodMatcher) {

        introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;

    }

    Set<Class<?>> classes = new LinkedHashSet<>(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;

}

最终，返回所有适合代理类的advisor

（2）创建AOP代理

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

    if (this.beanFactory instanceof ConfigurableListableBeanFactory) {

        AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass); // 为bean设置属性org.springframework.aop.framework.autoproxy.AutoProxyUtils.originalTargetClass，值是beanClass

    }

    ProxyFactory proxyFactory = new ProxyFactory(); //代理工厂

    proxyFactory.copyFrom(this); //为代理工厂设置proxyTargetClass，是否初始化等参数

    if (!proxyFactory.isProxyTargetClass()) { //默认应该条件为true，进入if

        if (shouldProxyTargetClass(beanClass, beanName)) { //判断是代理类，还是代理类的接口；判断的逻辑就是看bean的定义中，属性名为 org.springframework.aop.framework.autoproxy.AutoProxyUtils.preserveTargetClass的属性的值是否设置为了true。暂时只知道 ConfigurationClassPostProcessor可以配置这个属性为true；默认是false，即代理接口

            proxyFactory.setProxyTargetClass(true); //代理目标类，标记 proxyTargetClass=true

        }

        else {

            evaluateProxyInterfaces(beanClass, proxyFactory); //代理目标类的接口；如果是可以代理的接口，就把接口加入到ProxyFactory中，见(a)

        }

    }

    Advisor[] advisors = buildAdvisors(beanName, specificInterceptors); //合并共用和指定拦截器到advisor，可以把advisor叫做增强器；见(b) 

    proxyFactory.addAdvisors(advisors); //这是增强器

    proxyFactory.setTargetSource(targetSource);//设置实例对象，用于代理调用代理方法是使用

    customizeProxyFactory(proxyFactory);

    proxyFactory.setFrozen(this.freezeProxy);

    if (advisorsPreFiltered()) {

        proxyFactory.setPreFiltered(true);

    }

    return proxyFactory.getProxy(getProxyClassLoader()); //生成代理对象，见(c)

}

(a) 可代理的接口的定义

至少有一个方法的接口

或者

protected boolean isInternalLanguageInterface(Class<?> ifc) {

    return (ifc.getName().equals("groovy.lang.GroovyObject") ||

            ifc.getName().endsWith(".cglib.proxy.Factory") ||

            ifc.getName().endsWith(".bytebuddy.MockAccess"));

}

返回false的接口

或者

protected boolean isConfigurationCallbackInterface(Class<?> ifc) {

    return (InitializingBean.class == ifc || DisposableBean.class == ifc || Closeable.class == ifc ||

            AutoCloseable.class == ifc || ObjectUtils.containsElement(ifc.getInterfaces(), Aware.class));

}

返回false的接口

(b)合并共用和指定拦截器到advisor，默认没有共用拦截器

protected Advisor[] buildAdvisors(@Nullable String beanName, @Nullable Object[] specificInterceptors) {

    Advisor[] commonInterceptors = resolveInterceptorNames(); //把定义的拦截器包装成advisor，返回

    List<Object> allInterceptors = new ArrayList<>();

    if (specificInterceptors != null) {

        allInterceptors.addAll(Arrays.asList(specificInterceptors));

        if (commonInterceptors.length > 0) {

            if (this.applyCommonInterceptorsFirst) { //默认把拦截器的执行放在最前边执行

                allInterceptors.addAll(0, Arrays.asList(commonInterceptors));

            }

            else {

                allInterceptors.addAll(Arrays.asList(commonInterceptors));

            }

        }

    }

    Advisor[] advisors = new Advisor[allInterceptors.size()];

    for (int i = 0; i < allInterceptors.size(); i++) {

        advisors[i] = this.advisorAdapterRegistry.wrap(allInterceptors.get(i)); //包装advisor，适配方法是 DefaultAdvisorAdapterRegistry.wrap()

    }

    return advisors;

}

适配过程：

public Advisor wrap(Object adviceObject) throws UnknownAdviceTypeException {

    if (adviceObject instanceof Advisor) {

        return (Advisor) adviceObject; //如果是advisor对象，不用处理

    }

    if (!(adviceObject instanceof Advice)) { //只能是advicor or advice

        throw new UnknownAdviceTypeException(adviceObject);

    }

    Advice advice = (Advice) adviceObject; //advice对象都包装成 DefaultPointcutAdvisor对象

    if (advice instanceof MethodInterceptor) {

        // So well-known it doesn't even need an adapter.

        return new DefaultPointcutAdvisor(advice);

    }

    for (AdvisorAdapter adapter : this.adapters) {

        // Check that it is supported.

        if (adapter.supportsAdvice(advice)) {

            return new DefaultPointcutAdvisor(advice);

        }

    }

    throw new UnknownAdviceTypeException(advice);

}

(c)代理工厂生成代理对象

这里一直没有读懂aopProxyFactory对象的实例话，这里假定aopProxyFactory就是一个DefaultAopProxyFactory对象；

DefaultAopProxyFactory中生成代理对象的方法：

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() || Proxy.isProxyClass(targetClass)) {

            return new JdkDynamicAopProxy(config);

        }

        return new ObjenesisCglibAopProxy(config); //类代理，分析过程见【1】

    }

    else {

        return new JdkDynamicAopProxy(config); //接口代理, 分析过程见 【2】

    }

}

如果不是代理接口，就使用CGLIB字节码动态代理；否则使用JDK的动态代理。

【1】 jdk动态代理

JdkDynamicAopProxy.getProxy()方法：

public Object getProxy(@Nullable ClassLoader classLoader) {

    Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised , true);

    findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);

    return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);

}

所以，返回的代理对象就是JDK的Proxy.newProxyInstance方法生成的，而且参数需要的 InvocationHandler对象就是当前的JdkDynamicAopProxy对象；

我们知道，JDK动态代理的实现原理就是代理对象在执行目标方法的时候，会检查当前方法是否被代理？如果被代理，那么就执行 InvocationHandler的invoke方法代替；

下边看看JDK动态代理模式下的，代理对象真正执行方法时，切面织入方法的功能是怎样实现的。

JdkDynamicAopProxy实现 InvocationHandler接口，invoke方法的核心逻辑是：

List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass); // chain是 InterceptorAndDynamicMethodMatcher链表； 参见{1}

if (chain.isEmpty()) {

     //跳过热交换，只是执行目标类的方法，method.invoke

    Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);

    retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);

}

else {

     //创建 method invocation

    invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);   //反射方法处理过程，target参数就是被代理类的实例

     //执行拦截器链和方法，参看{4}

    retVal = invocation.proceed();

}

{1}把增强器advisors包装成mathodMatcher链的过程

调用DefaultAdvisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice()方法， 核心代码如下：

MethodInterceptor[] interceptors = registry.getInterceptors(advisor); // registry是 DefaultAdvisorAdapterRegistry实例，这里就是把advisor中的advice包装成 MethodInterceptor，见{2}

MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher(); //获得匹配方法；参见{3}

if (MethodMatchers.matches(mm, method, actualClass, hasIntroductions)) {

    if (mm.isRuntime()) {

        for (MethodInterceptor interceptor : interceptors) {

            interceptorList.add(new InterceptorAndDynamicMethodMatcher(interceptor, mm)); //采用组合模式，将拦截器对象和匹配方法对象放在 InterceptorAndDynamicMethodMatcher对象中，得到返回值对象；

        }

    }

    else {

        interceptorList.addAll(Arrays.asList(interceptors));

    }

}

{2}例如：下边是默认包装关系

MethodBeforeAdvice MethodBeforeAdviceInterceptor

AfterReturningAdvice AfterReturningAdviceInterceptor

ThrowsAdvice ThrowsAdviceInterceptor

根据advice的解析过程可知，before 类型的advice的目标类就是MethodBeforeAdvice类的子类；advice的pointcut依赖指定的目标类是AspectJExpressionPointcut

{3}由{2}的说明可知，MethodMatcher方法对象的获取过程就是获取AspectJExpressionPointcut对象；在pointcut实例化时会解析expression表达式，逻辑如下：

private PointcutExpression buildPointcutExpression(@Nullable ClassLoader classLoader) {

    PointcutParser parser = initializePointcutParser(classLoader);

    PointcutParameter[] pointcutParameters = new PointcutParameter[this.pointcutParameterNames.length];

    for (int i = 0; i < pointcutParameters.length; i++) {

        pointcutParameters[i] = parser.createPointcutParameter(

                this.pointcutParameterNames[i], this.pointcutParameterTypes[i]);

    }

    return parser.parsePointcutExpression(replaceBooleanOperators(resolveExpression()),  this.pointcutDeclarationScope, pointcutParameters); //expression的对象类是 PointcutExpressionImpl

}

需要说明的是，AspectJExpressionPointcut类实现IntroductionAwareMethodMatcher、MethodMatcher接口；

{4}循环处理拦截器链，使用matcher匹配，然后调用拦截器的invoke方法

if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) { //所有 advice都调用完之后，调用这里，但是after advice是逆向调用的，所有代理方法会在after adviec之前之前执行

    return invokeJoinpoint();

}

//other code

if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) { //匹配；见{5}分析

    return dm.interceptor.invoke(this); //调用；参见{6}

}

else {

    // Dynamic matching failed.

    // Skip this interceptor and invoke the next in the chain.

    return proceed(); //如果匹配失败，跳过当前advisor，继续下一个

}

{5}可知匹配过程就是AspectJExpressionPointcut的matches方法逻辑过程；

{6}看看典型advice的处理过程

before advice的 MethodBeforeAdviceInterceptor调用过程如下：

public Object invoke(MethodInvocation mi) throws Throwable {

    this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis() ); // AspectJMethodBeforeAdvice.before方法，这里就是调用before通知在切面里定义的执行方法

    return mi.proceed(); //跳转到 ReflectiveMethodInvocation. proceed()方法，实现调用多个advice的功能

}

AspectJMethodBeforeAdvice.before(){

    invokeAdviceMethod(getJoinPointMatch(), null, null);

}

after-returning的AfterReturningAdviceInterceptor调用过程如下：

public Object invoke(MethodInvocation mi) throws Throwable {

    Object retVal = mi.proceed(); //跳转到 ReflectiveMethodInvocation. proceed()方法，实现调用多个advice的功能

    this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis()); //调用后处理方法

    return retVal;

}

AspectJAfterReturningAdvice.afterReturning(){

    if (shouldInvokeOnReturnValueOf(method, returnValue)) {

        invokeAdviceMethod(getJoinPointMatch(), returnValue, null);

    }

}

可见，所有的advice都是先执行before advice 再执行after-returning advice ；所有的advice都执行完之后，执行被代理的方法；因为after advice是逆向调用的，所以被代理的方法会在after advice之前调用。

around advice通知是怎么实现的呢？

看到DefaultAdvisorAdapterRegistry类的wrap方法：

if (adviceObject instanceof Advisor) { //advice 不是advisor，跳过

    return (Advisor) adviceObject;

}

if (!(adviceObject instanceof Advice)) {

    throw new UnknownAdviceTypeException(adviceObject);

}

Advice advice = (Advice) adviceObject;

if (advice instanceof MethodInterceptor) {

    // So well-known it doesn't even need an adapter.

    return new DefaultPointcutAdvisor(advice); //advice 都在这里处理，被适配成 DefaultPointcutAdvisor对象

}

再看拦截器方法链——也就是advice的方法封装，也是DefaultAdvisorAdapterRegistry的方法：

public MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException {

    List<MethodInterceptor> interceptors = new ArrayList<>(3);

    Advice advice = advisor.getAdvice();

    if (advice instanceof MethodInterceptor) { //around advice的处理类 AspectJAroundAdvice实现了 MethodInterceptor接口，所以就是around advice的方法拦截器就是 AspectJAroundAdvice对象

        interceptors.add((MethodInterceptor) advice);

    }

    for (AdvisorAdapter adapter : this.adapters) {

        if (adapter.supportsAdvice(advice)) {

            interceptors.add(adapter.getInterceptor(advisor));

        }

    }

    if (interceptors.isEmpty()) {

        throw new UnknownAdviceTypeException(advisor.getAdvice());

    }

    return interceptors.toArray(new MethodInterceptor[interceptors.size()]);

}

下边看方法拦截器的调用过程：

public Object invoke(MethodInvocation mi) throws Throwable {

    if (!(mi instanceof ProxyMethodInvocation)) {

        throw new IllegalStateException("MethodInvocation is not a Spring ProxyMethodInvocation: " + mi);

    }

    ProxyMethodInvocation pmi = (ProxyMethodInvocation) mi;

    ProceedingJoinPoint pjp = lazyGetProceedingJoinPoint(pmi); //返回一个 MethodInvocationProceedingJoinPoint对象，这个对象就是在切面中定义的around方法的实参

    JoinPointMatch jpm = getJoinPointMatch(pmi);

    return invokeAdviceMethod(pjp, jpm, null, null); //调用父类的方法；参见{7}

}

{7}advice方法的调用，核心就是下边这一句

this.aspectJAdviceMethod.invoke(this.aspectInstanceFactory.getAspectInstance(), actualArgs);

解释：

this.aspectJAdviceMethod获取advice指定方法的Method对象；

this.aspectInstanceFactory.getAspectInstance()获取一个advice所属切面aspect的实例；

actualArgs是方法参数；

也就是method.invoke(object,args)而已；

before advice，after-returning advice在调用advice方法时，会调用下一个advice的方法，但是around advice没有这样做；事实上，around advice调用下一个advice方法的语句在，切面实现的方法中，从这一点上将，只有around advice的方法参数是必须要被使用的；而在around advice方法中，可以在point.proceed();语句前后加增强语句，正是“环绕”的意义所在；需要注意的是，如果有多个around advice被执行，那么point.proceed();语句后面的增强语句的执行过程像堆栈调用，即先被调用的后被执行；

到此，基于JDK的动态代理实现的AOP过程就分析完成了！

【2】 字节码代理

ObjenesisCglibAopProxy. getProxy()方法，暂时不研究了！