Java中动态代理

拼搏现实的明天。 2022-08-07 12:45 174阅读 0赞

动态代理作为代理模式的一种扩展形式，广泛应用于框架（尤其是基于AOP的框架）的设计与开发，本文将通过实例来讲解Java动态代理的实现过程。

**友情提示：本文略有难度，读者需具备代理模式相关基础知识**，![微笑][smile.gif]。

通常情况下，代理模式中的**每一个代理类在编译之后都会生成一个class文件，代理类所实现的接口和所代理的方法都被固定，这种代理被称之为静态代理(Static Proxy)**。那么有没有一种机制**能够让系统在运行时动态创建代理类**？答案就是本文将要介绍的**动态代理(Dynamic Proxy)**。动态代理是一种较为高级的代理模式，它在事务管理、AOP（Aspect-OrientedProgramming，面向方面编程）等领域都发挥了重要的作用。

在传统的代理模式中，客户端通过Proxy类调用RealSubject类的request()方法，同时还可以在代理类中封装其他方法（如preRequest()和postRequest()等）。如果按照这种方法使用代理模式，那么**代理类和真实主题类都应该是事先已经存在的，代理类的接口和所代理方法都已明确指定，如果需要为不同的真实主题类提供代理类或者代理一个真实主题类中的不同方法，都需要增加新的代理类，这将导致系统中的类个数急剧增加，因此需要想办法减少系统中类的个数。动态代理可以让系统能够根据实际需要来动态创建代理类，让同一个代理类能够代理多个不同的真实主题类而且可以代理不同的方法。**

从JDK 1.3开始，Java语言提供了对动态代理的支持，Java语言实现动态代理时需要用到位于java.lang.reflect包中的一些类，现简要说明如下：

**      (1) Proxy类**

Proxy类提供了用于创建动态代理类和实例对象的方法，它是所创建的动态代理类的父类，它最常用的方法如下：

* public static Class<?> getProxyClass(ClassLoader loader,Class<?>... interfaces)：该方法用于返回一个Class类型的代理类，在参数中需要提供类加载器并需要指定代理的接口数组（与真实主题类的接口列表一致）。
 * public static Object newProxyInstance(ClassLoader loader, Class<?>\[\]interfaces, InvocationHandler h)：该方法用于返回一个动态创建的代理类的实例，方法中第一个参数loader表示代理类的类加载器，第二个参数interfaces表示代理类所实现的接口列表（与真实主题类的接口列表一致），第三个参数h表示所指派的调用处理程序类。

**      (2) InvocationHandler接口**

InvocationHandler接口是代理处理程序类的实现接口，该接口作为代理实例的调用处理者的公共父类，每一个代理类的实例都可以提供一个相关的具体调用处理者（InvocationHandler接口的子类）。在该接口中声明了如下方法：

*  public Object invoke(Objectproxy, Method method, Object\[\] args)：该方法用于处理对代理类实例的方法调用并返回相应的结果，当一个代理实例中的业务方法被调用时将自动调用该方法。invoke()方法包含三个参数，其中第一个参数proxy表示代理类的实例，第二个参数method表示需要代理的方法，第三个参数args表示代理方法的参数数组。

**        动态代理类需要在运行时指定所代理真实主题类的接口，客户端在调用动态代理对象的方法时，调用请求会将请求自动转发给InvocationHandler对象的invoke()方法，由invoke()方法来实现对请求的统一处理。**

下面通过一个简单实例来学习如何使用动态代理模式：

<table style="color:rgb(0,0,0); font-family:Arial; font-size:14px; line-height:26px; background-color:rgb(242,242,242)"> 
 <tbody> 
 <tr> 
 <td> &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; Sunny软件公司欲为公司OA系统数据访问层DAO增加方法调用日志，记录每一个方法被调用的时间和调用结果，现使用动态代理进行设计和实现。 </td> 
 </tr> 
 </tbody> 
</table>

本实例完整代码如下所示：

**\[java\]**  [view plain][] [copy][view plain]

