2. 程式人生 > >Java靜態代理和動態代理

Java靜態代理和動態代理

阿新 • • 發佈：2019-02-16

本篇部落格的由來，之前我們學習大話設計，就瞭解了代理模式，但為什麼還要說呢？

原因：

1，通過DRP這個專案，瞭解到了動態代理，認識到我們之前一直使用的都是靜態代理，那麼動態代理又有什麼好處呢？它們二者的區別是什麼呢？

2，通過學習動態代理了解到動態代理是一種符合AOP設計思想的技術，那麼什麼又是AOP?

下面是我對它們的理解！

代理Proxy：

Proxy代理模式是一種結構型設計模式，主要解決的問題是：在直接訪問物件時帶來的問題

代理是一種常用的設計模式，其目的就是為其他物件提供一個代理以控制對某個物件的訪問。代理類負責為委託類預處理訊息，過濾訊息並轉發訊息，以及進行訊息被委託類執行後的後續處理。

                      

為了保持行為的一致性，代理類和委託類通常會實現相同的介面，所以在訪問者看來兩者沒有絲毫的區別。通過代理類這中間一層，能有效控制對委託類物件的直接訪問，也可以很好地隱藏和保護委託類物件，同時也為實施不同控制策略預留了空間，從而在設計上獲得了更大的靈活性。

更通俗的說，代理解決的問題當兩個類需要通訊時，引入第三方代理類，將兩個類的關係解耦，讓我們只瞭解代理類即可，而且代理的出現還可以讓我們完成與另一個類之間的關係的統一管理，但是切記，代理類和委託類要實現相同的介面，因為代理真正呼叫的還是委託類的方法。

使用場合舉例：

如果需要委託類處理某一業務，那麼我們就可以先在代理類中統一處理然後在呼叫具體實現類

按照代理的建立時期，代理類可以分為兩種： 

靜態：由程式設計師建立代理類或特定工具自動生成原始碼再對其編譯。在程式執行前代理類的.class檔案就已經存在了。

動態：在程式執行時運用反射機制動態建立而成。

下面分別用靜態代理與動態代理演示一個示例：

新增列印日誌的功能，即每個方法呼叫之前和呼叫之後寫入日誌

靜態代理：

具體使用者管理實現類

  1. public class UserManagerImpl implements UserManager {  
  2.     @Override  
  3.     public void addUser(String userId, String userName) {  
  4.         System.out.println("UserManagerImpl.addUser");  
  5.     }  
  6.     @Override  
  7.     public void delUser(String userId) {  
  8.         System.out.println("UserManagerImpl.delUser");  
  9.     }  
  10.     @Override  
  11.     public String findUser(String userId) {  
  12.         System.out.println("UserManagerImpl.findUser");  
  13.         return "張三";  
  14.     }  
  15.     @Override  
  16.     public void modifyUser(String userId, String userName) {  
  17.         System.out.println("UserManagerImpl.modifyUser");  
  18.     }  
  19. }  

代理類--代理使用者管理實現類

  1. public class UserManagerImplProxy implements UserManager {  
  2.     // 目標物件  
  3.     private UserManager userManager;  
  4.     // 通過構造方法傳入目標物件  
  5.     public UserManagerImplProxy(UserManager userManager){  
  6.         this.userManager=userManager;  
  7.     }  
  8.     @Override  
  9.     public void addUser(String userId, String userName) {  
  10.         try{  
  11.                 //新增列印日誌的功能  
  12.                 //開始新增使用者  
  13.                 System.out.println("start-->addUser()");  
  14.                 userManager.addUser(userId, userName);  
  15.                 //新增使用者成功  
  16.                 System.out.println("success-->addUser()");  
  17.             }catch(Exception e){  
  18.                 //新增使用者失敗  
  19.                 System.out.println("error-->addUser()");  
  20.             }  
  21.     }  
  22.     @Override  
  23.     public void delUser(String userId) {  
  24.         userManager.delUser(userId);  
  25.     }  
  26.     @Override  
  27.     public String findUser(String userId) {  
  28.         userManager.findUser(userId);  
  29.         return "張三";  
  30.     }  
  31.     @Override  
  32.     public void modifyUser(String userId, String userName) {  
  33.         userManager.modifyUser(userId,userName);  
  34.     }  
  35. }  

