Java之动态代理简介

Posted 2021-01-13 foundkey

图截于《大话设计模式》

Proxy模式是常用的设计模式，其特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。

用户可以更加结构图，自己编码完成Proxy模式。这种实现称为静态代理。

Java提供了java.lang.reflect.Proxy类与InvocationHandler接口，配合反射，可以实现动态代理。静态代理的代理类与代理操作，都是事先编码，运行过程种无法修改代理结构。动态代理的代理与代理操作，都是在运行过程中，动态生成，可以在运行过程中，修改代理结构。

InvocationHandler类提供代理操作行为，动态构建的代理类使用该接口调用代理操作。

Proxy类主要负责动态构建代理类，有以下静态方法：

• InvocationHandler getInvocationHandler(Object proxy)
• Class<?> getProxyClass(ClassLoader loader, Class<?>... interfaces)
• boolean isProxyClass(Class<?> cl)
• Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)

调用getProxyClass()会动态生成Proxy类的子类，并使用loader参数指定的类加载器加载；第二个参数interfaces指定该子类将要继承的接口，可以指定多个接口。

interface Foo { void funcA(); }     Class<?> proxyClass = Proxy.getProxyClass(Foo.class.getClassLoader(), Foo.class); System.out.println(proxyClass.getName()); for (Class<?> interfaceType : proxyClass.getInterfaces()) System.out.println("\\t" + interfaceType);     Class<?> proxyClassB = Proxy.getProxyClass(Foo.class.getClassLoader(), Foo.class, AutoCloseable.class); System.out.println(proxyClassB.getName()); for (Class<?> interfaceType : proxyClassB.getInterfaces()) System.out.println("\\t" + interfaceType);

输出如下：

testproxy.$Proxy0 interface testproxy.Foo testproxy.$Proxy1 interface testproxy.Foo interface java.lang.AutoCloseable

由输出可以推测，调用Proxy.getProxyClass()后，生成子类为：

$Proxy* extends Proxy implements interfasces

*为从0开始编号的整数，代表是第几个被创建的Proxy的子类。interfaces是Proxy.getProxyClass()方法的第二个不定参数。这些类的字节码创建在内存中。例如上面代码生成的子类为：

$Proxy0 extends Proxy implements Foo {...} $Proxy1 extends Proxy implements Foo, AutoCloseable {...}

   

实现同接口的Proxy子类，只会被创建一次，拥有共同的Class实例。

Class<?> proxyClassA = Proxy.getProxyClass(Foo.class.getClassLoader(), Foo.class); Class<?> proxyClassB = Proxy.getProxyClass(Foo.class.getClassLoader(), Foo.class); System.out.println(proxyClassA.getName()); System.out.println(proxyClassB.getName());

输出如下：

testproxy.$Proxy0 testproxy.$Proxy0

   

由于Proxy类只有一个带InvocationHandler接口的参数，所有所以需要获取指定版本的构造函数后，传入InvocationHandler接口的实现类获取动态子类的实例。

Foo fooProxy = (Foo) proxyClass.getConstructor(InvocationHandler.class) .newInstance(handler);

Proxy类提供的Proxy.newProxyInstance()，一步到位，简化了获取动态子类实例的操作。

Foo fooProxy = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(), new Class<?>[] { Foo.class }, handler)

fooProxy的实例为"$Proxy0 extends Proxy implements Foo {...}"类

   

InvocationHandler接口有一个invoke()方法需要实现，动态代理类正式调用这个方法执行代理操作。举个例子：

class SimpleHandler implements InvocationHandler { final private Object target;   public SimpleHandler(Object target) { // *需要保留委托类的引用 this.target = target; }   @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("---Proxy before---"); // *不适用第一个参数proxy，使用构造函数保留的引用调用委托类方法 Object result = method.invoke(target, args); System.out.println("---Proxy end---");   return result; } }

使用以下委托类和代码测试。

class FooImp implements Foo { @Override public void funcA() { System.out.println("FooImp"); } }     // Test Foo fooProxy = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(), new Class<?>[] { Foo.class }, new SimpleHandler(new FooImp())); fooProxy.funcA(); System.out.println(fooProxy.toString());

输出如下：

---Proxy before--- FooImp ---Proxy end--- ---Proxy before--- ---Proxy end--- testproxy.FooImp@4aa298b7

fooProxy的是实例是Proxy类的动态子类，调用该子类的funcA()方法时，实际上先调用了invoke()方法，再通过反射调用委托类的funcA()方法。

   

为什么toString()方法也被代理了？

实际上，Object的equal()、hashCode()也同时被代理的，这个与Proxy子类的构建过程有关，可以参考资料《JDK动态代理实现原理》。

   

实现InvocationHandler接口时，红色的注释指出两个疑点：

• 为什么要保留委托类实例的引用？
• 为什么不使用第一个参数proxy？

这个两个问题其实是一个问题，invoke()函数的第一个参数proxy引用的实例是Proxy类的动态子类，而不是委托类。如果使用反射调用动态子类的方法，又会再次调用invoke()函数，陷入无限循环中，直到内存移除崩溃。因此，需要保留委托类的引用，让invoke()方法可以调用到委托类的方法。这样又引出一个问题，proxy参数又什么用？

proxy参数可以做为返回值，实现方法链。具体可以参考《Understanding "proxy" arguments of the invoke method of java.lang.reflect.InvocationHandler》