Java动态代理的实现

来源：互联网发布：外国网友评论中国网络编辑：程序博客网时间：2024/06/05 05:12

概念

代理模式
代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。
按照代理的创建时期，代理类可以分为两种。
静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。
动态代理：在程序运行时，运用反射机制动态创建而成。

动态代理作为代理模式的一种扩展形式，广泛应用于框架（尤其是基于AOP的框架）的设计与开发，本文将通过实例来讲解Java动态代理的实现过程。

通常情况下，代理模式中的每一个代理类在编译之后都会生成一个class文件，代理类所实现的接口和所代理的方法都被固定，这种代理被称之为静态代理(Static Proxy)。那么有没有一种机制能够让系统在运行时动态创建代理类？答案就是本文将要介绍的动态代理(Dynamic Proxy)。动态代理是一种较为高级的代理模式，它在事务管理、AOP（面向方面编程）等领域都发挥了重要的作用。

在传统的代理模式中，客户端通过Proxy类调用RealSubject类的request()方法，同时还可以在代理类中封装其他方法（如preRequest()和postRequest()等）。如果按照这种方法使用代理模式，那么代理类和真实主题类都应该是事先已经存在的，代理类的接口和所代理方法都已明确指定，如果需要为不同的真实主题类提供代理类或者代理一个真实主题类中的不同方法，都需要增加新的代理类，这将导致系统中的类个数急剧增加，因此需要想办法减少系统中类的个数。动态代理可以让系统能够根据实际需要来动态创建代理类，让同一个代理类能够代理多个不同的真实主题类而且可以代理不同的方法。

从JDK 1.3开始，Java语言提供了对动态代理的支持，Java语言实现动态代理时需要用到位于java.lang.reflect包中的一些类，现简要说明如下：

(1) Proxy类

Proxy类提供了用于创建动态代理类和实例对象的方法，它是所创建的动态代理类的父类，它最常用的方法如下：

public static Class<?> getProxyClass(ClassLoader loader,Class<?>... interfaces)：该方法用于返回一个Class类型的代理类，在参数中需要提供类加载器并需要指定代理的接口数组（与真实主题类的接口列表一致）。
public static Object newProxyInstance(ClassLoader loader, Class<?>[]interfaces, InvocationHandler h)：该方法用于返回一个动态创建的代理类的实例，方法中第一个参数loader表示代理类的类加载器，第二个参数interfaces表示代理类所实现的接口列表（与真实主题类的接口列表一致），第三个参数h表示所指派的调用处理程序类。

(2) InvocationHandler接口

InvocationHandler接口是代理处理程序类的实现接口，该接口作为代理实例的调用处理者的公共父类，每一个代理类的实例都可以提供一个相关的具体调用处理者（InvocationHandler接口的子类）。在该接口中声明了如下方法：

public Object invoke(Objectproxy, Method method, Object[] args)：该方法用于处理对代理类实例的方法调用并返回相应的结果，当一个代理实例中的业务方法被调用时将自动调用该方法。invoke()方法包含三个参数，其中第一个参数proxy表示代理类的实例，第二个参数method表示需要代理的方法，第三个参数args表示代理方法的参数数组。

动态代理类需要在运行时指定所代理真实主题类的接口，客户端在调用动态代理对象的方法时，调用请求会将请求自动转发给InvocationHandler对象的invoke()方法，由invoke()方法来实现对请求的统一处理。

下面通过一个简单实例来学习如何使用动态代理模式：

Sunny软件公司欲为公司OA系统数据访问层DAO增加方法调用日志，记录每一个方法被调用的时间和调用结果，现使用动态代理进行设计和实现。

[java] view plain copy
 
import java.lang.reflect.Proxy;    
import java.lang.reflect.InvocationHandler;    
import java.lang.reflect.InvocationTargetException;    
import java.lang.reflect.Method;    
import java.util.Calendar;    
import java.util.GregorianCalendar;    
    