客戶端呼叫

  1. public class Client {  
  2.     public static void main(String[] args){  
  3.         //UserManager userManager=new UserManagerImpl();  
  4.         UserManager userManager=new UserManagerImplProxy(new UserManagerImpl());  
  5.         userManager.addUser("1111", "張三");  
  6.     }  
  7. }  

靜態代理類優缺點

優點：

代理使客戶端不需要知道實現類是什麼，怎麼做的，而客戶端只需知道代理即可（解耦合），對於如上的客戶端程式碼，newUserManagerImpl()可以應用工廠將它隱藏，如上只是舉個例子而已。

缺點：

1）代理類和委託類實現了相同的介面，代理類通過委託類實現了相同的方法。這樣就出現了大量的程式碼重複。如果介面增加一個方法，除了所有實現類需要實現這個方法外，所有代理類也需要實現此方法。增加了程式碼維護的複雜度。

2）代理物件只服務於一種型別的物件，如果要服務多型別的物件。勢必要為每一種物件都進行代理，靜態代理在程式規模稍大時就無法勝任了。如上的程式碼是隻為UserManager類的訪問提供了代理，但是如果還要為其他類如Department類提供代理的話，就需要我們再次新增代理Department的代理類。

舉例說明：代理可以對實現類進行統一的管理，如在呼叫具體實現類之前，需要列印日誌等資訊，這樣我們只需要新增一個代理類，在代理類中新增列印日誌的功能，然後呼叫實現類，這樣就避免了修改具體實現類。滿足我們所說的開閉原則。但是如果想讓每個實現類都新增列印日誌的功能的話，就需要新增多個代理類，以及代理類中各個方法都需要新增列印日誌功能（如上的代理方法中刪除，修改，以及查詢都需要新增上列印日誌的功能）

即靜態代理類只能為特定的介面(Service)服務。如想要為多個介面服務則需要建立很多個代理類。

引入動態代理：

根據如上的介紹，你會發現每個代理類只能為一個介面服務，這樣程式開發中必然會產生許多的代理類

所以我們就會想辦法可以通過一個代理類完成全部的代理功能，那麼我們就需要用動態代理

在上面的示例中，一個代理只能代理一種型別，而且是在編譯器就已經確定被代理的物件。而動態代理是在執行時，通過反射機制實現動態代理，並且能夠代理各種型別的物件

在Java中要想實現動態代理機制，需要java.lang.reflect.InvocationHandler介面和 java.lang.reflect.Proxy 類的支援

java.lang.reflect.InvocationHandler介面的定義如下：

  1. //Object proxy:被代理的物件  
  2. //Method method:要呼叫的方法  
  3. //Object[] args:方法呼叫時所需要引數  
  4. public interface InvocationHandler {  
  5.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;  
  6. }  

java.lang.reflect.Proxy類的定義如下：

  1. //CLassLoader loader:類的載入器  
  2. //Class<?> interfaces:得到全部的介面  
  3. //InvocationHandler h:得到InvocationHandler介面的子類的例項  
  4. public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException  

動態代理：

具體實現類

  1. public class UserManagerImpl implements UserManager {  
  2.     @Override  
  3.     public void addUser(String userId, String userName) {  
  4.         System.out.println("UserManagerImpl.addUser");  
  5.     }  
  6.     @Override  
  7.     public void delUser(String userId) {  
  8.         System.out.println("UserManagerImpl.delUser");  
  9.     }  
  10.     @Override  
  11.     public String findUser(String userId) {  
  12.         System.out.println("UserManagerImpl.findUser");  
  13.         return "張三";  
  14.     }  
  15.     @Override  
  16.     public void modifyUser(String userId, String userName) {  
  17.         System.out.println("UserManagerImpl.modifyUser");  
  18.     }  
  19. }  

