2. 程式人生 > >Java動態代理(JDK 和CGLIB、Javassist、ASM之間的差別)

Java動態代理(JDK 和CGLIB、Javassist、ASM之間的差別)

阿新 • • 發佈：2018-12-13
  1. import com.foo.proxy.Rechargable;  
  2. import com.foo.proxy.Vehicle;  
  3. import java.lang.reflect.InvocationHandler;  
  4. import java.lang.reflect.Method;  
  5. import java.lang.reflect.Proxy;  
  6. import java.lang.reflect.UndeclaredThrowableException;  
  7. /** 
  8.  生成的動態代理類的組織模式是繼承Proxy類，然後實現需要實現代理的類上的所有介面，而在實現的過程中，則是通過將所有的方法都交給了InvocationHandler來處理 
  9. */  
  10.  public final class ElectricCarProxy extends Proxy  
  11.   implements Rechargable, Vehicle  
  12. {  
  13.   private static Method m1;  
  14.   private static Method m3;  
  15.   private static Method m4;  
  16.   private static Method m0;  
  17.   private static Method m2;  
  18.   public ElectricCarProxy(InvocationHandler paramInvocationHandler)  
  19.     throws   
  20.   {  
  21.     super(paramInvocationHandler);  
  22.   }  
  23.   public final boolean equals(Object paramObject)  
  24.     throws   
  25.   {  
  26.     try  
  27.     { // 方法功能實現交給InvocationHandler處理  
  28.       return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();  
  29.     }  
  30.     catch (Error|RuntimeException localError)  
  31.     {  
  32.       throw localError;  
  33.     }  
  34.     catch (Throwable localThrowable)  
  35.     {  
  36.       throw new UndeclaredThrowableException(localThrowable);  
  37.     }  
  38.   }  
  39.   public final void recharge()  
  40.     throws   
  41.   {  
  42.     try  
  43.     {  
  44.        // 方法功能實現交給InvocationHandler處理  
  45.       this.h.invoke(this, m3, null);  
  46.       return;  
  47.     }  
  48.     catch (Error|RuntimeException localError)  
  49.     {  
  50.       throw localError;  
  51.     }  
  52.     catch (Throwable localThrowable)  
  53.     {  
  54.       throw new UndeclaredThrowableException(localThrowable);  
  55.     }  
  56.   }  
  57.   public final void drive()  
  58.     throws   
  59.   {  
  60.     try  
  61.     {  
  62.        // 方法功能實現交給InvocationHandler處理  
  63.       this.h.invoke(this, m4, null);  
  64.       return;  
  65.     }  
  66.     catch (Error|RuntimeException localError)  
  67.     {  
  68.       throw localError;  
  69.     }  
  70.     catch (Throwable localThrowable)  
  71.     {  
  72.       throw new UndeclaredThrowableException(localThrowable);  
  73.     }  
  74.   }  
  75.   public final int hashCode()  
  76.     throws   
  77.   {  
  78.     try  
  79.     {  
  80.        // 方法功能實現交給InvocationHandler處理  
  81.        return ((Integer)this.h.invoke(this, m0, null)).intValue();  
  82.     }  
  83.     catch (Error|RuntimeException localError)  
  84.     {  
  85.       throw localError;  
  86.     }  
  87.     catch (Throwable localThrowable)  
  88.     {  
  89.       throw new UndeclaredThrowableException(localThrowable);  
  90.     }  
  91.   }  
  92.   public final String toString()  
  93.     throws   
  94.   {  
  95.     try  
  96.     {  
  97.        // 方法功能實現交給InvocationHandler處理  
  98.       return (String)this.h.invoke(this, m2, null);  
  99.     }  
  100.     catch (Error|RuntimeException localError)  
  101.     {  
  102.       throw localError;  
  103.     }  
  104.     catch (Throwable localThrowable)  
  105.     {  
  106.       throw new UndeclaredThrowableException(localThrowable);  
  107.     }  
  108.   }  
  109.   static  
  110.   {  
  111.     try  
  112.     {  //為每一個需要方法物件，當呼叫相應的方法時，分別將方法物件作為引數傳遞給InvocationHandler處理  
  113.       m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });  
  114.       m3 = Class.forName("com.foo.proxy.Rechargable").getMethod("recharge", new Class[0]);  
  115.       m4 = Class.forName("com.foo.proxy.Vehicle").getMethod("drive", new Class[0]);  
  116.       m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);  
  117.       m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);  
  118.       return;  
  119.     }  
  120.     catch (NoSuchMethodException localNoSuchMethodException)  
  121.     {  
  122.       throw new NoSuchMethodError(localNoSuchMethodException.getMessage());  
  123.     }  
  124.     catch (ClassNotFoundException localClassNotFoundException)  
  125.     {  
  126.       throw new NoClassDefFoundError(localClassNotFoundException.getMessage());  
  127.     }  
  128.   }  
  129. }  

