萬字乾貨_JDK動態代理及其原始碼解析 拿捏了
2022-11-15 12:00:45
目錄
作者：小牛呼嚕嚕 | https://xiaoniuhululu.com
計算機內功、JAVA底層、面試相關資料等更多精彩文章在公眾號「小牛呼嚕嚕 」
大家好，我是呼嚕嚕，在之前的一篇文章-Java註解中，我們詳細講解了Java註解及其原理，其中反射呼叫註解的時候（class.getAnnotation），會繼承動態代理類AnotationInvocationHandler，建立註解的代理範例，來讓開發者後續操作註解。本篇文章將深入聊聊什麼是動態代理
代理模式
首先我們要明白動態代理屬於設計模式中的代理模式
所謂代理模式是指通過存取目標物件的代理物件，再由代理物件去存取目標物件
通俗點講，本來我們只可直接去商店買藥 ;突然有一天，我們的車壞了，導致我們無法直接去商店買藥。這個時候，又急著需要藥，我們可以打電話叫
代理人:小張去商店幫我們買藥，然後再讓他把藥給我們帶回來。這樣最終我們拿到了藥。
這樣一來就可以在不修改原目標物件的前提下，提供額外的功能操作，實現擴充套件目標物件的功能。
靜態代理
代理模式有靜態代理和動態代理兩種實現方式
靜態代理和動態代理的區別？什麼是靜態、動態？
從 JVM 層面來說:
- 靜態代理：
- 在編譯時就已經實現，編譯完成後代理類是一個實際的class檔案
- 代理類和委託類的關係在程式執行前就已確定
- 動態代理：
- 在執行時動態生成的，即編譯完成後沒有實際的class檔案，而是在執行時動態生成類位元組碼，並載入到JVM中
- 代理類和委託類的關係是在程式執行時確定
靜態代理的使用步驟
我們先聊聊靜態代理, 其一般使用步驟：
- 定義一個介面及其實現類；
- 建立一個代理類同樣實現這個介面
- 將目標物件注入進代理類，然後就可以在代理類的對應方法呼叫目標類中的對應方法
範例
我們來模擬一下上文買藥的例子，另外我們想代理人順便幫我們在買點水果啥的
定義一個介面，來代表我們的目標
public interface OurService {
void buyMed();
}
再實現我們的介面
public class OurServiceImpl implements OurService {
@Override
public void buyMed() {
System.out.println("買藥。。。");
}
}
建立代理類並額外附表其他目標，比如買蛋糕、水果啊之類的
public class MyStaticProxy implements OurService {
private OurService ourService;
public MyStaticProxy(OurService ourService) {
this.ourService = ourService;
}
@Override
public void buyMed() {
System.out.println("買藥前，先去買蛋糕。。。");
ourService.buyMed();
System.out.println("買藥後，再去買水果。。。");
}
}
最後測試類
public class TestStaticProxy {
public static void main(String[] args) {
OurService ourService = new OurServiceImpl();
//userService.buyMed(); 直接執行
MyStaticProxy myStaticProxy = new MyStaticProxy(ourService);
myStaticProxy.buyMed();//委託 代理類 去執行
}
}
結果：
買藥前，先去買蛋糕。。。
買藥。。。
買藥後，再去買水果。。。
靜態代理的缺陷
從上面的例子，我們可以發現靜態代理非常容易地實現了對一個類的代理操作，但是也有幾個缺點：
- 靜態代理不能使一個代理類反覆作用於多個目標物件，代理物件直接持有目標物件的參照，這導致代理物件和目標物件型別緊密耦合了在一起，需要對每個目標類都單獨寫一個代理類。
- 不易維護，一旦介面更改，代理類和目標類都需要更改，比較繁瑣。
解決靜態代理的缺陷的思路
通過上文我們可以發現靜態代理最大的缺點，就是不能使一個代理類反覆作用於多個目標物件，要想實現不同的增強功能，必須編寫不同的代理類，耦合性高。那我們能不能對於不同的源程式，讓JVM自動生成對應的代理類？如果可以的話，這樣不就可以解決問題了嘛。
首先我們得思考一個問題，java怎樣才能動態地生成代理類？
我們先來回顧一下物件的建立過程
建立一個範例物件的底層邏輯，其實與.class檔案和Class物件息息相關
"沒有物件， 那就new一個",對於每個javar來說都太熟悉了，但這樣往往忽視了底層的細節--最核心就是得到對應的Class物件
在文章https://mp.weixin.qq.com/s/v91bqRiKDWWgeNl1DIdaDQ中，我們聊到了JVM類的載入過程
載入階段：指的是將類對應的.class檔案中的二進位制位元組流讀入到記憶體中，將這個位元組流轉化為方法區的執行時資料結構，然後在堆區建立一個java.lang.Class 物件，作為對方法區中這些資料的存取入口
其中將類對應的.class檔案中的二進位制位元組流讀入到記憶體中，JVM虛擬機器器規範並沒有
指明二進位制位元組流必須得從某個Class檔案中獲取，確切地說是根本沒有指明要從哪裡獲取、如何獲取。
所以獲取類的二進位制位元組流(class位元組碼)有很多途徑：
- 從ZIP包獲取，這是JAR、EAR、WAR等格式的基礎
- 從網路中獲取，典型的應用是 Applet
- 執行時計算生成，這種場景使用最多的是動態代理技術，在 java.lang.reflect.Proxy 類中，就是用了 ProxyGenerator.generateProxyClass 來為特定介面生成形式為 *$Proxy 的代理類的二進位制位元組流
- 由其他檔案生成，典型場景是JSP應用，由JSP檔案生成對應的Class檔案。
- 從資料庫中讀取，這種場景相對少見些，例如有些中介軟體伺服器（如SAP Netweaver）可以選擇 把程式安裝到資料庫中來完成程式程式碼在叢集間的分發。
- 可以從加密檔案中獲取，這是典型的防Class檔案被反編譯的保護措施，通過載入時解密Class文 件來保障程式執行邏輯不被窺探。
在筆者之前講解Java反射的文章https://mp.weixin.qq.com/s/_n8HTIjkw7Emcunpb4-Iwg中，我們知曉：
- 類也是可以用來儲存資料的，Class類就像 普通類的模板 一樣，用來儲存「類所有相關資訊」的類，得到了Class物件也就可以得到了代理類
- 還講解了獲取Class範例4種方式，前提都需要先有代理類，但我們現在需要反過來先獲取代理類的位元組碼，從而動態生成代理類
所以要想解決靜態代理的缺陷，我們就得 想辦法先得到代理類的位元組碼，從而動態生成代理類！
這時候動態代理就應運而生了，動態代理無需宣告式的建立java代理類，而是在執行過程中動態生成"代理類"，即編譯完成後 **沒有實際的class檔案** 而是在執行時動態生成**類位元組碼**，並載入到JVM中。從而避免了靜態代理那樣需要宣告大量的代理類。
為了讓生成的代理類與目標物件保持一致性，我們將介紹兩種最常見的途徑：
- 通過目標類實現的介面 -> JDK動態代理
- 通過目標類本身 -> CGLIB動態代理
JDK動態代理
JDK 動態代理類使用步驟
- 定義一個介面及其實現類；
- 自定義
InvocationHandler並重寫invoke方法，在invoke 方法中我們會呼叫原生方法（被代理類的方法）並自定義一些處理邏輯； - 通過
Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h) 方法建立代理物件；
範例
我們繼續沿用本文上面的例子OurService，我們來為其再編寫一個自定義的JDK動態代理類：
public class MyInvocationHandler implements InvocationHandler {
//需要代理的目標物件
private Object target;
public MyInvocationHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws InvocationTargetException, IllegalAccessException {
//呼叫方法之前，我們可以新增額外邏輯
System.out.println("before method " + method.getName());
Object result = method.invoke(target, args);
//呼叫方法之後，我們也可以新增額外邏輯
System.out.println("after method " + method.getName());
return result;
}
}
接著編寫測試類：
public class TestDynamicProxy {
public static void main(String[] args) {
//檢視代理類原始碼,會在專案根目錄生成一個目錄:com/sum/proxy/$Proxy0.java
//System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");
//建立一個範例物件，這個物件是被代理的物件（這裡是介面實現類）
OurService ourService = new OurServiceImpl();
//建立一個與代理物件相關聯的InvocationHandler
InvocationHandler stuHandler = new MyInvocationHandler(ourService);
//建立一個代理物件stuProxy來代理OurServiceImpl
// 代理物件的每個執行方法都會替換執行Invocation中的invoke方法
OurService stuProxy = (OurService)Proxy.newProxyInstance(
ourService.getClass().getClassLoader(), // 目標類的類載入
ourService.getClass().getInterfaces(), // 需要代理的介面，可指定多個
stuHandler);
//代理去執行方法--買藥
stuProxy.buyMed();
}
}
結果：
before method buyMed
買藥。。。
after method buyMed
這樣我們就能夠實現程式碼複用，增加程式的解耦能力，解決靜態代理的缺陷。
底層原理
這塊是本文的重點，我們來看看原始碼，分析分析JDK動態代理是怎麼實現的？
我們來看下Proxy._newProxyInstance_的原始碼：
@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);//校驗
}
/*
* Look up or generate the designated proxy class.
*/
//先從快取獲取代理類, 如果沒有再去生成一個代理類!!!
Class<?> cl = getProxyClass0(loader, intfs);
/*
* Invoke its constructor with the designated invocation handler.
*/
try {
if (sm != null) {
checkNewProxyPermission(Reflection.getCallerClass(), cl);
}
//獲取引數型別是InvocationHandler.class的代理類構造器!!!
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範例去構造一個代理類的範例 !!!
//所有代理類都繼承自Proxy, 因此這裡會呼叫Proxy的構造器將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);
}
}
主要是3個核心的步驟：
Class<?> cl = getProxyClass0(loader, intfs);``從快取獲取代理類, 如果沒有再去通過目標類的實現介面生成一個代理類Class物件final Constructor<?> cons = cl.getConstructor(constructorParams);通過代理類Class物件獲取代理類構造器cons.newInstance(new Object[]{h});通過反射將代理類Class物件生成代理類的範例
我們來看下其中最核心的方法：
Class<?> cl = _getProxyClass0_(loader, intfs);
此處獲得了代理類Class物件，後面程式碼中獲取構造器也是通過這裡產生的類來獲得，是整個動態代理最核心的地方。
檢視getProxyClass0原始碼：
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
return proxyClassCache.get(loader, interfaces);
}
proxyClassCache.get(loader, interfaces);這邊有段註釋大致的意思：「先從快取獲取代理類, 如果沒有命中快取，再去通過ProxyClassFactory生成代理類」
我們繼續往下看proxyClassCache.get(loader, interfaces)：
public V get(K key, P parameter) {
//要求引數，傳進來的介面不能為空
Objects.requireNonNull(parameter);
//清除過期的快取
expungeStaleEntries();
//將ClassLoader包裝成CacheKey, 作為一級快取的key
Object cacheKey = CacheKey.valueOf(key, refQueue);
// lazily install the 2nd level valuesMap for the particular cacheKey
//獲取得到二級快取，用ConcurrentMap接受，保證執行緒安全
ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
if (valuesMap == null) {
//以CAS方式放入, 如果不存在則放入，否則返回原先的值
ConcurrentMap<Object, Supplier<V>> oldValuesMap
= map.putIfAbsent(cacheKey,
valuesMap = new ConcurrentHashMap<>());
if (oldValuesMap != null) {
valuesMap = oldValuesMap;
}
}
// create subKey and retrieve the possible Supplier<V> stored by that
// subKey from valuesMap
//根據代理類實現的介面陣列 來生成二級快取key並檢索
Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
//這裡通過subKey獲取到二級快取的值
Supplier<V> supplier = valuesMap.get(subKey);
Factory factory = null;
while (true) {//死迴圈，命中快取就直接返回結果，不然就建立代理物件然後返回
if (supplier != null) {
// supplier might be a Factory or a CacheValue<V> instance
//在這裡supplier可能是一個Factory也可能會是一個CacheValue
//命中快取就直接返回結果，不然就建立代理物件
V value = supplier.get();
if (value != null) {
return value;
}
}
// else no supplier in cache
// or a supplier that returned null (could be a cleared CacheValue
// or a Factory that wasn't successful in installing the CacheValue)
// lazily construct a Factory
if (factory == null) {
//新建一個Factory範例作為subKey對應的值
factory = new Factory(key, parameter, subKey, valuesMap);
}
if (supplier == null) {
//到這裡表明subKey沒有對應的值, 就將factory作為subKey的值放入
supplier = valuesMap.putIfAbsent(subKey, factory);
if (supplier == null) {
// successfully installed Factory
supplier = factory;
}
// else retry with winning supplier
//否則, 可能期間有其他執行緒修改了值, 那麼直接將subKey取出
} else {
if (valuesMap.replace(subKey, supplier, factory)) {
// successfully replaced
// cleared CacheEntry / unsuccessful Factory
// with our Factory
supplier = factory;
} else {
// retry with current supplier
supplier = valuesMap.get(subKey);
}
}
}
}
這是WeakCache快取類，非常複雜，我們只需關注
V value = supplier.get();這裡supplier可能是一個Factory也可能會是一個CacheValue，如果命中快取就直接返回結果結束迴圈
不然再次迴圈的時候
factory = new Factory(key, parameter, subKey, valuesMap);
supplier = factory;
這個時候V value = supplier.get();，其實調的是Factory.get()方法：
@Override
public synchronized V get() { // serialize access
// re-check
Supplier<V> supplier = valuesMap.get(subKey);
if (supplier != this) {
// something changed while we were waiting:
// might be that we were replaced by a CacheValue
// or were removed because of failure ->
// return null to signal WeakCache.get() to retry
// the loop
return null;
}
// else still us (supplier == this)
// create new value
V value = null;
try {
value = Objects.requireNonNull(valueFactory.apply(key, parameter));
} finally {
if (value == null) { // remove us on failure
valuesMap.remove(subKey, this);
}
}
// the only path to reach here is with non-null value
assert value != null;
// wrap value with CacheValue (WeakReference)
CacheValue<V> cacheValue = new CacheValue<>(value);
// put into reverseMap
reverseMap.put(cacheValue, Boolean.TRUE);
// try replacing us with CacheValue (this should always succeed)
if (!valuesMap.replace(subKey, this, cacheValue)) {
throw new AssertionError("Should not reach here");
}
// successfully replaced us with new CacheValue -> return the value
// wrapped by it
return value;
}
該get()方法，主要是 通過valueFactory建立代理類後 將代理類包裝為CacheValue類，並將valuesMap快取中對應代理類的Supplier替換為包裝後的CacheValue,這樣後面就可以直接呼叫CacheValue的get方法來獲取代理類
其中 value = Objects.requireNonNull(valueFactory.apply(key, parameter));此處valueFactory我們來看下它是怎麼過來的
final class WeakCache<K, P, V> {
...
private final BiFunction<K, P, V> valueFactory;
public WeakCache(BiFunction<K, P, ?> subKeyFactory,
BiFunction<K, P, V> valueFactory) {
this.subKeyFactory = Objects.requireNonNull(subKeyFactory);
this.valueFactory = Objects.requireNonNull(valueFactory);
}
...
}
發現其是WeakCache類初始化的時候，就過來的，我們再去上層找
public class Proxy implements java.io.Serializable {
...
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
return proxyClassCache.get(loader, interfaces);
}
...
}
終於找到來源proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
那valueFactory.apply(key, parameter)，parameter引數是目標類實現的介面Class物件 ,其實調到是ProxyClassFactory.apply()方法：
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) {
/*
* Verify that the class loader resolves the name of this
* interface to the same Class object.
*/
Class<?> interfaceClass = null;
try {
//驗證intf是否可以由指定的類載入進行載入
interfaceClass = Class.forName(intf.getName(), false, loader);
} catch (ClassNotFoundException e) {
}
if (interfaceClass != intf) {
throw new IllegalArgumentException(
intf + " is not visible from class loader");
}
/*
* Verify that the Class object actually represents an
* interface.
*/
//驗證intf是否是一個介面
if (!interfaceClass.isInterface()) {
throw new IllegalArgumentException(
interfaceClass.getName() + " is not an interface");
}
/*
* Verify that this interface is not a duplicate.
*/
//驗證intf在陣列中是否有重複
if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
throw new IllegalArgumentException(
"repeated interface: " + interfaceClass.getName());
}
}
//生成代理類的包名
String proxyPkg = null; // package to define proxy class in
//生成代理類的存取標誌, 預設是public final的
int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
/*
* Record the package of a non-public proxy interface so that the
* proxy class will be defined in the same package. Verify that
* all non-public proxy interfaces are in the same package.
*/
for (Class<?> intf : interfaces) {
int flags = intf.getModifiers();
//如果介面的存取標誌不是public, 那麼生成代理類的包名和介面包名相同
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 + ".";
}
/*
* Choose a name for the proxy class to generate.
*/
//生成代理類的序號
long num = nextUniqueNumber.getAndIncrement();
//生成代理類的全限定名, 包名+字首+序號, 例如：com.sun.proxy.$Proxy0.這個就是我們debug經常看到的
String proxyName = proxyPkg + proxyClassNamePrefix + num;
/*
* Generate the specified proxy class.
*/
// 用ProxyGenerator來生成位元組碼, 該類放在sun.misc包下 !!!
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
try {
//根據二進位制檔案生成相應的Class範例
return defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
/*
* A ClassFormatError here means that (barring bugs in the
* proxy class generation code) there was some other
* invalid aspect of the arguments supplied to the proxy
* class creation (such as virtual machine limitations
* exceeded).
*/
throw new IllegalArgumentException(e.toString());
}
}
}
其中byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags); （這裡我們留意一下引數）用ProxyGenerator來生成位元組碼,我們來看下generateProxyClass（）核心方法：
public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {
//初始化 ProxyGenerator，並將引數放入構造器中
ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
//獲取ClassFile的二進位制
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;
}
其中最關鍵的是final byte[] var4 = var3.generateClassFile();我們來看下generateClassFile（）方法：
private byte[] generateClassFile() {
//將所有的方法組裝成ProxyMethod物件
//為代理類生成toString, hashCode, equals等方法
this.addProxyMethod(hashCodeMethod, Object.class);
this.addProxyMethod(equalsMethod, Object.class);
this.addProxyMethod(toStringMethod, Object.class);
//目標類要實現的介面
Class[] var1 = this.interfaces;
int var2 = var1.length;
int var3;
Class var4;
//遍歷每一個介面的每一個方法, 並且為其生成ProxyMethod物件
for(var3 = 0; var3 < var2; ++var3) {
var4 = var1[var3];
Method[] var5 = var4.getMethods();
int var6 = var5.length;
for(int var7 = 0; var7 < var6; ++var7) {
Method var8 = var5[var7];
this.addProxyMethod(var8, var4);
}
}
Iterator var11 = this.proxyMethods.values().iterator();
List var12;
while(var11.hasNext()) {
var12 = (List)var11.next();
checkReturnTypes(var12);
}
Iterator var15;
//組裝要生成的class檔案的所有的欄位資訊和方法資訊!!!
try {
//新增構造器
this.methods.add(this.generateConstructor());
var11 = this.proxyMethods.values().iterator();
while(var11.hasNext()) {
var12 = (List)var11.next();
var15 = var12.iterator();
while(var15.hasNext()) {
ProxyGenerator.ProxyMethod var16 = (ProxyGenerator.ProxyMethod)var15.next();
//新增代理類的靜態欄位
this.fields.add(new ProxyGenerator.FieldInfo(var16.methodFieldName, "Ljava/lang/reflect/Method;", 10));
//新增代理類的代理方法
this.methods.add(var16.generateMethod());
}
}
//新增代理類的靜態欄位初始化方法
this.methods.add(this.generateStaticInitializer());
} catch (IOException var10) {
throw new InternalError("unexpected I/O Exception", var10);
}
if (this.methods.size() > 65535) {
throw new IllegalArgumentException("method limit exceeded");
} else if (this.fields.size() > 65535) {
throw new IllegalArgumentException("field limit exceeded");
} else {
this.cp.getClass(dotToSlash(this.className));
this.cp.getClass("java/lang/reflect/Proxy");
var1 = this.interfaces;
var2 = var1.length;
for(var3 = 0; var3 < var2; ++var3) {
var4 = var1[var3];
this.cp.getClass(dotToSlash(var4.getName()));
}
this.cp.setReadOnly();
ByteArrayOutputStream var13 = new ByteArrayOutputStream();
DataOutputStream var14 = new DataOutputStream(var13);
//構造class資訊，並寫入最終的class檔案！！！
try {
var14.writeInt(-889275714);
var14.writeShort(0);
var14.writeShort(49);
this.cp.write(var14);
var14.writeShort(this.accessFlags);
//寫入類索引
var14.writeShort(this.cp.getClass(dotToSlash(this.className)));
//寫入父類別索引, 生成的代理類都繼承自Proxy
var14.writeShort(this.cp.getClass("java/lang/reflect/Proxy"));
var14.writeShort(this.interfaces.length);
Class[] var17 = this.interfaces;
int var18 = var17.length;
for(int var19 = 0; var19 < var18; ++var19) {
Class var22 = var17[var19];
var14.writeShort(this.cp.getClass(dotToSlash(var22.getName())));
}
//寫入欄位計數值
var14.writeShort(this.fields.size());
var15 = this.fields.iterator();
while(var15.hasNext()) {
ProxyGenerator.FieldInfo var20 = (ProxyGenerator.FieldInfo)var15.next();
//寫入欄位集合
var20.write(var14);
}
//寫入方法計數值
var14.writeShort(this.methods.size());
var15 = this.methods.iterator();
while(var15.hasNext()) {
ProxyGenerator.MethodInfo var21 = (ProxyGenerator.MethodInfo)var15.next();
//寫入方法集合
var21.write(var14);
}
//寫入屬性計數值, 代理類class檔案沒有屬性所以為0
var14.writeShort(0);
return var13.toByteArray();
} catch (IOException var9) {
throw new InternalError("unexpected I/O Exception", var9);
}
}
}
我們可以發現generateClassFile()方法是按照Class檔案結構去填充資料，生產代理類Class
Class類就像 普通類的模板 一樣，用來儲存「類所有相關資訊」的類。
大概有3個步驟：
- 獲取目標類要實現的介面方法，將其包裝成ProxyMethod物件並註冊到Map集合中。
- 組裝要生成的class檔案的所有的欄位資訊和方法資訊等其他資訊
- 構造class資訊，並寫入最終的class檔案
至此，我們明白了Class<?> cl = getProxyClass0(loader, intfs);是如何通過目標類實現的介面Class 產生代理類的Class物件，而有代理類的Class物件，我們就能通過反射 獲得代理類範例物件。
我們再看一下，產生的代理類，在執行獲取代理類前加上一句
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");
會在專案根目錄生成一個目錄: com/sum/proxy/$Proxy0.java
public final class $Proxy0 extends Proxy implements OurService {
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 void buyMed() throws {
try {
super.h.invoke(this, m3, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
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("com.zj.demotest.test4.OurService").getMethod("buyMed");
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());
}
}
}
$Proxy0繼承了Proxy 類，繼承目標類實現的介面，並且實現了被代理的所有介面，以及equals、hashCode、toString等方法
其實我們可以發現為什麼JDK動態代理只能代理介面？因為Java中類只支援單繼承，介面可以多繼承，所以JDK動態代理只能去實現介面。
- 類和所有方法都被 public final 修飾，所以代理類只可被使用，不可以再被繼承
- proxy物件的原理是：內部維護一個
InvocationHandler，而InvocationHandler是對自定義邏輯的抽象。通過抽取InvocationHandler，將代理物件和自定義邏輯解耦。 - 代理物件的方法呼叫 都是 通過
super.h.invoke(this, m1, (Object[])null);呼叫，其中的super.h.invoke實際上是在建立代理的時候傳遞給 Proxy.newProxyInstance 的MyInvocationHandler物件，它繼承InvocationHandler類，負責實際的呼叫處理邏輯。MyInvocationHandler.invoke()接收到 method、args 等引數後, 然後通過反射讓被代理的物件 target執行方法
補充： CGLIB動態代理
CGLIB 動態代理類使用步驟
- 定義一個類；
- 自定義 MethodInterceptor 並重寫 intercept 方法，intercept 用於攔截增強被代理類的方法，和 JDK 動態代理中的 invoke 方法類似；
- 通過 Enhancer 類的 create()建立代理類；
範例
CGLIB是屬於一個開源專案，如果你要使用它的話，需要手動新增相關依賴。
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>x.x.x</version>
</dependency>
Spring在5.X之前預設的動態代理實現一直是jdk動態代理。但是從5.X開始，spring就開始預設使用CGLIB來作為動態代理實現。並且springboot從2.X開始也轉向了CGLIB動態代理實現。
編寫一個目標類：
public class Doctor {
private String name;
public void work() {
System.out.println("上班。。。");
}
}
自定義 MethodInterceptor（方法攔截器）
public class MyMethodInterceptor implements MethodInterceptor {
/**
* @param o 代理物件（增強的物件）
* @param method 被攔截的方法（需要增強的方法）
* @param args 方法入參
* @param methodProxy 用於呼叫原始方法
*/
@Override
public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
//呼叫方法之前，我們可以新增額外邏輯
System.out.println("before method " + method.getName());
//這裡要呼叫proxy.invokeSuper，而不是method.invoke，不然會出現棧溢位等問題
Object object = methodProxy.invokeSuper(o, args);
//呼叫方法之後，我們可以新增額外邏輯
System.out.println("after method " + method.getName());
return object;
}
}
最後編寫測試類：
public class TestCGlib {
public static void main(String[] args) {
Class cl = Doctor.class;
// 建立動態代理增強類
Enhancer enhancer = new Enhancer();
// 設定類載入器
enhancer.setClassLoader(cl.getClassLoader());
// 設定目標類
enhancer.setSuperclass(cl);
// 設定方法攔截器
enhancer.setCallback(new MyMethodInterceptor());
// 建立代理類
Doctor proxy = (Doctor) enhancer.create();
//執行方法
proxy.work();
}
}
結果：
before method work
上班。。。
after method work
由於本文篇幅過長且CGLIB不是本文的重點 ，CGLIB原始碼分析就不展開了，待後面有空出一下。
JDK 動態代理和 CGLIB 動態代理對比
- 可以代理的型別：
JDK 動態代理只能代理實現了介面的類或者直接代理介面,由於預設繼承Proxy類，java類是單繼承，介面可以多繼承- CGLIB 可以代理
未實現任何介面的類 - CGLIB 動態代理是通過生成一個被代理類的子類來攔截被代理類的方法呼叫，子類會被覆蓋其中的方法，並覆蓋其中方法的增強，因為採用的是繼承，所以
不能代理宣告為 final 型別的類和方法。
- 原理：
- JDK動態代理 ，通過
目標類實現的介面Class產生代理類的Class物件，而有了代理類的Class物件，我們就能通過反射機制 獲得代理類範例物件 - CGLIB動態代理利用
ASM框架，對代理物件類生成的class檔案載入進來，通過修改其位元組碼生成子類來處理
- 效率
- CGLIB 底層是ASM位元組碼生成框架,在Jdk1.6之前比使用java反射的效率要高，但隨著jdk的不斷優化，在1.8的時候JDK動態代理的效率已高於cglib，而且隨著 JDK 版本的升級，這個優勢會愈加明顯。
- Spring如何選擇是用JDK代理還是CGLIB代理？
- 當bean實現介面時，會用JDK代理模式
- 當bean沒有實現介面，用cglib實現
- 可以強制使用cglib（在spring設定中加入<aop:aspectj-autoproxy proxyt-target-class=」true」/>）
參考資料：
《Java虛擬機器器規範》
《深入理解Java虛擬機器器：JVM高階特性與最佳實踐第3版》
https://blog.csdn.net/huweiliyi/article/details/107609881
https://www.cnblogs.com/liuyun1995/p/8157098.html
本篇文章到這裡就結束啦，很感謝你能看到最後，如果喜歡的話，點贊收藏轉發，歡迎關注！更多精彩的文章