動態建立代理物件的類

  1. //動態代理類只能代理介面（不支援抽象類），代理類都需要實現InvocationHandler類，實現invoke方法。該invoke方法就是呼叫被代理介面的所有方法時需要呼叫的，該invoke方法返回的值是被代理介面的一個實現類  
  2. public class LogHandler implements InvocationHandler {  
  3.     // 目標物件  
  4.     private Object targetObject;  
  5.     //繫結關係，也就是關聯到哪個介面（與具體的實現類繫結）的哪些方法將被呼叫時，執行invoke方法。              
  6.     public Object newProxyInstance(Object targetObject){  
  7.         this.targetObject=targetObject;  
  8.         //該方法用於為指定類裝載器、一組介面及呼叫處理器生成動態代理類例項    
  9.         //第一個引數指定產生代理物件的類載入器，需要將其指定為和目標物件同一個類載入器  
  10.         //第二個引數要實現和目標物件一樣的介面，所以只需要拿到目標物件的實現介面  
  11.         //第三個引數表明這些被攔截的方法在被攔截時需要執行哪個InvocationHandler的invoke方法  
  12.         //根據傳入的目標返回一個代理物件  
  13.         return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),  
  14.                 targetObject.getClass().getInterfaces(),this);  
  15.     }  
  16.     @Override  
  17.     //關聯的這個實現類的方法被呼叫時將被執行  
  18.     /*InvocationHandler介面的方法，proxy表示代理，method表示原物件被呼叫的方法，args表示方法的引數*/  
  19.     public Object invoke(Object proxy, Method method, Object[] args)  
  20.             throws Throwable {  
  21.         System.out.println("start-->>");  
  22.         for(int i=0;i<args.length;i++){  
  23.             System.out.println(args[i]);  
  24.         }  
  25.         Object ret=null;  
  26.         try{  
  27.             /*原物件方法呼叫前處理日誌資訊*/  
  28.             System.out.println("satrt-->>");  
  29.             //呼叫目標方法  
  30.             ret=method.invoke(targetObject, args);  
  31.             /*原物件方法呼叫後處理日誌資訊*/  
  32.             System.out.println("success-->>");  
  33.         }catch(Exception e){  
  34.             e.printStackTrace();  
  35.             System.out.println("error-->>");  
  36.             throw e;  
  37.         }  
  38.         return ret;  
  39.     }  
  40. }  

被代理物件targetObject通過引數傳遞進來，我們通過targetObject.getClass().getClassLoader()獲取ClassLoader物件，然後通過targetObject.getClass().getInterfaces()獲取它實現的所有介面，然後將targetObject包裝到實現了InvocationHandler介面的LogHandler物件中。通過newProxyInstance函式我們就獲得了一個動態代理物件。

客戶端程式碼

  1. public class Client {  
  2.     public static void main(String[] args){  
  3.         LogHandler logHandler=new LogHandler();  
  4.         UserManager userManager=(UserManager)logHandler.newProxyInstance(new UserManagerImpl());  
  5.         //UserManager userManager=new UserManagerImpl();  
  6.         userManager.addUser("1111", "張三");  
  7.     }  
  8. }  

可以看到，我們可以通過LogHandler代理不同型別的物件，如果我們把對外的介面都通過動態代理來實現，那麼所有的函式呼叫最終都會經過invoke函式的轉發，因此我們就可以在這裡做一些自己想做的操作，比如日誌系統、事務、攔截器、許可權控制等。這也就是AOP(面向切面程式設計)的基本原理。

插曲：

AOP（AspectOrientedProgramming）：將日誌記錄，效能統計，安全控制，事務處理，異常處理等程式碼從業務邏輯程式碼中劃分出來，通過對這些行為的分離，我們希望可以將它們獨立到非指導業務邏輯的方法中，進而改變這些行為的時候不影響業務邏輯的程式碼---解耦。

針對如上的示例解釋：

我們來看上面的UserManagerImplProxy類，它的兩個方法System.out.println("start-->addUser()")和System.out.println("success-->addUser()")，這是做核心動作之前和之後的兩個擷取段，正是這兩個擷取段，卻是我們AOP的基礎，在OOP裡，System.out.println("start-->addUser()")、核心動作、System.out.println("success-->addUser()")這個三個動作在多個類裡始終在一起，但他們所要完成的邏輯卻是不同的，如System.out.println("start-->addUser()")裡做的可能是許可權的判斷，在所有類中它都是做許可權判斷，而在每個類裡核心動作卻各不相同，System.out.println("success-->addUser()")可能做的是日誌，在所有類裡它都做日誌。正是因為在所有的類裡，核心程式碼之前的操作和核心程式碼之後的操作都做的是同樣的邏輯，因此我們需要將它們提取出來，單獨分析，設計和編碼，這就是我們的AOP思想。一句話說，AOP只是在對OOP的基礎上進行進一步抽象，使我們的類的職責更加單一。

動態代理優點：