//抽象UserDAO：抽象主题角色    
interface AbstractUserDAO {    
    public Boolean findUserById(String userId);    
}    
    
//抽象DocumentDAO：抽象主题角色    
interface AbstractDocumentDAO {    
    public Boolean deleteDocumentById(String documentId);    
}    
    
//具体UserDAO类：真实主题角色    
class UserDAO implements AbstractUserDAO {    
    public Boolean findUserById(String userId) {    
        if (userId.equalsIgnoreCase("张无忌")) {    
            System.out.println("查询ID为" + userId + "的用户信息成功！");    
            return true;    
        }    
        else {    
            System.out.println("查询ID为" + userId + "的用户信息失败！");    
            return false;    
        }    
    }    
}    
    
//具体DocumentDAO类：真实主题角色    
class DocumentDAO implements AbstractDocumentDAO {    
    public Boolean deleteDocumentById(String documentId) {    
        if (documentId.equalsIgnoreCase("D001")) {    
            System.out.println("删除ID为" + documentId + "的文档信息成功！");    
            return true;    
        }    
        else {    
            System.out.println("删除ID为" + documentId + "的文档信息失败！");    
            return false;    
        }    
    }    
}    
    
//自定义请求处理程序类    
class DAOLogHandler implements InvocationHandler {    
    private Calendar calendar;    
    private Object object;    
        
    public DAOLogHandler() {        
    }    
        
    //自定义有参构造函数，用于注入一个需要提供代理的真实主题对象    
    public DAOLogHandler(Object object) {    
        this.object = object;    
    }    
        
    //实现invoke()方法，调用在真实主题类中定义的方法    
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {    
        beforeInvoke();    
        Object result = method.invoke(object, args); //转发调用    
        afterInvoke();    
        return null;    
    }    
    
    //记录方法调用时间    
    public void beforeInvoke(){    
        calendar = new GregorianCalendar();    
        int hour = calendar.get(Calendar.HOUR_OF_DAY);    
        int minute = calendar.get(Calendar.MINUTE);    
        int second = calendar.get(Calendar.SECOND);    
        String time = hour + ":" + minute + ":" + second;    
        System.out.println("调用时间：" + time);    
    }    
    
    public void afterInvoke(){    
        System.out.println("方法调用结束！" );    
    }    
}    

编写如下客户端测试代码：

[java] view plain copy
 
class Client {    
    public static void main(String args[]) {    
        InvocationHandler handler = null;    
            
        AbstractUserDAO userDAO = new UserDAO();    
        handler = new DAOLogHandler(userDAO);    
        AbstractUserDAO proxy = null;    
        //动态创建代理对象，用于代理一个AbstractUserDAO类型的真实主题对象    
        proxy = (AbstractUserDAO)Proxy.newProxyInstance(AbstractUserDAO. class.getClassLoader(), new Class[]{AbstractUserDAO.class}, handler);    
        proxy.findUserById("张无忌"); //调用代理对象的业务方法    
        
        System.out.println("------------------------------");    
        
        AbstractDocumentDAO docDAO = new DocumentDAO();    
        handler = new DAOLogHandler(docDAO);    
        AbstractDocumentDAO proxy_new = null;    
//动态创建代理对象，用于代理一个AbstractDocumentDAO类型的真实主题对象    
        proxy_new = (AbstractDocumentDAO)Proxy.newProxyInstance(Abstract DocumentDAO.class.getClassLoader(), new Class[]{AbstractDocumentDAO.class}, handler);    
        proxy_new.deleteDocumentById("D002"); //调用代理对象的业务方法    
    }     
}    

编译并运行程序，输出结果如下：

[java] view plain copy
 
调用时间：13:47:14  
查询ID为张无忌的用户信息成功！  
方法调用结束！  
------------------------------  
调用时间：13:47:14  
删除ID为D002的文档信息失败！  
方法调用结束！  

通过使用动态代理，我们可以实现对多个真实主题类的统一代理和集中控制。

