死磕Spring之AOP篇 - 初識JDK、CGLIB兩種動態代理

該系列文章是本人在學習 Spring 的過程中總結下來的，里面涉及到相關源碼，可能對讀者不太友好，請結合我的源碼注釋 Spring 源碼分析 GitHub 地址 進行閱讀。

Spring 版本：5.1.14.RELEASE

在開始閱讀 Spring AOP 源碼之前，需要對 Spring IoC 有一定的了解，可查看我的 《死磕Spring之IoC篇 - 文章導讀》 這一系列文章

了解 AOP 相關術語，可先查看 《Spring AOP 常見面試題） 》 這篇文章

該系列其他文章請查看：《死磕 Spring 之 AOP 篇 - 文章導讀》

前段時間，我對 Spring IoC 的源碼進行了比較全面的學習，並寫下了數篇文章進行知識分享。在學習完 Spring IoC 的源碼后，也沒敢懈怠，趁熱打鐵，閱讀了 Sping AOP 的相關源碼，在有了 Spring IoC 的基礎之后，你會發現 Spring AOP 的源碼並不復雜，嘿嘿 ~

在開始 Spring AOP 源碼分析之前，我們先來了解一下其底層 JDK 動態代理和 CGLIB 動態代理兩種 AOP 代理的實現，本文也會講到 Javassist 動態代理的一個簡單使用示例。

示例

Echo 服務：

public interface EchoService {

    String echo(String message);
}

默認實現：

public class DefaultEchoService implements EchoService {

    @Override
    public String echo(String message) {
        return "[ECHO] " + message;
    }
}

現在有這么一個需求，當你調用上面的 echo(String) 方法的時候，需要打印出方法的執行時間，那么我們可以怎么做？答案就是通過代理模式，通過代理類為這個對象提供一種代理以控制對這個對象的訪問，在代理類中輸出方法的執行時間。

靜態代理

代理類實現被代理類所實現的接口，同時持有被代理類的引用，新增處理邏輯，當我們調用代理類的方法時候，實際調用被代理類的引用。

代理類：

public class ProxyEchoService implements EchoService {
    /**
     * 被代理對象
     */
    private final EchoService echoService;

    public ProxyEchoService(EchoService echoService) {
        this.echoService = echoService;
    }

    @Override
    public String echo(String message) {
        long startTime = System.currentTimeMillis();
        // 調用被代理對象的方法
        String result = echoService.echo(message);
        long costTime = System.currentTimeMillis() - startTime;
        System.out.println("echo 方法執行的實現：" + costTime + " ms.");
        return result;
    }
}

示例：

public class StaticProxyDemo {

    public static void main(String[] args) {
        // 創建代理類，並傳入被代理對象，也就是 DefaultEchoService
        EchoService echoService = new ProxyEchoService(new DefaultEchoService());
        echoService.echo("Hello,World");
    }
}

控制台會輸出以下內容：

echo 方法執行的實現：0 ms.

得到的結論：

靜態代理就是通過實現被代理對象所實現的接口，內部保存了被代理對象，在實現的方法中對處理邏輯進行增強，實際的方法執行調用了被代理對象的方法。可以看到靜態代理比較簡潔直觀，但是在復雜的場景下，需要為每個目標對象創建一個代理類，不易於維護，我們更加注重的應該是業務開發，對於這一層增強處理應該抽取出來。

JDK 動態代理

基於接口代理，通過反射機制生成一個實現代理接口的類，在調用具體方法時會調用 InvokeHandler 來處理。

示例

public class JdkDynamicProxyDemo {

    public static void main(String[] args) {
        // 當前線程的類加載器
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        // $Proxy0
        Object proxy = Proxy.newProxyInstance(classLoader, new Class[]{EchoService.class}, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                if (EchoService.class.isAssignableFrom(method.getDeclaringClass())) {
                    // 被代理對象
                    EchoService echoService = new DefaultEchoService();
                    long startTime = System.currentTimeMillis();
                    String result = echoService.echo((String) args[0]);
                    long costTime = System.currentTimeMillis() - startTime;
                    System.out.println("echo 方法執行的實現：" + costTime + " ms.");
                    return result;
                }
                return null;
            }
        });
        EchoService echoService = (EchoService) proxy;
        echoService.echo("Hello,World");
    }
}

控制台會輸出以下內容：

echo 方法執行的實現：0 ms.

分析

借助 JDK 的 java.lang.reflect.Proxy 來創建代理對象，調用 Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) 方法可以創建一個代理對象，方法的三個入參分別是：

