歡迎光臨
每天分享高質量文章
當前位置：知識星球 > 後端 > 正文

CGLIB，Java的動態代理神器

2018-01-07 分類：後端 閱讀(299) 評論(0)

原文出自【佔小狼的部落格】，轉載請註明出處

前言

之前講過《JDK的動態代理實現》，內部透過反射類 Proxy和 InvocationHandler回呼介面實現，要求委託類必須實現一個介面，只能對該類介面中定義的方法進行代理，這在實際的專案中有一定的侷限性，遇到沒有介面的委託類，就無法應對。

幸好，有CGLIB這個神器的存在。

CGLIB實現

使用CGLIB(Code Generation Library)實現動態代理，並不要求委託類必須實現介面，底層採用ASM位元組碼生成框架生成代理類的位元組碼，下麵透過一個例子看看如何實現動態代理。

1、定義業務邏輯

  1. public class UserServiceImpl {  
  2.     public void add() {  
  3.         System.out.println("This is add service");  
  4.     }  
  5.     public void delete(int id) {  
  6.         System.out.println("This is delete service：delete " + id );  
  7.     }  
  8. }

2、實現 MethodInterceptor介面，定義方法的攔截器

  1. public class MyMethodInterceptor implements MethodInterceptor {
  2.     public Object intercept(Object obj, Method method, Object[] arg, MethodProxy proxy) throws Throwable {
  3.         System.out.println("Before:" + method);  
  4.         Object object = proxy.invokeSuper(obj, arg);
  5.         System.out.println("After:" + method); 
  6.         return object;
  7.     }
  8. }

3、利用 Enhancer類生成代理類；

  1. Enhancer enhancer = new Enhancer();  
  2. enhancer.setSuperclass(UserServiceImpl.class);  
  3. enhancer.setCallback(new MyMethodInterceptor());  
  4. UserServiceImpl userService = (UserServiceImpl)enhancer.create(); 

4、 userService.add()的執行結果：

  1. Before: add
  2. This is add service
  3. After: add

代理物件的生成過程由Enhancer類實現，大概步驟如下： 

1、生成代理類Class的二進位制位元組碼； 

2、透過 Class.forName載入二進位制位元組碼，生成Class物件； 

3、透過反射機制獲取實體構造，並初始化代理類物件。

位元組碼生成

Enhancer是CGLib的位元組碼增強器，可以方便的對類進行擴充套件，內部呼叫 GeneratorStrategy.generate方法生成代理類的位元組碼，透過以下方式可以生成class檔案。

  1. System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "C:\\\\Code\\\\whywhy\\\\target\\\\classes\\\\zzzzzz")

使用 反編譯工具 procyon 檢視代理類實現

  1. java -jar procyon-decompiler-0.5.30.jar UserService$$EnhancerByCGLIB$$394dddeb;

反編譯之後的代理類add方法實現如下：

  1. import net.sf.cglib.core.Signature;
  2. import net.sf.cglib.core.ReflectUtils;
  3. import net.sf.cglib.proxy.MethodProxy;
  4. import java.lang.reflect.Method;
  5. import net.sf.cglib.proxy.MethodInterceptor;
  6. import net.sf.cglib.proxy.Callback;
  7. import net.sf.cglib.proxy.Factory;
  9. // 
  10. // Decompiled by Procyon v0.5.30
  11. // 
  13. public class UserService$$EnhancerByCGLIB$$394dddeb extends UserService implements Factory
  14. {
  15.     private boolean CGLIB$BOUND;
  16.     private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
  17.     private static final Callback[] CGLIB$STATIC_CALLBACKS;
  18.     private MethodInterceptor CGLIB$CALLBACK_0;
  19.     private static final Method CGLIB$add$0$Method;
  20.     private static final MethodProxy CGLIB$add$0$Proxy;
  21.     private static final Object[] CGLIB$emptyArgs;
  24.     static void CGLIB$STATICHOOK2() {
  25.         CGLIB$THREAD_CALLBACKS = new ThreadLocal();
  26.         CGLIB$emptyArgs = new Object[0];
  27.         final Class> forName = Class.forName("UserService$$EnhancerByCGLIB$$394dddeb");
  28.         final Class> forName3;
  29.         CGLIB$add$0$Method = ReflectUtils.findMethods(new String[] { "add", "()V" }, (forName3 = Class.forName("UserService")).getDeclaredMethods())[0];
  30.         CGLIB$add$0$Proxy = MethodProxy.create((Class)forName3, (Class)forName, "()V", "add", "CGLIB$add$0");
  31.     }
  33.     final void CGLIB$add$0() {
  34.         super.add();
  35.     }
  37.     public final void add() {
  38.         MethodInterceptor cglib$CALLBACK_2;
  39.         MethodInterceptor cglib$CALLBACK_0;
  40.         if ((cglib$CALLBACK_0 = (cglib$CALLBACK_2 = this.CGLIB$CALLBACK_0)) == null) {
  41.             CGLIB$BIND_CALLBACKS(this);
  42.             cglib$CALLBACK_2 = (cglib$CALLBACK_0 = this.CGLIB$CALLBACK_0);
  43.         }
  44.         if (cglib$CALLBACK_0 != null) {
  45.             cglib$CALLBACK_2.intercept((Object)this, UserService$$EnhancerByCGLIB$$394dddeb.CGLIB$add$0$Method, UserService$$EnhancerByCGLIB$$394dddeb.CGLIB$emptyArgs, UserService$$EnhancerByCGLIB$$394dddeb.CGLIB$add$0$Proxy);
  46.             return;
  47.         }
  48.         super.add();
  49.     }
  51.     static {
  52.         CGLIB$STATICHOOK2();
  53.     }
  54. }