注：JDK中提供的动态代理只能代理一个或多个接口，如果需要动态代理具体类或抽象类，可以使用CGLib(Code Generation Library)等工具，CGLib是一个功能较为强大、性能和质量也较好的代码生成包，在许多AOP框架中都得以广泛应用，大家可以自行查阅相关资料来学习CGLib。

动态代理底层实现原理：

从上面可以看出，JDK的动态代理使用起来非常简单，但是只知道如何使用是不够的，知其然，还需知其所以然。所以要想搞清楚它的实现，那么得从源码入手。这里的源码是1.7.0_79。首先来看看它是如何生成代理类的：

[java] view plain copy
 
public static Object newProxyInstance(ClassLoader loader,    
                                      Class<?>[] interfaces,    
                                      InvocationHandler h)    
    throws IllegalArgumentException {    
    if (h == null) {    
        throw new NullPointerException();    
    }    
    
    final Class<?>[] intfs = interfaces.clone();    
    final SecurityManager sm = System.getSecurityManager();    
    if (sm != null) {    
        checkProxyAccess(Reflection.getCallerClass(), loader, intfs);    
    }    
    // 这里是生成class的地方    
    Class<?> cl = getProxyClass0(loader, intfs);    
    // 使用我们实现的InvocationHandler作为参数调用构造方法来获得代理类的实例    
    try {    
        final Constructor<?> cons = cl.getConstructor(constructorParams);    
        final InvocationHandler ih = h;    
        if (sm != null && ProxyAccessHelper.needsNewInstanceCheck(cl)) {    
            return AccessController.doPrivileged(new PrivilegedAction<Object>() {    
                public Object run() {    
                    return newInstance(cons, ih);    
                }    
            });    
        } else {    
            return newInstance(cons, ih);    
        }    
    } catch (NoSuchMethodException e) {    
        throw new InternalError(e.toString());    
    }    
}    

其中newInstance只是调用Constructor.newInstance来构造相应的代理类实例，这里重点是看getProxyClass0这个方法的实现：

[java] view plain copy
 
private static Class<?> getProxyClass0(ClassLoader loader,    
                                       Class<?>... interfaces) {    
    // 代理的接口数量不能超过65535（没有这种变态吧）    
    if (interfaces.length > 65535) {    
        throw new IllegalArgumentException("interface limit exceeded");    
    }    
    // JDK对代理进行了缓存，如果已经存在相应的代理类，则直接返回，否则才会通过ProxyClassFactory来创建代理    
    return proxyClassCache.get(loader, interfaces);    
}    

其中代理缓存是使用WeakCache实现的，如下：

[java] view plain copy
 
private static final WeakCache<ClassLoader, Class<?>[], Class<?>>    
    proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());   

我查看了底层代码，其实是用weakHashMap来实现缓存的。

[java] view plain copy
 
private static Map proxyClasses =  
ollections.synchronizedMap(new WeakHashMap());  

具体的缓存逻辑这里暂不关心，只需要关心ProxyClassFactory是如何生成代理类的，ProxyClassFactory是Proxy的一个静态内部类，实现了WeakCache的内部接口BiFunction的apply方法：

[java] view plain copy
 
