Java reflect proxy 源码

古城微笑少年丶 2022-06-06 00:57 72阅读 0赞

--------------------

<table> 
 <tbody> 
  <tr> 
   <td colspan="2"><a rel="nofollow"><span style="font-size:14px"></span></a> 
    <table> 
     <tbody> 
      <tr> 
       <td><span style="font-size:14px"><a rel="nofollow"><span style=""><strong>概述</strong></span></a>&nbsp;</span></td> 
       <td><span style="font-size:14px"><a rel="nofollow"><span style=""><strong>软件包</strong></span></a>&nbsp;</span></td> 
       <td><span style="font-size:14px">&nbsp;<span style=""><strong>类</strong></span>&nbsp;</span></td> 
       <td><span style="font-size:14px"><a rel="nofollow"><span style=""><strong>使用</strong></span></a>&nbsp;</span></td> 
       <td><span style="font-size:14px"><a rel="nofollow"><span style=""><strong>树</strong></span></a>&nbsp;</span></td> 
       <td><span style="font-size:14px"><a rel="nofollow"><span style=""><strong>已过时</strong></span></a>&nbsp;</span></td> 
       <td><span style="font-size:14px"><a rel="nofollow"><span style=""><strong>索引</strong></span></a>&nbsp;</span></td> 
       <td><span style="font-size:14px"><a rel="nofollow"><span style=""><strong>帮助</strong></span></a>&nbsp;</span></td> 
      </tr> 
     </tbody> 
    </table> </td> 
   <td align="right"><span style="font-size:14px"><em><strong>Java<sup><span style="">TM</span></sup>&nbsp;Platform<br> Standard&nbsp;Ed. 6</strong></em> </span></td> 
  </tr> 
  <tr> 
   <td><span style=""><span style="font-size:14px">&nbsp;<a title="java.lang.reflect 中的接口" rel="nofollow"><strong>上一个类</strong></a>&nbsp; &nbsp;<a title="java.lang.reflect 中的类" rel="nofollow"><strong>下一个类</strong></a></span></span></td> 
   <td><span style="font-size:14px"><span style=""><a rel="nofollow"><strong>框架</strong></a> &nbsp; &nbsp;<a rel="nofollow"><strong>无框架</strong></a> &nbsp; &nbsp;<a rel="nofollow"><strong>所有类</strong></a> </span></span></td> 
  </tr> 
  <tr> 
   <td><span style=""><span style="font-size:14px">摘要：&nbsp;嵌套&nbsp;|&nbsp;<a rel="nofollow">字段</a>&nbsp;|&nbsp;<a rel="nofollow">构造方法</a>&nbsp;|&nbsp;<a rel="nofollow">方法</a></span></span></td> 
   <td><span style=""><span style="font-size:14px">详细信息：&nbsp;<a rel="nofollow">字段</a>&nbsp;|&nbsp;<a rel="nofollow">构造方法</a>&nbsp;|&nbsp;<a rel="nofollow">方法</a></span></span></td> 
  </tr> 
 </tbody> 
</table>

--------------------

## java.lang.reflect   类 Proxy ##

java.lang.Object
      java.lang.reflect.Proxy

**所有已实现的接口：**

Serializable

--------------------

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"` 开头的类名空间应该为代理类保留。 
 *  代理类扩展 `java.lang.reflect.Proxy`。 
 *  代理类会按同一顺序准确地实现其创建时指定的接口。 
 *  如果代理类实现了非公共接口，那么它将在与该接口相同的包中定义。否则，代理类的包也是未指定的。注意，包密封将不阻止代理类在运行时在特定包中的成功定义，也不会阻止相同类加载器和带有特定签名的包所定义的类。 
 *  由于代理类将实现所有在其创建时指定的接口，所以对其 `Class` 对象调用 `getInterfaces` 将返回一个包含相同接口列表的数组（按其创建时指定的顺序），对其 `Class` 对象调用 `getMethods` 将返回一个包括这些接口中所有方法的 `Method` 对象的数组，并且调用 `getMethod` 将会在代理接口中找到期望的一些方法。 
 *  如果 `Proxy.isProxyClass` 方法传递代理类（由 `Proxy.getProxyClass` 返回的类，或由 `Proxy.newProxyInstance` 返回的对象的类），则该方法返回 true，否则返回 false。 
 *  代理类的 `java.security.ProtectionDomain` 与由引导类加载器（如 `java.lang.Object`）加载的系统类相同，原因是代理类的代码由受信任的系统代码生成。此保护域通常被授予 `java.security.AllPermission`。 
 *  每个代理类都有一个可以带一个参数（接口 `InvocationHandler` 的实现）的公共构造方法，用于设置代理实例的调用处理程序。并非必须使用反射 API 才能访问公共构造方法，通过调用 `Proxy.newInstance` 方法（将调用 `Proxy.getProxyClass` 的操作和调用带有调用处理程序的构造方法结合在一起）也可以创建代理实例。

