Terry.Li-彬
          
				
          虛其心，可解天下之問；專其心，可治天下之學；靜其心，可悟天下之理；恒其心，可成天下之業。
          
			          		
		
          
	
          

          

          
	
          
		
          
			
 
BlogJava ::
首頁 ::
新隨筆 ::
聯系 ::
聚合
 ::
管理 ::


			
			
				

          
	
          
		
          
			
			
			
				 
				143 
				隨筆 ::
				344 文章
				::
				130 評論
				::
				0 Trackbacks
			
		
          
	
          

          

			          		
		
          
	
          

          


          


          
	
					

          
	
	
	
          
		
          一、Java ClassLoader
          

          1，什么是ClassLoader 
          
與 C 或 C++ 編寫的程序不同，Java 程序并不是一個可執行文件，而是由許多獨立的類文件組成，每一個文件對應于一個 Java 類。 
          
此外，這些類文件并非立即全部都裝入內存，而是根據程序需要裝入內存。ClassLoader 是 JVM 中將類裝入內存的那部分。 
          
而且，Java ClassLoader 就是用 Java 語言編寫的。這意味著創建您自己的 ClassLoader 非常容易，不必了解 JVM 的微小細節。
          

          2，一些重要的方法 
          
A)loadClass 
          
ClassLoader.loadClass() 是ClassLoader的入口點。該方法的定義為：Class loadClass( String name, boolean resolve ); 
          
name：JVM 需要的類的名稱，如 Foo 或 java.lang.Object。 
          
resolve：參數告訴方法是否需要解析類。
          

          B)defineClass 
          
defineClass方法是ClassLoader的主要訣竅。該方法接受由原始字節組成的數組并把它轉換成Class對象。
          

          C)findSystemClass 
          
findSystemClass方法從本地文件系統中尋找類文件，如果存在，就使用defineClass將原始字節轉換成Class對象，以將該文件轉換成類。
          

          D)resolveClass 
          
可以不完全地(不帶解析)裝入類，也可以完全地(帶解析)裝入類。當編寫我們自己的loadClass時可以調用resolveClass，這取決于loadClass的resolve參數的值。
          

          E)findLoadedClass 
          
findLoadedClass充當一個緩存：當請求loadClass裝入類時，它調用該方法來查看ClassLoader是否已裝入這個類，這樣可以避免重新裝入已存在類所造成的麻煩。
          

          3，Java2中ClassLoader的變動 
          
1)loadClass的缺省實現 
          
在Java2中loadClass的實現嵌入了大多數查找類的一般方法，并使您通過覆蓋findClass方法來定制它，在適當的時候findClass會調用loadClass。 
          
這種方式的好處是可能不一定要覆蓋loadClass，只要覆蓋findClass就行了，這減少了工作量。
          

          2)新方法:findClass 
          
loadClass的缺省實現調用這個新方法。
          

          3)新方法:getSystemClassLoader 
          
如果覆蓋findClass或loadClass，getSystemClassLoader讓我們以實際ClassLoader對象來訪問系統ClassLoader，而不是固定的從findSystemClass 調用它。
          

          4)新方法:getParent 
          
為了將類請求委托給父ClassLoader，這個新方法允許ClassLoader獲取它的父ClassLoader。
          

          4，定制ClassLoader 
          
其實我們或多或少都使用過定制的ClassLoader，因為Applet查看器中就包含一個定制的ClassLoader。 
          
它不在本地文件系統中尋找類，而是訪問遠程服務器上的 Web 站點，經過 HTTP 裝入原始的字節碼文件，并把它們轉換成JVM 內的類。 
          
Applet查看器中的ClassLoader還可以做其它事情：它們支持安全性以及使不同的Applet在不同的頁面上運行而互不干擾。 
          
我們將寫一個自己的ClassLoader實現示例，它將實現如下步驟，這也是ClassLoader的工作原理: 
          
# 調用 findLoadedClass 來查看是否存在已裝入的類。 
          
# 如果沒有，那么采用那種特殊的神奇方式來獲取原始字節。 
          
# 如果已有原始字節，調用defineClass將它們轉換成Class對象。 
          
