該系列文章是本人在學習 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 代理的實現。
示例
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());
}
}
}
建立代理類的過程如下：
- 遍歷需要實現的介面，進行校驗；
- 校驗該介面是在存在這個 ClassLoader 中
- 校驗是否真的是介面（因為入參也可以不傳介面）
- 校驗是否出現相同的介面（因為入參也可以傳相同的介面）
- 遍歷需要實現的介面，判斷是否存在非
public的介面，該步驟和生成的代理類的名稱有關；- 如果存在，則記錄下來，並記錄所在的包名
- 如果存在非
public的介面，且還存在其他包路徑下的介面，則丟擲異常
- 如果不存在非
public的介面，則代理類的名稱字首為com.sun.proxy. - 生成一個代理類的名稱，
com.sun.proxy.$Proxy+ 唯一數字（從 0 開始遞增）- 對於非
public的介面，這裡的名字首就取原介面包名了，因為不是public修飾需要保證可訪問
- 對於非
- 根據代理類的名稱、需要實現的介面以及修飾符生成一個位元組陣列
- 根據第
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);
}
}
整個過程比較複雜，上面沒有深入分析，因為筆者實在是看不懂~?，可以先理解為建立一個目標類的子類?
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("D:\\workspaces\\idea\\study-java");
// 通過 CtClass 物件建立一個 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);
}
}
總結
本文對 JDK 動態代理和 CGLIB 動態代理進行了淺顯的分析，可以得出以下結論：
- 靜態代理通過實現被代理類所實現的介面，內部儲存被代理類的引用，在實現的方法中對處理邏輯進行增強，真正的方法執行呼叫被代理物件的方法。靜態代理比較簡潔直觀，不過每個目標物件都需要建立一個代理類，在複雜的場景下需要建立大量的代理類，不易於維護，也不易於擴充套件，我們更加註重的應該是業務開發，對於這一層增強處理應該抽取出來。
- JDK 動態代理基於介面代理，在 JVM 執行時通過反射機制生成一個實現代理介面的類，在呼叫具體方法時會呼叫 InvokeHandler 來進行處理。
- CGLIB 動態代理基於類代理（位元組碼提升），通過 ASM（Java 位元組碼的操作和分析框架）將被代理類的 class 檔案載入進來，通過修改其位元組碼生成一個子類來處理。
為什麼 JDK 動態代理只能基於介面代理，不能基於類代理？
JDK 動態代理通過
Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)建立代理物件，對於入參中的interfaces如果存在非介面，會丟擲異常；且從生成的代理物件中看到代理物件會繼承Proxy這個類，在 Java 中類只能是單繼承關係，無法再繼承一個代理類，所以只能基於介面代理。