Spring AOP(二) 修飾者模式和JDK Proxy

 在上邊一篇 文章 中我們介紹了Spring AOP的基本概念，今天我們就來學習一下與AOP實作相關的修飾者模式和Java Proxy相關的原理，為之後源碼分析打下基礎。

修飾者模式

 Java設計模式中的修飾者模式能動态地給目标對象增加額外的職責(Responsibility)。它使用組合(object composition)，即将目标對象作為修飾者對象(代理)的成員變量，由修飾者對象決定調用目标對象的時機和調用前後所要增強的行為。

 裝飾模式包含如下組成部分：

• Component: 抽象構件，也就是目标對象所實作的接口，有operation函數
• ConcreteComponent: 具體構件，也就是目标對象的類
• Decorator: 抽象裝飾類，也實作了抽象構件接口，也就是目标類和裝飾類都實作了相同的接口
• ConcreteDecorator: 具體裝飾類，其中addBeavior函數就是增強的行為，裝飾類可以自己決定addBeavior函數和目标對象函數operation函數的調用時機。

 修飾者模式調用的時序圖如下圖所示。程式首先建立目标對象，然後建立修飾者對象，并将目标對象傳入作為其成員變量。當程式調用修飾者對象的operation函數時，修飾者對象會先調用目标對象的operation函數，然後再調用自己的addBehavior函數。這就是類似于AOP的後置增強器，在目标對象的行為之後添加新的行為。

 Spring AOP的實作原理和修飾者模式類似。在上一篇文章中說到AOP的動态代理有兩種實作方式，分别是JDK Proxy和cglib。

 如下圖所示，JDK Proxy的類結構和上文中修飾者的類圖結構類似，都是代理對象和目标對象都實作相同的接口，代理對象持有目标對象和切面對象，并且決定目标函數和切面增強函數的調用時機。

 而cglib的實作略有不同，它沒有實作實作相同接口，而是代理對象繼承目标對象類。

 本文後續就講解一下JDK Proxy的相關源碼分析。

JDK Proxy

 JDK提供了Proxy類來實作動态代理的，可通過它的newProxyInstance函數來獲得代理對象。JDK還提供了InvocationHandler類，代理對象的函數被調用時，會調用它的invoke函數，程式員可以在其中實作所需的邏輯。

 JDK Proxy的基本文法如下所示。先構造一個

InvocationHandler

的實作類，然後調用

Proxy

的

newProxyInstance

函數生成代理對象，傳入類加載器，目标對象的接口和自定義的

InvocationHandler

執行個體。

public class CustomInvocationHandler implements InvocationHandler {
    private Object target;

    public CustomInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before invocation");
        Object retVal = method.invoke(target, args);
        System.out.println("After invocation");
        return retVal;
    }
}

CustomInvocationHandler customInvocationHandler = new CustomInvocationHandler(
        helloWord);
//通過Proxy.newProxyInstance生成代理對象
ProxyTest proxy = (ProxyTest) Proxy.newProxyInstance(
        ProxyTest.class.getClassLoader(),
       proxyObj.getClass().getInterfaces(), customInvocationHandler);           

生成代理對象

 我們首先來看一下

Proxy

newProxyInstance

函數。

newProxyInstance

函數的邏輯大緻如下：

• 首先根據傳入的目标對象接口動态生成代理類
• 然後擷取代理類的構造函數執行個體
• 最後将

  InvocationHandler

  作為參數通過反射調用構造函數執行個體，生成代理類對象。

   具體源碼如下所示。

public static Object newProxyInstance(ClassLoader loader,
                                        Class<?>[] interfaces,
                                        InvocationHandler h)
    throws IllegalArgumentException
{

    final Class<?>[] intfs = interfaces.clone();
    final SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
    }
    // 1 動态生成代理對象的類
    Class<?> cl = getProxyClass0(loader, intfs);

    // ... 代碼省略，下邊代碼其實是在try catch中的
    if (sm != null) {
        checkNewProxyPermission(Reflection.getCallerClass(), cl);
    }
    // 2 擷取代理類的構造函數
    final Constructor<?> cons = cl.getConstructor(constructorParams);
    final InvocationHandler ih = h;
    if (!Modifier.isPublic(cl.getModifiers())) {
        AccessController.doPrivileged(new PrivilegedAction<Void>() {
            public Void run() {
                cons.setAccessible(true);
                return null;
            }
        });
    }
    // 3調用構造函數，傳入InvocationHandler對象
    return cons.newInstance(new Object[]{h});
}           

 

getProxyClass0

