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

一、靜態代理

　　所謂靜態代理類是指：由程式設計師建立或由特定工具自動生成原始碼，再對其進行編譯。在程式執行之前，代理類的.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 }

　　執行結果如下：

　　總結一下就是，在代理類中注入依賴，即引入需要代理的實體類，通過代理類來呼叫實體類中的方法來實現靜態代理。

　　雖然靜態代理可以很好的對目標物件進行功能擴充套件，但對每一個服務都需要建立代理類，工作量較大且不易管理，而且如果介面發生改變的話，代理類也得進行相應的修改，這時動態代理的作用就顯現出來了。

二、動態代理

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

　　通過動態代理，我們不再需要手動建立代理類，只需編寫一個動態處理器即可，而真正的代理物件由JDK在執行時幫我們建立。所以我們也將之稱為JDK動態代理。

　　下面看一個例子，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虛擬機器中去）。

　　執行結果如下：

　　相比於靜態代理，動態代理的優勢還是很明顯的，不僅減少了對業務介面的依賴，還降低了耦合度，但它還是無法擺脫對介面的依賴。那麼對於沒有介面的類應該如何實現動態代理呢？

三、CGLIB代理

　　cglib是一個強大的高效能程式碼生成包，底層是通過使用一個小而快的位元組碼處理框架ASM來轉換並生成新的類，所以我們一般也稱之為cglib位元組碼生成。

　　與JDK動態代理不同，cglib是針對類來實現代理的，所以對於沒有介面的類我們可以通過cglib位元組碼生成來實現代理。原理是對指定的業務類生成一個子類，並覆蓋其中的業務方法實現代理。但因為採用的是繼承，所以不能對final修飾的類進行代理。

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

　　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()方法生成代理類物件。

 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代理。

　　原始碼地址：https://gitee.com/adamjiangwh