AOP的最后一步，就是代理类的调用了，这里我们以JdkDynamicAopProxy为例，首先我们先回顾一下JAVA动态代理。

JAVA动态代理

定义一个接口Interface和实现类RealSubject，通过实现InvocationHandler接口的invoke()提供代理类的方法。

interface Subject{
    void sayName();
}
public class RealSubject implements Subject{
    @Override
    public void sayName() {
        System.out.println("real subject say...");
    }
}
//创建动态代理    
Subject realSubject = new RealSubject();
//一定是接口类型
Subject proxySubject = (Subject) Proxy.newProxyInstance(realSubject.getClass().getClassLoader(),
        realSubject.getClass().getInterfaces(), 
         (proxy, method, args1) -> {
            System.out.println("before proxy invoke...");
            Object invoke = method.invoke(realSubject);
            System.out.println("before proxy invoke...");
            return invoke;
        });

proxySubject.sayName();
==============================
before proxy invoke...
real subject say...
before proxy invoke...

使用JDK动态代理一定要使用接口，并且提供InvocationHandler接口的实现。

如何查看这个生成的动态代理的类？
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true"); 加上这句话，生成动态代理的时候会在idea的工作目录下生成com/sun/proxy/$Proxy0.class类

newProxyInstance()方法 主要是通过getProxyClass0（）来生成代理对象的并且有一个ProxyClassCache缓存对象WeakCache，这里面又通过ProxyGenetor类来进行代理对象生成。
从下面生成代码中可见，生成的Proxy对象继承了Proxy并实现了需要代理的类Subject，Proxy里面有成员变量InvocationHandler h，所以生成的代理对象需要通过构造函数传入InvocationHandler。
同时，会默认代理equals(), toString(), hashCode() 方法

public final class $Proxy0 extends Proxy implements Subject {
private static Method m1;
private static Method m3;
private static Method m2;
private static Method m0;
//这个代理类是需要传入InvocationHandler作为构造函数
//继承了Proxy并实现了需要代理的类
public $Proxy0(InvocationHandler var1) throws  {
    super(var1);
}
public final boolean equals(Object var1) throws  {
    try {
        return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
    } catch (RuntimeException | Error var3) {
        throw var3;
    } catch (Throwable var4) {
        throw new UndeclaredThrowableException(var4);
    }
}
public final void sayName() throws  {
    try {
        //调用代理类的sayName，这里就通过invocationhandler的invoke方法进行增强。
        super.h.invoke(this, m3, (Object[])null);
    } catch (RuntimeException | Error var2) {
        throw var2;
    } catch (Throwable var3) {
        throw new UndeclaredThrowableException(var3);
    }
}
public final String toString() throws  {
    try {
        return (String)super.h.invoke(this, m2, (Object[])null);
    } catch (RuntimeException | Error var2) {
        throw var2;
    } catch (Throwable var3) {
        throw new UndeclaredThrowableException(var3);
    }
}
public final int hashCode() throws  {
    try {
        return (Integer)super.h.invoke(this, m0, (Object[])null);
    } catch (RuntimeException | Error var2) {
        throw var2;
    } catch (Throwable var3) {
        throw new UndeclaredThrowableException(var3);
    }
}
static {
    try {
        m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
        m3 = Class.forName("com.refinitiv.edp.boomi.sw.sqs.listener.Subject").getMethod("sayName");
        m2 = Class.forName("java.lang.Object").getMethod("toString");
        m0 = Class.forName("java.lang.Object").getMethod("hashCode");
    } catch (NoSuchMethodException var2) {
        throw new NoSuchMethodError(var2.getMessage());
    } catch (ClassNotFoundException var3) {
        throw new NoClassDefFoundError(var3.getMessage());
    }
}
}

JdkDynamicAopProxy的invoke

