Java 动态代理(Proxy)

开发 后端
主要是通过 java.lang.reflect.Proxy 类和 java.lang.reflect.InvocationHandler 接口。 Proxy 类主要用来获取动态代理对象,InvocationHandler 接口用来约束调用者行为。

动态代理可以提供对另一个对象的访问,同时隐藏实际对象的具体事实,代理对象对客户隐藏了实际对象。动态代理可以对请求进行其他的一些处理,在不允许直接访问某些类,或需要对访问做一些特殊处理等,这时候可以考虑使用代理。目前 Java 开发包中提供了对动态代理的支持,但现在只支持对接口的实现。

主要是通过 java.lang.reflect.Proxy 类和 java.lang.reflect.InvocationHandler 接口。 Proxy 类主要用来获取动态代理对象,InvocationHandler 接口用来约束调用者行为。

“写一个 ArrayList 类的代理,其内部实现和 ArrayList 中完全相同的功能,并可以计算每个方法运行的时间。”这是一份考题上的题目,没有答案,来看下实现:

  1. package example;  
  2. import java.lang.reflect.InvocationHandler;  
  3. import java.lang.reflect.Method;  
  4. import java.lang.reflect.Proxy;  
  5. import java.util.ArrayList;  
  6. import java.util.List;  
  7. import java.util.concurrent.TimeUnit;  
  8. /**  
  9.  * -----------------------------------------  
  10.  * @描述  TODO  
  11.  * @作者  fancy  
  12.  * @邮箱  fancydeepin@yeah.net  
  13.  * @日期  2012-8-27 <p>  
  14.  * -----------------------------------------  
  15.  */ 
  16. public class ProxyApp {  
  17.  
  18.  
  19.     public static void main(String[] args){  
  20.           
  21.         //ArrayList代理,通过代理计算每个方法调用所需时间  
  22.         List<Integer> arrayListProxy = (List<Integer>)Proxy.newProxyInstance(  
  23.             ArrayList.class.getClassLoader(),   /*定义代理类的类加载器,用于创建代理对象,不一定必须是ArrayList,也可以是其他的类加载器*/ 
  24.             ArrayList.class.getInterfaces(),     /*代理类要实现的接口列表*/ 
  25.             new InvocationHandler() {            /*指派方法调用的调用处理程序,这里用了匿名内部类*/ 
  26.                   
  27.                 private ArrayList<Integer> target = new ArrayList<Integer>(); //目标对象(真正操作的对象)  
  28.                 /**  
  29.                  * <B>方法描述:</B>  
  30.                  * <p style="margin-left:20px;color:#A52A2A;">  
  31.                  * 在代理实例上处理方法调用并返回结果  
  32.                  * @param proxy     代理对象(注意不是目标对象)  
  33.                  * @param method  被代理的方法  
  34.                  * @param args         被代理的方法的参数集  
  35.                  * @return <span style="color: #008080;"> 返回方法调用结果 </span>  
  36.                  */ 
  37.                 @Override 
  38.                 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
  39.                       
  40.                     long beginTime = System.currentTimeMillis();  //开始时间  
  41.                     TimeUnit.MICROSECONDS.sleep(1);  
  42.                     Object obj = method.invoke(target, args);          //实际调用的方法,并接受方法的返回值  
  43.                     long endTime = System.currentTimeMillis();   //结束时间  
  44.                     System.out.println("[" + method.getName() + "] spend " + (endTime - beginTime) + " ms");  
  45.                     return obj;   //返回实际调用的方法的返回值  
  46.                       
  47.                 }  
  48.                   
  49.             }  
  50.         );  
  51.         arrayListProxy.add(2);  
  52.         arrayListProxy.add(4);  
  53.         System.out.println("--------- 迭代 ---------");  
  54.         for(int i : arrayListProxy){  
  55.             System.out.print(i + "\t");  
  56.         }  
  57.     }  

后台打印输出结果:

 [add] spend 2 ms
[add] spend 1 ms
--------- 迭代 ---------
[iterator] spend 1 ms
2 4

