Java之动态代理简介

图截于《大话设计模式》

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》