2. 程式人生 > >Java 動態代理作用是什麼 ==AOP?

Java 動態代理作用是什麼 ==AOP?

阿新 • • 發佈：2019-02-06
之前雖然會用JDK的動態代理，但是有些問題卻一直沒有搞明白。比如說：InvocationHandler的invoke方法是由誰來呼叫的，代理物件是怎麼生成的，直到前幾個星期才把這些問題全部搞明白了。 
    廢話不多說了，先來看一下JDK的動態是怎麼用的。 

Java程式碼  收藏程式碼
  1. package dynamic.proxy;   
  2. import java.lang.reflect.InvocationHandler;  
  3. import java.lang.reflect.Method;  
  4. import java.lang.reflect.Proxy;  
  5. /**
     
  6.  * 實現自己的InvocationHandler 
  7.  * @author zyb 
  8.  * @since 2012-8-9 
  9.  * 
  10.  */  
  11. public class MyInvocationHandler implements InvocationHandler {  
  12.     // 目標物件   
  13.     private Object target;  
  14.     /** 
  15.      * 構造方法 
  16.      * @param target 目標物件  
  17.      */  
  18.     public MyInvocationHandler(Object target) {  
  19.         super();  
  20.         this.target = target;  
  21.     }  
  22.     /** 
  23.      * 執行目標物件的方法 
  24.      */  
  25.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
  26.         // 在目標物件的方法執行之前簡單的列印一下  
  27.         System.out.println("------------------before------------------");  
  28.         // 執行目標物件的方法  
  29.         Object result = method.invoke(target, args);  
  30.         // 在目標物件的方法執行之後簡單的列印一下  
  31.         System.out.println("-------------------after------------------");  
  32.         return result;  
  33.     }  
  34.     /** 
  35.      * 獲取目標物件的代理物件 
  36.      * @return 代理物件 
  37.      */  
  38.     public Object getProxy() {  
  39.         return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),   
  40.                 target.getClass().getInterfaces(), this);  
  41.     }  
  42. }  
  43. package dynamic.proxy;  
  44. /** 
  45.  * 目標物件實現的介面，用JDK來生成代理物件一定要實現一個介面 
  46.  * @author zyb 
  47.  * @since 2012-8-9 
  48.  * 
  49.  */  
  50. public interface UserService {  
  51.     /** 
  52.      * 目標方法  
  53.      */  
  54.     public abstract void add();  
  55. }  
  56. package dynamic.proxy;   
  57. /** 
  58.  * 目標物件 
  59.  * @author zyb 
  60.  * @since 2012-8-9 
  61.  * 
  62.  */  
  63. public class UserServiceImpl implements UserService {  
  64.     /* (non-Javadoc) 
  65.      * @see dynamic.proxy.UserService#add() 
  66.      */  
  67.     public void add() {  
  68.         System.out.println("--------------------add---------------");  
  69.     }  
  70. }  
  71. package dynamic.proxy;   
  72. import org.junit.Test;  
  73. /** 
  74.  * 動態代理測試類 
  75.  * @author zyb 
  76.  * @since 2012-8-9 
  77.  * 
  78.  */  
  79. public class ProxyTest {  
  80.     @Test  
  81.     public void testProxy() throws Throwable {  
  82.         // 例項化目標物件  
  83.         UserService userService = new UserServiceImpl();  
  84.         // 例項化InvocationHandler  
  85.         MyInvocationHandler invocationHandler = new MyInvocationHandler(userService);  
  86.         // 根據目標物件生成代理物件  
  87.         UserService proxy = (UserService) invocationHandler.getProxy();  
  88.         // 呼叫代理物件的方法  
  89.         proxy.add();  
  90.     }  
  91. }  


執行結果如下： 
------------------before------------------ 
--------------------add--------------- 
-------------------after------------------

   用起來是很簡單吧，其實這裡基本上就是AOP的一個簡單實現了，在目標物件的方法執行之前和執行之後進行了增強。Spring的AOP實現其實也是用了Proxy和InvocationHandler這兩個東西的。 

    用起來是比較簡單，但是如果能知道它背後做了些什麼手腳，那就更好不過了。首先來看一下JDK是怎樣生成代理物件的。既然生成代理物件是用的Proxy類的靜態方newProxyInstance，那麼我們就去它的原始碼裡看一下它到底都做了些什麼？ 
