java 动态代理原理

1.什么是代理

代理，字面含义：代为处理，这个代理的能力比原始的对象能力要大，而这个能力就是我们要为真实对象扩展的能力，这样说还是很抽象，看一个例子：让猴子礼貌买票

public class monkey{

    public void eat(){
        System.out.println("吃饭");
    }
    public void play(){
        System.out.println("玩游戏");
    }
    public void buy(){
        System.out.println("买票");
    }
}

这是一只猴子，我们现在需要实现一个功能，在猴子买票前，先要问好：

public class monkey2{
    public monkey  mk  = new monkey()
    public void eat(){
        mk.eat()
    }
    public void play(){
        mk.play()
    }
    public void buy(){
        System.out.println("你好");
        mk.buy()
    }
}

这个monkey2 就是monkey的代理了

2.静态代理 与 动态代理

既然有动态代理，自然也有静态代理，什么是静态代理? 为什么需要动态代理？不能用静态代理？
其实上面说的例子就是静态代理，静态代理指的是自己实现代理类，为了说明动态和静态的区别，我们在上面例子的基础上进行举例说明。我们现在这样要求：不仅要让猴子变礼貌，还要让所有的动物都变礼貌。

public class  pig{
   
}

public class  duck{
   
}

public class  chicken{
   
}
.
.
.
100 个小可爱在等着你。。。

试想一下，每个类都要手动的实现一遍吗？吐血 ing
于是动态代理横空出世。动态代理在Java 的lang包已经提供了实现。
我们都知道java代码最终会生成字节码文件，jvm加载的是字节码。
通过这个函数newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)就能生成代理对象的字节码，并加载为一个java对象，InvocationHandler 里面实现了扩展的功能。感觉很神奇，他是怎么实现的呢？且看下面实现原理。

3.实现原理

通常这个阶段都要画个图来说一下，没图没真相。

上述图是类UML，解释下上面图的含义，代理类（功能大一点） 与 被代理（monkey）需要实现同一接口，为什么呢？既然是代理了，是不是monkey能完成的事，代理对象也能完成，java的接口就是干这个事的，约束统一的接口。具体扩展的功能在 InvocationHandler 对象里实现。现在知道newProxyInstance 函数这里为什么需要传入 接口 和InvocationHandler对象了吧。

4.代理代码示例

下面是动态代理生成的字节码反编译的java代码，原理就是这样，完！

import com.example.jvm.bytecode.Subject;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy implements Subject {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m0;

    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})).booleanValue();
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    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 void request() throws  {
        try {
            super.h.invoke(this, m3, (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)).intValue();
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
            m3 = Class.forName("com.example.jvm.bytecode.Subject").getMethod("request", new Class[0]);
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}