java动态代理的实现以及原理

1.前言

之前对动态代理的技术只是表面上理解，没有形成一个体系，这里总结一下，整个动态代理的实现以及实现原理，以表述的更清楚一些。

2.动态代理的实现应用到的技术

1、动态编译技术，可以使用Java自带的JavaCompiler类，也可以使用CGLIB、ASM等字节码增强技术，Java的动态代理包括Spring的内部实现貌似用的都是这个

2、反射，包括对于类.class和getClass()方法的理解，Method类、Constructor类的理解

3、IO流，主要就是字符输出流FileWriter

4、对于ClassLoader的理解

3.动态代理示例

接口类：

public interface UserService {
    public abstract void add();
    public abstract void update();
}

接口实现类：

public class UserServiceImpl implements UserService {

     public void add() {
        System.out.println("----- add -----");
    }

    public void update(){
         System.out.println("----- update-----");
    }
}

代理处理类MyInvocationHandler.java

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class MyInvocationHandler implements InvocationHandler {

    private Object target;

    public MyInvocationHandler(Object target) {
        super();
        this.target = target;
    }

    public Object getProxy() {
        return Proxy.newProxyInstance(Thread.currentThread()
                .getContextClassLoader(), target.getClass().getInterfaces(),
                this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("----- before -----");
        Object result = method.invoke(target, args);
        System.out.println("----- after -----");
        return result;
    }
}

　测试类：

public class DynamicProxyTest {

    public static void main(String[] args) {
        UserService userService = new UserServiceImpl();
        MyInvocationHandler invocationHandler = new MyInvocationHandler(
                userService);

        UserService proxy = (UserService) invocationHandler.getProxy();
        proxy.add();
        proxy.update();
    }
}

　输出：

----- before -----
----- add -----
----- after -----
----- before -----
----- update -----
----- after -----

用起来是很简单，其实这里基本上就是AOP的一个简单实现了，目的是在目标对象的方法执行之前和执行之后进行了增强。

Spring的AOP实现其实也是用了Proxy和InvocationHandler这两个东西的。 

4.动态代理原理

下面我们从jdk实现的源代码的层面分析一下，动态代理产生的整个过程。

上面的程序的入口，便是代理处理类MyInvocationHandler中的getProxy()方法。

public Object getProxy() {
       return Proxy.newProxyInstance(Thread.currentThread()
               .getContextClassLoader(), target.getClass().getInterfaces(),
               this);
}

Proxy.newProxyInstance() 方法，最终将返回一个实现了指定接口的类的实例，

其三个参数分别是：ClassLoader，指定的接口及我们自己定义的InvocationHandler类。我摘几条关键的代码出来，看看这个代理类的实例对象到底是怎么生成的。

4.1 Proxy.newProxyInstance的源码（JDK1.6）：

public static Object newProxyInstance(ClassLoader loader,
                      Class<?>[] interfaces,
                      InvocationHandler h)
    throws IllegalArgumentException
    {
    if (h == null) {
        throw new NullPointerException();
    }
    /*
     * Look up or generate the designated proxy class.
     */
       //getProxyClass获得这个代理类
        Class<?> cl = getProxyClass0(loader, interfaces); // stack walk magic: do not refactor
    /*
     * Invoke its constructor with the designated invocation handler.
     */
    try {
            //然后通过c1.getConstructor()拿到构造函数
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            SecurityManager sm = System.getSecurityManager();
            if (sm != null && ProxyAccessHelper.needsNewInstanceCheck(cl)) {
                // create proxy instance with doPrivilege as the proxy class may
                // implement non-public interfaces that requires a special permission
                return AccessController.doPrivileged(new PrivilegedAction<Object>() {
                    public Object run() {
                        //通过cons.newInstance返回这个新的代理类的一个实例，注意：调用newInstance的时候，传入的参数为h，即我们自己定义好的InvocationHandler类
                        return newInstance(cons, ih);
                    }
                });
            } else {
                return newInstance(cons, ih);
            }
    } catch (NoSuchMethodException e) {
        throw new InternalError(e.toString());
    }
    }

4.2 我们再去看getProxyClass0()方法的源码:

private static Class<?> getProxyClass0(ClassLoader loader, Class<?>... interfaces) {
        .........省略一些代码
        // 如果目标类实现的接口数大于65535个则抛出异常（我XX）
        if (interfaces.length > 65535) {
        throw new IllegalArgumentException("interface limit exceeded");
    }
        //声明代理对象的Class对象
    Class proxyClass = null;
    String[] interfaceNames = new String[interfaces.length];
    Set interfaceSet = new HashSet();
        // 遍历目标类所实现的接口
    for (int i = 0; i < interfaces.length; i++) {
       // 拿到目标类实现的接口的名称
        String interfaceName = interfaces[i].getName();
        Class interfaceClass = null;
        try {
               // 加载目标类实现的接口到内存中
        interfaceClass = Class.forName(interfaceName, false, loader);
        } catch (ClassNotFoundException e) {
        }
        if (interfaceClass != interfaces[i]) {
        throw new IllegalArgumentException(
            interfaces[i] + " is not visible from class loader");
        }
        /*
         * JDK里规定了：动态代理 只能针对接口生成代理，不能只针对某一个类生成代理
这也算是一个缺点吧，如果需要对一个类生成代理则可用第三方库
         */
        if (!interfaceClass.isInterface()) {
        throw new IllegalArgumentException(
            interfaceClass.getName() + " is not an interface");
        }
           // 把目标类实现的接口代表的Class对象放到Set中
        interfaceSet.add(interfaceClass);
        interfaceNames[i] = interfaceName;
    }
    // 把目标类实现的接口名称作为缓存（Map）中的key
    Object key = Arrays.asList(interfaceNames);
    Map cache;
    synchronized (loaderToCache) {
           // 从缓存中获取cache
        cache = (Map) loaderToCache.get(loader);
        if (cache == null) {
               // 如果获取不到，则新建地个HashMap实例
        cache = new HashMap();
        loaderToCache.put(loader, cache);
        }
    }
    synchronized (cache) {
        do {
                //根据接口的名称从缓存中获取对象
        Object value = cache.get(key);
        if (value instanceof Reference) {
            proxyClass = (Class) ((Reference) value).get();
        }
        if (proxyClass != null) {
            // 如果代理对象的Class实例已经存在，则直接返回
            return proxyClass;
        } else if (value == pendingGenerationMarker) {
            // proxy class being generated: wait for it
            try {
            cache.wait();
            } catch (InterruptedException e) {
            }
            continue;
        } else {
            cache.put(key, pendingGenerationMarker);
            break;
        }
        } while (true);
    }
....................省略代码
try{
               // 这里就是动态生成代理对象的最关键的地方:利用ProxyGenerator为我们生成了最终代理类的字节码文件
        byte[] proxyClassFile =ProxyGenerator.generateProxyClass(proxyName,Interfaces);
        try {
               // 根据代理类的字节码生成代理类的实例
            proxyClass = defineClass0(loader, proxyName,
            proxyClassFile, 0, proxyClassFile.length);
        } catch (ClassFormatError e) {
            throw new IllegalArgumentException(e.toString());
        }
        }
        proxyClasses.put(proxyClass, null);
    } finally {
    return proxyClass;
    }

4.3 其中ProxyGenerator.generateProxyClass()的方法是最终生成代理类的字节码.

ProxyGenerator是sun.misc包中的类，它没有开源，不过我们可以根据它将生成的代理类的字节码保存在本地上，然后反编译查看生成的代理类。

具体请参照地址：http://blog.csdn.net/mhmyqn/article/details/48474815

4.4 反编译生成的$Proxy0.class代理类文件

下面从网上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;
  //这个就是 上面newInstance()方法中传入的代理实现类MyInvocationHandler，而这个类在代理类中的变量名为this.h
  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 {<br>      //见上面构造方法，this.h 就代表MyInvocationHandler类,所以执行的就是我们代理实现类中的invoke方法。
      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());
    }
  }
}

 由此总结一下动态代理实现过程。

