萬字乾貨_JDK動態代理及其源碼解析 拿捏了
目錄
作者：小牛呼嚕嚕 | //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對象
在文章//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反射的文章//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版》
//blog.csdn.net/huweiliyi/article/details/107609881
//www.cnblogs.com/liuyun1995/p/8157098.html
本篇文章到這裡就結束啦，很感謝你能看到最後，如果喜歡的話，點贊收藏轉發，歡迎關注！更多精彩的文章
