黑马程序员——Java中的动态代理

来源：互联网发布：aes256 加密java代码编辑：程序博客网时间：2024/05/08 15:35

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ---------------------

代理也是基本的设计模式之一，而代理通常也作为一种中介对象。

Java的动态代理的思想更向前迈进了一步，因为它可以动态地创建代理并动态地处理对所代理的方法的调用。在动态代理上所做的所有的调用都会被重定向到单一的调用处理器上，它的工作是揭示调用的类型并确定相应的对策。

下面就以一个创建动态代理类和查看的方法的代码来看看吧：

首先我们来定义下两个接口：

[java] view plaincopy
package cn.itcast.day3;  
  
import java.lang.reflect.Method;  
  
public interface Advice {  
     void beforeMethod(Method method);//定义之前的接口  
     void afterMethod(Method method);//定义之后的接口  
}  

接下来呢就是实现我们定义的接口：

[java] view plaincopy
package cn.itcast.day3;  
  
import java.lang.reflect.Method;  
  
public class MyAdvice implements Advice {  
long beginTime=0;  
    @Override  
    public void beforeMethod(Method method) {  
        // TODO Auto-generated method stub  
        System.out.println("开始学习啦！");  
        beginTime=System.currentTimeMillis();//定义开始时间（毫秒）  
    }  
  
    @Override  
    public void afterMethod(Method method) {  
        // TODO Auto-generated method stub        
        System.out.println("开始上班啦！");  
        long endTime=System.currentTimeMillis();//定义结束时间（毫秒）  
        System.out.println(method.getName()+"运行时间为"+(endTime-beginTime)+"毫秒");  
    }  
  
}  

下一步我们来调用实现接口的方法：

[java] view plaincopy
package cn.itcast.day3;  
  
import java.lang.reflect.Constructor;  
import java.lang.reflect.InvocationHandler;  
import java.lang.reflect.Method;  
import java.lang.reflect.Proxy;  
import java.util.ArrayList;  
import java.util.Collection;  
  
/*创建动态代理类及查看其方法*/  
public class ProxyTest {  
    public static void main(String[] args) throws Exception {  
        Class clazzProxy1=Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);  
        System.out.println(clazzProxy1.getName());  
        System.out.println("-------begin constructors lists--------");  
        Constructor[] constructors=clazzProxy1.getConstructors();  
        for(Constructor constructor : constructors){  
            String name=constructor.getName();  
            StringBuilder sBuilder=new StringBuilder(name);  
            sBuilder.append('(');  
            Class[] clazzParams=constructor.getParameterTypes();  
            //把构造函数里面的值取出来  
            for(Class clazzParam : clazzParams){  
                sBuilder.append(clazzParam.getName()).append(',');  
            }  
            if(clazzParams!=null&&clazzParams.length!=0)  
                sBuilder.deleteCharAt(sBuilder.length()-1);  
            sBuilder.append(')');  
            System.out.println(sBuilder.toString());  
        }  
        System.out.println("-------begin Method lists--------");  
        Method[] methods=clazzProxy1.getMethods();  
        for(Method method : methods){  
            String name=method.getName();  
            StringBuilder sBuilder=new StringBuilder(name);  
            sBuilder.append('(');  
            Class[] clazzParams=method.getParameterTypes();  
            //把构造函数里面的值取出来  
            for(Class clazzParam : clazzParams){  
                sBuilder.append(clazzParam.getName()).append(',');  
            }  
            if(clazzParams!=null&&clazzParams.length!=0)  
                sBuilder.deleteCharAt(sBuilder.length()-1);  
            sBuilder.append(')');  
            System.out.println(sBuilder.toString());  
        }  
        //创建实例对象,接收InvocationHandler对象  
        System.out.println("-------begin instance Object--------");  
        //Object obj=clazzProxy1.newInstance();如果这样写，运行时就会出错。所以要先得到构造函数  
         Constructor constructor=clazzProxy1.getConstructor(InvocationHandler.class);  
        //新建一个自己的实现类，实现InvocationHandler接口  
        class MyInvocationHandler implements InvocationHandler{  
  
            @Override  
            public Object invoke(Object proxy, Method method, Object[] args)  
                    throws Throwable {  
                // TODO Auto-generated method stub  
                return null;  
            }  
        }  
            Collection proxy1=(Collection)constructor.newInstance(new MyInvocationHandler());  
            System.out.println(proxy1);  
            proxy1.clear();//调用无返回值的方法就会成功  
            //proxy1.size();//这里会报空指针异常,size()方法有返回值  
            Collection proxy2=(Collection)constructor.newInstance(new InvocationHandler(){  
                @Override  
                public Object invoke(Object proxy, Method method, Object[] args)  
                        throws Throwable {  
                    return null;  
                }                 
            });  
            final ArrayList target=new ArrayList();  
            Collection proxy3 =(Collection)getProxy(target,new MyAdvice());  
            proxy3.add("a");  
            proxy3.add("b");  
            proxy3.add("c");  
            System.out.println(proxy3.size());  
          
    }  
  
    private static Object getProxy(final Object target,final Advice advice) {  
        Object proxy3=Proxy.newProxyInstance(  
                target.getClass().getClassLoader(),  
                //new Class[]{Collection.class},  
                target.getClass().getInterfaces(),  
                new InvocationHandler() {                         
                    public Object invoke(Object proxy, Method method, Object[] args)  
                            throws Throwable {  
                        //ArrayList target=new ArrayList();如果这句话在invoke方法内，就会输出0，无法获取数量  
                        /*long beginTime=System.currentTimeMillis();//定义开始时间（毫秒） 
                        Object reVal=method.invoke(target, args); 
                        long endTime=System.currentTimeMillis();//定义结束时间（毫秒） 
                        System.out.println(method.getName()+"运行时间为"+(endTime-beginTime)+"毫秒"); 
                        return reVal;*/  
                          
                        advice.beforeMethod(method);  
                        Object reVal=method.invoke(target, args);  
                        advice.afterMethod(method);                           
                        return reVal;  
                    }  
  
                      
                }  
                );  
        return proxy3;  
    }  
}  

上面的代码中若创建一个动态代理的类，就要实现InvocationHandler接口。

因为动态代理类可以将所有调用重定向到处理器，所以通常会向调用处理器的构造器传递给一个“实际”对象的引用，使得调用处理器在执行中介任务时，可以将请求转发。

invoke()方法中传递进来代理对象，用于以防止你需要区分请求的来源。当然也可以传递其他的参数来过滤某些方法的调用。

----------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------详细请查看：www.itheima.com

0 0