JDK動態代理與運行時織入字節碼

blog.csdn.net/u010061691/…

java jdk動態代理實際上是動態生成字節碼與反射機制的一個結合，說到反射機制不少人都用到過反射，只要獲得對應類的Class對象便可，調用方法，獲取成員變量等等，那麼jdk的動態代理就是在程序運行的過程當中，動態的將咱們維護的檢查性的代碼，放在正常的業務代碼以前，那麼怎麼調用我正常的業務代碼呢，由於業務可能有不少種，也就是說可能會有不一樣的類，可是都要執行相同的檢查性代碼，如咱們要取錢，或者是修改身份證，都必須驗證經過才能夠，這顯然是兩個類，一個是Money，一個是ID，因此咱們在調用正常業務代碼的時候，其實不知道咱們調用的是誰的代碼，這時候就用到反射，經過反射，動態的識別類型，而後再調用方法，如咱們要取錢，那麼傳入的應該是一個Money的實例，經過這個實例的getDeclaredMethod，或者是getMethod就能夠，獲取對應實例的方法，而後便可動態調用方法，只要在用反射前，加入咱們驗證的代碼便可，這時反射在動態代理中的應用。這部分代碼須要咱們本身實現InvocationHandler接口，實現其中的invoke方法，在這個方法中，就是咱們上述反射的實現。固然爲了調用到對應類的方法，咱們實現的invocationHandler類中，須要保存咱們要代理類的實例。

而動態生成字節碼是一種技術，就是在編譯期不能決定要生成字節碼的類型，也就是沒有對應的java文件，因此就不能生成class文件，像是靜態代理的話，咱們會明確的實現一個代理類，因此能夠在編譯期生成字節碼文件，可是動態代理不會明確實現某一個類的代理類，是針對全部業務類的一個公用的類，因爲在編譯期不能決定生成那個業務類的代理類因此就不能生成字節碼，反而是在運行的時候，看咱們傳入的實例是輸入什麼類的，生成對應類的代理類，由於這時候要肯定生成一個代理類 ，若是沒有字節碼文件，那麼該類就不會加載，更加不會執行，因此動態代理技術，會把字節碼文件動態的拼接出來，造成一個class文件，這就是動態生成字節碼的文件。這種技術是在java一個類中實現的

Proxy的靜態方法，newProxyInstance（），這個方法有三個參數，第一個參數是被代理類的類加載器（classLoader），第二個參數是被代理類的全部接口，第三個參數是咱們上面實現類（InvocationHandler）的實例，那麼這個方法，返回的就是一個代理類，就是在這個方法中，動態拼接處代理類的字節碼。

動態代理有兩個主要應用：第一是若是代碼中多處會用到相同的代碼，如安全性檢查，權限的驗證，在很對業務模塊都會用到，通常都是放在咱們業務代碼的頭部或者是尾部，那麼若是不用動態代理的話，這些相同的代碼就會分散在你程序的各個部分，首先代碼服用率太差，其次是可維護性不高，若是你想要改變你權限驗證的方式的話，那麼你須要在程序中每一個地方都改，這樣的話會很難維護，索性咱們將全部檢查性的代碼，都提取出來，一塊兒維護，這樣的代碼維護在一塊兒，那麼就至關方便的，這就是面向切面的編程也就是AOP，咱們把檢查性的代碼放在一個類裏一塊兒維護，那麼這個類就叫作切面。AOP的概念在spring中會普遍被用到，如spring中的生命式事務，就是用AOP實現的，動態爲數據庫操做加上事務，第二個主要應用，是相似攔截器的一種應用，攔截器就是在你業務代碼前，加上檢查性代碼，若是經過則執行你的業務代碼，若是不經過則不執行你的業務代碼。其實這裏不會徹底用到動態代理，主要是用帶動態代理中反射的實現部分，在實際的應用中通常會使用攔截器棧，也就是一系列的攔截器，就是說要檢查多個合法性，一個攔截器驗證經過則進入下一個攔截器，當全部攔截器驗證都經過，纔是真正的業務代碼。這種思想在其實就是設計模式中的責任鏈模式，在springmvc當中會有很大的應用，下面我簡單手動實現了一個攔截器（不是攔截器棧），這既是一個攔截器，也是動態代理的一個應用，但願對你們有幫助，下面是個人代碼。

以前雖然會用JDK的動態代理，可是有些問題卻一直沒有搞明白。好比說：InvocationHandler的invoke方法是由誰來調用的，代理對象是怎麼生成的，直到前幾個星期才把這些問題所有搞明白了。

廢話很少說了，先來看一下JDK的動態是怎麼用的。

Java代碼

