今天來看看Java的另一種代理方式——JDK動態代理
我們之前所介紹的代理方式叫靜態代理，也就是靜態的生成代理對象，而動態代理則是在運行時創建代理對象。動態代理有更強大的攔截請求功能，因為可以獲得類的運行時信息，可以根據運行時信息來獲得更為強大的執（騷）行（操）力（作）。
我們還是以上一個例子為例，這里的IStars接口和Stars類都不需要修改，只需要修改代理類。
創建JDK動態代理需要先實現InvocationHandler接口，并重寫其中的invoke方法，具體步驟如下：
1. 創建一個類實現InvocationHandler接口。
2. 給Proxy類提供委托類的ClassLoader和Interfaces來創建動態代理類。
3. 利用反射機制得到動態代理類的構造函數。
4. 利用動態代理類的構造函數創建動態代理類對象。
我們用動態代理來改造一下之前的類：
接口和委托類不需要修改：
|
1
2
3
4
|
public interface IStars { void sing(); void dance();} |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
public class Stars implements IStars{ private String name; public Stars(String name) { this.name = name; } public String getName() { return name; } public void setName(String name) { this.name = name; } public void sing(){ System.out.println(getName() + " 唱了一首歌."); } public void dance(){ System.out.println(getName() + " 跳了一支舞."); }} |
這是使用動態代理后的代理類：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
public class StarsNewProxy implements InvocationHandler { //代理類持有委托類的對象引用 private Object object; //保存sing和dance的次數 private int num; public StarsNewProxy(Object object){ this.object = object; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { if (!runBefore(method)){ return null; }; //利用反射機制將請求分派給委托類處理，Method的invoke返回Object對象作為方法執行結果 Object result = method.invoke(object,args); runAfter(method); return result; } private boolean runBefore(Method method){ System.out.println("我是代理，攔截到請求"); if (method.getName().equals("dance")){ System.out.println("抱歉，明星腳受傷了，不能跳舞表演了。"); return false; } return true; } private void runAfter(Method method){ System.out.println("我是代理，請求處理完畢"); }} |
新建一個工廠類來返回代理實例：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
public class StarsNewProxyFactory { //構建工廠類，客戶類調用此方法獲得代理對象 //對于客戶類而言，代理類對象和委托類對象是一樣的，不需要知道具體返回的類型 public static IStars getInstance(String name){ IStars stars = new Stars(name); InvocationHandler handler = new StarsNewProxy(stars); IStars proxy = null; proxy = (IStars) Proxy.newProxyInstance( stars.getClass().getClassLoader(), stars.getClass().getInterfaces(), handler ); return proxy; }} |
改寫一下測試類：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
public class Test { public static void main(String[] args){// testA(); testB(); } /** * 靜態代理 */ private static void testA(){ //創建目標對象 IStars stars = new Stars("Frank"); //代理對象，把目標傳給代理對象，建立關系 IStars starsProxy = new StarsProxy(stars); for (int i = 0;i < 5; i++){ starsProxy.sing(); } } /** * JDK動態代理 */ private static void testB(){ IStars proxy = StarsNewProxyFactory.getInstance("Frank"); proxy.dance(); proxy.sing(); }} |
輸出如下：
我是代理，攔截到請求
抱歉，明星腳受傷了，不能跳舞表演了。
我是代理，攔截到請求
Frank 唱了一首歌.
我是代理，請求處理完畢
使用動態代理時實現了InvocationHandler接口并重寫了invoke方法，invoke方法的三個參數：
|
1
2
3
4
5
|
Object invoke(Object proxy, Method method, Object[] args) throws Throwableproxy: 被代理的對象method: 被代理對象的某個方法的Method對象args: 被代理對象的某個方法接受的參數 |
Proxy的newProxyInstance方法詳情如下：
|
1
2
3
4
5
6
7
|
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentExceptionloader: 一個ClassLoader對象，定義了由哪個ClassLoader對象來對生成的代理對象進行加載interfaces: 一個Interface對象的數組，表示的是我將要給我需要代理的對象提供一組什么接口，如果我提供了一組接口給它，那么這個代理對象就宣稱實現了該接口(多態)，這樣我就能調用這組接口中的方法了h: 一個InvocationHandler對象，表示的是當我這個動態代理對象在調用方法的時候，會關聯到哪一個InvocationHandler對象上 |
可以看到，這里的動態代理跟靜態代理一樣，在代理類內部保存了一個委托類的實例，實際上都是調用原來的委托實例來進行需要的操作，代理類相當于給委托類加上一個外殼，把委托類置于代理類的內部，從而可以控制客戶類對委托類的訪問，就像上例中，代理類攔截了客戶類對Stars類的dance方法的訪問，并且輸出了補充信息。
動態代理跟靜態代理最大的不同便是生成代理類的時期不同，靜態代理是在編譯期，而動態代理則是在運行時根據委托類信息動態生成。
其次，動態代理實現的是InvocationHandler接口，而靜態代理則是直接實現公共接口。當然動態代理也是需要實現相同的接口的，只是將接口信息放在了getInstance內部，相當于代理類跟委托類之間的約定，“這幾個方法幫我代理一下吧”。
最后，動態代理可以獲得更多的運行時信息，使用起來也會更加靈活。
至此，JDK動態代理講解完畢，歡迎大家繼續關注！
以上就是詳解Java JDK動態代理的詳細內容，更多關于Java JDK動態代理的資料請關注服務器之家其它相關文章！
原文鏈接：https://cloud.tencent.com/developer/article/1016584