1.通过 Proxy.newProxyInstance() 方法，返回一个继承Proxy类，并且最终实现了指定接口的代理类的实例。

在这里分为两个大的步骤:

1. 通过getProxyClass0()方法生成代理类。在这个方法里面,

• ProxyGenerator.generateProxyClass()的方法是最终生成代理类的字节码.
• defineClass0()方法把相应的字节码生成代理类

         2. 调用 newInstance(Constructor<?> cons, InvocationHandler h)方法 创建一个新的代理类实例，创建对象时，传入我们定义好的代理处理类，InvocationHandle类。 

2. 调用新实例的方法，即此例中的add(), update()方法，即原InvocationHandler类中的invoke()方法。

5.动态代理的优点

1、最直观的，类少了很多
2、代理内容也就是InvocationHandler接口的实现类可以复用，可以给A接口用、也可以给B接口用，A接口用了InvocationHandler接口实现类A的代理，不想用了，可以方便地换成InvocationHandler接口实现B的代理
3、最重要的，用了动态代理，就可以在不修改原来代码的基础上，就在原来代码的基础上做操作，这就是AOP即面向切面编程

6.动态代理的缺点

动态代理的缺点，就是前面我们读源代码的时候遇到的。它只能针对接口生成代理，不能只针对某一个类生成代理。

如果需要为某一个单独的类实现一个代理的话，考虑使用CGLIB等第三方字节码（一种字节码增强技术）。

参考地址：http://blog.csdn.net/zhangerqing/article/details/42504281/

http://www.cnblogs.com/xrq730/p/4907999.html

http://blog.csdn.net/mhmyqn/article/details/4847481516:23:20

转载: https://www.cnblogs.com/haitaofeiyang/p/7724263.html