面試官：聊一聊JDK動態代理底層原理
作者：程序員清宇
JDK 動態代理使用的是 java.lang.reflect.Proxy? 類和 InvocationHandler? 接口。在動態代理機制中，Proxy? 類通過實現代理類的接口來生成代理對象，并將方法調用委托給 InvocationHandler。因此，JDK 動態代理的工作原理也決定了它只能代理接口，而不能直接代理具體類。?
在日常開發中，代理模式是一種常見的設計模式。代理可以為對象提供額外的功能或控制訪問。在Java中，代理分為靜態代理和動態代理，尤其是動態代理，應用廣泛且靈活性強。本文將深入分析Java中的代理機制，特別是動態代理的兩種實現方式：JDK動態代理和CGLIB動態代理。
1. 靜態代理
靜態代理是指代理類在編譯時就已經確定，代理類和目標類都需要實現同一個接口。代理類通過實現接口的方法，增強目標類的方法邏輯。
舉個例子：
/**
* 用戶接口
*/
public interface IUserService {
/**
* 查詢所有用戶
*/
void queryUserList();
}
/**
* 目標類實現類
*/
public class UserServiceImpl implements IUserService{
@Override
public void queryUserList() {
System.out.println("查詢所有用戶信息");
}
}
/**
* 代理類實現類
*/
public class UserServiceProxy implements IUserService {
private UserServiceImpl userService;
public UserServiceProxy(UserServiceImpl userService) {
this.userService = userService;
}
@Override
public void queryUserList() {
System.out.println("----鑒權操作----");
System.out.println("查詢所有用戶信息");
System.out.println("----記錄日志操作----");
}
}
====================================================================
/**
* 測試
*/
public class StaticAgentTest {
public static void main(String[] args) {
UserServiceProxy userServiceProxy = new UserServiceProxy(new UserServiceImpl());
userServiceProxy.queryUserList();
}
}輸出結果：
----鑒權操作----
查詢所有用戶信息
----記錄日志操作----上面的UserServiceProxy就是一個靜態代理類，可以在執行目標方法前后添加了自定義的邏輯。
然而，靜態代理有一個顯著的缺點——需要為每個目標類手動創建代理類，代碼冗余且不靈活。
要是能夠動態的生成這些代理類就好了，這不，動態代理應運而生。
2. 動態代理
動態代理和靜態代理的主要區別在于：靜態代理是在編譯時確定的，而動態代理是在運行時生成的。在Java中，動態代理可以分為兩種實現方式：JDK動態代理和CGLIB動態代理。
2.1 JDK動態代理
JDK動態代理只能代理實現了接口的類。它使用反射機制生成代理類，動態地處理目標對象的方法調用。
2.1.1 JDK動態代理的實現步驟
- 創建一個目標接口及其實現類。
- 使用InvocationHandler接口來自定義方法調用處理邏輯。
- 通過Proxy.newProxyInstance方法生成代理對象。
/**
* 用戶接口
*/
public interface IUserService {
/**
* 查詢所有用戶
*/
void queryUserList();
}
/**
* 目標類實現類
*/
public class UserServiceImpl implements IUserService{
@Override
public void queryUserList() {
System.out.println("查詢所有用戶信息");
}
}
==============================jdk動態代理=============================
/**
* 實現InvocationHandler，處理代理邏輯
*/
public class UserServiceInvocationHandler implements InvocationHandler {
private Object target;
public UserServiceInvocationHandler(Object targetClass) {
this.target = targetClass;
}
// 代理目標方法，增強
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("----代理方法執行前----");
// 代理目標方法
Object result = method.invoke(target, args);
System.out.println("----代理方法執行后----");
return result;
}
}
/**
* 測試jdk動態代理
*/
public class JdkProxyTest {
public static void main(String[] args) {
IUserService target = new UserServiceImpl();
// 創建代理對象
IUserService proxyInstance = (IUserService) Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
new UserServiceInvocationHandler(target)
);
// 執行代理方法
proxyInstance.queryUserList();
}
}運行結果：
----代理方法執行前----
查詢所有用戶信息
----代理方法執行后----2.1.2 JDK動態代理的底層原理及Proxy源碼解析
Proxy.newProxyInstance方法會生成一個代理對象，該代理對象會實現目標對象的接口，并將方法調用交給InvocationHandler的invoke方法。具體步驟如下：
- Proxy.newProxyInstance方法通過傳入目標類的類加載器、接口列表以及InvocationHandler對象，動態地生成代理類。
- 在代理類中，所有接口方法的實現都會調用InvocationHandler的invoke方法。
- invoke方法中通過反射調用目標對象的方法，同時可以在前后添加自定義邏輯。
JDK動態代理的好處不言而喻，可以在運行時創建代理類，不需要為每一個目標類創建一個代理類，缺點就是底層使用的是反射技術，在運行時反射生成代理對象，可能對性能有一定影響。
我們再來回顧下JDK動態代理創建過程，之所以能夠在運行時生成代理類和代理對象，完全是Proxy這個類在起作用，我們來看下這個類的方法。
圖片
其中有個getProxyClass(ClassLoader loader,Class<?>... interfaces)方法。
@CallerSensitive
public static Class<?> getProxyClass(ClassLoader loader,
Class<?>... interfaces)
throws IllegalArgumentException
{
final Class<?>[] intfs = interfaces.clone();
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}
return getProxyClass0(loader, intfs);
}從類名可以看出，這是一個獲取代理類的方法，我們知道，生成代理對象必須要有代理類，然后根據構造函數來創建我們的代理對象。
所以，我們先通過這個方法獲取下 代理類。
public static void main(String[] args) {
Class<?> proxyClass = Proxy.getProxyClass(UserServiceImpl.class.getClassLoader(), UserServiceImpl.class.getInterfaces());
// 獲取代理類的名字
System.out.println(proxyClass.getName());
// 獲取代理類中的方法
Method[] declaredMethods = proxyClass.getDeclaredMethods();
for (Method declaredMethod : declaredMethods) {
System.out.println(declaredMethod.getDeclaringClass() + " " + declaredMethod.getName());
}
// 查看代理類的構造函數
Constructor<?>[] constructors = proxyClass.getConstructors();
for (Constructor<?> constructor : constructors) {
System.out.println(constructor.toString());
}
}輸出結果：
com.sun.proxy.$Proxy0
class com.sun.proxy.$Proxy0 queryUserList
class com.sun.proxy.$Proxy0 equals
class com.sun.proxy.$Proxy0 toString
class com.sun.proxy.$Proxy0 hashCode
public com.sun.proxy.$Proxy0(java.lang.reflect.InvocationHandler)從輸出結果可以看出：
代理類的名稱是$Proxy0，其中有個方法queryUserList就是我們的代理方法，也可以看出代理類沒有無參構造，而是一個參數為java.lang.reflect.InvocationHandler的有參構造。
那我們就通過這個有參構造來創建下代理對象。
public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
Class<?> proxyClass = Proxy.getProxyClass(UserServiceImpl.class.getClassLoader(), UserServiceImpl.class.getInterfaces());
// 獲取構造方法
Constructor<?> constructor = proxyClass.getConstructor(InvocationHandler.class);
IUserService userService = (IUserService) constructor.newInstance(new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 查看下proxy對象
System.out.println(proxy.getClass());
// 查看下方法信息
System.out.println(method.getDeclaringClass() + " " + method.getName());
return null;
}
});
userService.queryUserList();// 第一次調用
userService.queryUserList();// 第二次調用
}class com.sun.proxy.$Proxy0
interface com.qy.staticAgent.IUserService queryUserList
class com.sun.proxy.$Proxy0
interface com.qy.staticAgent.IUserService queryUserList顯然，每調用一次queryUserList()方法，都會回調構造函數傳入的InvocationHandler對象的invoke方法，這里我們猜測下，是不是在生成的代理類中，有一個InvocationHandler類的對象變量，在代理接口方法中通過這個對象調用invoke方法，我們驗證下。
通過加入以下代碼，可以保存我們動態生成的代理類class文件。
//JDK1.8及以前的版本
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
//JDK1.8以后的版本
System.getProperties().put("jdk.proxy.ProxyGenerator.saveGeneratedFiles", "true");
生成的代理類文件
public final class $Proxy0 extends Proxy implements IUserService {
// 緩存反射調用的Method對象
private static Method m1; // 對應Object類的equals方法
private static Method m4; // 對應IUserService接口的delete方法
private static Method m2; // 對應Object類的toString方法
private static Method m3; // 對應IUserService接口的queryUserList方法
private static Method m0; // 對應Object類的hashCode方法
/**
* 構造函數，調用父類Proxy的構造函數
* @param var1 代理對象的InvocationHandler
* @throws Exception 可能拋出的異常
*/
public $Proxy0(InvocationHandler var1) throws {
super(var1); // 調用父類Proxy的構造函數，并傳遞InvocationHandler
}
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);
}
}
/**
* delete方法的代理實現，調用InvocationHandler的invoke方法
* @param var1 需要刪除的用戶ID
* @throws RuntimeException, Error, Throwable 在調用過程中可能拋出的異常
*/
public final void delete(int var1) throws {
try {
// 調用InvocationHandler的invoke方法，傳遞代理對象的delete方法和參數
super.h.invoke(this, m4, 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);
}
}
/**
* queryUserList方法的代理實現，調用InvocationHandler的invoke方法
* @throws RuntimeException, Error, Throwable 在調用過程中可能拋出的異常
*/
public final void queryUserList() throws {
try {
// 調用InvocationHandler的invoke方法，傳遞代理對象的queryUserList方法
super.h.invoke(this, m3, (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);
}
}
/**
* 靜態代碼塊，用于初始化反射的Method對象。
* 靜態代碼塊在類加載時執行一次，用于緩存方法對象。
*/
static {
try {
// 獲取Object類的equals方法
m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
// 獲取IUserService接口的delete方法，參數類型為int
m4 = Class.forName("com.qy.staticAgent.IUserService").getMethod("delete", Integer.TYPE);
// 獲取Object類的toString方法
m2 = Class.forName("java.lang.Object").getMethod("toString");
// 獲取IUserService接口的queryUserList方法，無參數
m3 = Class.forName("com.qy.staticAgent.IUserService").getMethod("queryUserList");
// 獲取Object類的hashCode方法
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}可以看出動態生成的代理類$Proxy0繼承Proxy對象，并且實現了IUserService接口，在代理方法的實現中，都會通過父類Proxy的InvocationHandler對象的invoke方法，這也解釋了為什么調用一次代理方法都會回調invoke方法。
當然，我們一般使用Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)直接創建代理對象。
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentExceptionnewProxyInstace創建代理對象的過程
/**
* 創建并返回一個指定接口的代理實例，該代理實例將方法調用委托給指定的InvocationHandler。
*
* @param loader 定義代理類的類加載器
* @param interfaces 代理類要實現的接口
* @param h 調用處理器，用于處理代理對象的方法調用
* @return 返回代理類的實例
* @throws IllegalArgumentException 如果接口數組中包含非法的接口
*/
@CallerSensitive
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<?> cl = getProxyClass0(loader, intfs);
/*
* 使用指定的InvocationHandler調用其構造函數
*/
try {
// 如果安全管理器不為空，檢查對新建代理類的權限
if (sm != null) {
checkNewProxyPermission(Reflection.getCallerClass(), cl);
}
// 獲取代理類的構造函數，構造函數參數為InvocationHandler類型
final Constructor<?> cons = cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
// 如果代理類不是public的，則將構造函數的訪問權限設置為可訪問
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);
}
}我們看下重點的方法：
getProxyClass0(loader, intfs)解析
// 緩存生成的代理類
private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {
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
// 如果由給定類加載器定義的實現給定接口的代理類已經存在，
// 則直接從緩存中返回該代理類的副本，否則通過ProxyClassFactory創建代理類。
return proxyClassCache.get(loader, interfaces);
}注釋寫的很清晰，如果緩存有，就從緩存取，沒有就通過ProxyClassFactory創建代理類。
ProxyClassFactory生成代理類源碼解析ProxyClassFactory是一個實現了 BiFunction<ClassLoader, Class<?>[], Class<?>> 接口的內部靜態類，用于為給定的類加載器和接口數組生成代理類。
/**
* ProxyClassFactory 是一個內部靜態類，實現了 BiFunction 接口，用于生成代理類。
* 該類為給定的類加載器和接口數組生成唯一命名的代理類，并返回該代理類的 Class 對象。
*/
private static final class ProxyClassFactory
implements BiFunction<ClassLoader, Class<?>[], Class<?>>
{
// 所有代理類名的前綴
private static final String proxyClassNamePrefix = "$Proxy";
// 用于生成唯一代理類名的數字，使用 AtomicLong 來保證線程安全
private static final AtomicLong nextUniqueNumber = new AtomicLong();
/**
* 為指定的類加載器和接口數組生成代理類。
*
* @param loader 類加載器，定義代理類的加載器
* @param interfaces 代理類要實現的接口數組
* @return 代理類的 Class 對象
* @throws IllegalArgumentException 如果接口不可見、重復或其他無效條件，則拋出異常
*/
@Override
public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
// 使用 IdentityHashMap 來存儲接口并檢查重復
Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
====================================校驗邏輯=============================================
for (Class<?> intf : interfaces) {
/*
* 驗證類加載器解析的接口是否與傳入的接口相同。
*/
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");
}
/*
* 確認傳入的 Class 對象是接口，而不是類或其他類型。
這里一定是接口
*/
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");
}
}
}
====================================定義生成文件名的規則===================================================
if (proxyPkg == null) {
// 如果沒有非公共接口，則使用默認的 com.sun.proxy 包
proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
}
/*
* 選擇生成的代理類的名稱。通過 AtomicLong 生成唯一的數字，避免類名沖突。
*/
long num = nextUniqueNumber.getAndIncrement();
String proxyName = proxyPkg + proxyClassNamePrefix + num;
====================================生成代理類字節碼===================================================
/*
* 生成代理類字節碼。
*/
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
try {
// 定義代理類，并將字節碼加載到指定的類加載器中
return defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
/*
* 如果出現 ClassFormatError，說明代理類生成過程中出現無效的參數或
* 虛擬機限制超出，拋出異常。
*/
throw new IllegalArgumentException(e.toString());
}
}
}apply方法執行流程
- 對類和方法的校驗，驗證接口的有效性，檢查接口是否是類加載器可見的接口，是否為接口類型，是否有重復。
- 代理類包名的生成遵循以下規則
- 公共接口（Public Interface）：
如果所有的代理接口都是公共的（即 public），代理類將定義在默認的 com.sun.proxy包下。具體來說，代理類的完整包名為 com.sun.proxy.$ProxyN，其中 N是一個唯一的數字，用于確保代理類名稱不沖突。
- 非公共接口（Non-public Interface）：
如果有任何一個接口是非公共的（即沒有使用 public 修飾符），則代理類必須定義在該非公共接口所在的包中。因為在 Java 中，非公共接口只能由同一個包中的類實現。
當多個非公共接口存在時，所有這些接口必須屬于同一個包。否則會拋出 IllegalArgumentException，因為代理類不能同時實現來自不同包的非公共接口。
- 包名的一致性：
代理類的包名要么是 com.sun.proxy，要么是非公共接口所在的包。
- 命名規則：
代理類的類名前綴為 "$Proxy"，并且會在其后附加一個自增的數字，保證生成的代理類名稱的唯一性。這個數字由一個 AtomicLong 計數器生成，確保多線程環境下也不會發生類名沖突，是線程安全的。
- 通過ProxyGenerator.generateProxyClass()生成代理類字節碼數組
/*
* 生成代理類字節碼。
*/
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags);在這個方法里有個參數saveGeneratedFiles就是控制是否將代理類文件保存下來，因為上面已經生成過了，這里就不做過多說明了。
private static final boolean saveGeneratedFiles = (Boolean)AccessController.doPrivileged(new GetBooleanAction("sun.misc.ProxyGenerator.saveGeneratedFiles"));
public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {
ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
// 生成代理類字節碼數組
final byte[] var4 = var3.generateClassFile();
// 判斷是否需要保存代理類文件
if (saveGeneratedFiles) {
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
try {
int var1 = var0.lastIndexOf(46);
Path var2;
if (var1 > 0) {
Path var3 = Paths.get(var0.substring(0, var1).replace('.', File.separatorChar));
Files.createDirectories(var3);
var2 = var3.resolve(var0.substring(var1 + 1, var0.length()) + ".class");
} else {
var2 = Paths.get(var0 + ".class");
}
Files.write(var2, var4, new OpenOption[0]);
return null;
} catch (IOException var4x) {
throw new InternalError("I/O exception saving generated file: " + var4x);
}
}
});
}
return var4;
}后續就是通過構造器生成我們的代理對象。至此，整個jdk動態代理的流程就已經結束了。
到現在，你應該知道為什么jdk的動態代理一定要基于接口實現了吧。
總結
我們知道，擴展一個類，要么繼承，要么實現接口，這兩種方式都可以對方法進行增強。
JDK 動態代理使用的是 java.lang.reflect.Proxy 類和 InvocationHandler 接口。在動態代理機制中，Proxy 類通過實現代理類的接口來生成代理對象，并將方法調用委托給 InvocationHandler。因此，JDK 動態代理的工作原理也決定了它只能代理接口，而不能直接代理具體類。
責任編輯：武曉燕
來源：
玄武后端技術棧