JdkDynamicAopProxy本身实现了InvocationHandler，所以需要关注它的invoke()方法，如何来进行增强的。

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    MethodInvocation invocation;
    Object oldProxy = null;
    boolean setProxyContext = false;
    //targetSource包含了realSubject，即真实对象
    TargetSource targetSource = this.advised.targetSource;
    Object target = null;

    try {
        //如果美标方法没有重写equals，这里处理equals方法
        if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
            // The target does not implement the equals(Object) method itself.
            return equals(args[0]);
        }
        //如果美标方法没有重写hashcode，这里处理hashcode方法
        else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
            // The target does not implement the hashCode() method itself.
            return hashCode();
        }
        //如果declaringClass是getDecoratedClass类型的
        else if (method.getDeclaringClass() == DecoratingProxy.class) {
            // There is only getDecoratedClass() declared -> dispatch to proxy config.
            return AopProxyUtils.ultimateTargetClass(this.advised);
        }
        //这里直接通过反射调用method，不需要走下面advice增强的逻辑
        //注意这里直接调用的target，即真实对象
        else 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;
        这个Advised是不是需要暴露出去，即用ThreadLocal包装一下，放到AopContext里
        if (this.advised.exposeProxy) {
            // Make invocation available if necessary.
            oldProxy = AopContext.setCurrentProxy(proxy);
            setProxyContext = true;
        }

        // Get as late as possible to minimize the time we "own" the target,
        // in case it comes from a pool.
        //target是真正的对象
        target = targetSource.getTarget();
        Class<?> targetClass = (target != null ? target.getClass() : null);

        // Get the interception chain for this method.
        //这个是核心方法，就是从Advised里面获取所有的Advisor，然后通过AdvisorAdapterRegistry将Advisor里的advice转换成MethodInteceptor
        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.
        //如果没有找到增强的Advice，就直接invoke method
        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.
            Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
            //这里直接通过反射调用method，不需要走下面advice增强的逻辑
            //注意这里直接调用的target，即真实对象
            retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
        }
        else {
            //如果找到合适的Advice，转成MethodInteceptor，然后包装成ReflectiveMethodInvocation，调用proceed();
            // 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.
        Class<?> returnType = method.getReturnType();
        if (retVal != null && retVal == target &&
                returnType != Object.class && returnType.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;
        }
        else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
            throw new AopInvocationException(
                    "Null return value from advice does not match primitive return type for: " + method);
        }
        return retVal;
    }
    finally {
        if (target != null && !targetSource.isStatic()) {
            // Must have come from TargetSource.
            targetSource.releaseTarget(target);
        }
        if (setProxyContext) {
            // Restore old proxy.
            AopContext.setCurrentProxy(oldProxy);
        }
    }
}

这里面有两个重要的方法：

• getInterceptorsAndDynamicInterceptionAdvice: 从Advised里找到合适的Advice，并通过适配器转换成MethodInteceptor。只与为什么会有Advice，可以参考Spring AOP（3）基于XML理解代理类的创建
• ReflectiveMethodInvocation: 将proxy和真是对象，以及method，Advice的数组包装成ReflectiveMethodInvocation，调用内部的proceed()方法进行增强。

1）getInterceptorsAndDynamicInterceptionAdvice