private static final class ProxyClassFactory    
    implements BiFunction<ClassLoader, Class<?>[], Class<?>> {    
    // 所有代理类名字的前缀    
    private static final String proxyClassNamePrefix = "$Proxy";    
    
    // 用于生成代理类名字的计数器    
    private static final AtomicLong nextUniqueNumber = new AtomicLong();    
    
    @Override    
    public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {    
        // 省略验证代理接口的代码……    
    
        String proxyPkg = null;     // 生成的代理类的包名    
        // 对于非公共接口，代理类的包名与接口的相同    
        for (Class<?> intf : interfaces) {    
            int flags = intf.getModifiers();    
            if (!Modifier.isPublic(flags)) {    
                String name = intf.getName();    
                int n = name.lastIndexOf('.');    
                String pkg = ((n == -1) ? "" : name.substring(0, n + 1));    
                if (proxyPkg == null) {    
                    proxyPkg = pkg;    
                } else if (!pkg.equals(proxyPkg)) {    
                    throw new IllegalArgumentException(    
                        "non-public interfaces from different packages");    
                }    
            }    
        }    
    
        // 对于公共接口的包名，默认为com.sun.proxy    
        if (proxyPkg == null) {    
            proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";    
        }    
    
        // 获取计数    
        long num = nextUniqueNumber.getAndIncrement();    
        // 默认情况下，代理类的完全限定名为：com.sun.proxy.$Proxy0，com.sun.proxy.$Proxy1……依次递增    
        String proxyName = proxyPkg + proxyClassNamePrefix + num;    
    
        // 这里才是真正的生成代理类的字节码的地方    
        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(    
            proxyName, interfaces);    
        try {    
            // 根据二进制字节码返回相应的Class实例    
            return defineClass0(loader, proxyName,    
                                proxyClassFile, 0, proxyClassFile.length);    
        } catch (ClassFormatError e) {    
            throw new IllegalArgumentException(e.toString());    
        }    
    }    
}    

ProxyGenerator是sun.misc包中的类，它没有开源，但是可以反编译来一探究竟：

[java] view plain copy
 
public static byte[] generateProxyClass(final String var0, Class[] var1) {    
    ProxyGenerator var2 = new ProxyGenerator(var0, var1);    
    final byte[] var3 = var2.generateClassFile();    
    // 这里根据参数配置，决定是否把生成的字节码（.class文件）保存到本地磁盘，我们可以通过把相应的class文件保存到本地，再反编译来看看具体的实现，这样更直观    
    if(saveGeneratedFiles) {    
        AccessController.doPrivileged(new PrivilegedAction() {    
            public Void run() {    
                try {    
                    FileOutputStream var1 = new FileOutputStream(ProxyGenerator.dotToSlash(var0) + ".class");    
                    var1.write(var3);    
                    var1.close();    
                    return null;    
                } catch (IOException var2) {    
                    throw new InternalError("I/O exception saving generated file: " + var2);    
                }    
            }    
        });    
    }    
    return var3;    
}    

saveGeneratedFiles这个属性的值从哪里来呢：

[java] view plain copy
 
private static final boolean saveGeneratedFiles = ((Boolean)AccessController.doPrivileged(new GetBooleanAction("sun.misc.ProxyGenerator.saveGeneratedFiles"))).booleanValue();    

GetBooleanAction实际上是调用Boolean.getBoolean(propName)来获得的，而Boolean.getBoolean(propName)调用了System.getProperty(name)，所以我们可以设置sun.misc.ProxyGenerator.saveGeneratedFiles这个系统属性为true来把生成的class保存到本地文件来查看。

这里要注意，当把这个属性设置为true时，生成的class文件及其所在的路径都需要提前创建，否则会抛出FileNotFoundException异常。如：

[java] view plain copy
 
Exception in thread "main" java.lang.InternalError: I/O exception saving generated file: java.io.FileNotFoundException: com/sun/proxy/$Proxy0.class (No such file or directory)    
at sun.misc.ProxyGenerator$1.run(ProxyGenerator.java:336)    
at sun.misc.ProxyGenerator$1.run(ProxyGenerator.java:327)    
at java.security.AccessController.doPrivileged(Native Method)    
at sun.misc.ProxyGenerator.generateProxyClass(ProxyGenerator.java:326)    
at java.lang.reflect.Proxy$ProxyClassFactory.apply(Proxy.java:672)    
at java.lang.reflect.Proxy$ProxyClassFactory.apply(Proxy.java:592)    
at java.lang.reflect.WeakCache$Factory.get(WeakCache.java:244)    
at java.lang.reflect.WeakCache.get(WeakCache.java:141)    
at java.lang.reflect.Proxy.getProxyClass0(Proxy.java:455)    
at java.lang.reflect.Proxy.newProxyInstance(Proxy.java:738)    
at com.mikan.proxy.ProxyTest.main(ProxyTest.java:15)    
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)    
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)    
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)    
at java.lang.reflect.Method.invoke(Method.java:606)    
at com.intellij.rt.execution.application.AppMain.main(AppMain.java:140)    