相關推薦

Java動態代理(JDK 和CGLIB、Javassist、ASM之間的差別)

import com.foo.proxy.Rechargable;   import com.foo.proxy.Vehicle;   import java.lang.reflect.InvocationHandler;   import java.lang.reflect.Method;   im

java動態代理——JDK和CGLIB原理解析與使用

CGLIB的動態代理  原理       代理為控制要訪問的目標物件提供了一種途徑。當訪問物件時，它引入了一個間接的層。JDK自從1.3版本開始，就引入了動態代理，並且經常被用來動態地建立代理。JDK的動態代理用起來非常簡單，當它有一個限制，就是使用動

java設定模式---代理模式--動態代理模式和cglib代理模式詳解

代理模式使用場景 代理模式的定義：什麼是代理模式呢？代理模式是常用的Java設計模式，它的特徵是代理類與委託類有同樣的介面，代理類主要負責為委託類預處理訊息、過濾訊息、把訊息轉發給委託類，以及事後處理消息等。代理類和委託類之間通常會存在關聯關係，一個代理類的物件與一個委託類的物件關聯，代理類的物

JDK的Proxy動態代理模式和CGLIB動態代理模式的區別和共同點

首先我們來談談聯眾代理模式的不同之處：《1》代理類不同點：（1）Proxy的代理類的建立是通過工具類或者工廠類自動建立的，   我們只需要呼叫Proxy.newProxyInstance(Loader,interfaces,h);正確的傳入相應的引數，就可以得到餓哦們想要的目

JAVA 動態代理原理和實現

ror binary lose ole jdk 動態代理 參數 try lob rac 在 Java 中動態代理和代理都很常見，幾乎是所有主流框架都用到過的知識。在面試中也是經常被提到的話題，於是便總結了本文。 Java動態代理的基本原理為：被代理對象需要實現某個接口（這是

Java動態代理概述和手寫實現動態代理

一：前提 Spring中最重要的兩種思想：控制反轉IOC(Inversion of Control)和麵向切面程式設計AOP(Aspect-Oriented Programming)，而AOP最重要的原理就是動態代理，今天我們談一下動態代理。動態代理顧名思義是代替別人做某些

Spring的兩種代理JDK和CGLIB的區別淺談

一、原理區別： java動態代理是利用反射機制生成一個實現代理介面的匿名類，在呼叫具體方法前呼叫InvokeHandler來處理。 而cglib動態代理是利用asm開源包，對代理物件類的class檔案

03、動態代理--JDK動態代理和CGLib動態代理的組合實例