Java程式碼  收藏程式碼
  1. /** 
  2.  * loader:類載入器 
  3.  * interfaces:目標物件實現的介面 
  4.  * h:InvocationHandler的實現類 
  5.  */  
  6. public static Object newProxyInstance(ClassLoader loader,  
  7.                       Class<?>[] interfaces,  
  8.                       InvocationHandler h)  
  9.     throws IllegalArgumentException  
  10.     {  
  11.     if (h == null) {  
  12.         throw new NullPointerException();  
  13.     }  
  14.     /* 
  15.      * Look up or generate the designated proxy class. 
  16.      */  
  17.     Class cl = getProxyClass(loader, interfaces);  
  18.     /* 
  19.      * Invoke its constructor with the designated invocation handler. 
  20.      */  
  21.     try {  
  22.             // 呼叫代理物件的構造方法（也就是$Proxy0(InvocationHandler h)）  
  23.         Constructor cons = cl.getConstructor(constructorParams);  
  24.             // 生成代理類的例項並把MyInvocationHandler的例項傳給它的構造方法  
  25.         return (Object) cons.newInstance(new Object[] { h });  
  26.     } catch (NoSuchMethodException e) {  
  27.         throw new InternalError(e.toString());  
  28.     } catch (IllegalAccessException e) {  
  29.         throw new InternalError(e.toString());  
  30.     } catch (InstantiationException e) {  
  31.         throw new InternalError(e.toString());  
  32.     } catch (InvocationTargetException e) {  
  33.         throw new InternalError(e.toString());  
  34.     }  
  35.     }  


   我們再進去getProxyClass方法看一下 