# 如果沒有原始字節，然后調用findSystemClass查看是否從本地文件系統獲取類。 
          
# 如果resolve參數是true，那么調用resolveClass解析Class對象。 
          
# 如果還沒有類，返回ClassNotFoundException。 
          
# 否則，將類返回給調用程序。 
          
話不多說，看看代碼先: 
          
FileClassLoader.java: 
          

          代碼
          

          

          

          

            
    
          1. import java.io.ByteArrayOutputStream;   
            2. 
    
          2. import java.io.File;   
            3. 
    
          3. import java.io.FileInputStream;   
            4. 
    
          4. import java.io.IOException;   
            5. 
    
          5.   
            6. 
    
          6. public class FileClassLoader extends ClassLoader {   
            7. 
    
          7.   public Class findClass(String name) {   
            8. 
    
          8.     byte[] data = loadClassData(name);   
            9. 
    
          9.     return defineClass(name, data, 0, data.length);   
            10. 
    
          10.   }   
            11. 
    
          11.      
            12. 
    
          12.   private byte[] loadClassData(String name) {   
            13. 
    
          13.     FileInputStream fis = null;   
            14. 
    
          14.     byte[] data = null;   
            15. 
    
          15.     try {   
            16. 
    
          16.       fis = new FileInputStream(new File("D:\\project\\test\\" + name + ".class"));   
            17. 
    
          17.       ByteArrayOutputStream baos = new ByteArrayOutputStream();   
            18. 
    
          18.       int ch = 0;   
            19. 
    
          19.       while ((ch = fis.read()) != -1) {   
            20. 
    
          20.         baos.write(ch);   
            21. 
    
          21.       }   
            22. 
    
          22.       data = baos.toByteArray();   
            23. 
    
          23.     } catch (IOException e) {   
            24. 
    
          24.       e.printStackTrace();   
            25. 
    
          25.     }   
            26. 
    
          26.     return data;   
            27. 
    
          27.   }   
            28. 
    
          28. }   
            29. 

          

          

          

          
MyApp.java: 
          

          代碼
          

          

          

          

            
    
          1. public class MyApp {   
            2. 
    
          2.   public static void main(String[] args) throws Exception {   
            3. 
    
          3.     FileClassLoader loader = new FileClassLoader();   
            4. 
    
          4.     Class objClass = loader.findClass("MyApp");   
            5. 
    
          5.     Object obj = objClass.newInstance();   
            6. 
    
          6.     System.out.println(objClass.getName());   
            7. 
    
          7.     System.out.println(objClass.getClassLoader());   
            8. 
    
          8.     System.out.println(obj);   
            9. 
    
          9.   }   
            10. 
    
          10. }   
            11. 

          

          

          

          
編譯并運行MyApp類，結果為: 
          

          代碼
          

          

          

          

            
    
          1. MyApp   
            2. 
    
          2. FileClassLoader@757aef  
            3. 
    
          3. MyApp@9cab16  
            4. 

          

          

          


          二、Bytecode
          

          1，什么是Bytecode 
          
C/C++編譯器把源代碼編譯成匯編代碼，Java編譯器把Java源代碼編譯成字節碼bytecode。 
          
Java跨平臺其實就是基于相同的bytecode規范做不同平臺的虛擬機，我們的Java程序編譯成bytecode后就可以在不同平臺跑了。 
          
.net框架有IL(intermediate language)，匯編是C/C++程序的中間表達方式，而bytecode可以說是Java平臺的中間語言。 
          
了解Java字節碼知識對debugging、performance tuning以及做一些高級語言擴展或框架很有幫助。
          

          2，使用javap生成Bytecode 
          
JDK自帶的javap.exe文件可以反匯編Bytecode，讓我們看個例子: 
          
Test.java: 
          

          代碼
          

          

          

          

            
    
          1. public class Test {   
            2. 
    
          2.   public static void main(String[] args) {   
            3. 
    
          3.     int i = 10000;   
            4. 
    
          4.     System.out.println("Hello Bytecode! Number = " + i);   
            5. 
    
          5.   }   
            6. 
    
          6. }   
            7. 

          

          

          

          