• ClassLoader loader：用於加載代理對象的 Class 類加載器
• Class<?>[] interfaces：代理對象需要實現的接口
• InvocationHandler h：代理對象的處理器

新生成的代理對象的 Class 對象會繼承 Proxy，且實現所有的入參 interfaces 中的接口，在實現的方法中實際是調用入參 InvocationHandler 的 invoke(..) 方法。

上面可以看到 InvocationHandler 是直接在入參中創建的，在 invoke(..) 方法中攔截 EchoService 的方法。這里的被代理對象是在其內部創建的，實際上我們可以在創建 InvocationHandler 實現類的時候進行設置，這里為了方便直接在內部創建。

新生成的 Class 對象

JDK 動態代理在 JVM 運行時會新生成一個代理對象，那么我們先來看看這個代理對象的字節碼，通過添加下面的 JVM 參數可以保存生成的代理對象的 .class 文件

# jdk8及以前版本
-Dsun.misc.ProxyGenerator.saveGeneratedFiles=true
# jdk8+
-Djdk.proxy.ProxyGenerator.saveGeneratedFiles=true

在同工程目錄下你會發現有一個 .class 文件，如下：

package com.sun.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
import org.geekbang.thinking.in.spring.aop.overview.EchoService;

public final class $Proxy0 extends Proxy implements EchoService {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final String echo(String var1) throws  {
        try {
            return (String)super.h.invoke(this, m3, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m3 = Class.forName("org.geekbang.thinking.in.spring.aop.overview.EchoService").getMethod("echo", Class.forName("java.lang.String"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

從這個代理對象中你可以看到，它繼承了 java.lang.reflect.Proxy 這個類，並實現了 EchoService 接口。在實現的 echo(String) 方法中，實際上調用的就是父類 Proxy 中的 InvocationHandler 的 incoke(..) 方法，這個 InvocationHandler 就是創建代理對象時傳入的參數。

Proxy 底層原理

newProxyInstance 方法

JDK 動態代理是通過 Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) 方法創建的代理對象，那我們來看看這個方法會做哪些事情

// java.lang.reflect.Proxy.java
public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
    throws IllegalArgumentException
{
    // InvocationHandler 不能為空
    Objects.requireNonNull(h);

    final Class<?>[] intfs = interfaces.clone();
    final SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
    }

    // 獲取代理對象的 Class 對象（生成一個代理類）
    Class<?> cl = getProxyClass0(loader, intfs);

    try {
        if (sm != null) {
            // 安全檢測，檢測是否能夠創建對象
            checkNewProxyPermission(Reflection.getCallerClass(), cl);
        }

        // 獲取代理類的構造器（入參為 InvocationHandler）
        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;
                }
            });
        }
        // 通過構造器創建一個實例對象，入參是 InvocationHandler 的實現類
        return cons.newInstance(new Object[]{h});
    } catch (IllegalAccessException|InstantiationException e) {
        throw new InternalError(e.toString(), e);
    } catch (InvocationTargetException e) {
        Throwable t = e.getCause();
        if (t instanceof RuntimeException) {
            throw (RuntimeException) t;
        } else {
            throw new InternalError(t.toString(), t);
        }
    } catch (NoSuchMethodException e) {
        throw new InternalError(e.toString(), e);
    }
}

這個方法的邏輯不復雜，獲取到代理類的 Class 對象，然后通過構造器創建一個代理對象，構造器的入參就是 InvocationHandler 的實現類。因為代理類會繼承 Proxy這個類，在 Proxy 中就有一個 Proxy(InvocationHandler h) 構造方法，所以可以獲取到對應的構造器。其中獲取代理對象的 Class 對象（生成一個代理類）調用 getProxyClass0(ClassLoader loader, Class<?>... interfaces) 方法。

getProxyClass0 方法

// java.lang.reflect.Proxy.java

/**
 * a cache of proxy classes
 */
private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
    proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

private static Class<?> getProxyClass0(ClassLoader loader,
                                       Class<?>... interfaces) {
    // 接口數量不能大於 65535
    if (interfaces.length > 65535) {
        throw new IllegalArgumentException("interface limit exceeded");
    }

    // If the proxy class defined by the given loader implementing
    // the given interfaces exists, this will simply return the cached copy;
    // otherwise, it will create the proxy class via the ProxyClassFactory
    // 
    return proxyClassCache.get(loader, interfaces);
}

先嘗試從 proxyClassCache 緩存中獲取對應的代理類，如果不存在則通過 ProxyClassFactory 函數創建一個代理類

ProxyClassFactory 代理類工廠

