Java JDK动态代理Proxy类的原理是什么？

本文转载自知乎问题Java JDK动态代理Proxy类的原理是什么？下用户@胖君回答

1. 什么是代理?

先从代理开始讲。
代理这种设计模式其实很好理解，基本就是最简单的一个 “组合”。比如说下面这个例子，我们有 A 这个类，本来可以直接调用 A 类的 foo() 方法。但代理模式就非要把 A 类当成 B 类的一个成员字段放在 B 类里面。然后因为 A 类和 B 类都实现了 Interface 这个接口，所以 B 类里也有 foo()方法。而且 B 类里的 foo()方法就是傻瓜式的调用 A 类的 foo()方法。

interface Interface{public void foo();}
/**委托类*/
class A implements Interface{
    public void foo(){System.out.println("Method a of class A!");}
}
/**代理类*/
class B implements Interface{
    public A a=new A();
    public void foo(){a.foo();}
}
/**用户*/
class Consumer{
    public static void consum(Interface i){
        i.foo();
    }
}
/**测试*/
public class TestProxy{
    public static void main(String[] args){
        Interface i=new B();
        Consumer.consum(i);
    }
}

2. 代理有什么好处？

乍一看，代理方法完全是多此一举，B 类的行为和 A 类完全一样，没有任何意义。但实际上，B 类的 foo() 方法在直接调用 A 类 foo() 方法之前和之后，可以做很多事情。举个例子，如果在 B 类里加个静态计数字段 count，然后每次调用 foo() 方法之后都计一下数，就可以监控 A 类 foo() 方法被调用的次数。

class B implements Interface{
    public static long count=0;
    public A a=new A();
    public void foo(){a.foo();count++;}
}

所以代理类里能非常好地控制，辅助被代理类，甚至是增加额外的功能。而且一般来说代理类 B 和被代理 A 都会实现同样的接口，这样对用户端（就是上面例子里的 Consumer 类）的代码没有任何影响，耦合很低。

3. 什么是动态代理？

上面例子里在 A 类外面套一个 B 类好像很简单，但实际到了工程级别的代码，需要代理的就不止一个两个了。每个代理类都手动写会累死，而且很枯燥，是没有技术含量的重复。所以这个时候 Java 的反射功能就立功了。代理类 B 是可以完全用反射动态生成的。
怎么动态生成 B 类呢？下面有个例子，通过反射动态加载 B 类，然后调用 B 类的 foo() 方法。

public class TestDynamicProxy{
    public static void main(String[] args){
        try{
            Class<?> refB=B.class;
            Method refFoo=refB.getDeclaredMethod("foo");
            Object refObj=refB.newInstance();
            refFoo.invoke(refObj);
        }catch(Exception e){
            System.out.println(e);
        }
    }
}

1. B.class 获得了 B 类的 Class 对象。
2. Class#getDeclaredMethod() 方法根据方法的名称"foo"获得了 foo() 方法的 Method 对象。
3. 最后调用这个 Method 对象的 invoke() 来执行这个方法。

但这个是动态生成吗？明显不是！上面这个方法只是在 B 类已经写好了的情况下动态调用 B 类。其实并没有动态生成 B 类，根本不能叫动态生成。真的要完全凭空用反射 “写” 一个 B 类的字节码文件出来然后加载它，其实要复杂地多，这就是为什么需要 Proxy 工具来替我们做的原因。

4.Proxy 类怎么实现动态代理？

Proxy 类里能替我们生成一个代理类对象的，就是 newProxyInstance() 方法。现在回过头看它的三个参数，

newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)

1. 第一个 ClassLoader 是为了生成 B 类的 Class 对象。作用是根据一组类的字节码 byte[] 直接生成这个类的 Class 对象。
2. 第二个参数是由委托类实现的接口的 Class 对象数组。主要是包含了最重要的代理类需要实现的接口方法的信息。
3. 最后一个最重要的就是一个实现了 InvocationHandler 接口的对象。InvocationHandler 接口在 java.lang.reflect 包里。最主要的就是定义了 invoke( ) 方法。它就是假设在已经动态生成了最后的 proxy 代理对象，以及所有接口定义的方法 Method 对象以及方法的参数的情况下，定义我们要怎么调用这些方法的地方。