1.  **import** java.lang.reflect.Proxy;  
2.  **import** java.lang.reflect.InvocationHandler;  
3.  **import** java.lang.reflect.InvocationTargetException;  
4.  **import** java.lang.reflect.Method;  
5.  **import** java.util.Calendar;  
6.  **import** java.util.GregorianCalendar;  
7.    
8.  //抽象UserDAO：抽象主题角色  
9.  **interface** AbstractUserDAO \{  
10.     **public** Boolean findUserById(String userId);  
11. \}  
12.   
13. //抽象DocumentDAO：抽象主题角色  
14. **interface** AbstractDocumentDAO \{  
15.     **public** Boolean deleteDocumentById(String documentId);  
16. \}  
17.   
18. //具体UserDAO类：真实主题角色  
19. **class** UserDAO **implements** AbstractUserDAO \{  
20.     **public** Boolean findUserById(String userId) \{  
21.         **if** (userId.equalsIgnoreCase("张无忌")) \{  
22.             System.out.println("查询ID为" + userId + "的用户信息成功！");  
23.             **return** **true**;  
24.         \}  
25.         **else** \{  
26.             System.out.println("查询ID为" + userId + "的用户信息失败！");  
27.             **return** **false**;  
28.         \}  
29.     \}  
30. \}  
31.   
32. //具体DocumentDAO类：真实主题角色  
33. **class** DocumentDAO **implements** AbstractDocumentDAO \{  
34.     **public** Boolean deleteDocumentById(String documentId) \{  
35.         **if** (documentId.equalsIgnoreCase("D001")) \{  
36.             System.out.println("删除ID为" + documentId + "的文档信息成功！");  
37.             **return** **true**;  
38.         \}  
39.         **else** \{  
40.             System.out.println("删除ID为" + documentId + "的文档信息失败！");  
41.             **return** **false**;  
42.         \}  
43.     \}  
44. \}  
45.   
46. //自定义请求处理程序类  
47. **class** DAOLogHandler **implements** InvocationHandler \{  
48.     **private** Calendar calendar;  
49.     **private** Object object;  
50.       
51.     **public** DAOLogHandler() \{      
52.     \}  
53.       
54.     //自定义有参构造函数，用于注入一个需要提供代理的真实主题对象  
55.     **public** DAOLogHandler(Object object) \{  
56.         **this**.object = object;  
57.     \}  
58.       
59.     //实现invoke()方法，调用在真实主题类中定义的方法  
60.     **public** Object invoke(Object proxy, Method method, Object\[\] args) **throws** Throwable \{  
61.         beforeInvoke();  
62.         Object result = method.invoke(object, args); //转发调用  
63.         afterInvoke();  
64.         **return** **null**;  
65.     \}  
66.   
67.     //记录方法调用时间  
68.     **public** **void** beforeInvoke()\{  
69.         calendar = **new** GregorianCalendar();  
70.         **int** hour = calendar.get(Calendar.HOUR\_OF\_DAY);  
71.         **int** minute = calendar.get(Calendar.MINUTE);  
72.         **int** second = calendar.get(Calendar.SECOND);  
73.         String time = hour + ":" + minute + ":" + second;  
74.         System.out.println("调用时间：" + time);  
75.     \}  
76.   
77.     **public** **void** afterInvoke()\{  
78.         System.out.println("方法调用结束！" );  
79.     \}  
80. \}

编写如下客户端测试代码：

**\[java\]**  [view plain][] [copy][view plain]

1.  **class** Client \{  
2.      **public** **static** **void** main(String args\[\]) \{  
3.          InvocationHandler handler = **null**;  
4.            
5.          AbstractUserDAO userDAO = **new** UserDAO();  
6.          handler = **new** DAOLogHandler(userDAO);  
7.          AbstractUserDAO proxy = **null**;  
8.          //动态创建代理对象，用于代理一个AbstractUserDAO类型的真实主题对象  
9.          proxy = (AbstractUserDAO)Proxy.newProxyInstance(AbstractUserDAO. **class**.getClassLoader(), **new** Class\[\]\{AbstractUserDAO.**class**\}, handler);  
10.         proxy.findUserById("张无忌"); //调用代理对象的业务方法  
11.       
12.         System.out.println("------------------------------");  
13.       
14.         AbstractDocumentDAO docDAO = **new** DocumentDAO();  
15.         handler = **new** DAOLogHandler(docDAO);  
16.         AbstractDocumentDAO proxy\_new = **null**;  
17. //动态创建代理对象，用于代理一个AbstractDocumentDAO类型的真实主题对象  
18.         proxy\_new = (AbstractDocumentDAO)Proxy.newProxyInstance(Abstract DocumentDAO.**class**.getClassLoader(), **new** Class\[\]\{AbstractDocumentDAO.**class**\}, handler);  
19.         proxy\_new.deleteDocumentById("D002"); //调用代理对象的业务方法  
20.     \}   
21. \}

编译并运行程序，输出结果如下：

<table style="color:rgb(0,0,0); font-family:Arial; font-size:14px; line-height:26px; background-color:rgb(243,243,243); width:494px; height:194px"> 
 <tbody> 
 <tr> 
 <td> 调用时间：13:47:14 查询ID为张无忌的用户信息成功！ 方法调用结束！ ------------------------------ 调用时间：13:47:14 删除ID为D002的文档信息失败！ 方法调用结束！ </td> 
 </tr> 
 </tbody> 
</table>

通过使用动态代理，我们可以实现对多个真实主题类的统一代理和集中控制。

**注：JDK中提供的动态代理只能代理一个或多个接口，如果需要动态代理具体类或抽象类，可以使用CGLib(Code Generation Library)等工具，CGLib是一个功能较为强大、性能和质量也较好的代码生成包，在许多AOP框架中都得以广泛应用，大家可以自行查阅相关资料来学习CGLib。**

[smile.gif]: /images/20220805/689305c0eebe44ceaeeed967f768ff19.png
[view plain]: http://blog.csdn.net/lovelion/article/details/8116704#