//Determine a list of MethodInterceptor objects for the given method, based on this configuration.
public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Method method, @Nullable Class<?> targetClass) {
    MethodCacheKey cacheKey = new MethodCacheKey(method);
    List<Object> cached = this.methodCache.get(cacheKey);
    if (cached == null) {
        //call advisorChainFactory to get the inteceptor list
        cached = this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(
                this, method, targetClass);
        this.methodCache.put(cacheKey, cached);
    }
    return cached;
}
//use DefaultAdvisorChainFactory to get the Interceptor list
public List<Object> getInterceptorsAndDynamicInterceptionAdvice(
        Advised config, Method method, @Nullable Class<?> targetClass) {

    // This is somewhat tricky... We have to process introductions first,
    // but we need to preserve order in the ultimate list.
    //AdvisorAdapterRegistry提供了默认的AdvisorAdapterRegistry
    //默认提供了MethodBeforeAdviceAdapter，AfterReturningAdviceAdapter，ThrowsAdviceAdapter
    AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();
    //拿到AdvisedSupport添加的advisor的数组
    Advisor[] advisors = config.getAdvisors();
    List<Object> interceptorList = new ArrayList<>(advisors.length);
    Class<?> actualClass = (targetClass != null ? targetClass : method.getDeclaringClass());
    Boolean hasIntroductions = null;
    //遍历advisor
    for (Advisor advisor : advisors) {
        //如果Advisor是PointcutAdvisor
        if (advisor instanceof PointcutAdvisor) {
            // Add it conditionally.
            PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;
            //验证pointCut的class是不是对的
            if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) {
                //拿到PointCut的MethodMatcher
                MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
                boolean match;
                //如果MethodMatcher是IntroductionAwareMethodMatcher类型的
                if (mm instanceof IntroductionAwareMethodMatcher) {
                    if (hasIntroductions == null) {
                        //在检查一下actualClass
                        hasIntroductions = hasMatchingIntroductions(advisors, actualClass);
                    }
                    //通过matchs方法检查method是不是匹配的
                    match = ((IntroductionAwareMethodMatcher) mm).matches(method, actualClass, hasIntroductions);
                }
                //如果是普通类型的，就直接MethodMatcher.match()验证
                else {
                    match = mm.matches(method, actualClass);
                }
                if (match) {
                    //如果找到匹配的，就通过registry来将advisor转换成MethodInterceptor
                    MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
                    if (mm.isRuntime()) {
                        // Creating a new object instance in the getInterceptors() method
                        // isn't a problem as we normally cache created chains.
                        for (MethodInterceptor interceptor : interceptors) {
                            interceptorList.add(new InterceptorAndDynamicMethodMatcher(interceptor, mm));
                        }
                    }
                    else {
                        interceptorList.addAll(Arrays.asList(interceptors));
                    }
                }
            }
        }
        //如果是IntroductionAdvisor，调用这个类型的matches
        else if (advisor instanceof IntroductionAdvisor) {
            IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
            if (config.isPreFiltered() || ia.getClassFilter().matches(actualClass)) {
                Interceptor[] interceptors = registry.getInterceptors(advisor);
                interceptorList.addAll(Arrays.asList(interceptors));
            }
        }
        //如果不是上面两种类型的Advisor，就直接获取Interceptor
        else {
            Interceptor[] interceptors = registry.getInterceptors(advisor);
            interceptorList.addAll(Arrays.asList(interceptors));
        }
    }
    return interceptorList;
}

2）ReflectiveMethodInvocation的使用

//ReflectiveMethodInvocation是调用interceptor的地方
public Object proceed() throws Throwable {
    // We start with an index of -1 and increment early.
    //当interceptorsAndDynamicMethodMatchers数量为1的时候，invokeJoinpoint就是直接通过反射调用真实的方法
    if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
        return invokeJoinpoint();
    }
    //从0开始一个个拿Interceptor
    Object interceptorOrInterceptionAdvice =
            this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
    //如果是InterceptorAndDynamicMethodMatcher，mm.isRuntime()这种情况才会封装InterceptorAndDynamicMethodMatcher
    if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
        // Evaluate dynamic method matcher here: static part will already have
        // been evaluated and found to match.
        InterceptorAndDynamicMethodMatcher dm =
                (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
        Class<?> targetClass = (this.targetClass != null ? this.targetClass : this.method.getDeclaringClass());
        //如果MethodMatcher验证成功，就调用interceptor
        if (dm.methodMatcher.matches(this.method, 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.
        //就直接是intercepto，就直接invoke这个MethodInterceptor
        return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
    }
}

MethodBeforeAdviceInterceptor类似这种，内部会调用advice的方法，然调用mi.proceed()进入递归。

public class MethodBeforeAdviceInterceptor implements MethodInterceptor, BeforeAdvice, Serializable {
    private final MethodBeforeAdvice advice;
    
    public MethodBeforeAdviceInterceptor(MethodBeforeAdvice advice) {
        Assert.notNull(advice, "Advice must not be null");
        this.advice = advice;
    }
    public Object invoke(MethodInvocation mi) throws Throwable {
        this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
        return mi.proceed();
    }
}