当前位置:编程学习 > JAVA >>

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 <p>
 * -----------------------------------------
 */  www.zzzyk.com
public class ProxyApp {


    public static void main(String[] args){
       
        //ArrayList代理,通过代理计算每个方法调用所需时间
        List<Integer> arrayListProxy = (List<Integer>)Proxy.newProxyInstance(
            ArrayList.class.getClassLoader(),   /*定义代理类的类加载器,用于创建代理对象,不一定必须是ArrayList,也可以是其他的类加载器*/
            ArrayList.class.getInte易做图ces(),     /*代理类要实现的接口列表*/
            new InvocationHandler() {            /*指派方法调用的调用处理程序,这里用了匿名内部类*/
               
                private ArrayList<Integer> target = new ArrayList<Integer>(); //目标对象(真正操作的对象)
                /**
                 * <B>方法描述:</B>
                 * <p style="margin-left:20px;color:#A52A2A;">
                 * 在代理实例上处理方法调用并返回结果
                 * @param proxy     代理对象(注意不是目标对象)
                 * @param method  被代理的方法
                 * @param args         被代理的方法的参数集
                 * @return <span style="color: #008080;"> 返回方法调用结果 </span>
                 */
                @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");<

补充:软件开发 , Java ,
CopyRight © 2022 站长资源库 编程知识问答 zzzyk.com All Rights Reserved
部分文章来自网络,