1. package dynamic.proxy;
3. import java.lang.reflect.InvocationHandler;
4. import java.lang.reflect.Method;
5. import java.lang.reflect.Proxy;
7. /**
8. * 實現本身的InvocationHandler
9. * @author zyb
10. * @since 2012-8-9
11. *
12. */
13. public class MyInvocationHandler implements InvocationHandler {
15. // 目標對象
16. private Object target;
18. /**
19. * 構造方法
20. * @param target 目標對象
21. */
22. public MyInvocationHandler(Object target) {
23. super();
24. this.target = target;
25. }
28. /**
29. * 執行目標對象的方法
30. */
31. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
33. // 在目標對象的方法執行以前簡單的打印一下
34. System.out.println("------------------before------------------");
36. // 執行目標對象的方法
37. Object result = method.invoke(target, args);
39. // 在目標對象的方法執行以後簡單的打印一下
40. System.out.println("-------------------after------------------");
42. return result;
43. }
45. /**
46. * 獲取目標對象的代理對象
47. * @return 代理對象
48. */
49. public Object getProxy() {
50. return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
51. target.getClass().getInterfaces(), this);
52. }
53. }
55. package dynamic.proxy;
57. /**
58. * 目標對象實現的接口，用JDK來生成代理對象必定要實現一個接口
59. * @author zyb
60. * @since 2012-8-9
61. *
62. */
63. public interface UserService {
65. /**
66. * 目標方法
67. */
68. public abstract void add();
70. }
72. package dynamic.proxy;
74. /**
75. * 目標對象
76. * @author zyb
77. * @since 2012-8-9
78. *
79. */
80. public class UserServiceImpl implements UserService {
82. /* (non-Javadoc)
83. * @see dynamic.proxy.UserService#add()
84. */
85. public void add() {
86. System.out.println("--------------------add---------------");
87. }
88. }
90. package dynamic.proxy;
92. import org.junit.Test;
94. /**
95. * 動態代理測試類
96. * @author zyb
97. * @since 2012-8-9
98. *
99. */
100. public class ProxyTest {
102. @Test
103. public void testProxy() throws Throwable {
104. // 實例化目標對象
105. UserService userService = new UserServiceImpl();
107. // 實例化InvocationHandler
108. MyInvocationHandler invocationHandler = new MyInvocationHandler(userService);
110. // 根據目標對象生成代理對象
111. UserService proxy = (UserService) invocationHandler.getProxy();
113. // 調用代理對象的方法
114. proxy.add();
116. }
117. }

執行結果以下：
------------------before------------------
--------------------add---------------
-------------------after------------------

用起來是很簡單吧，其實這裏基本上就是AOP的一個簡單實現了，在目標對象的方法執行以前和執行以後進行了加強。Spring的AOP實現其實也是用了Proxy和InvocationHandler這兩個東西的。

用起來是比較簡單，可是若是能知道它背後作了些什麼手腳，那就更好不過了。首先來看一下JDK是怎樣生成代理對象的。既然生成代理對象是用的Proxy類的靜態方newProxyInstance，那麼咱們就去它的源碼裏看一下它到底都作了些什麼？

Java代碼

1. /**
2. * loader:類加載器
3. * interfaces:目標對象實現的接口
4. * h:InvocationHandler的實現類
5. */
6. public static Object newProxyInstance(ClassLoader loader,
7. Class<?>[] interfaces,
8. InvocationHandler h)
9. throws IllegalArgumentException
10. {
11. if (h == null) {
12. throw new NullPointerException();
13. }
15. /*
16. * Look up or generate the designated proxy class.
17. */
18. Class cl = getProxyClass(loader, interfaces);
20. /*
21. * Invoke its constructor with the designated invocation handler.
22. */
23. try {
24. // 調用代理對象的構造方法（也就是$Proxy0(InvocationHandler h)）
25. Constructor cons = cl.getConstructor(constructorParams);
26. // 生成代理類的實例並把MyInvocationHandler的實例傳給它的構造方法
27. return (Object) cons.newInstance(new Object[] { h });
28. } catch (NoSuchMethodException e) {
29. throw new InternalError(e.toString());
30. } catch (IllegalAccessException e) {
31. throw new InternalError(e.toString());
32. } catch (InstantiationException e) {
33. throw new InternalError(e.toString());
34. } catch (InvocationTargetException e) {
35. throw new InternalError(e.toString());
36. }
37. }

咱們再進去getProxyClass方法看一下

Java代碼

