簡說設計模式——代理模式（續）

　　以前說了代理模式，即爲其餘對象提供一種代理以控制對這個對象的訪問，詳情見《簡說設計模式——代理模式》，而代理模式常見的實現方式爲靜態代理及動態代理。

1、靜態代理

　　所謂靜態代理類是指：由程序員建立或由特定工具自動生成源代碼，再對其進行編譯。在程序運行以前，代理類的.class文件就已經存在了。UML結構圖以下：

　　這裏以持久化層的數據交互類爲例，IUserDao是與數據庫進行交互的接口，UserDao爲IUserDao接口的實現類，UserDaoProxy爲代理類，兩者皆實現了IUserDao接口。說具體點就是，UserDao類是IUserDao接口的具體實現者，而UserDaoProxy類是經過調用UserDao類的相關方法來提供特定服務的。

　　1. IUserDao接口

　　這裏爲抽象目標類/接口。

1 public interface IUserDao {
2     
3     public void save();
4 
5 }

 　　2. UserDao接口

　　這裏爲具體目標類或被代理的對象。實現了IUserDao中的接口方法。

1 public class UserDao implements IUserDao {
2 
3     @Override
4     public void save() {
5         System.out.println("數據已保存！！！");
6     }
7     
8 }

 　　3. 靜態代理類

　　首先在靜態代理類中引入IUserDao接口，經過調用UserDao類的相關方法來提供特定服務。

 1 public class UserDaoProxy implements IUserDao {
 2     
 3     private IUserDao iUserDao;
 4 
 5     public UserDaoProxy(IUserDao iUserDao) {
 6         this.iUserDao = iUserDao;
 7     }
 8     
 9     @Override
10     public void save() {
11         System.out.println("開始事務...");
12         iUserDao.save();    //執行目標對象
13         System.out.println("提交事務...");
14     }
15 
16 }

　　4. Client客戶端

1 public class Client {
2     
3     public static void main(String[] args) {
4         UserDao userDao = new UserDao();
5         UserDaoProxy proxy = new UserDaoProxy(userDao);
6         proxy.save();
7     }
8 
9 }

　　運行結果以下：

　　

　　總結一下就是，在代理類中注入依賴，即引入須要代理的實體類，經過代理類來調用實體類中的方法來實現靜態代理。

　　靜態代理由咱們本身去生成固定的代碼進行編譯。須要定義接口或抽象的父類做爲抽象目標類，具體目標類和代理類一塊兒實現相同的接口或繼承相同的類，而後經過調用相同的方法來調用目標對象的方法。

　　靜態代理須要目標對象和代理對象實現相同的接口。能夠在不修改目標對象功能的前提下，對目標功能進行擴展。

　　雖然靜態代理能夠很好的對目標對象進行功能擴展，但對每個服務都須要創建代理類，工做量較大且不易管理，並且若是接口發生改變的話，代理類也得進行相應的修改，這時動態代理的做用就顯現出來了。

2、動態代理

　　動態代理與靜態代理的區別在於：在程序運行時，動態代理類是運用反射機制建立而成的。在抽象工廠模式的最後有提到用反射來代理switch語句進行選擇，這裏就運用到了相似的思想。

　　經過動態代理，咱們再也不須要手動建立代理類，只需編寫一個動態處理器便可，而真正的代理對象由JDK在運行時幫咱們建立。因此咱們也將之稱爲JDK動態代理。

　　方法步驟以下：

1. 寫一個代理類實現InvocationHandler接口，經過構造函數把代理對象（具體目標類）傳入到此處理器中，在invoke()方法中增長method.invoke(realSubject, args)
2. 在調用方法時，經過java.lang.reflect.Proxy和newProxyInstance()來獲取代理實現類，生成代理對象時，直接調用方法便可。

　　下面看一個例子，UML結構圖以下：

　　

　　1. IBusiness接口

　　被代理的接口。

1 public interface IBusiness {
2 
3     public void doWork();
4     
5 }

 　　2. Business類

　　具體實現類/被代理的對象。

1 public class Business implements IBusiness {
2 
3     @Override
4     public void doWork() {
5         System.out.println("進行業務邏輯處理");
6     }
7 
8 }

 　　3. BusinessHandler類