編譯后的Test.class: 
          

          代碼
          

          

          

          

            
    
          1. 漱壕   1 +   
            2. 
    
          2.            
            3. 
    
          3.       
            4. 
    
          4.      
            5. 
    
          5.      
            6. 
    
          6.      
            7. 
    
          7.      <init> ()V Code LineNumberTable main ([Ljava/lang/String;)V    
            8. 
    
          8. SourceFile   Test.java       
            9. 
    
          9.     ! " java/lang/StringBuilder Hello Bytecode! Number =   # $  # %  & ' (  ) * Test java/lang/Object java/lang/System out Ljava/io/PrintStream; append -(Ljava/lang/String;)Ljava/lang/StringBuilder; (I)Ljava/lang/StringBuilder; toString ()Ljava/lang/String; java/io/PrintStream println (Ljava/lang/String;)V !    
            10. 
    
          10.               
            11. 
    
          11.           *                      >     '<  Y                               
            12. 

          

          

          

          
使用javap -c Test > Test.bytecode生成的Test.bytecode: 
          

          代碼
          

          

          

          

            
    
          1. Compiled from "Test.java"  
            2. 
    
          2. public class Test extends java.lang.Object{   
            3. 
    
          3. public Test();   
            4. 
    
          4.   Code:   
            5. 
    
          5.    0:  aload_0   
            6. 
    
          6.    1:  invokespecial  #1; //Method java/lang/Object."<init>":()V   
            7. 
    
          7.    4:  return  
            8. 
    
          8.   
            9. 
    
          9. public static void main(java.lang.String[]);   
            10. 
    
          10.   Code:   
            11. 
    
          11.    0:  sipush  10000  
            12. 
    
          12.    3:  istore_1   
            13. 
    
          13.    4:  getstatic  #2; //Field java/lang/System.out:Ljava/io/PrintStream;   
            14. 
    
          14.    7:  new  #3; //class java/lang/StringBuilder   
            15. 
    
          15.    10:  dup   
            16. 
    
          16.    11:  invokespecial  #4; //Method java/lang/StringBuilder."<init>":()V   
            17. 
    
          17.    14:  ldc  #5; //String Hello Bytecode! Number =    
            18. 
    
          18.    16:  invokevirtual  #6; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;   
            19. 
    
          19.    19:  iload_1   
            20. 
    
          20.    20:  invokevirtual  #7; //Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;   
            21. 
    
          21.    23:  invokevirtual  #8; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;   
            22. 
    
          22.    26:  invokevirtual  #9; //Method java/io/PrintStream.println:(Ljava/lang/String;)V   
            23. 
    
          23.    29:  return  
            24. 
    
          24.   
            25. 
    
          25. }   
            26. 

          

          

          

          
JVM就是一個基于stack的機器，每個thread擁有一個存儲著一些frames的JVM stack，每次調用一個方法時生成一個frame。 
          
一個frame包括一個local variables數組(本地變量表)，一個Operand LIFO stack和運行時常量池的一個引用。

           
          

          我們來簡單分析一下生成的字節碼指令: 
          
aload和iload指令的“a”前綴和“i”分別表示對象引用和int類型，其他還有“b”表示byte，“c”表示char，“d”表示double等等 
          
我們這里的aload_0表示將把local variable table中index 0的值push到Operand stack，iload_1類似 
          
invokespecial表示初始化對象，return表示返回 
          
sipush表示把10000這個int值push到Operand stack 
          
getstatic表示取靜態域 
          
invokevirtual表示調用一些實例方法 
          
這些指令又稱為opcode，Java一直以來只有約202個Opcode，具體請參考Java Bytecode規范。
          

          我們看到Test.class文件不全是二進制的指令，有些是我們可以識別的字符，這是因為有些包名、類名和常量字符串沒有編譯成二進制Bytecode指令。
          

          3，體驗字節碼增強的魔力 
          
我們J2EE常用的Hibernate、Spring都用到了動態字節碼修改來改變類的行為。 
          
讓我們通過看看ASM的org.objectweb.asm.MethodWriter類的部分方法來理解ASM是如何修改字節碼的: 
          

          代碼
          

          

          

          

            
    
          1. class MethodWriter implements MethodVisitor {   
            2. 
    
          2.   
            3. 
    
          3.     private ByteVector code = new ByteVector();   
            4. 
    
          4.   
            5. 
    
          5.     public void visitIntInsn(final int opcode, final int operand) {   
            6. 
    
          6.         // Label currentBlock = this.currentBlock;   
            7. 
    
          7.         if (currentBlock != null) {   
            8. 
    
          8.             if (compute == FRAMES) {   
            9. 
    
          9.                 currentBlock.frame.execute(opcode, operand, null, null);   
            10. 
    
          10.             } else if (opcode != Opcodes.NEWARRAY) {   
            11. 
    
          11.                 // updates current and max stack sizes only for NEWARRAY   
            12. 
    
          12.                 // (stack size variation = 0 for BIPUSH or SIPUSH)   
            13. 
    
          13.                 int size = stackSize + 1;   
            14. 
    
          14.                 if (size > maxStackSize) {   
            15. 
    
          15.                     maxStackSize = size;   
            16. 
    
          16.                 }   
            17. 
    
          17.                 stackSize = size;   
            18. 
    
          18.             }   
            19. 
    
          19.         }   
            20. 
    
          20.         // adds the instruction to the bytecode of the method   
            21. 
    
          21.         if (opcode == Opcodes.SIPUSH) {   
            22. 
    
          22.             code.put12(opcode, operand);   
            23. 
    
          23.         } else { // BIPUSH or NEWARRAY   
            24. 
    
          24.             code.put11(opcode, operand);   
            25. 
    
          25.         }   
            26. 
    
          26.     }   
            27. 
    
          27.   
            28. 
    
          28.     public void visitMethodInsn(   
            29. 
    
          29.         final int opcode,   
            30. 
    
          30.         final String owner,   
            31. 
    
          31.         final String name,   
            32. 
    
          32.         final String desc)   
            33. 
    
          33.     {   
            34. 
    
          34.         boolean itf = opcode == Opcodes.INVOKEINTERFACE;   
            35. 
    
          35.         Item i = cw.newMethodItem(owner, name, desc, itf);   
            36. 
    
          36.         int argSize = i.intVal;   
            37. 
    
          37.         // Label currentBlock = this.currentBlock;   
            38. 
    
          38.         if (currentBlock != null) {   
            39. 
    
          39.             if (compute == FRAMES) {   
            40. 
    
          40.                 currentBlock.frame.execute(opcode, 0, cw, i);   
            41. 
    
          41.             } else {   
            42. 
    
          42.                 /*  
            43. 
    
          43.                  * computes the stack size variation. In order not to recompute  
            44. 
    
          44.                  * several times this variation for the same Item, we use the  
            45. 
    
          45.                  * intVal field of this item to store this variation, once it  
            46. 
    
          46.                  * has been computed. More precisely this intVal field stores  
            47. 
    
          47.                  * the sizes of the arguments and of the return value  
            48. 
    
          48.                  * corresponding to desc.  
            49. 
    
          49.                  */  
            50. 
    
          50.                 if (argSize == 0) {   
            51. 
    
          51.                     // the above sizes have not been computed yet,   
            52. 
    
          52.                     // so we compute them...   
            53. 
    
          53.                     argSize = getArgumentsAndReturnSizes(desc);   
            54. 
    
          54.                     // ... and we save them in order   
            55. 
    
          55.                     // not to recompute them in the future   
            56. 
    
          56.                     i.intVal = argSize;   
            57. 
    
          57.                 }   
            58. 
    
          58.                 int size;   
            59. 
    
          59.                 if (opcode == Opcodes.INVOKESTATIC) {   
            60. 
    
          60.                     size = stackSize - (argSize >> 2) + (argSize & 0x03) + 1;   
            61. 
    
          61.                 } else {   
            62. 
    
          62.                     size = stackSize - (argSize >> 2) + (argSize & 0x03);   
            63. 
    
          63.                 }   
            64. 
    
          64.                 // updates current and max stack sizes   
            65. 
    
          65.                 if (size > maxStackSize) {   
            66. 
    
          66.                     maxStackSize = size;   
            67. 
    
          67.                 }   
            68. 
    
          68.                 stackSize = size;   
            69. 
    
          69.             }   
            70. 
    
          70.         }   
            71. 
    
          71.         // adds the instruction to the bytecode of the method   
            72. 
    
          72.         if (itf) {   
            73. 
    
          73.             if (argSize == 0) {   
            74. 
    
          74.                 argSize = getArgumentsAndReturnSizes(desc);   
            75. 
    
          75.                 i.intVal = argSize;   
            76. 
    
          76.             }   
            77. 
    
          77.             code.put12(Opcodes.INVOKEINTERFACE, i.index).put11(argSize >> 2, 0);   
            78. 
    
          78.         } else {   
            79. 
    
          79.             code.put12(opcode, i.index);   
            80. 
    
          80.         }   
            81. 
    
          81.     }   
            82. 
    
          82. }   
            83. 

          

          

          

          
通過注釋我們可以大概理解visitIntInsn和visitMethodInsn方法的意思。 
          
比如visitIntInsn先計算stack的size，然后根據opcode來判斷是SIPUSH指令還是BIPUSH or NEWARRAY指令，并相應的調用字節碼修改相關的方法。

          三、ASM 
          
我們知道Java是靜態語言，而python、ruby是動態語言，Java程序一旦寫好很難在運行時更改類的行為，而python、ruby可以。 
          
不過基于bytecode層面上我們可以做一些手腳，來使Java程序多一些靈活性和Magic，ASM就是這樣一個應用廣泛的開源庫。
          

          ASM is a Java bytecode manipulation framework. It can be used to dynamically generate stub classes or other proxy classes, 
          
directly in binary form, or to dynamically modify classes at load time, i.e., just before they are loaded into the Java 
          
Virtual Machine.
          

          ASM完成了BCEL和SERP同樣的功能，但ASM 
          
只有30多k，而后兩者分別是350k和150k。apache真是越來越過氣了。
          

          讓我們來看一個ASM的簡單例子Helloworld.java，它生成一個Example類和一個main方法，main方法打印"Hello world!"語句: 
          

          代碼
          

          

          

          

            
    
          1. import java.io.FileOutputStream;   
            2. 
    
          2. import java.io.PrintStream;   
            3. 
    
          3.   
            4. 
    
          4. import org.objectweb.asm.ClassWriter;   
            5. 
    
          5. import org.objectweb.asm.MethodVisitor;   
            6. 
    
          6. import org.objectweb.asm.Opcodes;   
            7. 
    
          7. import org.objectweb.asm.Type;   
            8. 
    
          8. import org.objectweb.asm.commons.GeneratorAdapter;   
            9. 
    
          9. import org.objectweb.asm.commons.Method;   
            10. 
    
          10.   
            11. 
    
          11. public class Helloworld extends ClassLoader implements Opcodes {   
            12. 
    
          12.   
            13. 
    
          13.   public static void main(final String args[]) throws Exception {   
            14. 
    
          14.   
            15. 
    
          15.     // creates a ClassWriter for the Example public class,   
            16. 
    
          16.     // which inherits from Object   
            17. 
    
          17.   
            18. 
    
          18.     ClassWriter cw = new ClassWriter(0);   
            19. 
    
          19.     cw.visit(V1_1, ACC_PUBLIC, "Example", null, "java/lang/Object", null);   
            20. 
    
          20.     MethodVisitor mw = cw.visitMethod(ACC_PUBLIC, "<init>", "()V", null,   
            21. 
    
          21.         null);   
            22. 
    
          22.     mw.visitVarInsn(ALOAD, 0);   
            23. 
    
          23.     mw.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V");   
            24. 
    
          24.     mw.visitInsn(RETURN);   
            25. 
    
          25.     mw.visitMaxs(1, 1);   
            26. 
    
          26.     mw.visitEnd();   
            27. 
    
          27.     mw = cw.visitMethod(ACC_PUBLIC + ACC_STATIC, "main",   
            28. 
    
          28.         "([Ljava/lang/String;)V", null, null);   
            29. 
    
          29.     mw.visitFieldInsn(GETSTATIC, "java/lang/System", "out",   
            30. 
    
          30.         "Ljava/io/PrintStream;");   
            31. 
    
          31.     mw.visitLdcInsn("Hello world!");   
            32. 
    
          32.     mw.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println",   
            33. 
    
          33.         "(Ljava/lang/String;)V");   
            34. 
    
          34.     mw.visitInsn(RETURN);   
            35. 
    
          35.     mw.visitMaxs(2, 2);   
            36. 
    
          36.     mw.visitEnd();   
            37. 
    
          37.     byte[] code = cw.toByteArray();   
            38. 
    
          38.     FileOutputStream fos = new FileOutputStream("Example.class");   
            39. 
    
          39.     fos.write(code);   
            40. 
    
          40.     fos.close();   
            41. 
    
          41.     Helloworld loader = new Helloworld();   
            42. 
    
          42.     Class exampleClass = loader   
            43. 
    
          43.         .defineClass("Example", code, 0, code.length);   
            44. 
    
          44.     exampleClass.getMethods()[0].invoke(null, new Object[] { null });   
            45. 
    
          45.   
            46. 
    
          46.     // ------------------------------------------------------------------------   
            47. 
    
          47.     // Same example with a GeneratorAdapter (more convenient but slower)   
            48. 
    
          48.     // ------------------------------------------------------------------------   
            49. 
    
          49.   
            50. 
    
          50.     cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);   
            51. 
    
          51.     cw.visit(V1_1, ACC_PUBLIC, "Example", null, "java/lang/Object", null);   
            52. 
    
          52.     Method m = Method.getMethod("void <init> ()");   
            53. 
    
          53.     GeneratorAdapter mg = new GeneratorAdapter(ACC_PUBLIC, m, null, null,   
            54. 
    
          54.         cw);   
            55. 
    
          55.     mg.loadThis();   
            56. 
    
          56.     mg.invokeConstructor(Type.getType(Object.class), m);   
            57. 
    
          57.     mg.returnValue();   
            58. 
    
          58.     mg.endMethod();   
            59. 
    
          59.     m = Method.getMethod("void main (String[])");   
            60. 
    
          60.     mg = new GeneratorAdapter(ACC_PUBLIC + ACC_STATIC, m, null, null, cw);   
            61. 
    
          61.     mg.getStatic(Type.getType(System.class), "out", Type   
            62. 
    
          62.         .getType(PrintStream.class));   
            63. 
    
          63.     mg.push("Hello world!");   
            64. 
    
          64.     mg.invokeVirtual(Type.getType(PrintStream.class), Method   
            65. 
    
          65.         .getMethod("void println (String)"));   
            66. 
    
          66.     mg.returnValue();   
            67. 
    
          67.     mg.endMethod();   
            68. 
    
          68.     cw.visitEnd();   
            69. 
    
          69.     code = cw.toByteArray();   
            70. 
    
          70.     loader = new Helloworld();   
            71. 
    
          71.     exampleClass = loader.defineClass("Example", code, 0, code.length);   
            72. 
    
          72.     exampleClass.getMethods()[0].invoke(null, new Object[] { null });   
            73. 
    
          73.   }   
            74. 
    
          74. }   
            75. 

          

          

          

          