// java.lang.reflect.Proxy.java
private static final class ProxyClassFactory
    implements BiFunction<ClassLoader, Class<?>[], Class<?>>
{
    // prefix for all proxy class names
    private static final String proxyClassNamePrefix = "$Proxy";

    // next number to use for generation of unique proxy class names
    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) {
            // 校驗該接口是在存在這個 ClassLoader 中
            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;     // package to define proxy class in
        int accessFlags = Modifier.PUBLIC | Modifier.FINAL;

        /*
         * 遍歷需要實現的接口，判斷是否存在非 `public` 的接口
         * 如果存在，則記錄下來，並記錄所在的包名
         * 如果存在非 `public` 的接口，且還存在其他包路徑下的接口，則拋出異常
         */
        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");
                }
            }
        }

        // 如果不存在非 `public` 的接口，則代理類的名稱前綴為 `com.sun.proxy.`
        if (proxyPkg == null) {
            // if no non-public proxy interfaces, use com.sun.proxy package
            proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
        }

        // 生成一個代理類的名稱，`com.sun.proxy.$Proxy` + 唯一數字（從 0 開始遞增）
        // 對於非 `public` 的接口，這里的名前綴就取原接口包名了，因為不是 `public` 修飾需要保證可訪問
        long num = nextUniqueNumber.getAndIncrement();
        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());
        }
    }
}

創建代理類的過程如下：

1. 遍歷需要實現的接口，進行校驗；
   • 校驗該接口是在存在這個 ClassLoader 中
   • 校驗是否真的是接口（因為入參也可以不傳接口）
   • 校驗是否出現相同的接口（因為入參也可以傳相同的接口）
2. 遍歷需要實現的接口，判斷是否存在非 public 的接口，該步驟和生成的代理類的名稱有關；
   • 如果存在，則記錄下來，並記錄所在的包名
   • 如果存在非 public 的接口，且還存在其他包路徑下的接口，則拋出異常
3. 如果不存在非 public 的接口，則代理類的名稱前綴為 com.sun.proxy.
4. 生成一個代理類的名稱，com.sun.proxy.$Proxy + 唯一數字（從 0 開始遞增）
   • 對於非 public 的接口，這里的名前綴就取原接口包名了，因為不是 public 修飾需要保證可訪問
5. 根據代理類的名稱、需要實現的接口以及修飾符生成一個字節數組
6. 根據第 5 步生成的代理類對應的字節數組創建一個 Class 對象

可以看到就是根據入參中的接口創建一個 Class 對象，實現這些接口，然后創建一個實例對象

為什么 JDK 動態代理只能基於接口代理，不能基於類代理？

在該過程也可以看到，對於入參中的 interfaces 如果存在非接口，那么會拋出異常；且從生成的代理對象中看到會繼承 Proxy 這個類，在 Java 中類只能是單繼承關系，無法再繼承一個代理類，所以只能基於接口代理。

在代理對象中，入參 InvocationHandler h 實際放入了父類 Proxy 中，為什么不直接聲明到這個代理對象里面呢？

我覺得代理類既然是 JDK 動態生成的，那么 JDK 就需要識別出哪些類是生成的代理類，哪些是非代理類，或者說 JDK 需要對代理類做統一的處理，這時如果沒有一個統一的類 Proxy 來進行引用根本無法處理。當然，還有其他的原因，暫且不知道。

CGLIB 動態代理

JDK 動態代理的目標對象必須是一個接口，在我們日常生活中，無法避免開發人員不寫接口直接寫類，或者根本不需要接口，直接用類進行表達。這個時候我們就需要通過一些字節碼提升的手段，來幫助做這個事情，在運行時，非編譯時，來創建新的 Class 對象，這種方式稱之為字節碼提升。在 Spring 內部有兩個字節碼提升的框架，ASM（過於底層，直接操作字節碼）和 CGLIB（相對於前者更加簡便）。

CGLIB 動態代理則是基於類代理（字節碼提升），通過 ASM（Java 字節碼的操作和分析框架）將被代理類的 class 文件加載進來，通過修改其字節碼生成子類來處理。