　　BusinessHandler類實現類Invocation接口，它是方法調用接口，聲明瞭負責調用任意一個方法的invoke()方法，參數proxy指定動態代理類實例，參數method指定被調用的方法，參數args指定向被調用方法傳遞的參數，而invoke()方法的返回值表示被調用方法的返回值。其中 method.invoke(iBusiness, args) 至關於 iBusiness.method(args) 。

 1 public class BusinessHandler implements InvocationHandler {
 2     
 3     private IBusiness iBusiness;
 4     
 5     public BusinessHandler(IBusiness iBusiness) {
 6         this.iBusiness = iBusiness;
 7     }
 8 
 9     @Override
10     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
11         System.out.println("before");
12         method.invoke(iBusiness, args);
13         System.out.println("after");
14         return null;
15     }
16 
17 }

 　　4. Client客戶端

 1 public class Client {
 2     
 3     public static void main(String[] args) {
 4         Business business = new Business();
 5         
 6         //生成代理類對象
 7         IBusiness proxy = (IBusiness) Proxy.newProxyInstance(
 8                 business.getClass().getClassLoader(), 
 9                 business.getClass().getInterfaces(), 
10                 new BusinessHandler(business));
11         
12         proxy.doWork();
13     }
14 
15 }

　　 此處經過java.lang.reflect.Proxy類的newProxyInstance()方法來生成代理類對象，它的完整定義以下：

　　 public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler handler) throws IllegalArgumentException 

　　參數loader指定動態代理類的類加載器，參數interfaces指定動態代理類須要實現的全部接口，參數handler指定與動態代理類相關聯的InvocationHandler對象。因此咱們只需調用newProxyInstance()方法就能夠某一個對象的代理對象了。（有關ClassLoader類加載器的內容這裏就再也不贅述了，它的做用是將class文件加載到jvm虛擬機中去）。

　　運行結果以下：

　　

　　相比於靜態代理，動態代理的優點仍是很明顯的，不只減小了對業務接口的依賴，還下降了耦合度，但它仍是沒法擺脫對接口的依賴。那麼對於沒有接口的類應該如何實現動態代理呢？

3、CGLIB代理

　　cglib是一個強大的高性能代碼生成包，底層是經過使用一個小而快的字節碼處理框架ASM來轉換並生成新的類，因此咱們通常也稱之爲cglib字節碼生成。

　　與JDK動態代理不一樣，cglib是針對類來實現代理的，因此對於沒有接口的類咱們能夠經過cglib字節碼生成來實現代理。原理是對指定的業務類生成一個子類，並覆蓋其中的業務方法實現代理。但由於採用的是繼承，因此不能對final修飾的類進行代理。

　　下面看一個使用cglib進行代理的實例，需先導入相應的jar包（asm及cglib包）。

　　方法步驟以下：

1. 建立被代理類，建立攔截器（實現MethodInterceptor）
2. 實現Enhancer工具類，容許爲非接口類型建立一個Java代理
3. 使用setSuperclass()方法設置父類
4. 使用setCallback()方法設置回調函數（默認執行intercept方法）
5. 使用create()方法建立子類

　　1. 被代理類

　　首先定義業務類，無需實現接口。

1 public class Hello {
2     
3     public void sayHello() {
4         System.out.println("Hello World!");
5     }
6 
7 }

　　2. 攔截器

　　定義一個攔截器，經過實現MethodInterceptor接口的intercept()方法來實現回調方法，經過invokeSuper()執行目標對象的方法。

 1 public class HelloMethodInterceptor implements MethodInterceptor {
 2 
 3     @Override
 4     public Object intercept(Object object, Method method , Object[] objects , MethodProxy methodProxy ) throws Throwable {
 5         System.out.println("before " + method.getName());
 6         methodProxy.invokeSuper(object, objects);
 7         System.out.println("after " + method.getName());
 8         return null;
 9     }
10 
11 }

 　　3. Client客戶端

　　經過Enhancer增強類來建立動態代理類，經過它的setSuperclass()方法來指定要代理的業務類（即爲下方生成的代理類指定父類），而後經過create()方法生成代理類對象。

　　在enhance.create()建立完代理對象後，在代理類調用方法中，會被咱們實現的方法攔截器HelloMethodInterceptor攔截。若是被代理類被final修飾，則該類不能被繼承，即不能被代理；一樣，若是被代理類存在final修飾的方法，則該方法不能被代理。

 1 public class Client {
 2     
 3     public static void main(String[] args) {
 4         Enhancer enhancer = new Enhancer();        //工具類
 5         enhancer.setSuperclass(Hello.class);    //繼承被代理類
 6         enhancer.setCallback(new HelloMethodInterceptor());        //設置回調
 7         
 8         Hello hello = (Hello) enhancer.create();    //生成代理類對象
 9         hello.sayHello();
10     }
11 
12 }

 　　運行結果以下：

　　

　　綜上所述，cglib採用的是動態建立子類的方法，因此對final修飾的類不能進行代理。以Spring AOP編程爲例，JDK動態代理及cglib代理的區別在於，有接口的目標對象採用JDK代理，無接口的目標對象採用cglib代理。

　　使用cglib的前提條件爲：

• 須要引入cglib的jar文件
• 目標類不能爲final
• 目標對象的方法若是爲final/static，那麼就不會被攔截，即不會執行目標對象額外的業務方法 

 

　　源碼地址：https://gitee.com/adamjiangwh/GoF