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

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

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();
    }
}
   
   

运行结果为：