透過CGLIB生成的位元組碼相比JDK實現來說顯得更加複雜。

1、代理類 UserService$$EnhancerByCGLIB$$394dddeb繼承了委託類 UserSevice，且委託類的final方法不能被代理； 

2、代理類為每個委託方法都生成兩個方法，以add方法為例，一個是重寫的add方法，一個是CGLIB$add$0方法，該方法直接呼叫委託類的add方法； 

3、當執行代理物件的add方法時，會先判斷是否存在實現了MethodInterceptor介面的物件 cglib$CALLBACK_0，如果存在，則呼叫MethodInterceptor物件的 intercept方法：

  1. public Object intercept(Object obj, Method method, Object[] arg, MethodProxy proxy) {
  2.     System.out.println("Before:" + method);  
  3.     Object object = proxy.invokeSuper(obj, arg);
  4.     System.out.println("After:" + method); 
  5.     return object;
  6. }

引數分別為：1、代理物件；2、委託類方法；3、方法引數；4、代理方法的MethodProxy物件。

4、每個被代理的方法都對應一個MethodProxy物件， methodProxy.invokeSuper方法最終呼叫委託類的add方法，實現如下：

  1. public Object invokeSuper(Object obj, Object[] args) throws Throwable {
  2.     try {
  3.         init();
  4.         FastClassInfo fci = fastClassInfo;
  5.         return fci.f2.invoke(fci.i2, obj, args);
  6.     } catch (InvocationTargetException e) {
  7.         throw e.getTargetException();
  8.     }
  9. }

單看 invokeSuper方法的實現，似乎看不出委託類add方法呼叫，在MethodProxy實現中，透過FastClassInfo維護了委託類和代理類的FastClass。

  1. private static class FastClassInfo {
  2.     FastClass f1;
  3.     FastClass f2;
  4.     int i1;
  5.     int i2;
  6. }

以add方法的methodProxy為例，f1指向委託類物件，f2指向代理類物件，i1和i2分別是方法add和CGLIB$add$0在物件中索引位置。

FastClass實現機制

FastClass其實就是對Class物件進行特殊處理，提出下標概念index，透過索引儲存方法的取用資訊，將原先的反射呼叫，轉化為方法的直接呼叫，從而體現所謂的fast，下麵透過一個例子瞭解一下FastClass的實現機制。 1、定義原類

  1. class Test {
  2.     public void f(){
  3.         System.out.println("f method");
  4.     }
  6.     public void g(){
  7.         System.out.println("g method");
  8.     }
  9. }

2、定義Fast類

  1. class FastTest {
  2.     public int getIndex(String signature){
  3.         switch(signature.hashCode()){
  4.         case 3078479:
  5.             return 1;
  6.         case 3108270:
  7.             return 2;
  8.         }
  9.         return -1;
  10.     }
  12.     public Object invoke(int index, Object o, Object[] ol){
  13.         Test t = (Test) o;
  14.         switch(index){
  15.         case 1:
  16.             t.f();
  17.             return null;
  18.         case 2:
  19.             t.g();
  20.             return null;
  21.         }
  22.         return null;
  23.     }
  24. }

在FastTest中有兩個方法， getIndex中對Test類的每個方法根據hash建立索引， invoke根據指定的索引，直接呼叫標的方法，避免了反射呼叫。所以當呼叫 methodProxy.invokeSuper方法時，實際上是呼叫代理類的 CGLIB$add$0方法， CGLIB$add$0直接呼叫了委託類的add方法。

JDK和CGLIB動態代理的區別

1、JDK動態代理生成的代理類和委託類實現了相同的介面； 

2、CGLIB動態代理中生成的位元組碼更加複雜，生成的代理類是委託類的子類，且不能處理被final關鍵字修飾的方法； 

3、JDK採用反射機制呼叫委託類的方法，CGLIB採用類似索引的方式直接呼叫委託類方法；

END

贊(0)
標籤：

相關推薦

熱門標籤

iOS (11238)微軟 (4955)Linux (4274)安全 (4180)Python (4161)效能 (3165)運維 (2774)最佳化 (2419).NET (2262)Google (2136)機器學習 (1795)併發 (1613)分散式 (1559)叢集 (1240)SQL (1174)Mysql (1060)區塊鏈 (1017)Docker (977)微服務 (922)面試 (919)Apache (743)NLP (725)Redis (719)Android (668)Git (640)架構師 (632)Nginx (630)Facebook (599)JVM (595)爬蟲 (476)

熱門文章

分享創造快樂

© 2024 知識星球   網站地圖