代理模式屬于結構型模式，代理模式給某一個物件提供一個代理物件，并由代理物件控制對原物件的參考，即通過代理物件訪問目標物件，這樣做的好處是：可以在目標物件實作的基礎上，增強額外的功能操作，即擴展目標物件的功能，如Spring中的AOP，
代理模式有三種形式：靜態代理，JDK動態代理和Cglib動態代理（可以在記憶體動態的創建物件，而不需要實作介面），
代理模式主要涉及到抽象主題角色、代理主題角色、真實主題角色三個角色：
- 抽象主題角色：宣告了真實主題和代理主題的共同介面，這樣一來在任何可以使用真實主題的地方都可以使用代理主題，
- 真實主題角色：定義了代理角色所代表的真實物件，
- 代理主題角色：代理主題角色內部含有對真實主題的參考，從而可以在任何時候操作真實主題物件;代理主題角色提供一個與真實主題角色相同的介面，以便可以在任何時候都可以替代真實主體;控制對真實主題的參考，負責在需要的時候創建真實主題物件（和洗掉真實主題物件);代理角色通常在將客戶端呼叫傳遞給真實的主題之前或者之后，都要執行某個操作，而不是單純地將呼叫傳遞給真實主題物件，
靜態代理
靜態代理在使用時,需要定義介面或者父類,被代理物件(即目標物件)與代理物件一起實作相同的介面或者是繼承相同父類，
在一個學校有一名老師，老師的職責就是教書，但是某一天老師因事請假了，于是找了另一名老師來代課，下面就以這個例子來講解，
靜態代理的UML類圖如下：
抽象主題角色：
package com.charon.proxy.staticstate;
/**
* @className: ITeacherDao
* @description: 抽象主題角色
* @author: charon
* @create: 2022-03-24 23:23
*/
public interface ITeacherDao {
/**
* 教書方法
*/
void teach();
}
具體主題角色：
package com.charon.proxy.staticstate;
/**
* @className: TeacherDao
* @description:
* @author: charon
* @create: 2022-03-24 23:26
*/
public class TeacherDao implements ITeacherDao{
@Override
public void teach() {
System.out.println("老師在授課中，，，，");
}
}
代理主題角色：
package com.charon.proxy.staticstate;
/**
* @className: TeacherDaoProxy
* @description: 靜態代理
* @author: charon
* @create: 2022-03-24 23:27
*/
public class TeacherDaoProxy implements ITeacherDao{
/**
* 目標物件，聚合
*/
private ITeacherDao target;
public TeacherDaoProxy(ITeacherDao target) {
this.target = target;
}
@Override
public void teach() {
System.out.println("靜態代理開始前的方法，，，，");
target.teach();
System.out.println("靜態代理結束后的方法，，，，");
}
}
客戶端測驗：
package com.charon.proxy.staticstate;
/**
* @className: Client
* @description:
* @author: charon
* @create: 2022-03-23 22:52
*/
public class Client {
public static void main(String[] args) {
// 創建目標物件(被代理的物件)
TeacherDao teacherDao = new TeacherDao();
// 創建代理物件，同時將被代理物件傳遞給代理物件
TeacherDaoProxy teacherDaoProxy = new TeacherDaoProxy(teacherDao);
// 通過代理物件呼叫到被代理物件的方法(執行的是代理物件的方法，代理物件再去呼叫目標物件的方法)
teacherDaoProxy.teach();
}
}
列印:
靜態代理開始前的方法，，，，
老師在授課中，，，，
靜態代理結束后的方法，，，，
靜態代理總結：
優點：可以做到在符合“開閉原則”的情況下對目標物件進行功能擴展，
缺點：我們得為每一個目標物件都得創建代理類，作業量太大，不易管理，同時介面一旦發生改變，代理類也得相應修改，
JDK動態代理
在動態代理中我們不再需要再手動的創建代理類，我們只需要撰寫一個動態處理器就可以了，真正的代理物件由JDK在運行時為我們動態的來創建；通過java.lang.reflect.Proxy的API實作，
JDK動態代理的UML類圖：
JDK動態代理中，抽象主題角色和具體主題角色代碼不變，
動態處理器：
package com.charon.proxy.jdkdynamic;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* @className: ProxyFactory
* @description:
* @author: charon
* @create: 2022-03-24 23:44
*/
public class ProxyFactory {
/**
* 目標物件
*/
private Object target;
public ProxyFactory(Object target) {
this.target = target;
}
/**
* 動態代理
* @return
*/
public Object getProxyInstance(){
return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("JDK動態代理開始前的方法，，，，");
// 通過反射機制呼叫目標物件的方法
Object invoke = method.invoke(target, args);
System.out.println("JDK動態代理結束后的方法，，，，");
return invoke;
}
});
}
}
客戶端測驗：
package com.charon.proxy.jdkdynamic;
import com.charon.proxy.staticstate.ITeacherDao;
import com.charon.proxy.staticstate.TeacherDao;
/**
* @className: Client
* @description:
* @author: charon
* @create: 2022-03-24 23:53
*/
public class Client {
public static void main(String[] args) {
TeacherDao target = new TeacherDao();
ITeacherDao instance = (ITeacherDao) new ProxyFactory(target).getProxyInstance();
// 記憶體中生成的代理物件
System.out.println("記憶體中生成的代理物件: "+instance.getClass());
// 通過代理物件呼叫目標物件的方法
instance.teach();
}
}
列印：
記憶體中生成的代理物件: class com.sun.proxy.$Proxy0
JDK動態代理開始前的方法，，，，
老師在授課中，，，，
JDK動態代理結束后的方法，，，，
動態代理總結：
雖然相對于靜態代理，動態代理大大減少了我們的開發任務，同時減少了對業務介面的依賴，降低了耦合度，但是還是有一點點小小的遺憾之處，那就是它始終無法擺脫僅支持interface代理的桎梏，因為它的設計注定了這個遺憾，回想一下那些動態生成的代理類的繼承關系圖，它們已經注定有一個共同的父類叫Proxy，Java的繼承機制注定了這些動態代理類們無法實作對class的動態代理，原因是多繼承在Java中本質上就行不通，有很多條理由，人們可以否定對 class代理的必要性，但是同樣有一些理由，相信支持class動態代理會更美好，介面和類的劃分，本就不是很明顯，只是到了Java中才變得如此的細化，如果只從方法的宣告及是否被定義來考量，有一種兩者的混合體，它的名字叫抽象類，實作對抽象類的動態代理，相信也有其內在的價值，此外，還有一些歷史遺留的類，它們將因為沒有實作任何介面而從此與動態代理永世無緣，如此種種，不得不說是一個小小的遺憾，但是，不完美并不等于不偉大，偉大是一種本質，Java動態代理就是佐例，
Cglib動態代理
靜態代理和JDK代理都要求目標物件實作一個介面，但是有些時候目標物件只是一個單獨的物件，并沒有實作任何介面，這個時候可使用目標物件的子類來實作代理，這就是Cglib動態代理，Cglib動態代理也叫做子類代理，它是在記憶體中構建一個子類物件從而實作對目標物件功能擴展，Cglib是一個強大的高性能的代碼生成包，它可以在運行期間擴展java類與實作java介面，其底層是使用位元組碼處理框架ASM來轉換位元組碼并生成新的類，
使用Cglib需要引入的jar包（cglib3.3.0和asm3.3.1會有jar包沖突）：
<dependency>
<artifactId>asm-parent</artifactId>
<groupId>asm</groupId>
<version>3.3.1</version>
</dependency>
<dependency>
<groupId>asm</groupId>
<artifactId>asm-commons</artifactId>
<version>3.3.1</version>
</dependency>
<dependency>
<groupId>asm</groupId>
<artifactId>asm-tree</artifactId>
<version>3.3.1</version>
</dependency>
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>2.2</version>
</dependency>
Cglib動態代理的UML類圖：
具體主題角色：
package com.charon.proxy.cglib;
/**
* @className: TeacherDao
* @description:
* @author: charon
* @create: 2022-03-25 22:40
*/
public class TeacherDao {
public void teach(){
System.out.println("老師授課中，這是cglib動態代理，不需要實作介面");
}
}
動態處理器：
package com.charon.proxy.cglib;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
/**
* @className: ProxyFactory
* @description:
* @author: charon
* @create: 2022-03-25 22:41
*/
public class ProxyFactory implements MethodInterceptor {
private Object target;
public ProxyFactory(Object target) {
this.target = target;
}
/**
* 回傳代理物件
* @return
*/
public Object getProxyInstance(){
// 創建一個工具類
Enhancer enhancer = new Enhancer();
// 設定父類
enhancer.setSuperclass(target.getClass());
// 設定回呼函式
enhancer.setCallback(this);
// 回傳代理物件
return enhancer.create();
}
/**
* 重寫intercept方法，呼叫目標方法
* @param o
* @param method
* @param args
* @param methodProxy
* @return
* @throws Throwable
*/
@Override
public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
System.out.println("cglib代理模式開始前的方法，，，，");
Object invoke = method.invoke(target, args);
System.out.println("cglib代理模式結束后的方法，，，，");
return invoke;
}
}
客戶端測驗：
package com.charon.proxy.cglib;
/**
* @className: Client
* @description:
* @author: charon
* @create: 2022-03-25 22:56
*/
public class Client {
public static void main(String[] args) {
// 創建目標物件
TeacherDao target = new TeacherDao();
// 獲取到代理物件，并且將目標物件傳遞給代理物件
TeacherDao instance = (TeacherDao) new ProxyFactory(target).getProxyInstance();
// 執行代理方法
instance.teach();
}
}
列印：
cglib代理模式開始前的方法，，，，
老師授課中，這是cglib動態代理，不需要實作介面
cglib代理模式結束后的方法，，，，
CGLIB代理總結：
CGLIB創建的動態代理物件比JDK創建的動態代理物件的性能更高，但是CGLIB創建代理物件時所花費的時間卻比JDK多得多，所以對于單例的物件，因為無需頻繁創建物件，用CGLIB合適，反之使用JDK方式要更為合適一些，同時由于CGLib由于是采用動態創建子類的方法，對于final/static修飾的方法無法進行代理，
代理模式的主要優點有：
- 代理模式在客戶端與目標物件之間起到一個中介作用和保護目標物件的作用
- 代理物件可以擴展目標物件的功能
- 代理模式能將客戶端與目標物件分離，在一定程度上降低了系統的耦合度，增加了程式的可擴展性
其主要缺點是：
- 代理模式會造成系統設計中類的數量增加，增加了系統的復雜度
- 在客戶端和目標物件之間增加一個代理物件，會造成請求處理速度變慢
代理模式的應用場景
當無法或不想直接參考某個物件或訪問某個物件存在困難時，可以通過代理物件來間接訪問，使用代理模式主要有兩個目的：一是保護目標物件，二是增強目標物件，
代理模式的應用場景，
- 遠程代理，這種方式通常是為了隱藏目標物件存在于不同地址空間的事實，方便客戶端訪問，例如，用戶申請某些網盤空間時，會在用戶的檔案系統中建立一個虛擬的硬碟，用戶訪問虛擬硬碟時實際訪問的是網盤空間，
- 虛擬代理，這種方式通常用于要創建的目標物件開銷很大時，例如，下載一幅很大的影像需要很長時間，因某種計算比較復雜而短時間無法完成，這時可以先用小比例的虛擬代理替換真實的物件，消除用戶對服務器慢的感覺，
- 安全代理，這種方式通常用于控制不同種類客戶對真實物件的訪問權限，
- 智能指引，主要用于呼叫目標物件時，代理附加一些額外的處理功能，例如，增加計算真實物件的參考次數的功能，這樣當該物件沒有被參考時，就可以自動釋放它，
- 延遲加載，指為了提高系統的性能，延遲對目標的加載，例如，Hibernate中就存在屬性的延遲加載和關聯表的延時加載，
代理模式與配接器模式的區別
粗略的看，配接器模式與代理模式很相像，他們都可以視為一個物件提供一種前置的介面，但是，配接器模式的用意是要改變所考慮的物件介面，而代理模式并不能改變代理的物件的介面，在這一點上，兩個模式有明顯的區別，
本文著作權歸Charon和博客園共有，原創文章，歡迎轉載，但未經作者同意必須保留此段宣告，且在文章頁面明顯位置給出原文連接，否則保留追究法律責任的權利，轉載請註明出處，本文鏈接：https://www.uj5u.com/ruanti/449736.html
標籤：設計模式
上一篇：如何使UIActivityViewController基于動態陣列動態排除專案？
下一篇：設計模式之代理模式