示例

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class CglibDynamicProxyDemo {

    public static void main(String[] args) {
        // 創建 CGLIB 增強對象
        Enhancer enhancer = new Enhancer();
        // 指定父類，也就是被代理的類
        Class<?> superClass = DefaultEchoService.class;
        enhancer.setSuperclass(superClass);
        // 指定回調接口（攔截器）
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object source, Method method, Object[] args,
                                    MethodProxy methodProxy) throws Throwable {
                long startTime = System.currentTimeMillis();
                Object result = methodProxy.invokeSuper(source, args);
                long costTime = System.currentTimeMillis() - startTime;
                System.out.println("[CGLIB 字節碼提升] echo 方法執行的實現：" + costTime + " ms.");
                return result;
            }
        });

        // 創建代理對象
        EchoService echoService = (EchoService) enhancer.create();
        // 輸出執行結果
        System.out.println(echoService.echo("Hello,World"));
    }
}

控制台會輸出以下內容：

[CGLIB 字節碼提升] echo 方法執行的實現：19 ms.
[ECHO] Hello,World

分析

需要借助於 CGLIB 的 org.springframework.cglib.proxy.Enhancer 類來創建代理對象，設置以下幾個屬性：

• Class<?> superClass：被代理的類
• Callback callback：回調接口

新生成的代理對象的 Class 對象會繼承 superClass 被代理的類，在重寫的方法中會調用 callback 回調接口（方法攔截器）進行處理。

上面可以看到 Callback 是直接創建的，在 intercept(..) 方法中攔截 DefaultEchoService 的方法。因為 MethodInterceptor 繼承了 Callback 回調接口，所以這里傳入一個 MethodInterceptor 方法攔截器是沒問題的。

注意，如果你想設置一個 Callback[] 數組去處理不同的方法，那么需要設置一個 CallbackFilter 篩選器，用於選擇這個方法使用數組中的那個 Callback 去處理

新生成的 Class 對象

CGLIB 動態代理在 JVM 運行時會新生成一個代理類，這個代理對象繼承了目標類，也就是創建了一個目標類的子類，從而字節碼得到提升。那么我們可以看看這個代理類的字節碼，通過添加下面的 JVM 參數可以保存生成的代理類的 .class 文件

-Dcglib.debugLocation=${class文件 保存路徑}

在指定的保存路徑下你會發現存在這么一個 .class 文件，如下：

package org.geekbang.thinking.in.spring.aop.overview;

import java.lang.reflect.Method;
import org.springframework.cglib.core.ReflectUtils;
import org.springframework.cglib.core.Signature;
import org.springframework.cglib.proxy.Callback;
import org.springframework.cglib.proxy.Factory;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

public class DefaultEchoService$$EnhancerByCGLIB$$c868af31 extends DefaultEchoService implements Factory {
    private boolean CGLIB$BOUND;
    public static Object CGLIB$FACTORY_DATA;
    private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
    private static final Callback[] CGLIB$STATIC_CALLBACKS;
    private MethodInterceptor CGLIB$CALLBACK_0;
    private static Object CGLIB$CALLBACK_FILTER;
    private static final Method CGLIB$echo$0$Method;
    private static final MethodProxy CGLIB$echo$0$Proxy;
    private static final Object[] CGLIB$emptyArgs;
    private static final Method CGLIB$equals$1$Method;
    private static final MethodProxy CGLIB$equals$1$Proxy;
    private static final Method CGLIB$toString$2$Method;
    private static final MethodProxy CGLIB$toString$2$Proxy;
    private static final Method CGLIB$hashCode$3$Method;
    private static final MethodProxy CGLIB$hashCode$3$Proxy;
    private static final Method CGLIB$clone$4$Method;
    private static final MethodProxy CGLIB$clone$4$Proxy;

    static void CGLIB$STATICHOOK1() {
        CGLIB$THREAD_CALLBACKS = new ThreadLocal();
        CGLIB$emptyArgs = new Object[0];
        Class var0 = Class.forName("org.geekbang.thinking.in.spring.aop.overview.DefaultEchoService$$EnhancerByCGLIB$$c868af31");
        Class var1;
        CGLIB$echo$0$Method = ReflectUtils.findMethods(new String[]{"echo", "(Ljava/lang/String;)Ljava/lang/String;"}, (var1 = Class.forName("org.geekbang.thinking.in.spring.aop.overview.DefaultEchoService")).getDeclaredMethods())[0];
        CGLIB$echo$0$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/String;)Ljava/lang/String;", "echo", "CGLIB$echo$0");
        Method[] var10000 = ReflectUtils.findMethods(new String[]{"equals", "(Ljava/lang/Object;)Z", "toString", "()Ljava/lang/String;", "hashCode", "()I", "clone", "()Ljava/lang/Object;"}, (var1 = Class.forName("java.lang.Object")).getDeclaredMethods());
        CGLIB$equals$1$Method = var10000[0];
        CGLIB$equals$1$Proxy = MethodProxy.create(var1, var0, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$1");
        CGLIB$toString$2$Method = var10000[1];
        CGLIB$toString$2$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/String;", "toString", "CGLIB$toString$2");
        CGLIB$hashCode$3$Method = var10000[2];
        CGLIB$hashCode$3$Proxy = MethodProxy.create(var1, var0, "()I", "hashCode", "CGLIB$hashCode$3");
        CGLIB$clone$4$Method = var10000[3];
        CGLIB$clone$4$Proxy = MethodProxy.create(var1, var0, "()Ljava/lang/Object;", "clone", "CGLIB$clone$4");
    }

