代理模式3-JDK动态代理原理

JDK动态代理采用字节重组，重新生成对象来替代原始对象，达到动态代理的目的。
JDK动态代理的步骤如下：

1. 获取被代理对象的引用，获取他的所有类信息（class）。
2. JDK动态代理类重新生成一个新的类，同时新的类要实现被代理类实现的所有接口。【所以，要用jdk动态代理，必须是实现了接口，而且只有接口中的方法会被代理】
3. 动态生成的代码，会有新的逻辑，比如before()，after()等，这些都是可自己定制的；
4. 编译新生成的Java代码.class文件
5. 重新加载到JVM中运行
   上面过程就叫字节码重组。
   JDK规范：
   ClassPath下以$开头的.class文件一般都是自动生成的。

反编译代理类

由于是动态生成的，动态加载到JVM中，保存在内存里，而不在硬盘中，所以我们通过流把生成的代理类输出到磁盘，再反编译看看结果；

// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3) 

import java.lang.reflect.*;
import top.tomxwd.marry.Person;

// 看到真实代理对象继承了Proxy类，实现了Person接口，这也是为什么JDK动态代理是基于接口的原因
public final class $Proxy0 extends Proxy
    implements Person
{

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

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

    public final void findLove()
    {
        try
        {
            super.h.invoke(this, m3, null);
            return;
        }
        catch(Error _ex) { }
        catch(Throwable throwable)
        {
            throw new UndeclaredThrowableException(throwable);
        }
    }

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

    public final int hashCode()
    {
        try
        {
            // 这里是真正执行的方法，可以看到调用的是父类的h属性（通过Proxy源码发现是protected InvocationHandler h;）的invoke方法，
            // 那么也就是我们的JDKMeipo（实现了InvocationHandler接口），所以调用到了JDKMeipo的invoke方法。
            // 因此，把方法method、代理对象、参数丢给JDKMeipo的invoke方法，能让JDKMeipo完成代理的动作
            return ((Integer)super.h.invoke(this, m0, null)).intValue();
        }
        catch(Error _ex) { }
        catch(Throwable throwable)
        {
            throw new UndeclaredThrowableException(throwable);
        }
    }

    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m0;

    static 
    {
        try
        {
            m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] {
                Class.forName("java.lang.Object")
            });
            // 这里是真正代理的方法，通过反射来获取
            m3 = Class.forName("top.tomxwd.marry.Person").getMethod("findLove", new Class[0]);
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
        }
        catch(NoSuchMethodException nosuchmethodexception)
        {
            throw new NoSuchMethodError(nosuchmethodexception.getMessage());
        }
        catch(ClassNotFoundException classnotfoundexception)
        {
            throw new NoClassDefFoundError(classnotfoundexception.getMessage());
        }
    }
}

图解：

image.png

具体的还是看代码比较清晰；
总的来说三点比较重要：

1. 真实代理类其实是继承了Proxy然后实现被代理对象接口的类；

• 要注意，Proxy类里有h属性，而h属性就是InvocationHandler，也就是代理类（实现了InvocationHandler）

2. 调用invoke方法，其实调用的是代理类的invoke方法，而代理类中调用的时候一般会调用被代理类的同名方法；
3. 代理的方法是通过静态代码块里反射获取的，所以加载的时候就得到了被代理对象的所有方法。

注意了，最好是从Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this)获取真实代理开始看，首先Proxy的实现接口的方法，而这个方法本质上是调用h属性的方法，h属性其实就是我们的代理类，代理类触发被代理类方法的调用，并增加一些逻辑处理。技术难点应该在于如何动态生成$Proxy，其他就是各种调用。