Spring源碼剖析5：JDK和cglib動態代理原理詳解
AOP的基礎是Java動態代理，瞭解和使用兩種動態代理能讓咱們更好地理解 AOP，在講解AOP以前，讓咱們先來看看Java動態代理的使用方式以及底層實現原理。java
轉自https://www.jianshu.com/u/668...程序員
本文是基於jdk1.8來對動態代理的底層機制進行探究的面試
Java代理介紹
Java中代理的實現通常分爲三種：JDK靜態代理、JDK動態代理以及CGLIB動態代理。在Spring的AOP實現中，主要應用了JDK動態代理以及CGLIB動態代理。可是本文着重介紹JDK動態代理機制，CGLIB動態代理後面會接着探究。數據庫
代理通常實現的模式爲JDK靜態代理：建立一個接口，而後建立被代理的類實現該接口而且實現該接口中的抽象方法。以後再建立一個代理類，同時使其也實現這個接口。在代理類中持有一個被代理對象的引用，然後在代理類方法中調用該對象的方法。segmentfault
其實就是代理類爲被代理類預處理消息、過濾消息並在此以後將消息轉發給被代理類，以後還能進行消息的後置處理。代理類和被代理類一般會存在關聯關係(即上面提到的持有的被帶離對象的引用)，代理類自己不實現服務，而是經過調用被代理類中的方法來提供服務。後端
靜態代理
接口數組
被代理類緩存
代理類安全
測試類以及輸出結果微信
咱們能夠看出，使用JDK靜態代理很容易就完成了對一個類的代理操做。可是JDK靜態代理的缺點也暴露了出來：因爲代理只能爲一個類服務，若是須要代理的類不少，那麼就須要編寫大量的代理類，比較繁瑣。
下面咱們使用JDK動態代理來作一樣的事情
JDK動態代理
接口
被代理類
代理類
測試類以及輸出結果
JDK動態代理實現原理
JDK動態代理其實也是基本接口實現的。由於經過接口指向實現類實例的多態方式，能夠有效地將具體實現與調用解耦，便於後期的修改和維護。
經過上面的介紹，咱們能夠發現JDK靜態代理與JDK動態代理之間有些許類似，好比說都要建立代理類，以及代理類都要實現接口等。可是不一樣之處也很是明顯----在靜態代理中咱們須要對哪一個接口和哪一個被代理類建立代理類，因此咱們在編譯前就須要代理類實現與被代理類相同的接口，而且直接在實現的方法中調用被代理類相應的方法；可是動態代理則不一樣，咱們不知道要針對哪一個接口、哪一個被代理類建立代理類，由於它是在運行時被建立的。
讓咱們用一句話來總結一下JDK靜態代理和JDK動態代理的區別，而後開始探究JDK動態代理的底層實現機制：
JDK靜態代理是經過直接編碼建立的，而JDK動態代理是利用反射機制在運行時建立代理類的。
其實在動態代理中，核心是InvocationHandler。每個代理的實例都會有一個關聯的調用處理程序(InvocationHandler)。對待代理實例進行調用時，將對方法的調用進行編碼並指派到它的調用處理器(InvocationHandler)的invoke方法。因此對代理對象實例方法的調用都是經過InvocationHandler中的invoke方法來完成的，而invoke方法會根據傳入的代理對象、方法名稱以及參數決定調用代理的哪一個方法。
咱們從JDK動態代理的測試類中能夠發現代理類生成是經過Proxy類中的newProxyInstance來完成的，下面咱們進入這個函數看一看：
Proxy類中的newProxyInstance
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
//若是h爲空將拋出異常
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);
/*
* 使用指定的調用處理程序獲取代理類的構造函數對象
*/
try {
if (sm != null) {
checkNewProxyPermission(Reflection.getCallerClass(), cl);
}
final Constructor<?> cons = cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
//假如代理類的構造函數是private的，就使用反射來set accessible
if (!Modifier.isPublic(cl.getModifiers())) {
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
cons.setAccessible(true);
return null;
}
});
}
//根據代理類的構造函數來生成代理類的對象並返回
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);
}
}
因此代理類實際上是經過getProxyClass方法來生成的：
/**
* 生成一個代理類，可是在調用本方法以前必須進行權限檢查
*/
private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {
//若是接口數量大於65535，拋出非法參數錯誤
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
// 若是在緩存中有對應的代理類，那麼直接返回
// 不然代理類將有 ProxyClassFactory 來建立
return proxyClassCache.get(loader, interfaces);
}
那麼ProxyClassFactory是什麼呢？
/**
* 裏面有一個根據給定ClassLoader和Interface來建立代理類的工廠函數
*
*/
private static final class ProxyClassFactory
implements BiFunction<ClassLoader, Class<?>[], Class<?>>
{
// 代理類的名字的前綴統一爲「$Proxy」
private static final String proxyClassNamePrefix = "$Proxy";
// 每一個代理類前綴後面都會跟着一個惟一的編號，如$Proxy0、$Proxy一、$Proxy2
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) {
/*
* 驗證類加載器加載接口獲得對象是否與由apply函數參數傳入的對象相同
*/
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; // 聲明代理類所在的package
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 package下
proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
}
/*
* 爲代理類生成一個name package name + 前綴+惟一編號
* 如 com.sun.proxy.$Proxy0.class
*/
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) {
/*
* 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);能夠看到，其實生成代理類字節碼文件的工做是經過 ProxyGenerate類中的generateProxyClass方法來完成的。
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() {
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),
new String[0]);
Files.createDirectories(var3, new FileAttribute[0]);
var2 = var3.resolve(var0.substring(var1 + 1, var0.length()) + ".class");
} else {
var2 = Paths.get(var0 + ".class", new String[0]);
}
Files.write(var2, var4, new OpenOption[0]);
return null;
} catch (IOException var4x) {
throw new InternalError("I/O exception saving generated file: " + var4x);
}
}
});
}
return var4;
}
下面來看看真正用於生成代理類字節碼文件的generateClassFile方法：
private byte[] generateClassFile() {
//下面一系列的addProxyMethod方法是將接口中的方法和Object中的方法添加到代理方法中(proxyMethod)
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;
//得到接口中全部方法並添加到代理方法中
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);
}
//後面一系列的步驟用於寫代理類Class文件
Iterator var15;
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();
//將代理類字段聲明爲Method，而且字段修飾符爲 private static.
//由於 10 是 ACC_PRIVATE和ACC_STATIC的與運算 故代理類的字段都是 private static Method ***
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() > '\uffff') { //代理類中的方法數量超過65535就拋異常
throw new IllegalArgumentException("method limit exceeded");
} else if(this.fields.size() > '\uffff') {// 代理類中字段數量超過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);
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)));
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);
}
var14.writeShort(0);
return var13.toByteArray();
} catch (IOException var9) {
throw new InternalError("unexpected I/O Exception", var9);
}
}
}
代理類的方法調用
下面是將接口與Object中一些方法添加到代理類中的addProxyMethod方法：
private void addProxyMethod(Method var1, Class<?> var2) {
String var3 = var1.getName();//得到方法名稱
Class[] var4 = var1.getParameterTypes();//得到方法參數類型
Class var5 = var1.getReturnType();//得到方法返回類型
Class[] var6 = var1.getExceptionTypes();//異常類型
String var7 = var3 + getParameterDescriptors(var4);//得到方法簽名
Object var8 = (List)this.proxyMethods.get(var7);//根據方法前面得到proxyMethod的value
if(var8 != null) {//處理多個代理接口中方法重複的狀況
Iterator var9 = ((List)var8).iterator();
while(var9.hasNext()) {
ProxyGenerator.ProxyMethod var10 = (ProxyGenerator.ProxyMethod)var9.next();
if(var5 == var10.returnType) {
ArrayList var11 = new ArrayList();
collectCompatibleTypes(var6, var10.exceptionTypes, var11);
collectCompatibleTypes(var10.exceptionTypes, var6, var11);
var10.exceptionTypes = new Class[var11.size()];
var10.exceptionTypes = (Class[])var11.toArray(var10.exceptionTypes);
return;
}
}
} else {
var8 = new ArrayList(3);
this.proxyMethods.put(var7, var8);
}
((List)var8).add(new ProxyGenerator.ProxyMethod(var3, var4, var5, var6, var2, null));
}
這就是最終真正的代理類，它繼承自Proxy並實現了咱們定義的Subject接口。咱們經過
HelloInterface helloInterface = (HelloInterface ) Proxy.newProxyInstance(loader, interfaces, handler);
- 1
獲得的最終代理類對象就是上面這個類的實例。那麼咱們執行以下語句：
helloInterface.hello("Tom");
- 1
實際上就是執行上面類的相應方法，也就是：
public final void hello(String paramString)
{
try
{
this.h.invoke(this, m3, new Object[] { paramString });
//就是調用咱們自定義的InvocationHandlerImpl的 invoke方法：
return;
}
catch (Error|RuntimeException localError)
{
throw localError;
}
catch (Throwable localThrowable)
{
throw new UndeclaredThrowableException(localThrowable);
}
}
注意這裏的this.h.invoke中的h，它是類Proxy中的一個屬性
protected InvocationHandler h;
由於這個代理類繼承了Proxy，因此也就繼承了這個屬性，而這個屬性值就是咱們定義的
InvocationHandler handler = new InvocationHandlerImpl(hello);
- 1
同時咱們還發現，invoke方法的第一參數在底層調用的時候傳入的是this，也就是最終生成的代理對象ProxySubject，這是JVM本身動態生成的，而不是咱們本身定義的代理對象。
深刻理解CGLIB動態代理機制
Cglib是什麼
Cglib是一個強大的、高性能的代碼生成包，它普遍被許多AOP框架使用，爲他們提供方法的攔截。下圖是我網上找到的一張Cglib與一些框架和語言的關係：
對此圖總結一下：
- 最底層的是字節碼Bytecode，字節碼是Java爲了保證「一次編譯、處處運行」而產生的一種虛擬指令格式，例如iload_0、iconst_一、if_icmpne、dup等
- 位於字節碼之上的是ASM，這是一種直接操做字節碼的框架，應用ASM須要對Java字節碼、Class結構比較熟悉
- 位於ASM之上的是CGLIB、Groovy、BeanShell，後兩種並非Java體系中的內容而是腳本語言，它們經過ASM框架生成字節碼變相執行Java代碼，這說明在JVM中執行程序並不必定非要寫Java代碼----只要你能生成Java字節碼，JVM並不關心字節碼的來源，固然經過Java代碼生成的JVM字節碼是經過編譯器直接生成的，算是最「正統」的JVM字節碼
- 位於CGLIB、Groovy、BeanShell之上的就是Hibernate、Spring AOP這些框架了，這一層你們都比較熟悉
- 最上層的是Applications，即具體應用，通常都是一個Web項目或者本地跑一個程序
本文是基於CGLIB 3.1進行探究的
cglib is a powerful, high performance and quality Code Generation Library, It is used to extend JAVA classes and implements interfaces at runtime.
在Spring AOP中，一般會用它來生成AopProxy對象。不只如此，在Hibernate中PO(Persistant Object 持久化對象)字節碼的生成工做也要靠它來完成。
本文將深刻探究CGLIB動態代理的實現機制，配合下面這篇文章一塊兒食用口味更佳：
深刻理解JDK動態代理機制
CGLIB動態代理示例
下面由一個簡單的示例開始咱們對CGLIB動態代理的介紹：
爲了後續編碼的順利進行，咱們須要使用Maven引入CGLIB的包
圖1.1 被代理類
圖1.2 實現MethodInterceptor接口生成方法攔截器
圖1.3 生成代理類對象並打印在代理類對象調用方法以後的執行結果
JDK代理要求被代理的類必須實現接口，有很強的侷限性。而CGLIB動態代理則沒有此類強制性要求。簡單的說，CGLIB會讓生成的代理類繼承被代理類，並在代理類中對代理方法進行強化處理(前置處理、後置處理等)。在CGLIB底層，實際上是藉助了ASM這個很是強大的Java字節碼生成框架。
生成代理類對象
從圖1.3中咱們看到，代理類對象是由Enhancer類建立的。Enhancer是CGLIB的字節碼加強器，能夠很方便的對類進行拓展，如圖1.3中的爲類設置Superclass。
建立代理對象的幾個步驟:
- 生成代理類的二進制字節碼文件；
- 加載二進制字節碼，生成Class對象( 例如使用Class.forName()方法 )；
- 經過反射機制得到實例構造，並建立代理類對象
咱們來看看將代理類Class文件反編譯以後的Java代碼
package proxy;
import java.lang.reflect.Method;
import net.sf.cglib.core.ReflectUtils;
import net.sf.cglib.core.Signature;
import net.sf.cglib.proxy.Callback;
import net.sf.cglib.proxy.Factory;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
public class HelloServiceImpl$EnhancerByCGLIB$82ef2d06
extends HelloServiceImpl
implements Factory
{
private boolean CGLIB$BOUND;
private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
private static final Callback[] CGLIB$STATIC_CALLBACKS;
private MethodInterceptor CGLIB$CALLBACK_0;
private static final Method CGLIB$sayHello$0$Method;
private static final MethodProxy CGLIB$sayHello$0$Proxy;
private static final Object[] CGLIB$emptyArgs;
private static final Method CGLIB$finalize$1$Method;
private static final MethodProxy CGLIB$finalize$1$Proxy;
private static final Method CGLIB$equals$2$Method;
private static final MethodProxy CGLIB$equals$2$Proxy;
private static final Method CGLIB$toString$3$Method;
private static final MethodProxy CGLIB$toString$3$Proxy;
private static final Method CGLIB$hashCode$4$Method;
private static final MethodProxy CGLIB$hashCode$4$Proxy;
private static final Method CGLIB$clone$5$Method;
private static final MethodProxy CGLIB$clone$5$Proxy;
static void CGLIB$STATICHOOK1()
{
CGLIB$THREAD_CALLBACKS = new ThreadLocal();
CGLIB$emptyArgs = new Object[0];
Class localClass1 = Class.forName("proxy.HelloServiceImpl$EnhancerByCGLIB$82ef2d06");
Class localClass2;
Method[] tmp95_92 = ReflectUtils.findMethods(new String[] { "finalize", "()V", "equals", "(Ljava/lang/Object;)Z", "toString", "()Ljava/lang/String;", "hashCode", "()I", "clone", "()Ljava/lang/Object;" }, (localClass2 = Class.forName("java.lang.Object")).getDeclaredMethods());
CGLIB$finalize$1$Method = tmp95_92[0];
CGLIB$finalize$1$Proxy = MethodProxy.create(localClass2, localClass1, "()V", "finalize", "CGLIB$finalize$1");
Method[] tmp115_95 = tmp95_92;
CGLIB$equals$2$Method = tmp115_95[1];
CGLIB$equals$2$Proxy = MethodProxy.create(localClass2, localClass1, "(Ljava/lang/Object;)Z", "equals", "CGLIB$equals$2");
Method[] tmp135_115 = tmp115_95;
CGLIB$toString$3$Method = tmp135_115[2];
CGLIB$toString$3$Proxy = MethodProxy.create(localClass2, localClass1, "()Ljava/lang/String;", "toString", "CGLIB$toString$3");
Method[] tmp155_135 = tmp135_115;
CGLIB$hashCode$4$Method = tmp155_135[3];
CGLIB$hashCode$4$Proxy = MethodProxy.create(localClass2, localClass1, "()I", "hashCode", "CGLIB$hashCode$4");
Method[] tmp175_155 = tmp155_135;
CGLIB$clone$5$Method = tmp175_155[4];
CGLIB$clone$5$Proxy = MethodProxy.create(localClass2, localClass1, "()Ljava/lang/Object;", "clone", "CGLIB$clone$5");
tmp175_155;
Method[] tmp223_220 = ReflectUtils.findMethods(new String[] { "sayHello", "()V" }, (localClass2 = Class.forName("proxy.HelloServiceImpl")).getDeclaredMethods());
CGLIB$sayHello$0$Method = tmp223_220[0];
CGLIB$sayHello$0$Proxy = MethodProxy.create(localClass2, localClass1, "()V", "sayHello", "CGLIB$sayHello$0");
tmp223_220;
return;
}
final void CGLIB$sayHello$0()
{
super.sayHello();
}
public final void sayHello()
{
MethodInterceptor tmp4_1 = this.CGLIB$CALLBACK_0;
if (tmp4_1 == null)
{
tmp4_1;
CGLIB$BIND_CALLBACKS(this);
}
if (this.CGLIB$CALLBACK_0 != null) {
return;
}
super.sayHello();
}
final void CGLIB$finalize$1()
throws Throwable
{
super.finalize();
}
protected final void finalize()
throws Throwable
{
MethodInterceptor tmp4_1 = this.CGLIB$CALLBACK_0;
if (tmp4_1 == null)
{
tmp4_1;
CGLIB$BIND_CALLBACKS(this);
}
if (this.CGLIB$CALLBACK_0 != null) {
return;
}
super.finalize();
}
final boolean CGLIB$equals$2(Object paramObject)
{
return super.equals(paramObject);
}
public final boolean equals(Object paramObject)
{
MethodInterceptor tmp4_1 = this.CGLIB$CALLBACK_0;
if (tmp4_1 == null)
{
tmp4_1;
CGLIB$BIND_CALLBACKS(this);
}
MethodInterceptor tmp17_14 = this.CGLIB$CALLBACK_0;
if (tmp17_14 != null)
{
Object tmp41_36 = tmp17_14.intercept(this, CGLIB$equals$2$Method, new Object[] { paramObject }, CGLIB$equals$2$Proxy);
tmp41_36;
return tmp41_36 == null ? false : ((Boolean)tmp41_36).booleanValue();
}
return super.equals(paramObject);
}
final String CGLIB$toString$3()
{
return super.toString();
}
public final String toString()
{
MethodInterceptor tmp4_1 = this.CGLIB$CALLBACK_0;
if (tmp4_1 == null)
{
tmp4_1;
CGLIB$BIND_CALLBACKS(this);
}
MethodInterceptor tmp17_14 = this.CGLIB$CALLBACK_0;
if (tmp17_14 != null) {
return (String)tmp17_14.intercept(this, CGLIB$toString$3$Method, CGLIB$emptyArgs, CGLIB$toString$3$Proxy);
}
return super.toString();
}
final int CGLIB$hashCode$4()
{
return super.hashCode();
}
public final int hashCode()
{
MethodInterceptor tmp4_1 = this.CGLIB$CALLBACK_0;
if (tmp4_1 == null)
{
tmp4_1;
CGLIB$BIND_CALLBACKS(this);
}
MethodInterceptor tmp17_14 = this.CGLIB$CALLBACK_0;
if (tmp17_14 != null)
{
Object tmp36_31 = tmp17_14.intercept(this, CGLIB$hashCode$4$Method, CGLIB$emptyArgs, CGLIB$hashCode$4$Proxy);
tmp36_31;
return tmp36_31 == null ? 0 : ((Number)tmp36_31).intValue();
}
return super.hashCode();
}
final Object CGLIB$clone$5()
throws CloneNotSupportedException
{
return super.clone();
}
protected final Object clone()
throws CloneNotSupportedException
{
MethodInterceptor tmp4_1 = this.CGLIB$CALLBACK_0;
if (tmp4_1 == null)
{
tmp4_1;
CGLIB$BIND_CALLBACKS(this);
}
MethodInterceptor tmp17_14 = this.CGLIB$CALLBACK_0;
if (tmp17_14 != null) {
return tmp17_14.intercept(this, CGLIB$clone$5$Method, CGLIB$emptyArgs, CGLIB$clone$5$Proxy);
}
return super.clone();
}
public static MethodProxy CGLIB$findMethodProxy(Signature paramSignature)
{
String tmp4_1 = paramSignature.toString();
switch (tmp4_1.hashCode())
{
case -1574182249:
if (tmp4_1.equals("finalize()V")) {
return CGLIB$finalize$1$Proxy;
}
break;
}
}
public HelloServiceImpl$EnhancerByCGLIB$82ef2d06()
{
CGLIB$BIND_CALLBACKS(this);
}
public static void CGLIB$SET_THREAD_CALLBACKS(Callback[] paramArrayOfCallback)
{
CGLIB$THREAD_CALLBACKS.set(paramArrayOfCallback);
}
public static void CGLIB$SET_STATIC_CALLBACKS(Callback[] paramArrayOfCallback)
{
CGLIB$STATIC_CALLBACKS = paramArrayOfCallback;
}
private static final void CGLIB$BIND_CALLBACKS(Object paramObject)
{
82ef2d06 local82ef2d06 = (82ef2d06)paramObject;
if (!local82ef2d06.CGLIB$BOUND)
{
local82ef2d06.CGLIB$BOUND = true;
Object tmp23_20 = CGLIB$THREAD_CALLBACKS.get();
if (tmp23_20 == null)
{
tmp23_20;
CGLIB$STATIC_CALLBACKS;
}
local82ef2d06.CGLIB$CALLBACK_0 = (// INTERNAL ERROR //
對委託類進行代理
咱們上面貼出了生成的代理類源碼。以咱們上面的例子爲參考，下面咱們總結一下CGLIB在進行代理的時候都進行了哪些工做呢
- 生成的代理類HelloServiceImpl$EnhancerByCGLIB$82ef2d06繼承被代理類HelloServiceImpl。在這裏咱們須要注意一點：若是委託類被final修飾，那麼它不可被繼承，即不可被代理；一樣，若是委託類中存在final修飾的方法，那麼該方法也不可被代理；
- 代理類會爲委託方法生成兩個方法，一個是重寫的sayHello方法，另外一個是CGLIB$sayHello$0方法，咱們能夠看到它是直接調用父類的sayHello方法；
- 當執行代理對象的sayHello方法時，會首先判斷一下是否存在實現了MethodInterceptor接口的CGLIB$CALLBACK_0;，若是存在，則將調用MethodInterceptor中的intercept方法，如圖2.1。
圖2.1 intercept方法
圖2.2 代理類爲每一個委託方法都會生成兩個方法
在intercept方法中，咱們除了會調用委託方法，還會進行一些加強操做。在Spring AOP中，典型的應用場景就是在某些敏感方法執行先後進行操做日誌記錄。
咱們從圖2.1中看到，調用委託方法是經過代理方法的MethodProxy對象調用invokeSuper方法來執行的，下面咱們看看invokeSuper方法中的玄機：
圖2.3 invokeSuper方法
在這裏好像不能直接看出代理方法的調用。不要緊，我會慢慢介紹。
咱們知道，在JDK動態代理中方法的調用是經過反射來完成的。若是有對此不太瞭解的同窗，能夠看下我以前的博客----深刻理解JDK動態代理機制。可是在CGLIB中，方法的調用並非經過反射來完成的，而是直接對方法進行調用：FastClass對Class對象進行特別的處理，好比將會用數組保存method的引用，每次調用方法的時候都是經過一個index下標來保持對方法的引用。好比下面的getIndex方法就是經過方法簽名來得到方法在存儲了Class信息的數組中的下標。
圖2.4 getIndex方法
圖2.5 FastClassInfo類中持有兩個FastClass對象的引用.png
以咱們上面的sayHello方法爲例，f1指向委託類對象，f2指向代理類對象，i1和i2分別表明着sayHello方法以及CGLIB$sayHello$0方法在對象信息數組中的下標。
到此爲止CGLIB動態代理機制就介紹完了，下面給出三種代理方式之間對比。
| 代理方式 | 實現 | 優勢 | 缺點 | 特色 |
|---|---|---|---|---|
| JDK靜態代理 | 代理類與委託類實現同一接口，而且在代理類中須要硬編碼接口 | 實現簡單，容易理解 | 代理類須要硬編碼接口，在實際應用中可能會致使重複編碼，浪費存儲空間而且效率很低 | 好像沒啥特色 |
| JDK動態代理 | 代理類與委託類實現同一接口，主要是經過代理類實現InvocationHandler並重寫invoke方法來進行動態代理的，在invoke方法中將對方法進行加強處理 | 不須要硬編碼接口，代碼複用率高 | 只可以代理實現了接口的委託類 | 底層使用反射機制進行方法的調用 |
| CGLIB動態代理 | 代理類將委託類做爲本身的父類併爲其中的非final委託方法建立兩個方法，一個是與委託方法簽名相同的方法，它在方法中會經過super調用委託方法；另外一個是代理類獨有的方法。在代理方法中，它會判斷是否存在實現了MethodInterceptor接口的對象，若存在則將調用intercept方法對委託方法進行代理 | 能夠在運行時對類或者是接口進行加強操做，且委託類無需實現接口 | 不能對final類以及final方法進行代理 | 底層將方法所有存入一個數組中，經過數組索引直接進行方法調用 |
微信公衆號【黃小斜】做者是螞蟻金服 JAVA 工程師，專一於 JAVA 後端技術棧：SpringBoot、SSM全家桶、MySQL、分佈式、中間件、微服務，同時也懂點投資理財，堅持學習和寫做，相信終身學習的力量！關注公衆號後回覆」架構師「便可領取 Java基礎、進階、項目和架構師等免費學習資料，更有數據庫、分佈式、微服務等熱門技術學習視頻，內容豐富，兼顧原理和實踐，另外也將贈送做者原創的Java學習指南、Java程序員面試指南等乾貨資源
相關文章
- 1. spring aop原理 JDK動態代理和CGLIB動態代理
- 2. spring aop原理講解 JDK動態代理和CGLIB動態代理
- 3. JDK和CGLIB動態代理
- 4. 動態代理jdk 和cglib
- 5. cglib 和jdk 動態代理
- 6. Spring AOP中JDK和CGLib動態代理
- 7. JDK動態代理詳解（源碼剖析）
- 8. SpringAOP-JDK 動態代理和 CGLIB 代理
- 9. Spring ： 靜態代理模式和JDK、CGLIB動態代理
- 10. 動態代理：JDK動態代理和CGLIB代理的區別
- 更多相關文章...
- • Spring JDK動態代理（附帶實例） - Spring教程
- • Spring CGLlB動態代理（附帶實例） - Spring教程
- • ☆技術問答集錦（13）Java Instrument原理
- • Java Agent入門實戰（三）-JVM Attach原理與使用
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
歡迎關注本站公眾號,獲取更多信息