从代码上来看,用到了匿名内部类,这样一来,InvocationHandler 只能用一次,如果多个地方都需要用到这样一个相同的 InvocationHandler,可以将其抽象出来成为一个单独的类:

  1. package test;  
  2. import java.lang.reflect.InvocationHandler;  
  3. import java.lang.reflect.Method;  
  4. import java.util.concurrent.TimeUnit;  
  5. public class MyInvocationHandler implements InvocationHandler{  
  6.     private Object target; //目标对象      
  7.     public MyInvocationHandler(Object target){  
  8.         this.target = target;  
  9.     }  
  10.     @Override 
  11.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {          
  12.         long beginTime = System.currentTimeMillis();  
  13.         TimeUnit.MICROSECONDS.sleep(1);  
  14.         Object obj = method.invoke(target, args);  
  15.         long endTime = System.currentTimeMillis();  
  16.         System.out.println("[" + method.getName() + "] spend " + (endTime - beginTime) + " ms");  
  17.         return obj;      
  18.     }  

客户端调用改成:

  1. package example;  
  2. import java.lang.reflect.Proxy;  
  3. import java.util.ArrayList;  
  4. import java.util.List;  
  5. /**  
  6.  * -----------------------------------------  
  7.  * @描述  TODO  
  8.  * @作者  fancy  
  9.  * @邮箱  fancydeepin@yeah.net  
  10.  * @日期  2012-8-27 <p>  
  11.  * -----------------------------------------  
  12.  */ 
  13. public class ProxyApp {  
  14.     public static void main(String[] args){          
  15.         //ArrayList代理,通过代理计算每个方法调用所需时间  
  16.         List<Integer> arrayListProxy = (List<Integer>)Proxy.newProxyInstance(  
  17.             ArrayList.class.getClassLoader(),     /*定义代理类的类加载器,用于创建代理对象,不一定必须是ArrayList,也可以是其他的类加载器*/ 
  18.             ArrayList.class.getInterfaces(),       /*代理类要实现的接口列表*/ 
  19.             new MyInvocationHandler(new ArrayList<Integer>())         /*指派方法调用的调用处理程序,这里用了匿名内部类*/ 
  20.         );  
  21.         arrayListProxy.add(2);  
  22.         arrayListProxy.add(4);  
  23.         System.out.println("--------- 迭代 ---------");  
  24.         for(int i : arrayListProxy){  
  25.             System.out.print(i + "\t");  
  26.         }  
  27.     }  

从上面代码看来,客户端知道代理的实际目标对象,还知道怎么样去创建这样一个代理对象,如果想把这些信息全部对客户端隐藏起来,可以将这些代码挪到一个类中,将它们封装起来:

  1. package example;  
  2. import java.lang.reflect.InvocationHandler;  
  3. import java.lang.reflect.Method;  
  4. import java.lang.reflect.Proxy;  
  5. import java.util.ArrayList;  
  6. import java.util.List;  
  7. import java.util.concurrent.TimeUnit;  
  8. /**  
  9.  * -----------------------------------------  
  10.  * @描述  TODO  
  11.  * @作者  fancy  
  12.  * @邮箱  fancydeepin@yeah.net  
  13.  * @日期  2012-8-27 <p>  
  14.  * -----------------------------------------  
  15.  */ 
  16. public class ProxyUtil {  
  17.     public enum ArrayListProxy {  
  18.         PROXY;       
  19.         private Object target;    
  20.         ArrayListProxy(){  
  21.             this.target = new ArrayList<Object>();  
  22.         }  
  23.         public List getInstance(){  
  24.               
  25.             return (List)Proxy.newProxyInstance(ArrayList.class.getClassLoader(), ArrayList.class.getInterfaces(),  
  26.                     new InvocationHandler() {     
  27.                         @Override 
  28.                         public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
  29.                               
  30.                             long beginTime = System.currentTimeMillis();  
  31.                             TimeUnit.MICROSECONDS.sleep(1);  
  32.                             Object obj = method.invoke(target, args);  
  33.                             long endTime = System.currentTimeMillis();  
  34.                             System.out.println("[" + method.getName() + "] spend " + (endTime - beginTime) + " ms");  
  35.                             return obj;   
  36.                         }  
  37.                     });  
  38.         }  
  39.     }  

客户端调用改成:

  1. package example;  
  2. import java.util.List;  
  3. import example.ProxyUtil.ArrayListProxy;  
  4. /**  
  5.  * -----------------------------------------  
  6.  * @描述  TODO  
  7.  * @作者  fancy  
  8.  * @邮箱  fancydeepin@yeah.net  
  9.  * @日期  2012-8-27 <p>  
  10.  * -----------------------------------------  
  11.  */ 
  12. public class ProxyApp {  
  13.     public static void main(String[] args){  
  14.         List<Integer> arrayListProxy = ArrayListProxy.PROXY.getInstance();  
  15.         arrayListProxy.add(2);  
  16.         arrayListProxy.add(4);  
  17.         System.out.println("--------- 迭代 ---------");  
  18.         for(int i : arrayListProxy){  
  19.             System.out.print(i + "\t");  
  20.         }  
  21.     }  

上面代码中用到了枚举 enum,如果不想用枚举,就改用普通类来实现就行了。

原文链接:http://www.blogjava.net/fancydeepin/archive/2012/08/27/java_proxy.html

【编辑推荐】

  1. 近期面试经历总结及公司评价(上)
  2. 函数式编程是一个倒退
  3. 为什么Java程序占用的内存比实际分配的多
  4. Java 8 Lambda:模拟Mixin实现类多重继承
  5. Java项目经验——程序员成长的关键
责任编辑:张伟 来源: fancydeepin的博客
相关推荐

2011-04-06 11:41:25

Java动态代理

2017-10-12 14:56:11

2011-03-23 10:40:51

java代理模式

2015-09-22 11:09:47

Java 8动态代理

2023-12-06 08:23:44

代理模式设计模式

2021-07-06 06:39:22

Java静态代理动态代理

2017-05-11 21:30:01

Android动态代理ServiceHook

2023-02-24 07:42:30

Java动态代理

2011-11-17 14:32:45

Java静态代理动态代理

2015-09-28 15:59:00

Java动态代理机制

2010-12-02 13:36:48

Paros proxy网页程序漏洞

2015-09-24 08:55:14

Java动态代理扩展

2015-09-24 08:54:36

java动态代理

2010-04-21 09:26:54

Java动态代理

2012-02-08 10:12:19

Java反射

2020-04-27 07:28:00

Java反射动态代理

2020-12-28 07:47:35

动态代理AOP

2022-01-26 00:05:00

AOPRPC远程调用

2012-08-10 13:55:56

Java动态代理

2009-06-22 15:10:00

java 编程AOP
点赞
收藏

51CTO技术栈公众号