我們看到上面的例子分別使用ASM的MethodVisitor和GeneratorAdapter兩種方式來動態生成Example類并調用打印語句。

          四、cglib 
          
cglib is a powerful, high performance and quality Code Generation Library, It is used to extend JAVA classes and implements interfaces at runtime. 
          
cglib是Code Generation Library的縮寫。 
          
cglib依賴于ASM庫。 
          
Hibernate主要是利用cglib生成pojo的子類并override get方法來實現lazy loading機制，Spring則是利用cglib來實現動態代理。 
          
而JDK的動態代理機制要求有接口才行，這樣就強制我們的pojo實現某個接口。
          

          這里還是提供一個cglib的入門級的示例: 
          
MyClass.java: 
          

          代碼
          

          

          

          

            
    
          1. public class MyClass {   
            2. 
    
          2.   
            3. 
    
          3.   public void print() {   
            4. 
    
          4.     System.out.println("I'm in MyClass.print!");   
            5. 
    
          5.   }   
            6. 
    
          6.   
            7. 
    
          7. }   
            8. 

          

          

          

          
Main.java: 
          

          代碼
          

          

          

          

            
    
          1. import java.lang.reflect.Method;   
            2. 
    
          2. import net.sf.cglib.proxy.Enhancer;   
            3. 
    
          3. import net.sf.cglib.proxy.MethodInterceptor;   
            4. 
    
          4. import net.sf.cglib.proxy.MethodProxy;   
            5. 
    
          5.   
            6. 
    
          6. public class Main {   
            7. 
    
          7.   
            8. 
    
          8.   public static void main(String[] args) {   
            9. 
    
          9.   
            10. 
    
          10.     Enhancer enhancer = new Enhancer();   
            11. 
    
          11.     enhancer.setSuperclass(MyClass.class);   
            12. 
    
          12.     enhancer.setCallback(new MethodInterceptorImpl());   
            13. 
    
          13.     MyClass my = (MyClass) enhancer.create();   
            14. 
    
          14.     my.print();   
            15. 
    
          15.   }   
            16. 
    
          16.   
            17. 
    
          17.   private static class MethodInterceptorImpl implements MethodInterceptor {   
            18. 
    
          18.     public Object intercept(Object obj, Method method, Object[] args,   
            19. 
    
          19.         MethodProxy proxy) throws Throwable {   
            20. 
    
          20.       // log something   
            21. 
    
          21.       System.out.println(method + " intercepted!");   
            22. 
    
          22.   
            23. 
    
          23.       proxy.invokeSuper(obj, args);   
            24. 
    
          24.       return null;   
            25. 
    
          25.     }   
            26. 
    
          26.   }   
            27. 
    
          27. }   
            28. 

          

          

          

          
