Java动态代理
引言
最近在看AOP代码，其中利用到了Java动态代理机制来实现AOP织入。所以好好地把Java动态代理学习了一遍。其中重点感谢《Java动态代理机制分析及扩展》这篇博文。受益匪浅，比《Thinking in Java》讲的还要详细。本文在原文的基础上增加了些其他参考资料的内容和自己的测试Demo及理解。
代理模式
首先，先来理解下什么是代理模式。
代理模式：给某一个对象提供一个代理，并由代理对象控制对原对象的引用。
代理模式包含如下角色：
- Subject：抽象主题角色
- Proxy：代理主题角色
- RealSubject：真实主题角色
Client将不直接调用RealSubject。而是通过Proxy作为中间人。Proxy可在调用RealSubject的request()方法前后加上一些处理。例如写日志等。
//: typeinfo/SimpleProxyDemo.java
import static net.mindview.util.Print.*;
interface Interface {
void doSomething();
void somethingElse(String arg);
}
class RealObject implements Interface {
public void doSomething() { print("doSomething"); }
public void somethingElse(String arg) {
print("somethingElse " + arg);
}
}
class SimpleProxy implements Interface {
private Interface proxied;
public SimpleProxy(Interface proxied) {
this.proxied = proxied;
}
public void doSomething() {
print("SimpleProxy doSomething");
proxied.doSomething();
}
public void somethingElse(String arg) {
print("SimpleProxy somethingElse " + arg);
proxied.somethingElse(arg);
}
}
class SimpleProxyDemo {
public static void consumer(Interface iface) {
iface.doSomething();
iface.somethingElse("bonobo");
}
public static void main(String[] args) {
consumer(new RealObject());
consumer(new SimpleProxy(new RealObject()));
}
} /* Output:
doSomething
somethingElse bonobo
SimpleProxy doSomething
doSomething
SimpleProxy somethingElse bonobo
somethingElse bonobo
*///:~
Java的动态代理比代理的思想更向前迈进一步。因为它可以动态地创建代理并动态地处理对所代理方法的调用。在动态代理上所做的所有调用都会被重定向到单一的调用处理上，它的工作是揭示调用的类型并确定相应的对策。
下面是利用动态代理改写后的。其中看不懂的类和接口，在下一部分会进行解释。
//: typeinfo/SimpleDynamicProxy.java
import java.lang.reflect.*;
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 {
System.out.println("**** proxy: " + proxy.getClass() +
", method: " + method + ", args: " + args);
if(args != null)
for(Object arg : args)
System.out.println(" " + arg);
return method.invoke(proxied, args);
}
}
class SimpleDynamicProxy {
public static void consumer(Interface iface) {
iface.doSomething();
iface.somethingElse("bonobo");
}
public static void main(String[] args) {
RealObject real = new RealObject();
consumer(real);
// Insert a proxy and call again:
Interface proxy = (Interface)Proxy.newProxyInstance(
Interface.class.getClassLoader(),
new Class[]{ Interface.class },
new DynamicProxyHandler(real));
consumer(proxy);
}
} /* Output: (95% match)
doSomething
somethingElse bonobo
**** proxy: class $Proxy0, method: public abstract void Interface.doSomething(), args: null
doSomething
**** proxy: class $Proxy0, method: public abstract void Interface.somethingElse(java.lang.String), args: [Ljava.lang.Object;@42e816
bonobo
somethingElse bonobo
*///:~
相关类和接口
动态代理类（简称代理类）： is a class that implements a list of interfaces specified at runtime when the class is created（不太好翻译）
代理接口：是代理类实现的一个接口
动态代理类实例：是代理类的一个实例，每一个动态代理类实例都有一个关联的调用处理程序对象（实现接口 InvocationHandler ）。
通过调用一个代理接口的动态代理类实例上的方法调用，将被指派给实例的调用处理程序的 invoke 方法
-
java.lang.reflect.Proxy：Java动态代理机制的主类。提供了一组静态方法来为一组接口动态地生成代理类及其实例。
// Proxy的静态方法 // 方法 1: 该方法用于获取指定代理对象所关联的调用处理器 static InvocationHandler getInvocationHandler(Object proxy) // 方法 2：该方法用于获取关联于指定类装载器和一组接口的动态代理类的类对象 static Class getProxyClass(ClassLoader loader, Class[] interfaces) // 方法 3：该方法用于判断指定类对象是否是一个动态代理类 static boolean isProxyClass(Class cl) // 方法 4：该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例 static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h) -
java.lang.reflect.InvocationHandler：这是调用处理器接口，它自定义了一个 invoke 方法，用于集中处理在动态代理类实例上的方法调用，通常在该方法中实现对委托类的代理访问。
// InvocationHandler的核心方法 // 该方法负责集中处理动态代理类上的所有方法调用。第一个参数既是代理类实例，第二个参数是被调用的方法对象 // 第三个方法是调用参数。调用处理器根据这三个参数进行预处理或分派到委托类实例上发射执行 Object invoke(Object proxy, Method method, Object[] args)每次生成动态代理类实例时都需要指定一个实现了该接口的调用处理器对象。
-
java.lang.ClassLoader：这是类装载器类，负责将类的字节码装载到 Java 虚拟机（JVM）中并为其定义类对象，然后该类才能被使用。Proxy 静态方法生成代理类同样需要通过类装载器来进行装载才能使用，它与普通类的唯一区别就是其字节码是由 JVM 在运行时动态生成的而非预存在于任何一个 .class 文件中。
每次生成动态代理类实例时都需要指定一个类装载器对象
代理机制
四个步骤：
- 通过实现 InvocationHandler 接口创建自己的调用处理器；
- 通过为 Proxy 类指定 ClassLoader 对象和一组 interface 来创建动态代理类；
- 通过反射机制获得动态代理类的构造函数，其唯一参数类型是调用处理器接口类型；
- 通过构造函数创建动态代理类实例，构造时调用处理器对象作为参数被传入。
// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发
// 其内部通常包含指向委托类实例的引用，用于真正执行分派转发过来的方法调用
InvocationHandler handler = new InvocationHandlerImpl(..);
// 通过 Proxy 为包括 Interface 接口在内的一组接口动态创建代理类的类对象
Class clazz = Proxy.getProxyClass(classLoader, new Class[] { Interface.class, ... });
// 通过反射从生成的类对象获得构造函数对象
Constructor constructor = clazz.getConstructor(new Class[] { InvocationHandler.class });
// 通过构造函数对象创建动态代理类实例
Interface Proxy = (Interface)constructor.newInstance(new Object[] { handler });
还有更为简便的方法，Proxy 的静态方法 newProxyInstance 已经为我们封装了步骤 2 到步骤 4 的过程，所以简化后的过程如下：
// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发
InvocationHandler handler = new InvocationHandlerImpl(..);
// 通过 Proxy 直接创建动态代理类实例
Interface proxy = (Interface)Proxy.newProxyInstance( classLoader,
new Class[] { Interface.class },
handler );
下面了解一下，动态生成的代理类的特点：
包：如果所代理的接口都是 public 的，那么它将被定义在顶层包（即包路径为空），如果所代理的接口中有非 public 的接口（因为接口不能被定义为 protect 或 private，所以除 public 之外就是默认的 package 访问级别），那么它将被定义在该接口所在包（假设代理了 com.ibm.developerworks 包中的某非 public 接口 A，那么新生成的代理类所在的包就是 com.ibm.developerworks），这样设计的目的是为了最大程度的保证动态代理类不会因为包管理的问题而无法被成功定义并访问；
类修饰符：该代理类具有 final 和 public 修饰符，意味着它可以被所有的类访问，但是不能被再度继承；
类名：格式是“$ProxyN”，其中 N 是一个逐一递增的阿拉伯数字，代表 Proxy 类第 N 次生成的动态代理类，值得注意的一点是，并不是每次调用 Proxy 的静态方法创建动态代理类都会使得 N 值增加，原因是如果对同一组接口（包括接口排列的顺序相同）试图重复创建动态代理类，它会很聪明地返回先前已经创建好的代理类的类对象（进行了缓存），而不会再尝试去创建一个全新的代理类，这样可以节省不必要的代码重复生成，提高了代理类的创建效率。
类继承关系：该类的继承关系如图：
由图可见，Proxy 类是它的父类，这个规则适用于所有由 Proxy 创建的动态代理类。而且该类还实现了其所代理的一组接口，这就是为什么它能够被安全地类型转换到其所代理的某接口的根本原因。
下面了解一下动态代理类实例的一些特点。
每个实例都会关联一个调用处理器对象，可以通过 Proxy 提供的静态方法 getInvocationHandler 去获得代理类实例的调用处理器对象。在代理类实例上调用其代理的接口中所声明的方法时，这些方法最终都会由调用处理器的 invoke 方法执行，此外，值得注意的是，代理类的根类 java.lang.Object 中有三个方法也同样会被分派到调用处理器的 invoke 方法执行，它们是 hashCode，equals 和 toString，可能的原因有：一是因为这些方法为 public 且非 final 类型，能够被代理类覆盖；二是因为这些方法往往呈现出一个类的某种特征属性，具有一定的区分度，所以为了保证代理类与委托类对外的一致性，这三个方法也应该被分派到委托类执行。
多代理接口中方法重复：当代理的一组接口有重复声明的方法且该方法被调用时，代理类总是从排在最前面的接口中获取方法对象并分派给调用处理器，而无论代理类实例是否正在以该接口（或继承于该接口的某子接口）的形式被外部引用，因为在代理类内部无法区分其当前的被引用类型。
public interface InterfaceA {
void doSomething();
void doA();
}
public interface InterfaceB {
void doSomething();
void doB();
}
public class RealObject implements InterfaceA, InterfaceB {
public void doSomething() {}
public void doA() {}
public void doB() {}
}
public class InvocationHandlerImpl implements InvocationHandler{
private Object proxied;
public InvocationHandlerImpl(Object proxied) {
this.proxied = proxied;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("*** proxy: " + proxy.getClass() + ", method: " + method + ", args: "+args);
if (args != null)
for (Object arg : args)
System.out.println(" " + arg);
return method.invoke(proxied, args);
}
}
public class SimpleDynamicProxy {
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, InterruptedException {
RealObject object = new RealObject();
InvocationHandler handler = new InvocationHandlerImpl(object);
Class clazz = Proxy.getProxyClass(
RealObject.class.getClassLoader(),
new Class[] {InterfaceB.class, InterfaceA.class});
Constructor constructor = clazz.getConstructor(
new Class[] {InvocationHandler.class});
InterfaceA proxy = (InterfaceA) constructor.newInstance(new Object[] {handler});
proxy.doSomething();
}
} /* Output:
*** proxy: class com.sun.proxy.$Proxy0, method: public abstract void com.chaycao.Test.proxy.InterfaceB.doSomething(), args: null
*/
虽然代理类实例 proxy 正以接口 InterfaceA 的形式被外部引用。但获取的方法对象是 在 getProxyClass 方法 排前面的 InterfaceB 中的。
再谈多代理：之前一直不理解为什么会有多代理的存在，一个代理类实例只能以一种接口形式被调用。后来明白，所谓的多代理是针对代理类而言的，代理类的实例可以有多种接口形式的选择。如下：
public class SimpleDynamicProxy {
public static void consumer(InterfaceB iface) {
iface.doSomething();
}
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, InterruptedException {
RealObject object = new RealObject();
InvocationHandler handler = new InvocationHandlerImpl(object);
Class clazz = Proxy.getProxyClass(
RealObject.class.getClassLoader(),
new Class[] {InterfaceA.class, InterfaceB.class});
Constructor constructor = clazz.getConstructor(
new Class[] {InvocationHandler.class});
InterfaceA proxy_a = (InterfaceA) constructor.newInstance(new Object[] {handler});
InterfaceB proxy_b = (InterfaceB) constructor.newInstance(new Object[] {handler});
proxy_a.doSomething();
proxy_a.doA();
proxy_b.doSomething();
proxy_b.doB();
}
} /*Output:
*** proxy: class com.sun.proxy.$Proxy0, method: public abstract void com.chaycao.Test.proxy.InterfaceA.doSomething(), args: null
*** proxy: class com.sun.proxy.$Proxy0, method: public abstract void com.chaycao.Test.proxy.InterfaceA.doA(), args: null
*** proxy: class com.sun.proxy.$Proxy0, method: public abstract void com.chaycao.Test.proxy.InterfaceA.doSomething(), args: null
*** proxy: class com.sun.proxy.$Proxy0, method: public abstract void com.chaycao.Test.proxy.InterfaceB.doB(), args: null
*/
下面是被代理的一组接口的特点：
- 要注意不能有重复的接口，以避免动态代理类代码生成时的编译错误。
- 这些接口对于类装载器必须可见，否则类装载器将无法链接它们，将会导致类定义失败。再次，需被代理的所有非 public 的接口必须在同一个包中，否则代理类生成也会失败。
- 接口的数目不能超过 65535，这是 JVM 设定的限制。
参考资料
- 《Thinking in Java》动态代理
- Java动态代理机制分析及扩展
- Graphic Design Patterns-代理模式
- Java Platform SE 8