1. public static Class<?> getProxyClass(ClassLoader loader,
2. Class<?>... interfaces)
3. throws IllegalArgumentException
4. {
5. // 若是目標類實現的接口數大於65535個則拋出異常（我XX，誰會寫這麼NB的代碼啊？）
6. if (interfaces.length > 65535) {
7. throw new IllegalArgumentException("interface limit exceeded");
8. }
10. // 聲明代理對象所表明的Class對象（有點拗口）
11. Class proxyClass = null;
13. String[] interfaceNames = new String[interfaces.length];
15. Set interfaceSet = new HashSet(); // for detecting duplicates
17. // 遍歷目標類所實現的接口
18. for (int i = 0; i < interfaces.length; i++) {
20. // 拿到目標類實現的接口的名稱
21. String interfaceName = interfaces[i].getName();
22. Class interfaceClass = null;
23. try {
24. // 加載目標類實現的接口到內存中
25. interfaceClass = Class.forName(interfaceName, false, loader);
26. } catch (ClassNotFoundException e) {
27. }
28. if (interfaceClass != interfaces[i]) {
29. throw new IllegalArgumentException(
30. interfaces[i] + " is not visible from class loader");
31. }
33. // 中間省略了一些可有可無的代碼 .......
35. // 把目標類實現的接口表明的Class對象放到Set中
36. interfaceSet.add(interfaceClass);
38. interfaceNames[i] = interfaceName;
39. }
41. // 把目標類實現的接口名稱做爲緩存（Map）中的key
42. Object key = Arrays.asList(interfaceNames);
44. Map cache;
46. synchronized (loaderToCache) {
47. // 從緩存中獲取cache
48. cache = (Map) loaderToCache.get(loader);
49. if (cache == null) {
50. // 若是獲取不到，則新建地個HashMap實例
51. cache = new HashMap();
52. // 把HashMap實例和當前加載器放到緩存中
53. loaderToCache.put(loader, cache);
54. }
56. }
58. synchronized (cache) {
60. do {
61. // 根據接口的名稱從緩存中獲取對象
62. Object value = cache.get(key);
63. if (value instanceof Reference) {
64. proxyClass = (Class) ((Reference) value).get();
65. }
66. if (proxyClass != null) {
67. // 若是代理對象的Class實例已經存在，則直接返回
68. return proxyClass;
69. } else if (value == pendingGenerationMarker) {
70. try {
71. cache.wait();
72. } catch (InterruptedException e) {
73. }
74. continue;
75. } else {
76. cache.put(key, pendingGenerationMarker);
77. break;
78. }
79. } while (true);
80. }
82. try {
83. // 中間省略了一些代碼 .......
85. // 這裏就是動態生成代理對象的最關鍵的地方
86. byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
87. proxyName, interfaces);
88. try {
89. // 根據代理類的字節碼生成代理類的實例
90. proxyClass = defineClass0(loader, proxyName,
91. proxyClassFile, 0, proxyClassFile.length);
92. } catch (ClassFormatError e) {
93. throw new IllegalArgumentException(e.toString());
94. }
95. }
96. // add to set of all generated proxy classes, for isProxyClass
97. proxyClasses.put(proxyClass, null);
99. }
100. // 中間省略了一些代碼 .......
102. return proxyClass;
103. }

進去ProxyGenerator類的靜態方法generateProxyClass，這裏是真正生成代理類class字節碼的地方。

Java代碼

1. public static byte[] generateProxyClass(final String name,
2. Class[] interfaces)
3. {
4. ProxyGenerator gen = new ProxyGenerator(name, interfaces);
5. // 這裏動態生成代理類的字節碼，因爲比較複雜就不進去看了
6. final byte[] classFile = gen.generateClassFile();
8. // 若是saveGeneratedFiles的值爲true，則會把所生成的代理類的字節碼保存到硬盤上
9. if (saveGeneratedFiles) {
10. java.security.AccessController.doPrivileged(
11. new java.security.PrivilegedAction<Void>() {
12. public Void run() {
13. try {
14. FileOutputStream file =
15. new FileOutputStream(dotToSlash(name) + ".class");
16. file.write(classFile);
17. file.close();
18. return null;
19. } catch (IOException e) {
20. throw new InternalError(
21. "I/O exception saving generated file: " + e);
22. }
23. }
24. });
25. }
27. // 返回代理類的字節碼
28. return classFile;
29. }

如今，JDK是怎樣動態生成代理類的字節的原理已經一目瞭然了。

好了，再來解決另一個問題，那就是由誰來調用InvocationHandler的invoke方法的。要解決這個問題就要看一下JDK到底爲咱們生成了一個什麼東西。用如下代碼能夠獲取到JDK爲咱們生成的字節碼並寫到硬盤中。

Java代碼