    final String CGLIB$echo$0(String var1) {
        return super.echo(var1);
    }

    public final String echo(String var1) {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        return var10000 != null ? (String)var10000.intercept(this, CGLIB$echo$0$Method, new Object[]{var1}, CGLIB$echo$0$Proxy) : super.echo(var1);
    }

    final boolean CGLIB$equals$1(Object var1) {
        return super.equals(var1);
    }

    public final boolean equals(Object var1) {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        if (var10000 != null) {
            Object var2 = var10000.intercept(this, CGLIB$equals$1$Method, new Object[]{var1}, CGLIB$equals$1$Proxy);
            return var2 == null ? false : (Boolean)var2;
        } else {
            return super.equals(var1);
        }
    }

    final String CGLIB$toString$2() {
        return super.toString();
    }

    public final String toString() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        return var10000 != null ? (String)var10000.intercept(this, CGLIB$toString$2$Method, CGLIB$emptyArgs, CGLIB$toString$2$Proxy) : super.toString();
    }

    final int CGLIB$hashCode$3() {
        return super.hashCode();
    }

    public final int hashCode() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        if (var10000 != null) {
            Object var1 = var10000.intercept(this, CGLIB$hashCode$3$Method, CGLIB$emptyArgs, CGLIB$hashCode$3$Proxy);
            return var1 == null ? 0 : ((Number)var1).intValue();
        } else {
            return super.hashCode();
        }
    }

    final Object CGLIB$clone$4() throws CloneNotSupportedException {
        return super.clone();
    }

    protected final Object clone() throws CloneNotSupportedException {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        return var10000 != null ? var10000.intercept(this, CGLIB$clone$4$Method, CGLIB$emptyArgs, CGLIB$clone$4$Proxy) : super.clone();
    }

    public static MethodProxy CGLIB$findMethodProxy(Signature var0) {
        String var10000 = var0.toString();
        switch(var10000.hashCode()) {
        case -1042135322:
            if (var10000.equals("echo(Ljava/lang/String;)Ljava/lang/String;")) {
                return CGLIB$echo$0$Proxy;
            }
            break;
        case -508378822:
            if (var10000.equals("clone()Ljava/lang/Object;")) {
                return CGLIB$clone$4$Proxy;
            }
            break;
        case 1826985398:
            if (var10000.equals("equals(Ljava/lang/Object;)Z")) {
                return CGLIB$equals$1$Proxy;
            }
            break;
        case 1913648695:
            if (var10000.equals("toString()Ljava/lang/String;")) {
                return CGLIB$toString$2$Proxy;
            }
            break;
        case 1984935277:
            if (var10000.equals("hashCode()I")) {
                return CGLIB$hashCode$3$Proxy;
            }
        }

        return null;
    }

    public DefaultEchoService$$EnhancerByCGLIB$$c868af31() {
        CGLIB$BIND_CALLBACKS(this);
    }

    public static void CGLIB$SET_THREAD_CALLBACKS(Callback[] var0) {
        CGLIB$THREAD_CALLBACKS.set(var0);
    }

    public static void CGLIB$SET_STATIC_CALLBACKS(Callback[] var0) {
        CGLIB$STATIC_CALLBACKS = var0;
    }

    private static final void CGLIB$BIND_CALLBACKS(Object var0) {
        DefaultEchoService$$EnhancerByCGLIB$$c868af31 var1 = (DefaultEchoService$$EnhancerByCGLIB$$c868af31)var0;
        if (!var1.CGLIB$BOUND) {
            var1.CGLIB$BOUND = true;
            Object var10000 = CGLIB$THREAD_CALLBACKS.get();
            if (var10000 == null) {
                var10000 = CGLIB$STATIC_CALLBACKS;
                if (var10000 == null) {
                    return;
                }
            }

            var1.CGLIB$CALLBACK_0 = (MethodInterceptor)((Callback[])var10000)[0];
        }

    }

    public Object newInstance(Callback[] var1) {
        CGLIB$SET_THREAD_CALLBACKS(var1);
        DefaultEchoService$$EnhancerByCGLIB$$c868af31 var10000 = new DefaultEchoService$$EnhancerByCGLIB$$c868af31();
        CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
        return var10000;
    }

    public Object newInstance(Callback var1) {
        CGLIB$SET_THREAD_CALLBACKS(new Callback[]{var1});
        DefaultEchoService$$EnhancerByCGLIB$$c868af31 var10000 = new DefaultEchoService$$EnhancerByCGLIB$$c868af31();
        CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
        return var10000;
    }

    public Object newInstance(Class[] var1, Object[] var2, Callback[] var3) {
        CGLIB$SET_THREAD_CALLBACKS(var3);
        DefaultEchoService$$EnhancerByCGLIB$$c868af31 var10000 = new DefaultEchoService$$EnhancerByCGLIB$$c868af31;
        switch(var1.length) {
        case 0:
            var10000.<init>();
            CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
            return var10000;
        default:
            throw new IllegalArgumentException("Constructor not found");
        }
    }

    public Callback getCallback(int var1) {
        CGLIB$BIND_CALLBACKS(this);
        MethodInterceptor var10000;
        switch(var1) {
        case 0:
            var10000 = this.CGLIB$CALLBACK_0;
            break;
        default:
            var10000 = null;
        }

        return var10000;
    }

    public void setCallback(int var1, Callback var2) {
        switch(var1) {
        case 0:
            this.CGLIB$CALLBACK_0 = (MethodInterceptor)var2;
        default:
        }
    }

    public Callback[] getCallbacks() {
        CGLIB$BIND_CALLBACKS(this);
        return new Callback[]{this.CGLIB$CALLBACK_0};
    }

    public void setCallbacks(Callback[] var1) {
        this.CGLIB$CALLBACK_0 = (MethodInterceptor)var1[0];
    }

    static {
        CGLIB$STATICHOOK1();
    }
}