Java程式碼  收藏程式碼
  1. public static Class<?> getProxyClass(ClassLoader loader,   
  2.                                          Class<?>... interfaces)  
  3.     throws IllegalArgumentException  
  4.     {  
  5.     // 如果目標類實現的介面數大於65535個則丟擲異常（我XX，誰會寫這麼NB的程式碼啊？）  
  6.     if (interfaces.length > 65535) {  
  7.         throw new IllegalArgumentException("interface limit exceeded");  
  8.     }  
  9.     // 宣告代理物件所代表的Class物件（有點拗口）  
  10.     Class proxyClass = null;  
  11.     String[] interfaceNames = new String[interfaces.length];  
  12.     Set interfaceSet = new HashSet();   // for detecting duplicates  
  13.     // 遍歷目標類所實現的介面  
  14.     for (int i = 0; i < interfaces.length; i++) {  
  15.         // 拿到目標類實現的介面的名稱  
  16.         String interfaceName = interfaces[i].getName();  
  17.         Class interfaceClass = null;  
  18.         try {  
  19.         // 載入目標類實現的介面到記憶體中  
  20.         interfaceClass = Class.forName(interfaceName, false, loader);  
  21.         } catch (ClassNotFoundException e) {  
  22.         }  
  23.         if (interfaceClass != interfaces[i]) {  
  24.         throw new IllegalArgumentException(  
  25.             interfaces[i] + " is not visible from class loader");  
  26.         }  
  27.         // 中間省略了一些無關緊要的程式碼 .......  
  28.         // 把目標類實現的介面代表的Class物件放到Set中  
  29.         interfaceSet.add(interfaceClass);  
  30.         interfaceNames[i] = interfaceName;  
  31.     }  
  32.     // 把目標類實現的介面名稱作為快取（Map）中的key  
  33.     Object key = Arrays.asList(interfaceNames);  
  34.     Map cache;  
  35.     synchronized (loaderToCache) {  
  36.         // 從快取中獲取cache  
  37.         cache = (Map) loaderToCache.get(loader);  
  38.         if (cache == null) {  
  39.         // 如果獲取不到，則新建地個HashMap例項  
  40.         cache = new HashMap();  
  41.         // 把HashMap例項和當前載入器放到快取中  
  42.         loaderToCache.put(loader, cache);  
  43.         }  
  44.     }  
  45.     synchronized (cache) {  
  46.         do {  
  47.         // 根據介面的名稱從快取中獲取物件  
  48.         Object value = cache.get(key);  
  49.         if (value instanceof Reference) {  
  50.             proxyClass = (Class) ((Reference) value).get();  
  51.         }  
  52.         if (proxyClass != null) {  
  53.             // 如果代理物件的Class例項已經存在，則直接返回  <

相關推薦

Java 動態代理作用是什麼 ==AOP?

之前雖然會用JDK的動態代理，但是有些問題卻一直沒有搞明白。比如說：InvocationHandler的invoke方法是由誰來呼叫的，代理物件是怎麼生成的，直到前幾個星期才把這些問題全部搞明白了。      廢話不多說了，先來看一下JDK的動態是怎麼用的。  Java程式碼  

Java 動態代理及AOP實現機制

www javadoc 底層 service ack 兩種方法 實現機制 之間 sets AOP實現機制http://www.iteye.com/topic/1116696 AOP: (Aspect Oriented Programming) 面向切面編程AOP包括切面（a

Java 動態代理作用是什麼？為什麼要動態代理

作者：Intopass 連結：https://www.zhihu.com/question/20794107/answer/75164285 來源：知乎 著作權歸作者所有。商業轉載請聯絡作者獲得授權，非商業轉載請註明出處。 ① 首先你要明白靜態代理的作用 我們有一個字型提供類，有多種實現（從磁碟，從

理解Java 動態代理和AOP（可以自己動手寫AOP框架！）

說到AOP，很容易就想到 spring AOP。因為它是AOP裡最優秀的實現框架。但本文不打算討論 spring AOP，只想把如何通過動態代理方式實現AOP思想說通。當然，整明白了這個道理，理解 spring AOP 也就簡單了！ 首先我覺得需特別強調一下什麼是面向介面程

Java動態代理（AOP）

[TOC] 動態代理（理解）： 基於反射機制。 現在需要知道以下的就行： 1. 什麼是動態代理 ？ 使用jdk的反射機制，建立物件的能力， 建立的是代理類的物件。 而不用你建立類檔案。不用寫java檔案。 動態：在程式執行時，呼叫jdk提供的方法才能建立代理類的物件。 jdk動態代理

Java動態代理學習【Spring AOP基礎之一】

tor -1 我們 null exception 文件 cat static 一個 　　Spring AOP使用的其中一個底層技術就是Java的動態代理技術。Java的動態代理技術主要圍繞兩個類進行的　 　　java.lang.reflect.InvocationHan

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

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

（京東面試題）java動態代理主要怎麼實現的，spring aop 原理 如下類

京東面試題 1、java動態代理主要怎麼實現的，spring aop 原理 如下類 public class Test { public void example(){ System.out.println("example"); } } 如何實現在方法exampl

AOP與JAVA動態代理

AOP與JAVA動態代理 1、AOP的各種實現 AOP就是面向切面程式設計，我們可以從以下幾個層面來實現AOP 在編譯期修改原始碼 在執行期位元組碼載入前修改位元組碼 在執行期位元組碼載入後動態建立代理類的位元組碼 2、AOP各種實現機制的比較 以下是各種實現機制的比較：

Java動態代理+註解體現Spring AOP思想

在MVC的架構中，優秀的程式碼是Service業務層只做業務邏輯處理，如果要新增新功能（如日誌，事務等），不應該汙染業務層程式碼。 講得很抽象，簡單來說，如果我要在業務層新增日誌功能，在業務層程式碼內不應該出現Logger這個東西。 想知道怎麼

Java動態代理的作用及好處

Java動態代理的優勢是實現無侵入式的程式碼擴充套件，也就是方法的增強；讓你可以在不用修改原始碼的情況下，增強一些方法；在方法的前後你可以做你任何想做的事情（甚至不去執行這個方法就可以）。 1.動態代理是設計模式中的代理模式： 定義：為其它物件提供一種代理以

Java JDK 動態代理（AOP）使用及實現原理分析

/** * A factory function that generates, defines and returns the proxy class given * the ClassLoader and array of interfaces. */ privat

Java之代理（jdk靜態代理，jdk動態代理，cglib動態代理，aop，aspectj）

一．概念 代理是什麼呢？舉個例子，一個公司是賣攝像頭的，但公司不直接跟使用者打交道，而是通過代理商跟使用者打交道。如果：公司介面中有一個賣產品的方法，那麼公司需要實現這個方法，而代理商也必須實現這個方法。如果公司賣

Java 動態代理(AOP實現機制)

浪費了“黃金五年”的Java程式設計師，還有救嗎？ >>>   

Java-JDK動態代理（AOP）使用及實現原理分析

# Java-JDK動態代理（AOP）使用及實現原理分析 # 第一章:代理的介紹 介紹:我們需要掌握的程度 > 動態代理(理解) 基於反射機制 掌握的程度: 1.什麼是動態代理? 2.動態代理能夠做什麼? 後面我們在用Spirng和Mybatis的時候,要理解怎麼使用的. ## 1.什麼是代理

java動態代理【一】

bject print reat 映射 tor ted borde 需要 static java動態代理的定義：為其他目標類的方法增加切面的邏輯，即在執行目標類方法的時候，先去執行一段如校驗檢測的邏輯代碼。java通俗一點就是生成一個繼承目標類的子類，並在每個調用方法都添加

Java——動態代理

插入 ref exc tcl try 反射 mil 動態 () 在靜態代理中，我們在調用target類的時候，都是先拿到proxy類。由於proxy類中將target類作為了成員變量，而且跟target類繼承了一樣的接口，具有同樣的

Java動態代理

throws ice handle main throw int 表示 isp logs 首先我們定義一個接口 public interface SayService { public void say(); } View Code 接著實現這個接口 p

JAVA動態代理機制解析

定義 book lang 並不是 stat 控制 () highlight 什麽 1. 概述　　首先，我們來思考如下兩個問題：　　什麽是代理模式？為什麽要使用代理模式？ 　　簡單總結一下，所謂的代理模式就是在原有的服務上多加一個占位，通過這個占位去控制服務的訪問。通過代理模

Java動態代理 深度詳解

實現 接下來 href 新建 結構 str 如果 cat 子類 代理模式是設計模式中非常重要的一種類型，而設計模式又是編程中非常重要的知識點，特別是在業務系統的重構中，更是有舉足輕重的地位。代理模式從類型上來說，可以分為靜態代理和動態代理兩種類型。 今天我將用非常簡單易懂的