listen -- offer pri eth err imp instance music package com.offer.note.Java基礎.動態代理.CGLib引入增強; public interface Browser { void visitI

java動態代理（JDK和CGLIB）筆記

動態代理：為一堆interface或類的實現提供統一的執行通道，從含義上就像區域網電腦通過代理上網一樣，走統一的通道，代理控制通道，自然可以在通道里加上自定義實現，例如像AOP切面，日誌等。 JDK的動態代理只能對介面實現，代理類需要實現InvocationHandler 介面。 一、介面 pub

Java動態代理之JDK實現和CGlib實現

     原文地址：http://www.cnblogs.com/ygj0930/p/6542259.html       一：代理模式（靜態代理）    &nbs

【轉載】Java動態代理之JDK實現和CGlib實現（簡單易懂）

      原文地址：http://www.cnblogs.com/ygj0930/p/6542259.html       一：代理模式（靜態代理）           代理模式是常用設計模式的一種，我們在軟體設計時常用的代理一般是指靜態代理，也就是在程式碼中顯式指定的

java動態代理（JDK和cglib）

JAVA的動態代理  代理模式  代理模式是常用的java設計模式，他的特徵是代理類與委託類有同樣的介面，代理類主要負責為委託類預處理訊息、過濾訊息、把訊息轉發給委託類，以及事後處理訊息等。代理類與委託類之間通常會存在關聯關係，一個代理類的物件與一個委託類的物件關聯，代理類的物件本身並不真正實現服務，

【八】Java設計模式GOF23之動態代理（原生JDK和CGLIB）

一、使用JDK原生動態代理 基於Java反射機制。 Java動態代理是基於介面的，如果物件沒有實現介面則選擇用CGLIB方式實現動態代理。 實現步驟： 1.首先實現一個InvocationHandler，方法呼叫會被轉發到該類的invoke()方法。 2.然後在需要

Java動態代理（JDK介面代理和Cglib類代理）

代理模式 代理模式是常用的java設計模式，它的特徵是代理類與委託類有同樣的介面，代理類主要負責為委託類預處理訊息、過濾訊息、把訊息轉發給委託類，以及事後處理訊息等。代理類與委託類之間通常會存在關聯關係，一個代理類的物件與一個委託類的物件關聯，代理類的物件本身並不真正實現服

Java動態代理之JDK實現和CGlib實現（簡單易懂）

原文地址：http://www.cnblogs.com/ygj0930/p/6542259.html 一：代理模式（靜態代理）           代理模式是常用設計模式的一種，我們在軟體設計時常用的代理一般是指靜態代理，也就是在程式碼中顯式指定的代理。      

java 動態代理模式（jdk和cglib）

ref false spa err ast 反射 步驟 3.1 rate 1 package proxy.dynamicproxy; 2 3 import java.lang.reflect.InvocationHandler; 4 import java.la

java中代理，靜態代理，動態代理以及spring aop代理方式，實現原理統一彙總 Spring中AOP的兩種代理方式（Java動態代理和CGLIB代理）

若代理類在程式執行前就已經存在，那麼這種代理方式被成為 靜態代理 ，這種情況下的代理類通常都是我們在Java程式碼中定義的。 通常情況下， 靜態代理中的代理類和委託類會實現同一介面或是派生自相同的父類。 一、概述1. 什麼是代理我們大家都知道微商代理，簡單地說就是代替廠家賣商品，廠家“委託”代理為

代理設計模式 （靜態代理設計模式）+ 動態代理（JDK和Cglib）

一、代理設計模式 1、設計模式：前人總結一套解決特定問題的程式碼 2、代理設計模式優點： 　　　　2.1 保護真實物件 　　　　2.2 讓真實物件職責更明確 　　　　2.3 擴充套件 3、代理設計模式 　　　　3.1 真實物件（老總） 　　　　3.2 代理物件（祕書） 　　　　3.3 抽象物

【代理模式】jdk和cglib動態代理實現的區別

jdk和cglib動態代理實現的區別 1、jdk動態代理生成的代理類和委託類實現了相同的介面； 2、cglib動態代理中生成的位元組碼更加複雜，生成的代理類是委託類的子類，且不能處理被final關鍵字

使用JDK和Cglib兩種方式動態代理

一 使用JDK動態代理這種方式，只能對介面進行動態代理，有一定的侷限性；介面：package org.spring.test2; import java.util.Map; public interface UserService { void insert(Map&l