1.为什么要使用代理
代理可以在运行时创建一个实现了一组给定接口的新类。这种功能只有在编译时无法确定需要实现哪个接口时才有必要使用。
假设有一个表示接口的Class对象(有可能只包含一个接口),它的确切类型在编译时无法知道,如果想要根据这个Class对象来构造一个实现这些接口的类,就需要使用newInstance方法或者反射找出类的构造器,但是,不能实例化一个接口,需要在程序处于运行状态时定义一个新类。
代理机制可以解决这个问题,代理类可以在运行时创建新的类,这样的代理类能够实现执行的接口。并且代理类具有指定接口中的全部方法以及Object类中的全部方法。
2.创建代理对象
要想创建一个代理对象,需要使用Proxy类的newProxyInstance方法。
这个方法有三个参数:
- ClassLoader loader:类加载器,用null表示默认的类加载器。
- Class<?>[] interfaces:Class对象数组,每个元素都是需要实现的接口
- InvocationHandler h:调用处理器
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
调用处理器是实现了InvocationHandler接口的类的对象,这个接口中只有一个invoke方法,无论什么时候调用代理对象的方法,调用处理器的invoke方法都会被调用,并向其传递Method对象和原始的调用参数。
public Object invoke(Object proxy, Method m, Object[] args)
以一个例子说明:
package proxy; import java.lang.reflect.*; import java.util.*; public class ProxyTest { public static void main(String[] args) { Object[] elements = new Object[1000]; for (int i = 0; i < elements.length; i++) { Integer value = i + 1; InvocationHandler handler = new TraceHandler(value); Object proxy = Proxy.newProxyInstance(null, new Class[] { Comparable.class } , handler); elements[i] = proxy; } Integer key = new Random().nextInt(elements.length) + 1; System.out.println("key: " + key); int result = Arrays.binarySearch(elements, key); System.out.println("result: " + result); if (result >= 0) System.out.println(elements[result]); } } class TraceHandler implements InvocationHandler { private Object target; public TraceHandler(Object t) { target = t; } public Object invoke(Object proxy, Method m, Object[] args) throws Throwable { // print implicit argument System.out.print(target); // print method name System.out.print("." + m.getName() + "("); // print explicit arguments if (args != null) { for (int i = 0; i < args.length; i++) { System.out.print(args[i]); if (i < args.length - 1) System.out.print(", "); } } System.out.println(")"); // invoke actual method return m.invoke(target, args); } }
以一个例子来分析代码执行过程,首先for循环,创建了1000个Interger对象value,将这些value对象传递到处理器的构造函数中,然后构造一个代理类对象,将这些代理类对象放入到element对象数组中。然后构造一个随机的Integer对象,假设key值为104,然后Arrays.binarySearch(elements, key);在elements对象数组中寻找对象值为104的索引,这个时候就发生了一些很令人难人寻味的事情。
这里就要看一下Arrays.binarySearch方法的具体实现:
public static int binarySearch(Object[] a, Object key) { return binarySearch0(a, 0, a.length, key); }
然后看一下binarySearch0方法的具体实现,注意参数传递关系,a是第一个参数,key是最后一个参数
// Like public version, but without range checks. private static int binarySearch0(Object[] a, int fromIndex, int toIndex, Object key) { int low = fromIndex; int high = toIndex - 1; while (low <= high) { int mid = (low + high) >>> 1; @SuppressWarnings("rawtypes") Comparable midVal = (Comparable)a[mid]; @SuppressWarnings("unchecked") int cmp = midVal.compareTo(key); if (cmp < 0) low = mid + 1; else if (cmp > 0) high = mid - 1; else return mid; // key found } return -(low + 1); // key not found. }
注意这个方法中的下面的代码,同时注意参数对应关系
Comparable midVal = (Comparable)a[mid];int cmp = midVal.compareTo(key);
有点乱,将思路再次梳理一下:
(1)Arrays.binarySearch(elements, key);其中,key是Integer对象104
(2)调用binarySearch(elements, 104);返回binarySearch0(elements, 0, elements.length, 104);
(3)然后开始调用binarySearch0(elements, 0, elements.length, 104);方法:mid=500,midVal是Object对象elements[500]采用强制类型转换得到的Comparable接口类型的对象,在int cmp = midVal.compareTo(104);这行代码执行的时候,由于数组中都是代理对象,而elements[500]也是(null, new Class[] { Comparable.class } , handler);且handler = new TraceHandler(value);中value是500对应的代理对象,当这个代理对象执行.compareTo(104)这个方法的时候,由于compareTo方法是Comparable接口中的唯一方法,如果代理对象调用了这个方法,就会去执行hander调用处理器对象对应的invoke(Object proxy, Method m, Object[] args)方法,此时构造函数中的target就是value也就是500,elements[500].compareTo(104)对应到invoke方法中就是,proxy=elements[500],m=compareTo,args={104},然后就简单了,首先打印500,然后打印.compareTo(,然后打印args中所有的对象即104,然后打印),最后返回的是m.invoke(target, args);对应着elements[500].compareTo(104);也就是又回到了原来的方法中...最后二分法结束之后返回的result的值才是索引值并且大于0,然后进入System.out.println(elements[result]);然后又开始了...又开始了,
System.out.println的实现是:
public void println(Object x) { String s = String.valueOf(x); synchronized (this) { print(s); newLine(); } }
String.valueOf的实现是:
public static String valueOf(Object obj) { return (obj == null) ? "null" : obj.toString(); }
这里就看出问题来了,toString方法也会被重定向到调用处理器上,这是为什么呢,明明toString都不属于Comparable接口,为什么还是要调用处理器。这是因为,即使不属于Comparable接口,toString方法也被代理了,因此就会...
总的输出为:
key: 104 500.compareTo(104) 250.compareTo(104) 125.compareTo(104) 62.compareTo(104) 93.compareTo(104) 109.compareTo(104) 101.compareTo(104) 105.compareTo(104) 103.compareTo(104) 104.compareTo(104) result: 103 104.toString() 104
3.代理类的特性
下面就要解释一下上面的toString方法到底是怎么回事。
所有的代理类都扩展于Proxy类,一个代理类只有一个实例域--调用处理器,它定义在Proxy的父类中。为了履行代理对象的职责,所需要的任何附加数据都必须存储在调用处理器中。例如,代理Comparable对象时,TranceHandler包装了实际的对象。
所有的代理类都覆盖了Object类中的方法toString、equals和hashCode。如同所有的代理方法一样,这些方法仅仅调用了调用处理器的invoke。Object类中的其他方法没有被重新定义。
对于特定的类加载器和预设的一组接口来说,只能有一个代理类。即如果使用同一个类加载器和接口数组调用两次newProxyInstance方法的话,那么只能够得到同一个类的两个对象。
代理类一定是public和final,如果代理类实现的所有接口都是public,代理类就不属于某个特定的包;否则,所有非公有的接口都必须属于同一个包,同时,代理类与属于这个包。
可以通过Proxy类中的isProxyClass方法检测一个特定的Class对象是否代表着一个代理类。
代理类真的是很麻烦呀。