JAVA的動態代理
代理模式
代理模式是常用的java設計模式，他的特徵是代理類與委託類有同樣的接口，代理類主要負責爲委託類預處理消息、過濾消息、把消息轉發給委託類，以及事後處理消息等。代理類與委託類之間通常會存在關聯關係，一個代理類的對象與一個委託類的對象關聯，代理類的對象本身並不真正實現服務，而是通過調用委託類的對象的相關方法，來提供特定的服務。
按照代理的創建時期，代理類可以分爲兩種。
靜態代理：由程序員創建或特定工具自動生成源代碼，再對其編譯。在程序運行前，代理類的.class文件就已經存在了。
動態代理：在程序運行時，運用反射機制動態創建而成。
首先看一下靜態代理：
<span style="font-family:KaiTi_GB2312;font-size:18px;">1、Count.java
1.package net.battier.dao;
2.
3./**
4. * 定義一個賬戶接口
5. *
6. * @author Administrator
7. *
8. */
9.public interface Count {
10. // 查看賬戶方法
11. public void queryCount();
12.
13. // 修改賬戶方法
14. public void updateCount();
15.
16.}
2、CountImpl.java
1.package net.battier.dao.impl;
2.
3.import net.battier.dao.Count;
4.
5./**
6. * 委託類(包含業務邏輯)
7. *
8. * @author Administrator
9. *
10. */
11.public class CountImpl implements Count {
12.
13. @Override
14. public void queryCount() {
15. System.out.println("查看賬戶方法...");
16.
17. }
18.
19. @Override
20. public void updateCount() {
21. System.out.println("修改賬戶方法...");
22.
23. }
24.
25.}
26.
27.、CountProxy.java
28.package net.battier.dao.impl;
29.
30.import net.battier.dao.Count;
31.
32./**
33. * 這是一個代理類（增強CountImpl實現類）
34. *
35. * @author Administrator
36. *
37. */
38.public class CountProxy implements Count {
39. private CountImpl countImpl;
40.
41. /**
42. * 覆蓋默認構造器
43. *
44. * @param countImpl
45. */
46. public CountProxy(CountImpl countImpl) {
47. this.countImpl = countImpl;
48. }
49.
50. @Override
51. public void queryCount() {
52. System.out.println("事務處理之前");
53. // 調用委託類的方法;
54. countImpl.queryCount();
55. System.out.println("事務處理之後");
56. }
57.
58. @Override
59. public void updateCount() {
60. System.out.println("事務處理之前");
61. // 調用委託類的方法;
62. countImpl.updateCount();
63. System.out.println("事務處理之後");
64.
65. }
66.
67.}
3、TestCount.java
1.package net.battier.test;
2.
3.import net.battier.dao.impl.CountImpl;
4.import net.battier.dao.impl.CountProxy;
5.
6./**
7. *測試Count類
8. *
9. * @author Administrator
10. *
11. */
12.public class TestCount {
13. public static void main(String[] args) {
14. CountImpl countImpl = new CountImpl();
15. CountProxy countProxy = new CountProxy(countImpl);
16. countProxy.updateCount();
17. countProxy.queryCount();
18.
19. }
20.}
</span>
觀察代碼可以發現每一個代理類只能爲一個接口服務，這樣一來程序開發中必然會產生過多的代理，而且，所有的代理操作除了調用的方法不一樣之外，其他的操作都一樣，則此時肯定是重複代碼。解決這一問題最好的做法是可以通過一個代理類完成全部的代理功能，那麼此時就必須使用動態代理完成。
再來看一下動態代理：
JDK動態代理中包含一個類和一個接口：
InvocationHandler接口：
public interface InvocationHandler {
public Object invoke(Object proxy,Method method,Object[] args) throws Throwable;
}
參數說明：
Object proxy：指被代理的對象。
Method method：要調用的方法
Object[] args：方法調用時所需要的參數
可以將InvocationHandler接口的子類想象成一個代理的最終操作類，替換掉ProxySubject。
Proxy類：
Proxy類是專門完成代理的操作類，可以通過此類爲一個或多個接口動態地生成實現類，此類提供瞭如下的操作方法：
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
參數說明：
ClassLoader loader：類加載器
Class<?>[] interfaces：得到全部的接口
InvocationHandler h：得到InvocationHandler接口的子類實例
Ps:類加載器
在Proxy類中的newProxyInstance（）方法中需要一個ClassLoader類的實例，ClassLoader實際上對應的是類加載器，在Java中主要有一下三種類加載器;
Booststrap ClassLoader：此加載器採用C++編寫，一般開發中是看不到的；
Extendsion ClassLoader：用來進行擴展類的加載，一般對應的是jre\lib\ext目錄中的類;
AppClassLoader：(默認)加載classpath指定的類，是最常使用的是一種加載器。
動態代理
與靜態代理類對照的是動態代理類，動態代理類的字節碼在程序運行時由Java反射機制動態生成，無需程序員手工編寫它的源代碼。動態代理類不僅簡化了編程工作，而且提高了軟件系統的可擴展性，因爲Java 反射機制可以生成任意類型的動態代理類。java.lang.reflect 包中的Proxy類和InvocationHandler 接口提供了生成動態代理類的能力。
<span style="font-family:KaiTi_GB2312;font-size:18px;">動態代理示例:
1、BookFacade.java
1.package net.battier.dao;
2.
3.public interface BookFacade {
4. public void addBook();
5.}
2、BookFacadeImpl.java
1.package net.battier.dao.impl;
2.
3.import net.battier.dao.BookFacade;
4.
5.public class BookFacadeImpl implements BookFacade {
6.
7. @Override
8. public void addBook() {
9. System.out.println("增加圖書方法。。。");
10. }
11.
12.}
13.
14.、BookFacadeProxy.java
15.
16.package net.battier.proxy;
17.
18.import java.lang.reflect.InvocationHandler;
19.import java.lang.reflect.Method;
20.import java.lang.reflect.Proxy;
21.
22./**
23. * JDK動態代理代理類
24. *
25. * @author student
26. *
27. */
28.public class BookFacadeProxy implements InvocationHandler {
29. private Object target;
30. /**
31. * 綁定委託對象並返回一個代理類
32. * @param target
33. * @return
34. */
35. public Object bind(Object target) {
36. this.target = target;
37. //取得代理對象
38. return Proxy.newProxyInstance(target.getClass().getClassLoader(),
39. target.getClass().getInterfaces(), this); //要綁定接口(這是一個缺陷，cglib彌補了這一缺陷)
40. }
41.
42. @Override
43. /**
44. * 調用方法
45. */
46. public Object invoke(Object proxy, Method method, Object[] args)
47. throws Throwable {
48. Object result=null;
49. System.out.println("事物開始");
50. //執行方法
51. result=method.invoke(target, args);
52. System.out.println("事物結束");
53. return result;
54. }
55.
56.}
3、TestProxy.java
1.package net.battier.test;
2.
3.import net.battier.dao.BookFacade;
4.import net.battier.dao.impl.BookFacadeImpl;
5.import net.battier.proxy.BookFacadeProxy;
6.
7.public class TestProxy {
8.
9. public static void main(String[] args) {
10. BookFacadeProxy proxy = new BookFacadeProxy();
11. BookFacade bookProxy = (BookFacade) proxy.bind(new BookFacadeImpl());
12. bookProxy.addBook();
13. }
14.
15.}
但是，JDK的動態代理依靠接口實現，如果有些類並沒有實現接口，則不能使用JDK代理，這就要使用cglib動態代理了。
Cglib動態代理
JDK的動態代理機制只能代理實現了接口的類，而不能實現接口的類就不能實現JDK的動態代理，cglib是針對類來實現代理的，他的原理是對指定的目標類生成一個子類，並覆蓋其中方法實現增強，但因爲採用的是繼承，所以不能對final修飾的類進行代理。
示例
1、BookFacadeCglib.java
1.package net.battier.dao;
2.
3.public interface BookFacade {
4. public void addBook();
5.}
2、BookCadeImpl1.java
1.package net.battier.dao.impl;
2.
3./**
4. * 這個是沒有實現接口的實現類
5. *
6. * @author student
7. *
8. */
9.public class BookFacadeImpl1 {
10. public void addBook() {
11. System.out.println("增加圖書的普通方法...");
12. }
13.}
3、BookFacadeProxy.java
1.package net.battier.proxy;
2.
3.import java.lang.reflect.Method;
4.
5.import net.sf.cglib.proxy.Enhancer;
6.import net.sf.cglib.proxy.MethodInterceptor;
7.import net.sf.cglib.proxy.MethodProxy;
8.
9./**
10. * 使用cglib動態代理
11. *
12. * @author student
13. *
14. */
15.public class BookFacadeCglib implements MethodInterceptor {
16. private Object target;
17.
18. /**
19. * 創建代理對象
20. *
21. * @param target
22. * @return
23. */
24. public Object getInstance(Object target) {
25. this.target = target;
26. Enhancer enhancer = new Enhancer();
27. enhancer.setSuperclass(this.target.getClass());
28. // 回調方法
29. enhancer.setCallback(this);
30. // 創建代理對象
31. return enhancer.create();
32. }
33.
34. @Override
35. // 回調方法
36. public Object intercept(Object obj, Method method, Object[] args,
37. MethodProxy proxy) throws Throwable {
38. System.out.println("事物開始");
39. proxy.invokeSuper(obj, args);
40. System.out.println("事物結束");
41. return null;
42.
43.
44. }
45.
46.}
4、TestCglib.java
1.package net.battier.test;
2.
3.import net.battier.dao.impl.BookFacadeImpl1;
4.import net.battier.proxy.BookFacadeCglib;
5.
6.public class TestCglib {
7.
8. public static void main(String[] args) {
9. BookFacadeCglib cglib=new BookFacadeCglib();
10. BookFacadeImpl1 bookCglib=(BookFacadeImpl1)cglib.getInstance(new BookFacadeImpl1());
11. bookCglib.addBook();
12. }
13.}
</span>