代理实例具有以下属性：

*  提供代理实例 `proxy` 和一个由其代理类 `Foo` 实现的接口，以下表达式将返回 true： 
    
        proxy instanceof Foo
    
    并且以下的强制转换操作将会成功（而不抛出 `ClassCastException`）： 
    
        (Foo) proxy
 *  每个代理实例都有一个关联的调用处理程序，它会被传递到其构造方法中。静态 `Proxy.getInvocationHandler` 方法将返回与作为其参数传递的代理实例相关的调用处理程序。 
 *  代理实例上的接口方法调用将按照该方法的文档描述进行编码，并被指派到调用处理程序的 `Invoke` 方法。 
 *  在代理实例上的 `java.lang.Object` 中声明的 `hashCode`、`equals` 或 `toString` 方法的调用将按照与编码和指派接口方法调用相同的方式进行编码，并被指派到调用处理程序的 `invoke` 方法，如上所述。传递到 `invoke` 的 `Method` 对象的声明类是 `java.lang.Object`。代理类不重写从 `java.lang.Object` 继承的代理实例的其他公共方法，所以这些方法的调用行为与其对 `java.lang.Object` 实例的操作一样。

### 在多代理接口中重复的方法 ###

当代理类的两个或多个接口包含一个具有相同名称和参数签名的方法时，代理类的接口顺序变得非常重要。在代理实例上调用*重复方法* 时，传递到调用处理程序的 `Method` 对象没有必要成为其声明类可以从接口（通过该接口调用代理方法）的引用类型指派的对象。此限制存在的原因是，生成的代理类中的相应方法实现无法确定它通过哪一个接口调用。因此，在代理实例上调用重复方法时，第一个接口中的方法的 `Method` 对象包含接口的代理类列表中的方法（直接或通过超级接口继承），该对象会传递到调用处理程序的 `invoke` 方法，无论该方法调用通过哪一种引用类型发生。

如果代理接口包含某一方法，它的名称和参数签名与 `java.lang.Object` 的 `hashCode`、`equals` 或 `toString` 方法相同，那么在代理实例上调用这样的方法时，传递到调用处理程序的 `Method` 对象将使 `java.lang.Object` 成为其声明类。换句话说，`java.lang.Object` 公共的非最终方法理论上在所有代理接口之前，以便确定哪一个 `Method` 对象传递到调用处理程序。

还要注意，当重复方法被指派到调用处理程序时，`invoke` 方法只可以抛出经过检查的异常类型，该异常类型可以使用*所有* 代理接口（可以通过它调用）中方法的 `throws` 子句指派一种异常类型。如果 `invoke` 方法抛出一个经过检查的异常，该异常没有指派给任何由一个代理接口（可以通过它调用）中的方法声明的异常类型，那么该代理实例上的调用将抛出一个未经检查的 `UndeclaredThrowableException`。此限制表示并非所有的由传递到 `invoke` 方法的 `Method` 对象上调用 `getExceptionTypes` 返回的异常类型都可以由 `invoke` 方法成功抛出。

**从以下版本开始：**

1.3

**另请参见：**

`InvocationHandler`, 序列化表格

--------------------

