Java动态代理

最新推荐文章于 2024-07-08 19:58:37 发布

快乐的燕子会飞

最新推荐文章于 2024-07-08 19:58:37 发布

阅读量1k

点赞数

分类专栏： java 文章标签： Java动态代理

本文链接：https://blog.csdn.net/jzhf2012/article/details/8534028

版权

java 专栏收录该内容

36 篇文章 5 订阅

订阅专栏

没事的时候翻看lang.reflect包下的代码，发现有两部分内容:涉及反射和动态代理。
很多地方都可以看到动态代理的影子，只是一直没仔细看下。

在学习之前，先提出几个问题，带着问题来看代码:

1.什么是动态代理?
2.为什么使用动态代理?
3.使用它有哪些好处?

4.哪些地方需要动态代理?

熟悉设计模式的人对于代理模式可能都不陌生。代理对象和被代理对象一般实现相同的接口，调用者与代理对象进行交互。代理的存在对于调用者来说是透明的，调用者看到的只是接口。代理对象则可以封装一些内部的处理逻辑，如访问控制、远程通信、日志、缓存等。比如一个对象访问代理就可以在普通的访问机制之上添加缓存的支持。这种模式在RMI和EJB中都得到了广泛的使用。传统的代理模式的实现，需要在源代码中添加一些附加的类。这些类一般是手写或是通过工具来自动生成。JDK 5引入的动态代理机制，允许开发人员在运行时刻动态的创建出代理类及其对象。在运行时刻，可以动态创建出一个实现了多个接口的代理类。每个代理类的对象都会关联一个表示内部处理逻辑的InvocationHandler接口的实现。当使用者调用了代理对象所代理的接口中的方法的时候，这个调用的信息会被传递给InvocationHandler的invoke方法。在 invoke方法的参数中可以获取到代理对象、方法对应的Method对象和调用的实际参数。invoke方法的返回值被返回给使用者。这种做法实际上相当于对方法调用进行了拦截。熟悉AOP的人对这种使用模式应该不陌生。但是这种方式不需要依赖AspectJ等AOP框架。

动态代理可以提供对另一个对象的访问，同时隐藏实际对象的具体事实，代理对象对客户隐藏了实际对象。动态代理可以对请求进行其他的一些处理，在不允许直接访问某些类，

或需要对访问做一些特殊处理等，这时候可以考虑使用代理。目前 Java 开发包中提供了对动态代理的支持，但现在只支持对接口的实现。

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

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

package proxy;
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;

public class ProxyApp {

	 public static void main(String[] args){
	        
	        //ArrayList代理,通过代理计算每个方法调用所需时间
	        List<Integer> arrayListProxy = (List<Integer>)Proxy.newProxyInstance(
	            ArrayList.class.getClassLoader(),   /*定义代理类的类加载器,用于创建代理对象,不一定必须是ArrayList,也可以是其他的类加载器*/
	            ArrayList.class.getInterfaces(),     /*代理类要实现的接口列表*/
	            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>
	                 */
	                
	                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");
	        }
	    }
}

从代码上来看，用到了匿名内部类，这样一来，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;
/**
 * -----------------------------------------
 * -----------------------------------------
 */
public class ProxyApp {


    public static void main(String[] args){
        
        //ArrayList代理,通过代理计算每个方法调用所需时间
        List<Integer> arrayListProxy = (List<Integer>)Proxy.newProxyInstance(
            ArrayList.class.getClassLoader(),     /*定义代理类的类加载器,用于创建代理对象,不一定必须是ArrayList,也可以是其他的类加载器*/
            ArrayList.class.getInterfaces(),       /*代理类要实现的接口列表*/
            new MyInvocationHandler(new ArrayList<Integer>())         /*指派方法调用的调用处理程序,这里用了匿名内部类*/
        );
        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;

/**
 * -----------------------------------------
 * -----------------------------------------
 */
public class ProxyUtil {

    public enum ArrayListProxy {
        PROXY;
        
        private Object target;
        
        ArrayListProxy(){
            this.target = new ArrayList<Object>();
        }
        
        public List getInstance(){
            
            return (List)Proxy.newProxyInstance(ArrayList.class.getClassLoader(), ArrayList.class.getInterfaces(),
                    new InvocationHandler() {
                        
                        @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.util.List;
import example.ProxyUtil.ArrayListProxy;

/**
 * -----------------------------------------
------------------
 */
public class ProxyApp {


    public static void main(String[] args){
        
        List<Integer> arrayListProxy = ArrayListProxy.PROXY.getInstance();
        arrayListProxy.add(2);
        arrayListProxy.add(4);
        System.out.println("--------- 迭代 ---------");
        for(int i : arrayListProxy){
            System.out.print(i + "\t");
        }
        
    }
}

上面代码中用到了枚举 enum，如果不想用枚举，就改用普通类来实现就行了。

总结：

回答以下问题：

1.什么是动态代理?

答：Java动态代理类位于Java.lang.reflect包下，一般主要涉及到以下两个类：

一、Interface InvocationHandler：该接口中仅定义了一个方法Object：invoke(Object obj,Method method,J2EEjava语言JDK1.4APIjavalangObject.html">Object[] args）。在实际使用时，第一个参数obj一般是指代理类，method是被代理的方法，如上例中的request(），args为该方法的参数数组。这个抽象方法在代理类中动态实现。

二、Proxy：该类即为动态代理类，作用类似于上例中的ProxySubject，其中主要包含以下内容：

Protected Proxy(InvocationHandler h）：构造函数，估计用于给内部的h赋值。

Static Class getProxyClass (ClassLoader loader,Class[] interfaces）：获得一个代理类，其中loader是类装载器，interfaces是真实类所拥有的全部接口的数组。

Static Object newProxyInstance(Clas sLoader loader,Class[] interfaces,InvocationHandler h）：返回代理类的一个实例，返回后的代理类可以当作被代理类使用（可使用被代理类的在Subject接口中声明过的方法）。

所谓Dynamic Proxy是这样一种class：它是在运行时生成的class，在生成它时你必须提供一组interface给它，然后该class就宣称它实现了这些 interface。你当然可以把该class的实例当作这些interface中的任何一个来用。当然啦，这个Dynamic Proxy其实就是一个Proxy，它不会替你作实质性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工作。

2.为什么使用动态代理?

动态代理可以提供对另一个对象的访问，同时隐藏实际对象的具体事实，代理对象对客户隐藏了实际对象。动态代理可以对请求进行其他的一些处理，在不允许直接访问某些类，