即我们要在运行当前main方法的路径下创建com/sun/proxy目录，并创建一个$Proxy0.class文件，才能够正常运行并保存class文件内容。

反编译$Proxy0.class文件，如下所示：

[java] view plain copy
 
package com.sun.proxy;    
    
import com.mikan.proxy.HelloWorld;    
import java.lang.reflect.InvocationHandler;    
import java.lang.reflect.Method;    
import java.lang.reflect.Proxy;    
import java.lang.reflect.UndeclaredThrowableException;    
    
public final class $Proxy0 extends Proxy implements HelloWorld {    
  private static Method m1;    
  private static Method m3;    
  private static Method m0;    
  private static Method m2;    
    
  public $Proxy0(InvocationHandler paramInvocationHandler) {    
    super(paramInvocationHandler);    
  }    
    
  public final boolean equals(Object paramObject) {    
    try {    
      return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();    
    }    
    catch (Error|RuntimeException localError) {    
      throw localError;    
    }    
    catch (Throwable localThrowable) {    
      throw new UndeclaredThrowableException(localThrowable);    
    }    
  }    
    
  public final void sayHello(String paramString) {    
    try {    
      this.h.invoke(this, m3, new Object[] { paramString });    
      return;    
    }    
    catch (Error|RuntimeException localError) {    
      throw localError;    
    }    
    catch (Throwable localThrowable) {    
      throw new UndeclaredThrowableException(localThrowable);    
    }    
  }    
    
  public final int hashCode() {    
    try {    
      return ((Integer)this.h.invoke(this, m0, null)).intValue();    
    }    
    catch (Error|RuntimeException localError) {    
      throw localError;    
    }    
    catch (Throwable localThrowable) {    
      throw new UndeclaredThrowableException(localThrowable);    
    }    
  }    
    
  public final String toString() {    
    try {    
      return (String)this.h.invoke(this, m2, null);    
    }    
    catch (Error|RuntimeException localError) {    
      throw localError;    
    }    
    catch (Throwable localThrowable) {    
      throw new UndeclaredThrowableException(localThrowable);    
    }    
  }    
    
  static {    
    try {    
      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });    
      m3 = Class.forName("com.mikan.proxy.HelloWorld").getMethod("sayHello", new Class[] { Class.forName("java.lang.String") });    
      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);    
      m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);    
      return;    
    }    
    catch (NoSuchMethodException localNoSuchMethodException) {    
      throw new NoSuchMethodError(localNoSuchMethodException.getMessage());    
    }    
    catch (ClassNotFoundException localClassNotFoundException) {    
      throw new NoClassDefFoundError(localClassNotFoundException.getMessage());    
    }    
  }    
}    

可以看到，动态生成的代理类有如下特性：

继承了Proxy类，实现了代理的接口，由于java不能多继承，这里已经继承了Proxy类了，不能再继承其他的类，所以JDK的动态代理不支持对实现类的代理，只支持接口的代理。
提供了一个使用InvocationHandler作为参数的构造方法。
生成静态代码块来初始化接口中方法的Method对象，以及Object类的equals、hashCode、toString方法。
重写了Object类的equals、hashCode、toString，它们都只是简单的调用了InvocationHandler的invoke方法，即可以对其进行特殊的操作，也就是说JDK的动态代理还可以代理上述三个方法。
代理类实现代理接口的sayHello方法中，只是简单的调用了InvocationHandler的invoke方法，我们可以在invoke方法中进行一些特殊操作，甚至不调用实现的方法，直接返回。

至此JDK动态代理的实现原理就分析的差不多了。同时我们可以想像一下Spring AOP提供的各种拦截该如何实现，就已经很明了了，如下所示：