这三个参数的分工用大白话讲就是：第一参数 ClassLoader 和第二参数接口的 Class 对象是用来动态生成委托类的包括类名，方法名，继承关系在内的一个空壳。用 B 类的例子演示就像下面这样，

class $ProxyN implements Interface{
    public void foo(){
        //do something...
    }
}

只有接口定义的方法名，没有实际操作。实际的操作是交给第三个参数 InvocationHandler 的 invoke() 方法来执行。

所以最主要的业务逻辑应该是在第三个参数 InvocationHandler 的 invoke() 方法里定义。下面代码，是根据之前 A 类 B 类的例子用 Proxy 类实现动态代理的 Demo。代码里原先的 B 类被擦掉了，完全由 Proxy 类动态生成。

interface Interface{public void foo();}

class A implements Interface{
    public void foo(){System.out.println("Method a of class A!");}
}

/*    //这是Proxy要动态生成的B类。
class B implements Interface{
    public void foo(){a.foo();}
    public A a=new A();
}
 */

class Consumer{
    public static void consum(Interface i){
        i.foo();
    }
}

class DynamicProxyHandler implements InvocationHandler {
    private Object proxied;
    public DynamicProxyHandler(Object proxied) {
        this.proxied = proxied;
    }
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        try{
            return method.invoke(proxied, args);
        }catch(Exception e){
            System.out.println(e);
            return null;
        }
    }
}

public class TestDynamicProxy{
    public static void main(String[] args){
        A a=new A();
    //直接把A类对象a当参数传进去，就动态产生一个代理类对象
        Interface proxy = (Interface)Proxy.newProxyInstance(Interface.class.getClassLoader(), new Class<?>[]{Interface.class }, new DynamicProxyHandler(a));
        Consumer.consum(proxy);
    }
}

在实现了 InvocationHandler 接口的 DynamicProxyHandler 类里有一个被代理类的对象 proxied 作为成员字段。在获得了参数传进来的代理类对象和 Method 对象之后，直接用 Method#invoke(Object o) 方法，调用了代理类对象的方法。第一个参数 ClassLoader 直接用的是 Interface 接口的类加载器 (Interface.class.getClassLoader())。第二参数就是 Interface 接口的 Class 对象。

然后，剩下的事就交给 Proxy 来完成。关键的难点在于怎么根据给定的 ClassLoader 和接口的方法信息动态生成一个所谓 “空壳”。其实 newProxyInstance() 方法隐藏了非常多其他的复杂性，比如说访问权限检查，包路径设置，安全检查等等琐碎的事，但这里先不说。只说核心步骤。

下面截取 newProxyInstance() 方法源码里比较重要的一段贴上来，看看底层是怎么实现的。

/*
 * Choose a name for the proxy class to generate.
 */
long num;
synchronized (nextUniqueNumberLock) {
    num = nextUniqueNumber++;
}
String proxyName = proxyPkg + proxyClassNamePrefix + num;

/*
 * Generate the specified proxy class.
 */
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
    proxyName, interfaces);
try {
    proxyClass = defineClass0(loader, proxyName, proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
     throw new IllegalArgumentException(e.toString());
}

可以看到，proxyName 是动态生成的代理类的名称，一般是 ·$ProxyN 的格式。N 代表代理是 N 次生成动态代理。

然后见证奇迹的时刻到了，关键的核心步骤有两个：

1. ProxyGenerator.generateProxyClass() 方法生成了类加载器要用到的字节码。它需要的参数只有两个，1）类名，2）实现的接口的 Class 对象。然后它就神奇地生成了一堆字节码 byte[]，基本就是一个凭空造出来的编译好的. class 文件。这个方法来自神秘的 sun.misc 包。也查不到源码。
2. 最后神秘的字节码和加载器，以及类名一起被交到另一个 native 方法 defineClass0( ) 里，由它生成代理类的 Class 对象。至于 native 方法怎么实现，源码里也查不到。

最后再总结一下，使用 Proxy 的三步，

1. 在第三个参数，实现 InvocationHandler 接口的对象的 invoke() 方法里写业务逻辑。
2. 第二个参数是代理实现接口的 Class 对象
3. 第一个参数是一个 ClassLoader。一般直接用调用类的加载器

如果实在想知道鬼畜的 ProxyGenerator.generateProxyClass(）的内部原理，就看谁能把人肉源码机 R 大 @RednaxelaFX 召唤出来了，哈哈:v