你會看到這個代理類繼承了 DefaultEchoService 目標類，在重寫的 echo(String) 方法中會調用 Callback 的 intercept(..) 攔截方法進行處理，由於生成的代理類不是那么容易理解，這里就不做分析了，有一個大致的思路就可以，感興趣的可以研究研究。

Enhancer 底層原理

create() 方法

CGLIB 動態代理可以通過 Enhancer.create() 方法進行字節碼提升，該過程比較復雜，不易看懂，我們簡單看看做了什么事情

// org.springframework.cglib.proxy.Enhancer.java

public Object create() {
    this.classOnly = false;
    this.argumentTypes = null;
    return this.createHelper();
}

private Object createHelper() {
    // Callback 的校驗
    this.preValidate();
    // 創建一個 EnhancerKey 對象，主要設置代理類名稱、和 Cllback 的類
    Object key = KEY_FACTORY.newInstance(this.superclass != null ? this.superclass.getName() : null,
                                         ReflectUtils.getNames(this.interfaces), 
                                         this.filter == ALL_ZERO ? null : new WeakCacheKey(this.filter), 
                                         this.callbackTypes, 
                                         this.useFactory, 
                                         this.interceptDuringConstruction, 
                                         this.serialVersionUID);
    this.currentKey = key;
    // 創建一個代理對象（代理類的子類）
    Object result = super.create(key);
    return result;
}

preValidate 方法

// org.springframework.cglib.proxy.Enhancer.java

private static final CallbackFilter ALL_ZERO = new CallbackFilter() {
    public int accept(Method method) {
        return 0;
    }
};

private void preValidate() {
    // 設置 Callback 的類型
    if (this.callbackTypes == null) {
        this.callbackTypes = CallbackInfo.determineTypes(this.callbacks, false);
        this.validateCallbackTypes = true;
    }

    // 如果 Callback 篩選器為空，則設置為取第一個
    // `filter` 用於篩選攔截方法所對應的 Callback
    if (this.filter == null) {
        if (this.callbackTypes.length > 1) {
            throw new IllegalStateException("Multiple callback types possible but no filter specified");
        }

        this.filter = ALL_ZERO;
    }
}

create(Object) 方法