函數的源碼如下所示，通過代理類緩存擷取代理類資訊，如果不存在則會生成代理類。

// 生成代理類
private static Class<?> getProxyClass0(ClassLoader loader,
                                        Class<?>... interfaces) {
    if (interfaces.length > 65535) {
        throw new IllegalArgumentException("interface limit exceeded");
    }

    // 如果已經有Proxy類的緩存則直接傳回，否則要進行建立
    return proxyClassCache.get(loader, interfaces);
}           

生成代理類

 JDK Proxy通過

ProxyClassFactory

生成代理類。其

apply

函數大緻邏輯如下：

• 校驗接口是否符合規範
• 生成代理類的名稱和包名
• 生成代理類位元組碼
• 根據位元組碼生成代理類Class

// 生成代理類的工廠類
private static final class ProxyClassFactory
    implements BiFunction<ClassLoader, Class<?>[], Class<?>>
{
    // 所有代理類名的字首
    private static final String proxyClassNamePrefix = "$Proxy";

    // 生成唯一類名的原子Long對象
    private static final AtomicLong nextUniqueNumber = new AtomicLong();

    @Override
    public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {

        Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
        for (Class<?> intf : interfaces) {
            // 通過loader找到接口對應的類資訊。
            Class<?> interfaceClass = null;
            try {
                interfaceClass = Class.forName(intf.getName(), false, loader);
            } catch (ClassNotFoundException e) {
            }
            if (interfaceClass != intf) {
                throw new IllegalArgumentException(
                    intf + " is not visible from class loader");
            }
            // 判斷找出來的類确實是一個接口
            if (!interfaceClass.isInterface()) {
                throw new IllegalArgumentException(
                    interfaceClass.getName() + " is not an interface");
            }
            // 判斷接口是否重複
            if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
                throw new IllegalArgumentException(
                    "repeated interface: " + interfaceClass.getName());
            }
        }
        // 代理類的包路徑
        String proxyPkg = null;
        int accessFlags = Modifier.PUBLIC | Modifier.FINAL;

        // 記錄非公開的代理接口，以便于生成的代理類和原來的類在同一個路徑下。 
        for (Class<?> intf : interfaces) {
            int flags = intf.getModifiers();
            if (!Modifier.isPublic(flags)) {
                accessFlags = Modifier.FINAL;
                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");
                }
            }
        }
        // 如果沒有非公開的Proxy接口，使用com.sun.proxy報名
        if (proxyPkg == null) {
            proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
        }

        long num = nextUniqueNumber.getAndIncrement();
        // 預設情況下，代理類的完全限定名為：com.sun.proxy.$Proxy0，$Proxy1……依次遞增  
        String proxyName = proxyPkg + proxyClassNamePrefix + num;

        // 生成代理類位元組碼
        byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
            proxyName, interfaces, accessFlags);
        try {
            // 根據位元組碼傳回相應的Class執行個體
            return defineClass0(loader, proxyName,
                                proxyClassFile, 0, proxyClassFile.length);
        } catch (ClassFormatError e) {
            throw new IllegalArgumentException(e.toString());
        }
    }
}           

 其中關于位元組碼生成的部分邏輯我們就暫時不深入介紹了，感興趣的同學可以自行研究。

$Proxy反編譯

 我們來看一下生成的代理類的反編譯代碼。代理類實作了

Object

的基礎函數，比如

toString

、

hasCode

和

equals

，也實作了目标接口中定義的函數，比如說

ProxyTest

接口的

test

$Proxy

中函數的實作都是直接調用了

InvocationHandler

invoke

public final class $Proxy0 extends Proxy
  implements ProxyTest 
// 會實作目标接口，但是由于內建了Proxy，是以無法再內建其他類
{
  private static Method m1;
  private static Method m0;
  private static Method m3;
  private static Method m2;
  // 構造函數要傳入一個InvocationHandler對象
  public $Proxy0(InvocationHandler paramInvocationHandler)
    throws 
  {
    super(paramInvocationHandler);
  }
  // equal函數
  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 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);
  }
  // test函數，也就是ProxyTest接口中定義的函數
  public final void test(String paramString)
    throws 
  {
    try
    {
      // 調用InvocationHandler的invoke函數
      this.h.invoke(this, m3, new Object[] { paramString });
      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);
  }
  // 擷取各個函數的Method對象
  static
  {
    try
    {
      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
      m3 = Class.forName("com.proxy.test2.HelloTest").getMethod("say", new Class[] { Class.forName("java.lang.String") });
      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());
  }
}           

後記

 下一篇文章就是AOP的源碼分析了，希望大家繼續關注。