Java基础（十四）代理（Proxy）

　　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对象是否代表着一个代理类。

　　代理类真的是很麻烦呀。