protected Object create(Object key) {
    try {
        // 獲取類加載器
        ClassLoader loader = this.getClassLoader();
        Map<ClassLoader, AbstractClassGenerator.ClassLoaderData> cache = CACHE;
        // 獲取 ClassLoaderData 類加載器數據
        AbstractClassGenerator.ClassLoaderData data = (AbstractClassGenerator.ClassLoaderData)cache.get(loader);
        if (data == null) {
            Class var5 = AbstractClassGenerator.class;
            synchronized(AbstractClassGenerator.class) {
                cache = CACHE;
                data = (AbstractClassGenerator.ClassLoaderData)cache.get(loader);
                if (data == null) {
                    Map<ClassLoader, AbstractClassGenerator.ClassLoaderData> newCache = new WeakHashMap(cache);
                    data = new AbstractClassGenerator.ClassLoaderData(loader);
                    newCache.put(loader, data);
                    CACHE = newCache;
                }
            }
        }

        this.key = key;
        // 通過類加載器根據 `key` 創建一個 Class 對象（例如 FastClassByCGLIB）
        Object obj = data.get(this, this.getUseCache());
        // 通過 Class 對象創建一個代理對象
        return obj instanceof Class ? this.firstInstance((Class)obj) : this.nextInstance(obj);
    } catch (Error | RuntimeException var9) {
        throw var9;
    } catch (Exception var10) {
        throw new CodeGenerationException(var10);
    }
}

整個過程比較復雜，上面沒有深入分析，因為筆者實在是看不懂~😢，可以先理解為創建一個目標類的子類😈

可參考 cglib動態代理的使用和分析 這篇文章

Javassist 動態代理

Javassist 和 CGLIB 一樣，是一個操作 Java 字節碼的類庫，支持 JVM 運行時創建 Class 對象，實現動態代理當然不在話下。例如 Dubbo 就是默認使用 Javassist 來進行動態代理的。

使用示例

我們來看一下 Javassist 的使用示例：

package com.study.proxy;

import javassist.*;

import java.lang.reflect.Method;

public class JavassistTest {

    public static void main(String[] args) throws Exception {
        // 獲取默認的單例 ClassPool 對象
        ClassPool cp = ClassPool.getDefault();
        // 使用 ClassPool 生成指定名稱的 CtClass 對象，用於創建 Class 對象
        CtClass clazz = cp.makeClass("com.study.proxy.Person");

        // 創建一個字段，設置類型和名稱
        CtField field = new CtField(cp.get("java.lang.String"), "name", clazz);
        // 設置該字段的修飾符
        field.setModifiers(Modifier.PRIVATE);

        // 為 CtClass 添加兩個方法，上面 `field` 字段的 setter、getter 方法
        clazz.addMethod(CtNewMethod.setter("setName", field));
        clazz.addMethod(CtNewMethod.getter("getName", field));
        // 將 `field` 字段添加到 CtClass 對象中，並設置默認值
        clazz.addField(field, CtField.Initializer.constant("jingping"));

        // 創建一個構造方法，指定參數類型、所屬類
        CtConstructor ctConstructor = new CtConstructor(new CtClass[]{}, clazz);
        StringBuffer body = new StringBuffer();
        body.append("{\n this.name=\"liujingping\"; \n}");
        // 設置構造器的內容
        ctConstructor.setBody(body.toString());
        // 將構造器添加到 CtClass 對象中
        clazz.addConstructor(ctConstructor);

        // 創建一個方法，指定返回類型、名稱、參數類型、所屬類
        CtMethod ctMethod = new CtMethod(CtClass.voidType, "say", new CtClass[]{}, clazz);
        // 設置方法的修飾符
        ctMethod.setModifiers(Modifier.PUBLIC);
        body = new StringBuffer();
        body.append("{\n System.out.println(\"say: hello, \" + this.name); \n}");
        // 設置方法的內容
        ctMethod.setBody(body.toString());
        // 將方法添加到 CtClass 對象中
        clazz.addMethod(ctMethod);
        // 設置 .class 文件的保存路徑
        clazz.writeFile(".");

        // 通過 CtClass 對象創建一個 Class 對象，無法繼續修改 Class 對象
        Class<?> c = clazz.toClass();
        // 創建一個實例對象
        Object obj = c.newInstance();
        Method get = obj.getClass().getMethod("getName");
        // 輸出 liujingping
        System.out.println(get.invoke(obj));
        Method say = obj.getClass().getDeclaredMethod("say");
        // 輸出 say: hello, liujingping
        say.invoke(obj);
        Method set = obj.getClass().getDeclaredMethod("setName", String.class);
        set.invoke(obj, "liujingping2");
        // 輸出 liujingping2
        System.out.println(get.invoke(obj));
        // 輸出 say: hello, liujingping2
        say.invoke(obj);
    }
}

上面會創建一個 com.study.proxy.Person Class 對象，如下：

package com.study.proxy;

