Spring AOP 多个切点实现:JdkDynamicAopProxy

Spring Aop 的底层生成代理类i的实现除 jdk的动态代理技术外，还用到了Cglib，不过在封装两者的设计原理上相差不大，只是底层工具不同而已。

本文只分析JdkDynamicAopProxy 是如何为一个目标方法执行织入多个切点，也就是将原本可能需要多个“代理类“实现的业务放到一个代理类中（JdkDynamicAopProxy）完成。

JdkDynamicAopProxy 本身就是一个JDK代理的InvocationHandler，spring 在调用其getProxy()方法返回一个代理类对象时：

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);
    }

Proxy.newProxyInstance(classLoader, proxiedInterfaces, this); 传入的 Handler 就是this，也就是 一个 JdkDynamicAopProxy 对象。所以代理的业务就在 JdkDynamicAopProxy
的 invoke()方法上。

 /**
      * Implementation of <code>InvocationHandler.invoke</code>.
      * <p>Callers will see exactly the exception thrown by the target,
      * unless a hook method throws an exception.
      */
     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
         MethodInvocation invocation;
         Object oldProxy = null;
         boolean setProxyContext = false;

         TargetSource targetSource = this.advised.targetSource;
         Class targetClass = null;
         Object target = null;

         try {
             if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
                 // The target does not implement the equals(Object) method itself.
                 return equals(args[0]);
             }
             if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
                 // The target does not implement the hashCode() method itself.
                 return hashCode();
             }
             if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
                     method.getDeclaringClass().isAssignableFrom(Advised.class)) {
                 // Service invocations on ProxyConfig with the proxy config...
                 return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
             }

             Object retVal;

             if (this.advised.exposeProxy) {
                 // Make invocation available if necessary.
                 oldProxy = AopContext.setCurrentProxy(proxy);
                 setProxyContext = true;
             }

             // May be null. Get as late as possible to minimize the time we "own" the target,
             // in case it comes from a pool.
             target = targetSource.getTarget();
             if (target != null) {
                 targetClass = target.getClass();
             }

             // Get the interception chain for this method.
             List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

             // Check whether we have any advice. If we don't, we can fallback on direct
             // reflective invocation of the target, and avoid creating a MethodInvocation.
             if (chain.isEmpty()) {
                 // We can skip creating a MethodInvocation: just invoke the target directly
                 // Note that the final invoker must be an InvokerInterceptor so we know it does
                 // nothing but a reflective operation on the target, and no hot swapping or fancy proxying.
                 retVal = AopUtils.invokeJoinpointUsingReflection(target, method, args);
             }
             else {
                 // We need to create a method invocation...
                 invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
                 // Proceed to the joinpoint through the interceptor chain.
                 retVal = invocation.proceed();
             }

             // Massage return value if necessary.
             if (retVal != null && retVal == target && method.getReturnType().isInstance(proxy) &&
                     !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
                 // Special case: it returned "this" and the return type of the method
                 // is type-compatible. Note that we can't help if the target sets
                 // a reference to itself in another returned object.
                 retVal = proxy;
             }
             return retVal;
         }
         finally {
             if (target != null && !targetSource.isStatic()) {
                 // Must have come from TargetSource.
                 targetSource.releaseTarget(target);
             }
             if (setProxyContext) {
                 // Restore old proxy.
                 AopContext.setCurrentProxy(oldProxy);
             }
         }
     }

invoke方法中的红色加粗代码就是重点部分：

List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass); 
该行代码是构建代理链，获取到目标方法需要增强的一系列业务代理对象。

invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
通过将目标方法和 多个业务代理对象 创建成一个 ReflectiveMethodInvocation，来实际完成  执行目标方法时执行一些拦截器，也就是代理业务。

retVal = invocation.proceed();
该行代码开始执行代理业务和目标方法。

下面是ReflectiveMethodInvocation 的 proceed方法代码：

 public Object proceed() throws Throwable {
         //    We start with an index of -1 and increment early.
         if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
             return invokeJoinpoint();
         }

         Object interceptorOrInterceptionAdvice =
             this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
         if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
             // Evaluate dynamic method matcher here: static part will already have
             // been evaluated and found to match.
             InterceptorAndDynamicMethodMatcher dm =
                 (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
             if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
                 return dm.interceptor.invoke(this);
             }
             else {
                 // Dynamic matching failed.
                 // Skip this interceptor and invoke the next in the chain.
                 return proceed();
             }
         }
         else {
             // It's an interceptor, so we just invoke it: The pointcut will have
             // been evaluated statically before this object was constructed.
             return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
         }
     }

可以看到proceed()方法通过从interceptorsAndDynamicMethodMatchers(list)集合中取出拦截器，拦截器是在前面创建ReflectiveMethodInvocation对象时传入的chain，

通过判断拦截器集合中所有拦截器是否执行完，未执行完这递归调用proceed()方法，执行完则执行目标方法。

以上就是JdkDynamicAopProxy实现多个拦截器拦截目标方法的动态代理业务。