Java 動態代理 原理解析

概要

AOP的攔截功能是由java中的動態代理來實現的。說白了，就是在目標類的基礎上增長切面邏輯，生成加強的目標類（該切面邏輯或者在目標類函數執行以前，或者目標類函數執行以後，或者在目標類函數拋出異常時候執行。Spring中的動態代理是使用了JDK的動態代理和Cglib進行實現的。咱們這裏分析的是JDK中的動態代理實現機制。

下面咱們經過例子快速瞭解JDK中的動態代理實現方式。

示例

須要代理的接口

public interface IHello {
    public void sayHello();
}

須要代理的類

public class HelloImpl implements IHello {
    public void sayHello() {
        System.out.println("Hello World...");
    }
}

調用處理器實現類

public class ProxyHandler implements InvocationHandler {
    private Object target;
    public ProxyHandler(Object target) {
        this.target = target;
    }
    public Object proxyInstance() {
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(), this);
    }
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("aspect before ... ");
        Object result = method.invoke(this.target, args);
        System.out.println("aspect after ... ");
        return result;
    }
}

測試類入口

public class Main {
    public static void main(String[] args) {
        ProxyHandler proxy = new ProxyHandler(new HelloImpl());
        IHello hello = (IHello) proxy.proxyInstance();
        hello.sayHello();
    }
}

Proxy 源碼解析

newProxyInstance() 方法

省略了不關心的代碼

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,  InvocationHandler h) 
    throws IllegalArgumentException {
 
    Class<?> cl = getProxyClass0(loader, intfs);
    try {
        final Constructor<?> cons = cl.getConstructor(constructorParams);
        cons.setAccessible(true);
        return cons.newInstance(new Object[]{h});
    } catch (Exception e) {
        ......
    } 
}

1. 調用 getProxyClass0() 方法獲取代理類的 Class 對象
2. 經過反射生成 代理類的實例，並返回。

getProxyClass0() 方法

private static Class<?> getProxyClass0(ClassLoader loader, Class<?>... interfaces) {
    if (interfaces.length > 65535) {
        throw new IllegalArgumentException("interface limit exceeded");
    }
    return proxyClassCache.get(loader, interfaces);
}

1. 檢查須要代理的類接口數量是否超過65535個，接口個數用2個byte存儲，最大支持65535個。
2. 把獲取代理類的Class對象委託給 proxyClassCache() 方法。

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

proxyClassCache.get() 方法

1. 首先經過 classLoader 獲取該classLoader下全部的代理類緩存map。
2. 從該代理類緩存map中根據代理類全部實現的全部接口進行查找代理類。

若是都沒有找到對應的代理類，則使用ProxyClassFactory.apply() 方法生成代理類

ProxyClassFactory.apply()

1. 生成代理類的報名和類名
2. 經過ProxyGenerator.generateProxyClass() 方法動態生成代理類字節碼。
3. 經過classloader 動態加載 字節碼，並生成動態代理類的Class實例，並返回

ProxyGenerator.generateProxyClass()

簡單的列出 生成字節碼的片斷

添加默認的代理方法 hashCode、equals、toString 三個代理方法

循環迭代全部的接口，把接口中全部的方法都生成代理方法。

生成字節碼：
從代碼中咱們能夠看到，有class文件中的 魔術頭、小版本號、主版本號、類方法標誌、當前類、超類、接口個數、每一個實現接口、屬性個數、每一個屬性、方法個數、每一個方法等信息。

動態生成代理類class文件

下面咱們調用JDK內部提供的ProxyGenerator.generateProxyClass 方法把動態生成的代理類持久化到磁盤上。代碼以下：

public static void main(String[] args) {
    String name = "ProxyHello";
    byte[] data = ProxyGenerator.generateProxyClass(name, new Class[] { IHello.class });
    try {
        FileOutputStream out = new FileOutputStream("d:\\"+name + ".class");
        out.write(data);
        out.close();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

在D盤根目錄下生成ProxyHello.class文件。經過反編譯工具，咱們獲得以下代碼：

import com.qunar.proxy.IHello;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class ProxyHello extends Proxy
  implements IHello
{
  private static Method m1;
  private static Method m3;
  private static Method m2;
  private static Method m0;

  public ProxyHello(InvocationHandler paramInvocationHandler)
    throws 
  {
    super(paramInvocationHandler);
  }

  public final boolean equals(Object paramObject)
    throws 
  {
    try
    {
      return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
    }
    catch (RuntimeException localRuntimeException)
    {
      throw localRuntimeException;
    }
    catch (Throwable localThrowable)
    {
    }
    throw new UndeclaredThrowableException(localThrowable);
  }

  public final void sayHello()
    throws 
  {
    try
    {
      this.h.invoke(this, m3, null);
      return;
    }
    catch (RuntimeException localRuntimeException)
    {
      throw localRuntimeException;
    }
    catch (Throwable localThrowable)
    {
    }
    throw new UndeclaredThrowableException(localThrowable);
  }

  public final String toString()
    throws 
  {
    try
    {
      return (String)this.h.invoke(this, m2, null);
    }
    catch (RuntimeException localRuntimeException)
    {
      throw localRuntimeException;
    }
    catch (Throwable localThrowable)
    {
    }
    throw new UndeclaredThrowableException(localThrowable);
  }

  public final int hashCode()
    throws 
  {
    try
    {
      return ((Integer)this.h.invoke(this, m0, null)).intValue();
    }
    catch (RuntimeException localRuntimeException)
    {
      throw localRuntimeException;
    }
    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.qunar.proxy.IHello").getMethod("sayHello", new Class[0]);
      m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
      return;
    }
    catch (NoSuchMethodException localNoSuchMethodException)
    {
      throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
    }
    catch (ClassNotFoundException localClassNotFoundException)
    {
    }
    throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
  }
}

經過反編譯後的代碼咱們能夠看到，他內部包含4個代理方法：
equals、toString、hashCode 還有 IHello接口中的 sayHello 方法。

該代理類繼承了Proxy，並把咱們建立的ProxyHandler 類經過構造方法自動注入到 代理類中。

當咱們調用代理類的sayHello方法時，sayHello方法就會調用咱們實現的ProxyHandler 類中的invoke() 方法，ProxyHandler.invoke() 方法調用咱們真正的目標類的sayHello方法。