目錄
- 代理模式
- 靜態代理
- 靜態代理和動態代理的區別？什么是靜態、動態？
- 靜態代理的使用步驟
- 示例
- 靜態代理的缺陷
- 解決靜態代理的缺陷的思路
- JDK動態代理
- JDK 動態代理類使用步驟
- 示例
- 底層原理
- 補充： CGLIB動態代理
- CGLIB 動態代理類使用步驟
- 示例
- JDK 動態代理和 CGLIB 動態代理對比
作者：小牛呼嚕嚕 | 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怎樣才能動態地生成代理類？
我們先來回顧一下物件的創建程序
推薦閱讀：https://mp.weixin.qq.com/s/tsbDfyYLqr3ctzwHirQ8UQ
創建一個實體物件的底層邏輯，其實與.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 = https://www.cnblogs.com/xiaoniuhululu/p/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 = https://www.cnblogs.com/xiaoniuhululu/p/supplier.get();這里supplier可能是一個Factory也可能會是一個CacheValue，如果命中快取就直接回傳結果結束回圈
不然再次回圈的時候
factory = new Factory(key, parameter, subKey, valuesMap);
supplier = factory;
這個時候V value = https://www.cnblogs.com/xiaoniuhululu/p/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 = https://www.cnblogs.com/xiaoniuhululu/p/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 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 = https://www.cnblogs.com/xiaoniuhululu/p/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的代碼中我們可以發現：
$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
本篇文章到這里就結束啦，很感謝你能看到最后，如果喜歡的話，點贊收藏轉發，歡迎關注！更多精彩的文章
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/534085.html
標籤：Java
上一篇：this和super關鍵字