Proxy是在什么时候调用InvocationHandler的invoke方法的

最近看到spring的动态代理，扒到深处看到时 Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);看到这一句，顿时比较懵逼，还是没有搞懂invoke方法的调用，然后搜索了一下，碍，遇见一位大神的文章

特来记录一下，嘿嘿：首先这里是原文链接

其实前面的可以省略了（太晚啦，要睡觉啦），什么创建接口、实现类、创建实现InvocationHandler的类（不创建也行）等等操作，直接上重点，代理对象执行invoke的地方：

首先，我们编译后，会得出一个代理对象的class文件，打开这个class文件就解开谜题了（当时也是懵逼了，这招没想到，啊哈哈）：

我们Proxy的类中，有一个受保护的InvocationHandler成员属性：

public class Proxy implements java.io.Serializable {

    private static final long serialVersionUID = -2222568056686623797L;

    /** parameter types of a proxy class constructor */
    private static final Class<?>[] constructorParams =
        { InvocationHandler.class };

    /**
     * a cache of proxy classes
     */
    private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
        proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

    /**
     * the invocation handler for this proxy instance.
     * @serial
     */
    protected InvocationHandler h;//在这里！

    /**
     * Prohibits instantiation.
     */
    private Proxy() {
    }

    /**
     * Constructs a new {@code Proxy} instance from a subclass
     * (typically, a dynamic proxy class) with the specified value
     * for its invocation handler.
     *
     * @param  h the invocation handler for this proxy instance
     *
     * @throws NullPointerException if the given invocation handler, {@code h},
     *         is {@code null}.
     */
    protected Proxy(InvocationHandler h) {
        Objects.requireNonNull(h);
        this.h = h;
    }

接着看代理对象的实现：

public final class $Proxy0 extends Proxy implements Subject（目标类，被代理的类） {
    private static Method m1;
    private static Method m0;
    private static Method m3;
    private static Method m2;  

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals",
                    new Class[] { Class.forName("java.lang.Object") });  

            m0 = Class.forName("java.lang.Object").getMethod("hashCode",
                    new Class[0]);  

            m3 = Class.forName("***.RealSubject").getMethod("request",  //代理方法名称
                    new Class[0]);  

            m2 = Class.forName("java.lang.Object").getMethod("toString",
                    new Class[0]);  

        } catch (NoSuchMethodException nosuchmethodexception) {
            throw new NoSuchMethodError(nosuchmethodexception.getMessage());
        } catch (ClassNotFoundException classnotfoundexception) {
            throw new NoClassDefFoundError(classnotfoundexception.getMessage());
        }
    } //static  

    public $Proxy0(InvocationHandler invocationhandler) {
        super(invocationhandler);
    }  

    @Override
    public final boolean equals(Object obj) {
        try {
            return ((Boolean) super.h.invoke(this, m1, new Object[] { obj })) .booleanValue();
        } catch (Throwable throwable) {
            throw new UndeclaredThrowableException(throwable);
        }
    }  

    @Override
    public final int hashCode() {
        try {
            return ((Integer) super.h.invoke(this, m0, null)).intValue();
        } catch (Throwable throwable) {
            throw new UndeclaredThrowableException(throwable);
        }
    }  

    public final void request() {  //代理方法
        try {
            super.h.invoke(this, m3, null);
            return;
        } catch (Error e) {
        } catch (Throwable throwable) {
            throw new UndeclaredThrowableException(throwable);
        }
    }  

    @Override
    public final String toString() {
        try {
            return (String) super.h.invoke(this, m2, null);
        } catch (Throwable throwable) {
            throw new UndeclaredThrowableException(throwable);
        }
    }
}  

看到这里就明白了。新返回的代理对象，调用了父类（Proxy）h的方法，这里也就是invoke方法与Proxy相关的地方啦。