<rt id="bn8ez"></rt>
<label id="bn8ez"></label>
  • 

    • <span id="bn8ez"></span>
    

    <label id="bn8ez"><meter id="bn8ez"></meter></label>
    

    
    

    




    







												


        

    
	

    
	
    
		
    
			
				
    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 禮物 閱讀(2272) 評論(1)  編輯  收藏  
	
    

    







    
	    
    


    

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

    




    





    


    

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

    



    

				

    




    







    
        
	



主站蜘蛛池模板：
可以免费观看的国产视频|
国产免费av片在线看|
亚洲国产精品网站久久|
免费看的成人yellow视频|
成人特级毛片69免费观看|
亚洲一区免费观看|
最好免费观看韩国+日本|
a毛片全部播放免费视频完整18|
亚洲性无码av在线|
久久精品国产亚洲5555|
亚洲精品视频在线观看免费|
精品在线视频免费|
亚洲精品成人网站在线播放|
免费一级黄色毛片|
91手机看片国产永久免费|
一区二区三区免费电影|
亚洲一区二区三区播放在线
|
亚洲精品无码不卡在线播放HE|
免费无码黄十八禁网站在线观看|
黄色网址免费在线观看|
亚洲欧洲精品成人久久曰|
亚洲av永久无码精品秋霞电影影院|
日本免费一本天堂在线|
**实干一级毛片aa免费|
久久免费香蕉视频|
国产精品亚洲天堂|
亚洲福利一区二区精品秒拍|
亚洲人成无码www久久久|
国产美女在线精品免费观看|
日韩精品久久久久久免费
|
性短视频在线观看免费不卡流畅|
国产精品无码永久免费888|
亚洲精品日韩一区二区小说|
亚洲综合色丁香麻豆|
亚洲国产精品无码专区影院|
伊在人亚洲香蕉精品区麻豆|
成人免费无毒在线观看网站|
久久99国产综合精品免费|
2022国内精品免费福利视频|
激情吃奶吻胸免费视频xxxx|
亚洲综合精品伊人久久|