<table> 
 <tbody> 
  <tr> 
   <th colspan="2" align="left"><span style=""><span style="font-size:14px">字段摘要</span></span></th> 
  </tr> 
  <tr> 
   <td align="right"><span style=""><code><span style="font-size:14px">protected &nbsp;<a title="java.lang.reflect 中的接口" rel="nofollow">InvocationHandler</a></span></code></span></td> 
   <td><span style="font-size:14px"><code><strong><a rel="nofollow">h</a></strong></code> <br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;此代理实例的调用处理程序。</span></td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <th colspan="2" align="left"><span style=""><span style="font-size:14px">构造方法摘要</span></span></th> 
  </tr> 
  <tr> 
   <td align="right"><span style=""><code><span style="font-size:14px">protected </span></code></span></td> 
   <td><span style="font-size:14px"><code><strong><a rel="nofollow">Proxy</a></strong>(<a title="java.lang.reflect 中的接口" rel="nofollow">InvocationHandler</a>&nbsp;h)</code> <br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;使用其调用处理程序的指定值从子类（通常为动态代理类）构建新的 <code>Proxy</code> 实例。</span></td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <th colspan="2" align="left"><span style=""><span style="font-size:14px">方法摘要</span></span></th> 
  </tr> 
  <tr> 
   <td align="right"><span style=""><code><span style="font-size:14px">static&nbsp;<a title="java.lang.reflect 中的接口" rel="nofollow">InvocationHandler</a></span></code></span></td> 
   <td><span style="font-size:14px"><code><strong><a rel="nofollow">getInvocationHandler</a></strong>(<a title="java.lang 中的类" rel="nofollow">Object</a>&nbsp;proxy)</code> <br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;返回指定代理实例的调用处理程序。</span></td> 
  </tr> 
  <tr> 
   <td align="right"><span style=""><code><span style="font-size:14px">static&nbsp;<a title="java.lang 中的类" rel="nofollow">Class</a>&lt;?&gt;</span></code></span></td> 
   <td><span style="font-size:14px"><code><strong><a rel="nofollow">getProxyClass</a></strong>(<a title="java.lang 中的类" rel="nofollow">ClassLoader</a>&nbsp;loader, <a title="java.lang 中的类" rel="nofollow">Class</a>&lt;?&gt;...&nbsp;interfaces)</code> <br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;返回代理类的 <code>java.lang.Class</code> 对象，并向其提供类加载器和接口数组。</span></td> 
  </tr> 
  <tr> 
   <td align="right"><span style=""><code><span style="font-size:14px">static&nbsp;boolean</span></code></span></td> 
   <td><span style="font-size:14px"><code><strong><a rel="nofollow">isProxyClass</a></strong>(<a title="java.lang 中的类" rel="nofollow">Class</a>&lt;?&gt;&nbsp;cl)</code> <br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;当且仅当指定的类通过 <code>getProxyClass</code> 方法或 <code>newProxyInstance</code> 方法动态生成为代理类时，返回 true。</span></td> 
  </tr> 
  <tr> 
   <td align="right"><span style=""><code><span style="font-size:14px">static&nbsp;<a title="java.lang 中的类" rel="nofollow">Object</a></span></code></span></td> 
   <td><span style="font-size:14px"><code><strong><a rel="nofollow">newProxyInstance</a></strong>(<a title="java.lang 中的类" rel="nofollow">ClassLoader</a>&nbsp;loader, <a title="java.lang 中的类" rel="nofollow">Class</a>&lt;?&gt;[]&nbsp;interfaces, <a title="java.lang.reflect 中的接口" rel="nofollow"> InvocationHandler</a>&nbsp;h)</code> <br> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。</span></td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <th align="left"><strong><span style="font-size:14px">从类 java.lang.<a title="java.lang 中的类" rel="nofollow">Object</a> 继承的方法</span></strong></th> 
  </tr> 
  <tr> 
   <td><code><span style="font-size:14px"><a rel="nofollow">clone</a>, <a rel="nofollow"> equals</a>, <a rel="nofollow">finalize</a>, <a rel="nofollow">getClass</a>, <a rel="nofollow">hashCode</a>, <a rel="nofollow">notify</a>, <a rel="nofollow"> notifyAll</a>, <a rel="nofollow">toString</a>, <a rel="nofollow"> wait</a>, <a rel="nofollow">wait</a>, <a rel="nofollow">wait</a></span></code></td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <th align="left"><span style=""><strong><span style="font-size:14px">字段详细信息</span></strong></span></th> 
  </tr> 
 </tbody> 
</table>

### h ###

protected InvocationHandler h

此代理实例的调用处理程序。

<table> 
 <tbody> 
  <tr> 
   <th align="left"><span style=""><span style="font-size:14px">构造方法详细信息</span></span></th> 
  </tr> 
 </tbody> 
</table>

### Proxy ###

protected Proxy(InvocationHandler h)

使用其调用处理程序的指定值从子类（通常为动态代理类）构建新的 `Proxy` 实例。

**参数：**

`h` \- 此代理实例的调用处理程序

<table> 
 <tbody> 
  <tr> 
   <th align="left"><span style=""><span style="font-size:14px">方法详细信息</span></span></th> 
  </tr> 
 </tbody> 
</table>

### getProxyClass ###

public static Class<?> getProxyClass(ClassLoader loader,
                                         Class<?>... interfaces)
                                  throws IllegalArgumentException

