JAVA代理机制

JAVA代理相关主要知识如下：

（1）利用代理可以在运行时创建一个实现了一组给定接口的新类。

        这种功能只有在编译时无法确定需要实现哪个接口时才有必要使用。



（2）假设有一个表示接口的Class对象，它的确切类型在编译时无法知道。

        要想构建一个实现接口的类，就需要使用NewInstance方法或反射找出这个类的构造器。

        但是不能实例化一个接口，需要在程序处于运行状态时定义一个新类。



（3）为解决这个问题，有些程序将会生成代码，将这些代码放置在一个文件中，使用编译器，然后再加载结果类文件。

        针对上述繁琐的过程，可以使用代理机制。

        代理机制是一种很好的解决方案，代理类可以再运行时创建全新的类，这样的代理类能够实现指定的接口。

        但是，这样做的速度会比较的慢，且需要将编译器与程序放在一起。



（4）它具有下列的方法：

       （a）指定接口所需要的全部方法。

       （b）Object类中的全部方法，例如toString、equals等。



（5）但是不能在运行时定义这些方法，需要提供一个调用处理器（Invocationhandler）。

         调用处理器是实现了Invocationhandler接口的类对象。

         这个接口只有一个方法：

                        Object invoke(Object proxy, Method method, Object[] args)



（6）无论何时调用代理对象方法，调用处理器的invoke方法都会被调用，并向其传递Method对象和原始的调用参数。



（7）要创建以一个代理对象，需使用Proxy类的NewProxyInstance方法。方法的三个参数为：

       （a）一个类加载器。

       （b）一个Class对象数组，每个元素都是需要实现的接口。

       （c）一个调用处理器。



（8）代理类的特性：

        代理类实在程序运行过程中创建的，一旦被创建，就变成常规类了。

        所有的代理类都扩展于Proxy类。一个代理类只有一个实例域——调用处理器。它定义在Proxy超类中，

        为了履行代理对象的职责，所需要的任何附加数据都必须存储在调用处理器中。 

        所有代理类都覆盖了Object类中的toString、equals和hashCode方法。



（9）对于特定的类加载器和预设的一组接口来说，只能有一个代理类。

        如果使用同一个类加载器的接口数组调用两次newProxyInstance方法，那么只能得到同一个类的两个对象，

        也可以使用getProxyClass方法获得这个类：

                     Class proxyClass = Proxy.getProxyClass(null, interfaces);



（10）代理类一定是public和final。

        如果代理类实现的所有接口都是public,代理类就不属于某个特定的包；

        否则，所有非公有的接口都必须属于同一个包，同时，代理类也属于这个包。

        可以通过调用Proxy类中的isProxyClass方法检测一个特定的Class对象是否代表一个代理类。



        通过下面的代码展示，能够让我们进一步的理解代理类及其运行机制：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;
import java.util.Random;

public class TestProxy {
	public static void main(String[] args) {
		Object[] elements = new Object[1000];
		for (int i = 0; i < elements.length; i++) {
			Integer value = i + 1;
			/**创建调用处理器**/
			InvocationHandler handle = new TraceHandler(value);
			/**创建代理类对象**/
			Object proxy = Proxy.newProxyInstance(null, new Class[] { Comparable.class }, handle);
			elements[i] = proxy;
		}

		Integer key = new Random().nextInt(elements.length) + 1;
		int result = Arrays.binarySearch(elements, key);
		if (result >= 0)
			System.err.println(elements[result]);
	}
}

class TraceHandler implements InvocationHandler {
	private Object target;

	public TraceHandler(Object t) {
		target = t;
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
		System.err.print(target);
		System.err.print("." +method.getName()+"(");
		if (args != null) {
			for (int i = 0; i < args.length; i++) {
				System.err.print(args[i]);
				if (i < args.length - 1)
					System.err.print(", ");
			}
		}
		System.err.println(")");
		/**执行method所代表的包含指定参数的方法**/
		return method.invoke(target, args);
	}
}