Java动态代理一——动态类Proxy的使用

原创：http://www.cnblogs.com/linjiqin/archive/2011/02/18/1957600.html

1.什么是动态代理?

答：动态代理可以提供对另一个对象的访问，同时隐藏实际对象的具体事实。代理一般会实现它所表示的实际对象的接口。代理可以访问实际对象，但是延迟实现实际对象的部分功能，实际对象实现系统的实际功能，代理对象对客户隐藏了实际对象。客户不知道它是与代理打交道还是与实际对象打交道。
2.为什么使用动态代理?

答：因为动态代理可以对请求进行任何处理

3.使用它有哪些好处?

答：因为动态代理可以对请求进行任何处理
4.哪些地方需要动态代理?

答：不允许直接访问某些类；对访问要做特殊处理等

 

目前Java开发包中包含了对动态代理的支持，但是其实现只支持对接口的的实现。 其实现主要通过java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口。 

Proxy类主要用来获取动态代理对象，InvocationHandler接口用来约束调用者实现

以下为模拟案例，通过动态代理实现在方法调用前后向控制台输出两句字符串

目录结构

<br/>

定义一个HelloWorld接口

  
  

   
    1 
   
   package
   
    com.ljq.test;

   
    2 
   
   

   
    3 
   
    
   
   /**
   
   

   
    4 
   
    * 定义一个HelloWorld接口

   
    5 
   
    * 

   
    6 
   
    * 
   
   @author
   
    jiqinlin

   
    7 
   
    *

   
    8 
   
    
   
   */
   
   

   
    9 
   
    
   
   public
   
    
   
   interface
   
    HelloWorld {

   
   10 
   
       
   
   public
   
    
   
   void
   
    sayHelloWorld();

   
   11 
   
   }
  
  

<br/>

类HelloWorldImpl是HelloWorld接口的实现

  
  

   
    1 
   
   package
   
    com.ljq.test;

   
    2 
   
   

   
    3 
   
    
   
   /**
   
   

   
    4 
   
    * 类HelloWorldImpl是HelloWorld接口的实现

   
    5 
   
    * 

   
    6 
   
    * 
   
   @author
   
    jiqinlin

   
    7 
   
    *

   
    8 
   
    
   
   */
   
   

   
    9 
   
    
   
   public
   
    
   
   class
   
    HelloWorldImpl 
   
   implements
   
    HelloWorld{

   
   10 
   
   

   
   11 
   
       
   
   public
   
    
   
   void
   
    sayHelloWorld() {

   
   12 
   
           System.out.println(
   
   "
   
   HelloWorld!
   
   "
   
   );

   
   13 
   
       }

   
   14 
   
   

   
   15 
   
   }
  
  

HelloWorldHandler是 InvocationHandler接口实现

  
  

   
    1 
   
   package
   
    com.ljq.test;

   
    2 
   
   

   
    3 
   
    
   
   import
   
    java.lang.reflect.InvocationHandler;

   
    4 
   
    
   
   import
   
    java.lang.reflect.Method;

   
    5 
   
   

   
    6 
   
    
   
   /**
   
   

   
    7 
   
    * 实现在方法调用前后向控制台输出两句字符串

   
    8 
   
    * 

   
    9 
   
    * 
   
   @author
   
    jiqinlin

   
   10 
   
    *

   
   11 
   
    
   
   */
   
   

   
   12 
   
    
   
   public
   
    
   
   class
   
    HelloWorldHandler 
   
   implements
   
    InvocationHandler{

   
   13 
   
       
   
   //
   
   要代理的原始对象
   
   

   
   14 
   
    
   
       
   
   private
   
    Object obj;

   
   15 
   
       

   
   16 
   
       
   
   public
   
    HelloWorldHandler(Object obj) {

   
   17 
   
           
   
   super
   
   ();

   
   18 
   
           
   
   this
   
   .obj 
   
   =
   
    obj;

   
   19 
   
       }

   
   20 
   
   

   
   21 
   
       
   
   /**
   
   

   
   22 
   
        * 在代理实例上处理方法调用并返回结果

   
   23 
   
        * 

   
   24 
   
        * 
   
   @param
   
    proxy 代理类

   
   25 
   
        * 
   
   @param
   
    method 被代理的方法

   
   26 
   
        * 
   
   @param
   
    args 该方法的参数数组

   
   27 
   
        
   
   */
   
   

   
   28 
   
       
   
   public
   
    Object invoke(Object proxy, Method method, Object[] args) 
   
   throws
   
    Throwable {

   
   29 
   
           Object result 
   
   =
   
    
   
   null
   
   ;

   
   30 
   
           
   
   //
   
   调用之前
   
   

   
   31 
   
    
   
           doBefore();

   
   32 
   
           
   
   //
   
   调用原始对象的方法
   
   

   
   33 
   
   
   
           result
   
   =
   
   method.invoke(obj, args);

   
   34 
   
           
   
   //
   
   调用之后
   
   

   
   35 
   
   
   
           doAfter();

   
   36 
   
           
   
   return
   
    result;

   
   37 
   
       }

   
   38 
   
       

   
   39 
   
       
   
   private
   
    
   
   void
   
    doBefore(){

   
   40 
   
           System.out.println(
   
   "
   
   before method invoke
   
   "
   
   );

   
   41 
   
       }

   
   42 
   
       

   
   43 
   
       
   
   private
   
    
   
   void
   
    doAfter(){

   
   44 
   
           System.out.println(
   
   "
   
   after method invoke
   
   "
   
   );

   
   45 
   
       }

   
   46 
   
       

   
   47 
   
   }
  
  

测试类

  
  

   
   package com.ljq.test;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;



   
   public
   
    
   
   class
   
    HelloWorldTest {

    
   
   public
   
    
   
   static
   
    
   
   void
   
    main(String[] args) {
        HelloWorld helloWorld
   
   =
   
   new
   
    HelloWorldImpl();
        InvocationHandler handler
   
   =
   
   new
   
    HelloWorldHandler(helloWorld);
        
        
   
   //
   
   创建动态代理对象
   
   

   
           HelloWorld proxy
   
   =
   
   (HelloWorld)Proxy.newProxyInstance(
                helloWorld.getClass().getClassLoader(), 
                helloWorld.getClass().getInterfaces(), 
                handler);
        proxy.sayHelloWorld();
    }
}
  
  

运行结果为：