動態代理與靜態代理相比較，最大的好處是介面中宣告的所有方法都被轉移到呼叫處理器一個集中的方法中處理（InvocationHandler.invoke）。這樣，在介面方法數量比較多的時候，我們可以進行靈活處理，而不需要像靜態代理那樣每一個方法進行中轉。而且動態代理的應用使我們的類職責更加單一，複用性更強

總結：

其實所謂代理，就是一個人或者一個機構代表另一個人或者另一個機構採取行動。在一些情況下，一個客戶不想或者不能夠直接引用一個物件，而代理物件可以在客戶端和目標物件之前起到中介的作用。

代理物件就是把被代理物件包裝一層，在其內部做一些額外的工作，比如使用者需要上facebook,而普通網路無法直接訪問，網路代理幫助使用者先翻牆，然後再訪問facebook。這就是代理的作用了。

縱觀靜態代理與動態代理，它們都能實現相同的功能，而我們看從靜態代理到動態代理的這個過程，我們會發現其實動態代理只是對類做了進一步抽象和封裝，使其複用性和易用性得到進一步提升而這不僅僅符合了面向物件的設計理念，其中還有AOP的身影，這也提供給我們對類抽象的一種參考。關於動態代理與AOP的關係，個人覺得AOP是一種思想，而動態代理是一種AOP思想的實現！

相關推薦

java 靜態代理和動態代理

www. 同時 訪問方式 自身 代理模式 動態 滿足 size 基礎 代理模式 一、概述 　　代理是一種模式，提供了對目標對象的間接訪問方式，即通過代理訪問目標對象。如此便於在目標實現的基礎上增加額外的功能操作，前攔截，後攔截等，以滿足自身的業務需求，同時代理模式便於擴展目

Java 8中的靜態代理和動態代理的簡單心得

歡迎來到我的第一個部落格 個人學習的一點心得,第一次寫寫的不好見諒 看看程式碼吧 程式碼1. public interface CarSales { void sell(); } 程式碼2. public class QQCar implements

Java設計模式之代理模式的靜態代理和動態代理

前言 代理模式分為靜態和動態。同時靜態代理又分為普通代理和強制代理。因此本文會通過示例的方式詳細介紹著三種代理模式。我們依然以網上購物為例。   普通代理 定義：要求客戶端只能訪問代理角色，而不能直接訪問真實角色。我們需要修改真實角色： 1 public class RealCon

java中的代理（靜態代理和動態代理）

之前本人在設計模式中有寫過靜態代理和動態代理的相關程式碼測試，可以看下。 今天我們主要學一下理論相關知識。 AOP的原理就是動態代理機制。RPC框架也是實現了AOP機制。 靜態代理 靜態代理：在程式碼編譯時就確定了被代理的類是哪一個。 這個靜態代理比較簡單，代理類和被代

Java的靜態代理和動態代理

什麼是代理 什麼是代理呢，其實很好理解，就是不直接訪問目標，而是通過一箇中間層來訪問，就好像下面這樣： Java的靜態代理 舉個例子，如果我們一些水果，比如：香蕉、蘋果等，寫成Java程式碼，大概是下面這個樣子： //Fruit.java /** * 水果

設計模式 - Java靜態代理和動態代理

本篇部落格的由來，之前我們學習大話設計，就瞭解了代理模式，但為什麼還要說呢？ 原因： 1，通過DRP這個專案，瞭解到了動態代理，認識到我們之前一直使用的都是靜態代理，那麼動態代理又有什麼好處呢？它們二者的區別是什麼呢？ 2，通過學習動態代理了解到動態代理是一種符合AOP設計思想的技術，那

Java 靜態代理和動態代理的使用及原理解析

代理模式是軟體開發中常見的設計模式，它的目的是讓呼叫者不用持有具體操作者的引用，而是通過代理者去對具體操作者執行具體的操作。 靜態代理的實現 操作介面： public interface Operate { void doSomething(); } 複製程式碼 操作者： public cla

java靜態代理和動態代理（一）

代理Proxy：  Proxy代理模式是一種結構型設計模式，主要解決的問題是：在直接訪問物件時帶來的問題。  代理是一種常用的設計模式，其目的就是為其他物件提供一個代理以控制對某個物件的訪問。代理類負責為委託類預處理訊息，過濾訊息並轉發訊息，以及進行訊息被委託類執行後的後續處理。 &

java學習之代理（2）：靜態代理和動態代理