public class Person {
    private String name = "jingping";

    public void setName(String var1) {
        this.name = var1;
    }

    public String getName() {
        return this.name;
    }

    public Person() {
        this.name = "liujingping";
    }

    public void say() {
        System.out.println("say: hello, " + this.name);
    }
}

動態代理

package com.study.proxy;

import javassist.util.proxy.ProxyFactory;

import java.lang.reflect.Method;

public class JavassistProxy {

    public void say() {
        System.out.println("hello, liujingping");
    }

    public static void main(String[] args) throws Exception {
        ProxyFactory factory = new ProxyFactory();
        // 指定代理類的父類
        factory.setSuperclass(JavassistProxy.class);
        // 設置方法過濾器，用於判斷是否攔截方法
        factory.setFilter((Method method) -> {
            // 攔截 `say` 方法
            return "say".equals(method.getName());
        });
        factory.getClass().getDeclaredField("writeDirectory").set(factory, ".");
        JavassistProxy proxy = (JavassistProxy) factory.create(new Class<?>[]{}, new Object[]{}, (o, method, method1, objects) -> {
            System.out.println("前置處理");
            Object result = method1.invoke(o, objects);
            System.out.println("后置處理");
            return result;
        });
        proxy.say();
    }
}

控制台會輸出：

前置處理
hello, liujingping
后置處理

新生成的 Class 對象

上面我通過反射設置了 ProxyFactory 的 writeDirectory 屬性為 .，沒找到這個屬性的寫入方法😂，那么會在當前工程保存一個同包名的 .class 文件，如下：

package com.study.proxy;

import java.io.ObjectStreamException;
import java.lang.reflect.Method;
import javassist.util.proxy.MethodHandler;
import javassist.util.proxy.ProxyObject;
import javassist.util.proxy.RuntimeSupport;

public class JavassistProxy_$$_jvst475_0 extends JavassistProxy implements ProxyObject {
    private MethodHandler handler;
    public static byte[] _filter_signature;
    public static final long serialVersionUID;
    private static Method[] _methods_;

    public JavassistProxy_$$_jvst475_0() {
        this.handler = RuntimeSupport.default_interceptor;
        super();
    }

    public final void _d8say() {
        super.say();
    }

    public final void say() {
        Method[] var1 = _methods_;
        this.handler.invoke(this, var1[16], var1[17], new Object[0]);
    }

    static {
        Method[] var0 = new Method[26];
        Class var1 = Class.forName("com.fullmoon.study.proxy.JavassistProxy_$$_jvst475_0");
        RuntimeSupport.find2Methods(var1, "say", "_d8say", 16, "()V", var0);
        _methods_ = var0;
        serialVersionUID = -1L;
    }

    public void setHandler(MethodHandler var1) {
        this.handler = var1;
    }

    public MethodHandler getHandler() {
        return this.handler;
    }

    Object writeReplace() throws ObjectStreamException {
        return RuntimeSupport.makeSerializedProxy(this);
    }
}

可以看到會繼承 JavassistProxy 目標類，並實現 Javassist 的 ProxyObject 接口，在 say() 方法中會調用 MethodHandler 處理類進行攔截處理，這里我們僅做了解，因為 Spring AOP 中沒有使用到這種動態代理。

總結

本文對 JDK 動態代理和 CGLIB 動態代理進行了淺顯的分析，可以得出以下結論：

• 靜態代理通過實現被代理類所實現的接口，內部保存被代理類的引用，在實現的方法中對處理邏輯進行增強，真正的方法執行調用被代理對象的方法。靜態代理比較簡潔直觀，不過每個目標對象都需要創建一個代理類，在復雜的場景下需要創建大量的代理類，不易於維護，也不易於擴展，我們更加注重的應該是業務開發，對於這一層增強處理應該抽取出來。
• JDK 動態代理基於接口代理，在 JVM 運行時通過反射機制生成一個實現代理接口的類，在調用具體方法時會調用 InvokeHandler 來進行處理。
• CGLIB 動態代理基於類代理（字節碼提升），通過 ASM（Java 字節碼的操作和分析框架）將被代理類的 class 文件加載進來，通過修改其字節碼生成一個子類來處理。

為什么 JDK 動態代理只能基於接口代理，不能基於類代理？

JDK 動態代理通過 Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) 創建代理對象，對於入參中的 interfaces 如果存在非接口，會拋出異常；且從生成的代理對象中看到代理對象會繼承 Proxy 這個類，在 Java 中類只能是單繼承關系，無法再繼承一個代理類，所以只能基於接口代理。