靜態(tài)代理模式
因為需要對一些函數(shù)進行二次處理，或是某些函數(shù)不讓外界知道時，可以使用代理模式，通過訪問第三方，間接訪問原函數(shù)的方式，達到以上目的。
|
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
37
38
39
40
41
42
43
44
|
interface Hosee{ String sayhi();}class Hoseeimpl implements Hosee{ @Override public String sayhi() { return "Welcome oschina hosee's blog"; }}class HoseeProxy implements Hosee{ Hosee h; public HoseeProxy(Hosee h) { this.h = h; } @Override public String sayhi() { System.out.println("I'm proxy!"); return h.sayhi(); }}public class StaticProxy{ public static void main(String[] args) { Hoseeimpl h = new Hoseeimpl(); HoseeProxy hp = new HoseeProxy(h); System.out.println(hp.sayhi()); }} |
1.1 靜態(tài)代理的弊端
如果要想為多個類進行代理，則需要建立多個代理類，維護難度加大。
仔細想想，為什么靜態(tài)代理會有這些問題，是因為代理在編譯期就已經(jīng)決定，如果代理哪個發(fā)生在運行期，這些問題解決起來就比較簡單，所以動態(tài)代理的存在就很有必要了。
2.動態(tài)代理
|
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
37
38
39
40
41
42
43
44
45
46
47
|
import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;interface HoseeDynamic{ String sayhi();}class HoseeDynamicimpl implements HoseeDynamic{ @Override public String sayhi() { return "Welcome oschina hosee's blog"; }}class MyProxy implements InvocationHandler{ Object obj; public Object bind(Object obj) { this.obj = obj; return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj .getClass().getInterfaces(), this); } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("I'm proxy!"); Object res = method.invoke(obj, args); return res; }}public class DynamicProxy{ public static void main(String[] args) { MyProxy myproxy = new MyProxy(); HoseeDynamicimpl dynamicimpl = new HoseeDynamicimpl(); HoseeDynamic proxy = (HoseeDynamic)myproxy.bind(dynamicimpl); System.out.println(proxy.sayhi()); }} |
類比靜態(tài)代理，可以發(fā)現(xiàn)，代理類不需要實現(xiàn)原接口了，而是實現(xiàn)InvocationHandler。通過
|
1
2
|
Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj .getClass().getInterfaces(), this); |
來動態(tài)生成一個代理類，該類的類加載器與被代理類相同，實現(xiàn)的接口與被代理類相同。
通過上述方法生成的代理類相當于靜態(tài)代理中的代理類。
這樣就實現(xiàn)了在運行期才決定代理對象是怎么樣的，解決了靜態(tài)代理的弊端。
當動態(tài)生成的代理類調用方法時，會觸發(fā)invoke方法，在invoke方法中可以對被代理類的方法進行增強。
通過動態(tài)代理可以很明顯的看到它的好處，在使用靜態(tài)代理時，如果不同接口的某些類想使用代理模式來實現(xiàn)相同的功能，將要實現(xiàn)多個代理類，但在動態(tài)代理中，只需要一個代理類就好了。
除了省去了編寫代理類的工作量，動態(tài)代理實現(xiàn)了可以在原始類和接口還未知的時候，就確定代理類的代理行為，當代理類與原始類脫離直接聯(lián)系后，就可以很靈活地重用于不同的應用場景中。
2.1 動態(tài)代理的弊端
代理類和委托類需要都實現(xiàn)同一個接口。也就是說只有實現(xiàn)了某個接口的類可以使用Java動態(tài)代理機制。但是，事實上使用中并不是遇到的所有類都會給你實現(xiàn)一個接口。因此，對于沒有實現(xiàn)接口的類，就不能使用該機制。
而CGLIB則可以實現(xiàn)對類的動態(tài)代理
2.2 回調函數(shù)原理
上文說了，當動態(tài)生成的代理類調用方法時，會觸發(fā)invoke方法。
很顯然invoke方法并不是顯示調用的，它是一個回調函數(shù)，那么回調函數(shù)是怎么被調用的呢？
上述動態(tài)代理的代碼中，唯一不清晰的地方只有
|
1
2
|
Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj .getClass().getInterfaces(), this); |
跟蹤這個方法的源碼，可以看到程序進行了驗證、優(yōu)化、緩存、同步、生成字節(jié)碼、顯示類加載等操作，前面的步驟并不是我們關注的重點，而最后它調用了
|
1
2
|
byte[] proxyClassFile = ProxyGenerator.generateProxyClass( proxyName, interfaces); |
該方法用來完成生成字節(jié)碼的動作，這個方法可以在運行時產(chǎn)生一個描述代理類的字節(jié)碼byte[]數(shù)組。
在main函數(shù)中加入
|
1
|
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true"); |
加入這句代碼后再次運行程序，磁盤中將會產(chǎn)生一個名為”$Proxy().class”的代理類Class文件，反編譯（反編譯工具我使用的是 JD-GUI ）后可以看見如下代碼：
|
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
|
import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;import java.lang.reflect.UndeclaredThrowableException;public final class $Proxy0 extends Proxy implements HoseeDynamic{ private static Method m1; private static Method m3; private static Method m0; private static Method m2; public $Proxy0(InvocationHandler paramInvocationHandler) throws { super(paramInvocationHandler); } public final boolean equals(Object paramObject) throws { try { return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue(); } catch (Error|RuntimeException localError) { throw localError; } catch (Throwable localThrowable) { throw new UndeclaredThrowableException(localThrowable); } } public final String sayhi() throws { try { return (String)this.h.invoke(this, m3, null); } catch (Error|RuntimeException localError) { throw localError; } catch (Throwable localThrowable) { throw new UndeclaredThrowableException(localThrowable); } } public final int hashCode() throws { try { return ((Integer)this.h.invoke(this, m0, null)).intValue(); } catch (Error|RuntimeException localError) { throw localError; } catch (Throwable localThrowable) { throw new UndeclaredThrowableException(localThrowable); } } public final String toString() throws { try { return (String)this.h.invoke(this, m2, null); } catch (Error|RuntimeException localError) { throw localError; } catch (Throwable localThrowable) { throw new UndeclaredThrowableException(localThrowable); } } static { try { m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") }); m3 = Class.forName("HoseeDynamic").getMethod("sayhi", new Class[0]); m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]); m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]); return; } catch (NoSuchMethodException localNoSuchMethodException) { throw new NoSuchMethodError(localNoSuchMethodException.getMessage()); } catch (ClassNotFoundException localClassNotFoundException) { throw new NoClassDefFoundError(localClassNotFoundException.getMessage()); } }} |
動態(tài)代理類不僅代理了顯示定義的接口中的方法，而且還代理了java的根類Object中的繼承而來的equals()、hashcode()、toString()這三個方法，并且僅此三個方法。
可以在上述代碼中看到，無論調用哪個方法，都會調用到InvocationHandler的invoke方法，只是參數(shù)不同。
2.3 動態(tài)代理與靜態(tài)代理的區(qū)別
Proxy類的代碼被固定下來，不會因為業(yè)務的逐漸龐大而龐大；
可以實現(xiàn)AOP編程，這是靜態(tài)代理無法實現(xiàn)的；
解耦，如果用在web業(yè)務下，可以實現(xiàn)數(shù)據(jù)層和業(yè)務層的分離。
動態(tài)代理的優(yōu)勢就是實現(xiàn)無侵入式的代碼擴展。 靜態(tài)代理這個模式本身有個大問題，如果類方法數(shù)量越來越多的時候，代理類的代碼量是十分龐大的。所以引入動態(tài)代理來解決此類問題
3. CGLIB
cglib是針對類來實現(xiàn)代理的，他的原理是對指定的目標類生成一個子類，并覆蓋其中方法實現(xiàn)增強，但因為采用的是繼承，所以不能對final修飾的類進行代理。
|
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
37
38
39
40
41
42
43
44
45
46
47
48
49
|
import java.lang.reflect.Method;import net.sf.cglib.proxy.Enhancer;import net.sf.cglib.proxy.MethodInterceptor;import net.sf.cglib.proxy.MethodProxy;class CGlibHosee{ public String sayhi() { return "Welcome oschina hosee's blog"; }}class CGlibHoseeProxy{ Object obj; public Object bind(final Object target) { this.obj = target; Enhancer enhancer = new Enhancer(); enhancer.setSuperclass(obj.getClass()); enhancer.setCallback(new MethodInterceptor() { @Override public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { System.out.println("I'm proxy!"); Object res = method.invoke(target, args); return res; } }); return enhancer.create(); }}public class CGlibProxy{ public static void main(String[] args) { CGlibHosee cGlibHosee = new CGlibHosee(); CGlibHoseeProxy cGlibHoseeProxy = new CGlibHoseeProxy(); CGlibHosee proxy = (CGlibHosee) cGlibHoseeProxy.bind(cGlibHosee); System.out.println(proxy.sayhi()); }} |
cglib需要指定父類和回調方法。當然cglib也可以與Java動態(tài)代理一樣面向接口，因為本質是繼承。
感謝閱讀，希望能幫助到大家，謝謝大家對本站的支持！
原文鏈接：http://blog.csdn.net/qq_35101189/article/details/55819880
