Java动态代理（Proxy）

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

十年建站经验，成都做网站、成都网站制作客户的见证与正确选择。成都创新互联公司提供完善的营销型网页建站明细报价表。后期开发更加便捷高效，我们致力于追求更美、更快、更规范。

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

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

 
 
 
  
  
  package example;  
  
  
  import java.lang.reflect.InvocationHandler;  
  
  
  import java.lang.reflect.Method;  
  
  
  import java.lang.reflect.Proxy;  
  
  
  import java.util.ArrayList;  
  
  
  import java.util.List;  
  
  
  import java.util.concurrent.TimeUnit;  
  
  
  /**  
  
  
   * -----------------------------------------  
  
  
   * @描述  TODO  
  
  
   * @作者  fancy  
  
  
   * @邮箱  fancydeepin@yeah.net  
  
  
   * @日期  2012-8-27   
  
  
   * -----------------------------------------  
  
  
   */ 
  
  
  public class ProxyApp {  
  
  
   
  
  
   
  
  
      public static void main(String[] args){  
  
  
            
  
  
          //ArrayList代理,通过代理计算每个方法调用所需时间  
  
  
          List arrayListProxy = (List)Proxy.newProxyInstance(  
  
  
              ArrayList.class.getClassLoader(),   /*定义代理类的类加载器,用于创建代理对象,不一定必须是ArrayList,也可以是其他的类加载器*/ 
  
  
              ArrayList.class.getInterfaces(),     /*代理类要实现的接口列表*/ 
  
  
              new InvocationHandler() {            /*指派方法调用的调用处理程序,这里用了匿名内部类*/ 
  
  
                    
  
  
                  private ArrayList target = new ArrayList(); //目标对象(真正操作的对象)  
  
  
                  /**  
  
  
                   * 方法描述：  
  
  
                   *   
  
  
                   * 在代理实例上处理方法调用并返回结果  
  
  
                   * @param proxy     代理对象(注意不是目标对象)  
  
  
                   * @param method  被代理的方法  
  
  
                   * @param args         被代理的方法的参数集  
  
  
                   * @return  返回方法调用结果   
  
  
                   */ 
  
  
                  @Override 
  
  
                  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
  
  
                        
  
  
                      long beginTime = System.currentTimeMillis();  //开始时间  
  
  
                      TimeUnit.MICROSECONDS.sleep(1);  
  
  
                      Object obj = method.invoke(target, args);          //实际调用的方法,并接受方法的返回值  
  
  
                      long endTime = System.currentTimeMillis();   //结束时间  
  
  
                      System.out.println("[" + method.getName() + "] spend " + (endTime - beginTime) + " ms");  
  
  
                      return obj;   //返回实际调用的方法的返回值  
  
  
                        
  
  
                  }  
  
  
                    
  
  
              }  
  
  
          );  
  
  
          arrayListProxy.add(2);  
  
  
          arrayListProxy.add(4);  
  
  
          System.out.println("--------- 迭代 ---------");  
  
  
          for(int i : arrayListProxy){  
  
  
              System.out.print(i + "\t");  
  
  
          }  
  
  
      }  
  
  
  }

后台打印输出结果：

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

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

 
 
 
  
  
  package test;  
  
  
  import java.lang.reflect.InvocationHandler;  
  
  
  import java.lang.reflect.Method;  
  
  
  import java.util.concurrent.TimeUnit;  
  
  
  public class MyInvocationHandler implements InvocationHandler{  
  
  
      private Object target; //目标对象      
  
  
      public MyInvocationHandler(Object target){  
  
  
          this.target = target;  
  
  
      }  
  
  
      @Override 
  
  
      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {          
  
  
          long beginTime = System.currentTimeMillis();  
  
  
          TimeUnit.MICROSECONDS.sleep(1);  
  
  
          Object obj = method.invoke(target, args);  
  
  
          long endTime = System.currentTimeMillis();  
  
  
          System.out.println("[" + method.getName() + "] spend " + (endTime - beginTime) + " ms");  
  
  
          return obj;      
  
  
      }  
  
  
  }

客户端调用改成：

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

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

 
 
 
  
  
  package example;  
  
  
  import java.lang.reflect.InvocationHandler;  
  
  
  import java.lang.reflect.Method;  
  
  
  import java.lang.reflect.Proxy;  
  
  
  import java.util.ArrayList;  
  
  
  import java.util.List;  
  
  
  import java.util.concurrent.TimeUnit;  
  
  
  /**  
  
  
   * -----------------------------------------  
  
  
   * @描述  TODO  
  
  
   * @作者  fancy  
  
  
   * @邮箱  fancydeepin@yeah.net  
  
  
   * @日期  2012-8-27   
  
  
   * -----------------------------------------  
  
  
   */ 
  
  
  public class ProxyUtil {  
  
  
      public enum ArrayListProxy {  
  
  
          PROXY;       
  
  
          private Object target;    
  
  
          ArrayListProxy(){  
  
  
              this.target = new ArrayList