返回代理类的 `java.lang.Class` 对象，并向其提供类加载器和接口数组。该代理类将由指定的类加载器定义，并将实现提供的所有接口。如果类加载器已经定义了具有相同排列接口的代理类，那么现有的代理类将被返回；否则，类加载器将动态生成并定义这些接口的代理类。

对可以传递给 `Proxy.getProxyClass` 的参数有以下几个限制：

*  `interfaces` 数组中的所有 `Class` 对象必须表示接口，而不能表示类或基本类型。 
 *  `interfaces` 数组中的两个元素不能引用同一 `Class` 对象。 
 *  所有接口类型的名称通过特定的类加载器必须可见。换句话说，对于类加载器 `cl` 和所有接口 `i`，以下表达式必须为 true： 
    
        Class.forName(i.getName(), false, cl) == i
 *  所有非公共接口必须位于同一包中；否则，该代理类将不可能实现所有的接口，无论它在哪一个包中定义。 
 *  对于有相同签名的指定接口中任何成员方法集： 
    
     *  如果任何方法的返回类型是基本类型或 void，那么所有的方法必须具有与此相同的返回类型。 
     *  否则，该方法之一必须是返回类型，它可以指派给该方法其余的所有返回类型。 
 *  得到的代理类必须不超过虚拟机在类上施加的任何限制。例如，虚拟机可以限制某一类实现至多 65535 的接口数；在这种情况下，`interfaces` 数组的大小必须不超过 65535。

如果违反了这些限制，`Proxy.getProxyClass` 将抛出 `IllegalArgumentException`。如果 `interfaces` 数组参数或其任何元素为 `null`，则将抛出 `NullPointerException`。

注意，指定的代理接口的顺序非常重要：对接口组合相同但顺序不同的代理类的两个请求会导致两个不同的代理类。

**参数：**

`loader` \- 定义代理类的类加载器

`interfaces` \- 代理类要实现的接口列表

**返回：**

用指定的类加载器定义的代理类，它可以实现指定的接口

**抛出：**

`IllegalArgumentException` \- 如果违反传递到 `getProxyClass` 的参数上的任何限制

`NullPointerException` \- 如果 `interfaces` 数组参数或其任何元素为 `null`

--------------------

### newProxyInstance ###

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

返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。此方法相当于：

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

`Proxy.newProxyInstance` 抛出 `IllegalArgumentException`，原因与 `Proxy.getProxyClass` 相同。

**参数：**

`loader` \- 定义代理类的类加载器

`interfaces` \- 代理类要实现的接口列表

`h` \- 指派方法调用的调用处理程序

**返回：**

一个带有代理类的指定调用处理程序的代理实例，它由指定的类加载器定义，并实现指定的接口

**抛出：**

`IllegalArgumentException` \- 如果违反传递到 `getProxyClass` 的参数上的任何限制

`NullPointerException` \- 如果 `interfaces` 数组参数或其任何元素为 `null`，或如果调用处理程序 `h` 为 `null`

--------------------

### isProxyClass ###

public static boolean isProxyClass(Class<?> cl)

当且仅当指定的类通过 `getProxyClass` 方法或 `newProxyInstance` 方法动态生成为代理类时，返回 true。

此方法的可靠性对于使用它做出安全决策而言非常重要，所以此方法的实现不应仅测试相关的类是否可以扩展 `Proxy`。

**参数：**

`cl` \- 要测试的类

**返回：**

如该类为代理类，则为 `true`，否则为 `false`

**抛出：**

`NullPointerException` \- 如果 `cl` 为 `null`

--------------------

### getInvocationHandler ###

public static InvocationHandler getInvocationHandler(Object proxy)
                                                  throws IllegalArgumentException

返回指定代理实例的调用处理程序。

**参数：**

`proxy` \- 返回调用处理程序的代理实例

**返回：**

代理实例的调用处理程序

**抛出：**

`IllegalArgumentException` \- 如果参数不是一个代理实例

--------------------

[提交错误或意见][Link 1]  
有关更多的 API 参考资料和开发人员文档，请参阅 [ Java SE 开发人员文档][Java SE]。该文档包含更详细的、面向开发人员的描述，以及总体概述、术语定义、使用技巧和工作代码示例。

[Link 1]: http://bugs.sun.com/services/bugreport/index.jsp
[Java SE]: http://java.sun.com/javase/6/webnotes/devdocs-vs-specs.html
[Link 2]: http://java.sun.com/javase/6/docs/legal/license.html
[Link 3]: http://java.sun.com/docs/redist.html