1. package dynamic.proxy;
3. import java.io.FileOutputStream;
4. import java.io.IOException;
6. import sun.misc.ProxyGenerator;
8. /**
9. * 代理類的生成工具
10. * @author zyb
11. * @since 2012-8-9
12. */
13. public class ProxyGeneratorUtils {
15. /**
16. * 把代理類的字節碼寫到硬盤上
17. * @param path 保存路徑
18. */
19. public static void writeProxyClassToHardDisk(String path) {
20. // 第一種方法，這種方式在剛纔分析ProxyGenerator時已經知道了
21. // System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", true);
23. // 第二種方法
25. // 獲取代理類的字節碼
26. byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy11", UserServiceImpl.class.getInterfaces());
28. FileOutputStream out = null;
30. try {
31. out = new FileOutputStream(path);
32. out.write(classFile);
33. out.flush();
34. } catch (Exception e) {
35. e.printStackTrace();
36. } finally {
37. try {
38. out.close();
39. } catch (IOException e) {
40. e.printStackTrace();
41. }
42. }
43. }
44. }
46. package dynamic.proxy;
48. import org.junit.Test;
50. /**
51. * 動態代理測試類
52. * @author zyb
53. * @since 2012-8-9
54. *
55. */
56. public class ProxyTest {
58. @Test
59. public void testProxy() throws Throwable {
60. // 實例化目標對象
61. UserService userService = new UserServiceImpl();
63. // 實例化InvocationHandler
64. MyInvocationHandler invocationHandler = new MyInvocationHandler(userService);
66. // 根據目標對象生成代理對象
67. UserService proxy = (UserService) invocationHandler.getProxy();
69. // 調用代理對象的方法
70. proxy.add();
72. }
74. @Test
75. public void testGenerateProxyClass() {
76. ProxyGeneratorUtils.writeProxyClassToHardDisk("F:/$Proxy11.class");
77. }
78. }

經過以上代碼，就能夠在F盤上生成一個$Proxy.class文件了，如今用反編譯工具來看一下這個class文件裏面的內容。

Java代碼

1. // Decompiled by DJ v3.11.11.95 Copyright 2009 Atanas Neshkov Date: 2012/8/9 20:11:32
2. // Home Page: http://members.fortunecity.com/neshkov/dj.html http://www.neshkov.com/dj.html - Check often for new version!
3. // Decompiler options: packimports(3)
5. import dynamic.proxy.UserService;
6. import java.lang.reflect.*;
8. public final class $Proxy11 extends Proxy
9. implements UserService
10. {
12. // 構造方法，參數就是剛纔傳過來的MyInvocationHandler類的實例
13. public $Proxy11(InvocationHandler invocationhandler)
14. {
15. super(invocationhandler);
16. }
18. public final boolean equals(Object obj)
19. {
20. try
21. {
22. return ((Boolean)super.h.invoke(this, m1, new Object[] {
23. obj
24. })).booleanValue();
25. }
26. catch(Error _ex) { }
27. catch(Throwable throwable)
28. {
29. throw new UndeclaredThrowableException(throwable);
30. }
31. }
33. /**
34. * 這個方法是關鍵部分
35. */
36. public final void add()
37. {
38. try
39. {
40. // 實際上就是調用MyInvocationHandler的public Object invoke(Object proxy, Method method, Object[] args)方法，第二個問題就解決了
41. super.h.invoke(this, m3, null);
42. return;
43. }
44. catch(Error _ex) { }
45. catch(Throwable throwable)
46. {
47. throw new UndeclaredThrowableException(throwable);
48. }
49. }
51. public final int hashCode()
52. {
53. try
54. {
55. return ((Integer)super.h.invoke(this, m0, null)).intValue();
56. }
57. catch(Error _ex) { }
58. catch(Throwable throwable)
59. {
60. throw new UndeclaredThrowableException(throwable);
61. }
62. }
64. public final String toString()
65. {
66. try
67. {
68. return (String)super.h.invoke(this, m2, null);
69. }
70. catch(Error _ex) { }
71. catch(Throwable throwable)
72. {
73. throw new UndeclaredThrowableException(throwable);
74. }
75. }
77. private static Method m1;
78. private static Method m3;
79. private static Method m0;
80. private static Method m2;
82. // 在靜態代碼塊中獲取了4個方法：Object中的equals方法、UserService中的add方法、Object中的hashCode方法、Object中toString方法
83. static
84. {
85. try
86. {
87. m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] {
88. Class.forName("java.lang.Object")
89. });
90. m3 = Class.forName("dynamic.proxy.UserService").getMethod("add", new Class[0]);
91. m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
92. m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
93. }
94. catch(NoSuchMethodException nosuchmethodexception)
95. {
96. throw new NoSuchMethodError(nosuchmethodexception.getMessage());
97. }
98. catch(ClassNotFoundException classnotfoundexception)
99. {
100. throw new NoClassDefFoundError(classnotfoundexception.getMessage());
101. }
102. }
103. }

好了，到目前爲止，前面 的兩個問題都已經知道回事了，如今再用JDK動態代理的時候就不僅會用而已了，真正的達到了「知其然，知其因此然」的目的。。。