[java] view plain copy
 
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {    
    // BeforeAdvice    
    Object retVal = null;    
    try {    
        // AroundAdvice    
        retVal = method.invoke(target, args);    
        // AroundAdvice    
        // AfterReturningAdvice    
    }    
    catch (Throwable e) {    
        // AfterThrowingAdvice    
    }    
    finally {    
        // AfterAdvice    
    }    
    return retVal;    
}    

上面是对于Spring AOP使用JDK动态代理实现的基本框架代码，当然具体的实现肯定比这个复杂得多，但是基本原理不外乎如是。所以理解基本原理对于理解其他的代码也是很有好处的。

但是，JDK的动态代理依靠接口实现，如果有些类并没有实现接口，则不能使用JDK代理，这就要使用cglib动态代理了。

Cglib动态代理
JDK的动态代理机制只能代理实现了接口的类，而不能实现接口的类就不能实现JDK的动态代理，cglib是针对类来实现代理的，他的原理是对指定的目标类生成一个子类，并覆盖其中方法实现增强，但因为采用的是继承，所以不能对final修饰的类进行代理。

示例

1、BookFacadeCglib.java

[java] view plain copy
 
<strong><span style="font-family:Arial;color:#333333;"><span style="font-size: 14px;">   </span></span></strong> package net.battier.dao;    
        
    public interface BookFacade {    
        public void addBook();    
    }  <strong><span style="font-family:Arial;color:#333333;"><span style="font-size: 14px;">  
</span></span></strong>  

2、BookCadeImpl1.java

[java] view plain copy
 
<strong>   </strong> package net.battier.dao.impl;    
        
    /**  
     * 这个是没有实现接口的实现类  
     *   
     * @author student  
     *   
     */    
    public class BookFacadeImpl1 {    
        public void addBook() {    
            System.out.println("增加图书的普通方法...");    
        }    
    }  <strong>  
</strong>  

3、BookFacadeProxy.java

[java] view plain copy
 
<strong>   </strong> package net.battier.proxy;    
        
    import java.lang.reflect.Method;    
        
    import net.sf.cglib.proxy.Enhancer;    
    import net.sf.cglib.proxy.MethodInterceptor;    
    import net.sf.cglib.proxy.MethodProxy;    
        
    /**  
     * 使用cglib动态代理  
     *   
     * @author student  
     *   
     */    
    public class BookFacadeCglib implements MethodInterceptor {    
        private Object target;    
        
        /**  
         * 创建代理对象  
         *   
         * @param target  
         * @return  
         */    
        public Object getInstance(Object target) {    
            this.target = target;    
            Enhancer enhancer = new Enhancer();    
            enhancer.setSuperclass(this.target.getClass());    
            // 回调方法    
            enhancer.setCallback(this);    
            // 创建代理对象    
            return enhancer.create();    
        }    
        
        @Override    
        // 回调方法    
        public Object intercept(Object obj, Method method, Object[] args,    
                MethodProxy proxy) throws Throwable {    
            System.out.println("事物开始");    
            proxy.invokeSuper(obj, args);    
            System.out.println("事物结束");    
            return null;    
        
        
        }    
        
    }  <strong>  
</strong>  

4、TestCglib.java

[java] view plain copy
 
<strong>    </strong>package net.battier.test;    
        
    import net.battier.dao.impl.BookFacadeImpl1;    
    import net.battier.proxy.BookFacadeCglib;    
        
    public class TestCglib {    
            
        public static void main(String[] args) {    
            BookFacadeCglib cglib=new BookFacadeCglib();    
            BookFacadeImpl1 bookCglib=(BookFacadeImpl1)cglib.getInstance(new BookFacadeImpl1());    
            bookCglib.addBook();    
        }    
    }  <strong>  
</strong>  

参考文章：http://blog.csdn.net/mhmyqn/article/details/48474815

http://blog.csdn.net/lovelion/article/details/8116704

http://www.cnblogs.com/jqyp/archive/2010/08/20/1805041.html

转载自：http://blog.csdn.net/zhushuai1221/article/details/52167803

0 0