JAVA动态代理

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);
    }
}
  1. 代理有什么好处?

乍一看,代理方法完全是多此一举,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 类)的代码没有任何影响,耦合很低。

  1. 什么是动态代理?

上面例子里在 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

你可能感兴趣的:(Java基础)