Proxy

public class Proxy
extends Object implements Serializable

Proxy提供了创建动态代理类和实例的静态方法，它也是由这些方法创建的所有动态代理类的超类。

为某个接口创建代理 Foo ：

     InvocationHandler handler = new MyInvocationHandler(...);
     Class proxyClass = Proxy.getProxyClass(
         Foo.class.getClassLoader(), new Class[] { Foo.class });
     Foo f = (Foo) proxyClass.
         getConstructor(new Class[] { InvocationHandler.class }).
         newInstance(new Object[] { handler });
 

     Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),
                                          new Class[] { Foo.class },
                                          handler);
 

动态代理类 （以下简称为代理类 ）是一个类，它实现了创建类时在运行时指定的接口列表，其行为如下所述。 代理接口是由代理类实现的接口。 代理实例是代理类的实例。 每个代理实例都有一个关联的调用处理程序对象，它实现了接口InvocationHandler 。 通过其代理接口之一上的代理实例的方法调用将被分派到invoke实例的调用处理程序的方法，并传递代理实例，一个java.lang.reflect.Method对象识别的方法被调用，和类型的数组Object包含参数。 调用处理程序适当地处理编码的方法调用，并且返回的结果将作为代理实例上方法调用的结果返回。

代理类具有以下属性：

• Proxy classes are public, final, and not abstract.
• The unqualified name of a proxy class is unspecified. The space of class names that begin with the string "$Proxy" should be, however, reserved for proxy classes.
• A proxy class extends java.lang.reflect.Proxy.
• A proxy class implements exactly the interfaces specified at its creation, in the same order.
• If a proxy class implements a non-public interface, then it will be defined in the same package as that interface. Otherwise, the package of a proxy class is also unspecified. Note that package sealing will not prevent a proxy class from being successfully defined in a particular package at runtime, and neither will classes already defined by the same class loader and the same package with particular signers.
• Since a proxy class implements all of the interfaces specified at its creation, invoking getInterfaces on its Class object will return an array containing the same list of interfaces (in the order specified at its creation), invoking getMethods on its Class object will return an array of 方法 objects that include all of the methods in those interfaces, and invoking getMethod will find methods in the proxy interfaces as would be expected.
• The Proxy.isProxyClass method will return true if it is passed a proxy class-- a class returned by Proxy.getProxyClass or the class of an object returned by Proxy.newProxyInstance-- and false otherwise.
• The java.security.ProtectionDomain of a proxy class is the same as that of system classes loaded by the bootstrap class loader, such as java.lang.Object, because the code for a proxy class is generated by trusted system code. This protection domain will typically be granted java.security.AllPermission.
• Each proxy class has one public constructor that takes one argument, an implementation of the interface InvocationHandler, to set the invocation handler for a proxy instance. Rather than having to use the reflection API to access the public constructor, a proxy instance can be also be created by calling the Proxy.newProxyInstance method, which combines the actions of calling Proxy.getProxyClass with invoking the constructor with an invocation handler.

代理实例具有以下属性：

• Given a proxy instance proxy and one of the interfaces implemented by its proxy class Foo, the following expression will return true:

       proxy instanceof Foo
   

  and the following cast operation will succeed (rather than throwing a ClassCastException):

       (Foo) proxy
   

• Each proxy instance has an associated invocation handler, the one that was passed to its constructor. The static Proxy.getInvocationHandler method will return the invocation handler associated with the proxy instance passed as its argument.
• An interface method invocation on a proxy instance will be encoded and dispatched to the invocation handler's invoke method as described in the documentation for that method.
• An invocation of the hashCode, equals, or toString methods declared in java.lang.Object on a proxy instance will be encoded and dispatched to the invocation handler's invoke method in the same manner as interface method invocations are encoded and dispatched, as described above. The declaring class of the 方法 object passed to invoke will be java.lang.Object. Other public methods of a proxy instance inherited from java.lang.Object are not overridden by a proxy class, so invocations of those methods behave like they do for instances of java.lang.Object.

Methods Duplicated in Multiple Proxy Interfaces

当代理类的两个或多个接口包含具有相同名称和参数签名的方法时，代理类的接口顺序变得很重要。 当这样的重复的方法是在一个代理实例调用时， 方法传递给调用处理程序对象将不一定是其声明类是从该代理的方法是通过调用接口的引用类型分配的一个。 存在此限制是因为生成的代理类中的相应方法实现无法确定通过哪个接口调用它。 因此，当重复的方法是在代理实例调用时， 方法对象为接口的代理类的列表包含方法（直接或继承通过超接口）中最重要的接口中的方法传递给调用处理程序的invoke方法，而与方法调用发生的引用类型无关。

如果代理接口包含具有相同的名称和参数签名的方法hashCode ， equals ，或toString的方法java.lang.Object ，当这种方法在代理实例调用时， 方法传递到调用处理程序对象将java.lang.Object作为其宣布课程。 换句话说， java.lang.Object的公共非最终方法在逻辑上位于所有代理接口之前，以确定哪个方法对象传递给调用处理程序。

另请注意，将重复方法分派给调用处理程序时， invoke方法可能只会引发已检查的异常类型，这些异常类型可分配给该方法的throws子句中的一个异常类型， throws在可调用的所有代理接口中通过。 如果invoke方法抛出一个检查的异常，该异常不可分配给该方法声明的任何异常类型，并且该异常类型可以通过其中一个代理接口进行调用，则未UndeclaredThrowableException将由代理实例上的调用引发。 此限制意味着，并非所有通过调用返回的异常类型的getExceptionTypes的上方法传递给对象invoke方法一定可以成功地抛出invoke方法。

Summary

Inherited methods

From class java.lang.Object Object clone() 创建并返回此对象的副本。 boolean equals(Object obj) 指示其他某个对象是否“等于”这一个。 void finalize() 当垃圾收集确定没有更多对该对象的引用时，由对象上的垃圾回收器调用。 final Class<?> getClass() 返回此 Object的运行时类。 int hashCode() 返回对象的哈希码值。 final void notify() 唤醒正在等待该对象监视器的单个线程。 final void notifyAll() 唤醒在该对象监视器上等待的所有线程。 String toString() 返回对象的字符串表示形式。 final void wait(long millis, int nanos) 导致当前线程等待，直到另一个线程为此对象调用 notify()方法或 notifyAll()方法，或者某个其他线程中断当前线程，或者经过了一定的实时时间。 final void wait(long millis) 导致当前线程等待，直到另一个线程调用此对象的 notify()方法或 notifyAll()方法，或经过了指定的时间量。 final void wait() 使当前线程等待，直到另一个线程调用此对象的 notify()方法或 notifyAll()方法。

Fields

InvocationHandler h

Protected constructors

Proxy (InvocationHandler h)

Public methods

InvocationHandler getInvocationHandler (Object proxy)

Class<?> getProxyClass (ClassLoader loader, 
                Class...<?> interfaces)

boolean isProxyClass (Class<?> cl)

Object newProxyInstance (ClassLoader loader, 
                Class[]<?> interfaces, 
                InvocationHandler h)

     Proxy.getProxyClass(loader, interfaces).
         getConstructor(new Class[] { InvocationHandler.class }).
         newInstance(new Object[] { handler });