一，代理的概念 代理是一個物件，代理物件為其他物件提供一種代理，以控制對這個物件的訪問，代理物件起到中介作用，可以去掉或者增加額外的服務。 如：火車票代售點就是火車站售票處的一個代理物件，可通過訪問代售點進行業務處理。 二，靜態代理的2種實現方式：繼承和聚合 靜態代理中的代

java靜態代理和動態代理的區別

本篇部落格的由來，之前我們學習大話設計，就瞭解了代理模式，但為什麼還要說呢？原因：1，通過DRP這個專案，瞭解到了動態代理，認識到我們之前一直使用的都是靜態代理，那麼動態代理又有什麼好處呢？它們二者的區別是什麼呢？2，通過學習動態代理了解到動態代理是一種符合AOP設計思想的技

Java設計模式之—靜態代理和動態代理

靜態代理 代理從字面意思來看就是，替代XX去做某事，在我們的程式中，一般替代實際物件去進行操作，扮演著中間人的角色： 客戶端 –> 業務類 客戶端 –> 代理 –>業務類（代理） 代理介面 interface O

java設計模式--代理模式（靜態代理和動態代理）

完全拷貝，有些地方修改了一下 1、動態代理（Dynamic Proxy） 　　代理分為靜態代理和動態代理，靜態代理是在編譯時就將介面、實現類、代理類一股腦兒全部手動完成，但如果我們需要很多的代理，每一個都這麼手動的去建立實屬浪費時間，而且會有大量的重複程

java梳理-靜態代理和動態代理有什麼區別

 一 概念 為某個物件提供一個代理，以控制對這個物件的訪問。 代理類和委託類有共同的父類或父介面，這樣在任何使用委託類物件的地方都可以用代理物件替代。代理類負責請求的預處理、過濾、將請求分派給委託類處理、以及委託類執行完請求後的後續處理。       代理模式是經典設計模式中的一種，屬於物件建立型設計模式。

Java靜態代理和動態代理

本篇部落格的由來，之前我們學習大話設計，就瞭解了代理模式，但為什麼還要說呢？ 原因： 1，通過DRP這個專案，瞭解到了動態代理，認識到我們之前一直使用的都是靜態代理，那麼動態代理又有什麼好處呢？它們二者的區別是什麼呢？ 2，通過學習動態代理了解到動態代理是一種符合AOP

Java中的靜態代理和動態代理

[toc] 最近在學習MyBatis原始碼，瞭解到MyBatis裡之所以只需要開發者編寫Mapper介面即可執行SQL，就是因為JDK的動態代理在背後默默為我們做了很多事情。但是我自己對動態代理還只是一知半解，於是手機整理資料學習，整理了這篇筆記。 說到動態代理，首先要講的就是設計模式中的代理模式，而對於

spring靜態代理和動態代理

row main 同時 rac images 處理 解決 pro abstract 本節要點： Java靜態代理 Jdk動態代理 1 面向對象設計思想遇到的問題 在傳統OOP編程裏以對象為核心，並通過對象之間的協作來形成一個完整的軟件功能，由於對象可以繼承，因此我們可以

java 進階一：代理和動態代理

實現 public rgs tostring 開源項目 body llb ack code 靜態代理： 　　定義頂級接口：Iservice //目標類和代理類都實現該接口 public interface Iservice { public String serv

靜態代理和動態代理

代理模式 操作 改變 final false 為我 什麽 csdn 思考 代理模式（靜態代理） 代理模式是為其他對象提供一種代理以控制對這個對象的訪問。 定義上也不算好理解， 上一個 《大話設計模式》 的圖。 Subject 類（一般是抽象類或接口）， 定義了一個方法

代理模式（靜態代理和動態代理）

Java 靜態代理 靜態代理通常用於對原有業務邏輯的擴充。比如持有二方包的某個類，並呼叫了其中的某些方法。然後出於某種原因，比如記錄日誌、列印方法執行時間，但是又不好將這些邏輯寫入二方包的方法裡。所以可以建立一個代理類實現和二方方法相同的方法，通過讓代理類持有真實物件，然後在原始碼中呼叫代理類方法，

Java核心-反射和動態代理（JDK Proxy和Cglib）

反射和動態代理放有一定的相關性，但單純的說動態代理是由反射機制實現的，其實是不夠全面不準確的，動態代理是一種功能行為，而它的實現方法有很多。要怎麼理解以上這句話，請看下文。 一、反射 反射機制是 Java 語言提供的一種基礎功能，賦予程式在執行時 自省 （intro