打印結果為: 
          

          代碼
          

          

          

          

            
    
          1. public void MyClass.print() intercepted!   
            2. 
    
          2. I'm in MyClass.print!   
            3. 

          

          

          

          
這個示例就基本上實現了日志AOP的功能，很簡單吧。

           
          

          參考資料 
          
CLR和JRE的運行機制的初步總結 
          
Java虛擬機 
          
了解Java ClassLoader 
          
Java Virtual Machine Specification 
          
Java bytecode 
          
解讀字節碼文件 
          
Java Bytecode Specification and Verification 
          
ASM User Guide 
          
Hello, ASM 
          
cglig指南 
          
Java下的框架編程--cglib的應用 
          
AOP = Proxy Pattern + Method Reflection + Aspect DSL + 自動代碼生成 
          
深入淺出Spring AOP
          

	
          
	
	
          
		posted on 2007-09-23 10:28 禮物 閱讀(2282) 評論(1)  編輯  收藏  
	
          

          







          
	    
    


          

          
	
          評論
          
		
		
				
          			
					
          
						# re: 深入了解Java ClassLoader、Bytecode 、ASM、cglib 
							
								2008-01-24 16:15
							
						tian
					
          
					
          
						寫的真好,贊一個:)  回復  更多評論
						
          
						  
					
          
				
          
				
          
			

          




          





          


          

	
          
		
          
				
		
	
		
          
		
		
          只有注冊用戶登錄后才能發表評論。
          
		
          
			
		
          
			
		
          
		
		
          
		
		          		
		
          
		
          			
		
		
		
		
          
		
          
		
		
          
		
          
			網站導航:
		
		
          
		
          
			
		
          	
		
          
			 
		
          
		
          
			
		
          
		
          
			
				
		
          		
	
          	

          



          

				

          




    







          
        
	




主站蜘蛛池模板：
平顶山市|
大竹县|
醴陵市|
乌拉特中旗|
西畴县|
翁源县|
乐亭县|
凌云县|
扬中市|
甘孜县|
纳雍县|
伽师县|
孟连|
交城县|
曲周县|
乳源|
永胜县|
桂东县|
双峰县|
巢湖市|
正定县|
阿克陶县|
宽城|
中江县|
克山县|
庆城县|
奉化市|
离岛区|
泗阳县|
绵阳市|
海淀区|
温州市|
贵阳市|
宝坻区|
漳平市|
开封县|
澄迈县|
绵竹市|
克拉玛依市|
固镇县|
随州市|