`

深入了解Java ClassLoader、Bytecode 、ASM、cglib

阅读更多

一、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:

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

public class FileClassLoader extends ClassLoader {
  public Class findClass(String name) {
    byte[] data = loadClassData(name);
    return defineClass(name, data, 0, data.length);
  }
  
  private byte[] loadClassData(String name) {
    FileInputStream fis = null;
    byte[] data = null;
    try {
      fis = new FileInputStream(new File("D:\\project\\test\\" + name + ".class"));
      ByteArrayOutputStream baos = new ByteArrayOutputStream();
      int ch = 0;
      while ((ch = fis.read()) != -1) {
        baos.write(ch);
      }
      data = baos.toByteArray();
    } catch (IOException e) {
      e.printStackTrace();
    }
    return data;
  }
}


MyApp.java:

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


编译并运行MyApp类,结果为:

Java代码 复制代码
  1. MyApp   
  2. FileClassLoader@757aef  
  3. MyApp@9cab16  

二、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:

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


编译后的Test.class:

Java代码 复制代码
  1. 漱壕   1 +   
  2.            
  3.       
  4.      
  5.      
  6.      
  7.      <init> ()V Code LineNumberTable main ([Ljava/lang/String;)V    
  8. SourceFile   Test.java       

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

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

public static void main(java.lang.String[]);
  Code:
   0:  sipush  10000
   3:  istore_1
   4:  getstatic  #2; //Field java/lang/System.out:Ljava/io/PrintStream;
   7:  new  #3; //class java/lang/StringBuilder
   10:  dup
   11:  invokespecial  #4; //Method java/lang/StringBuilder."<init>":()V
   14:  ldc  #5; //String Hello Bytecode! Number = 
   16:  invokevirtual  #6; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   19:  iload_1
   20:  invokevirtual  #7; //Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
   23:  invokevirtual  #8; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;
   26:  invokevirtual  #9; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   29:  return

}


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是如何修改字节码的:

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

    private ByteVector code = new ByteVector();

    public void visitIntInsn(final int opcode, final int operand) {
        // Label currentBlock = this.currentBlock;
        if (currentBlock != null) {
            if (compute == FRAMES) {
                currentBlock.frame.execute(opcode, operand, null, null);
            } else if (opcode != Opcodes.NEWARRAY) {
                // updates current and max stack sizes only for NEWARRAY
                // (stack size variation = 0 for BIPUSH or SIPUSH)
                int size = stackSize + 1;
                if (size > maxStackSize) {
                    maxStackSize = size;
                }
                stackSize = size;
            }
        }
        // adds the instruction to the bytecode of the method
        if (opcode == Opcodes.SIPUSH) {
            code.put12(opcode, operand);
        } else { // BIPUSH or NEWARRAY
            code.put11(opcode, operand);
        }
    }

    public void visitMethodInsn(
        final int opcode,
        final String owner,
        final String name,
        final String desc)
    {
        boolean itf = opcode == Opcodes.INVOKEINTERFACE;
        Item i = cw.newMethodItem(owner, name, desc, itf);
        int argSize = i.intVal;
        // Label currentBlock = this.currentBlock;
        if (currentBlock != null) {
            if (compute == FRAMES) {
                currentBlock.frame.execute(opcode, 0, cw, i);
            } else {
                /*
                 * computes the stack size variation. In order not to recompute
                 * several times this variation for the same Item, we use the
                 * intVal field of this item to store this variation, once it
                 * has been computed. More precisely this intVal field stores
                 * the sizes of the arguments and of the return value
                 * corresponding to desc.
                 */
                if (argSize == 0) {
                    // the above sizes have not been computed yet,
                    // so we compute them...
                    argSize = getArgumentsAndReturnSizes(desc);
                    // ... and we save them in order
                    // not to recompute them in the future
                    i.intVal = argSize;
                }
                int size;
                if (opcode == Opcodes.INVOKESTATIC) {
                    size = stackSize - (argSize >> 2) + (argSize & 0x03) + 1;
                } else {
                    size = stackSize - (argSize >> 2) + (argSize & 0x03);
                }
                // updates current and max stack sizes
                if (size > maxStackSize) {
                    maxStackSize = size;
                }
                stackSize = size;
            }
        }
        // adds the instruction to the bytecode of the method
        if (itf) {
            if (argSize == 0) {
                argSize = getArgumentsAndReturnSizes(desc);
                i.intVal = argSize;
            }
            code.put12(Opcodes.INVOKEINTERFACE, i.index).put11(argSize >> 2, 0);
        } else {
            code.put12(opcode, i.index);
        }
    }
}


通过注释我们可以大概理解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完成了BCELSERP同样的功能,但ASM
只有30多k,而后两者分别是350k和150k。apache真是越来越过气了。

让我们来看一个ASM的简单例子Helloworld.java,它生成一个Example类和一个main方法,main方法打印"Hello world!"语句:

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

import org.objectweb.asm.ClassWriter;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;
import org.objectweb.asm.commons.GeneratorAdapter;
import org.objectweb.asm.commons.Method;

public class Helloworld extends ClassLoader implements Opcodes {

  public static void main(final String args[]) throws Exception {

    // creates a ClassWriter for the Example public class,
    // which inherits from Object

    ClassWriter cw = new ClassWriter(0);
    cw.visit(V1_1, ACC_PUBLIC, "Example", null, "java/lang/Object", null);
    MethodVisitor mw = cw.visitMethod(ACC_PUBLIC, "<init>", "()V", null,
        null);
    mw.visitVarInsn(ALOAD, 0);
    mw.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V");
    mw.visitInsn(RETURN);
    mw.visitMaxs(1, 1);
    mw.visitEnd();
    mw = cw.visitMethod(ACC_PUBLIC + ACC_STATIC, "main",
        "([Ljava/lang/String;)V", null, null);
    mw.visitFieldInsn(GETSTATIC, "java/lang/System", "out",
        "Ljava/io/PrintStream;");
    mw.visitLdcInsn("Hello world!");
    mw.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println",
        "(Ljava/lang/String;)V");
    mw.visitInsn(RETURN);
    mw.visitMaxs(2, 2);
    mw.visitEnd();
    byte[] code = cw.toByteArray();
    FileOutputStream fos = new FileOutputStream("Example.class");
    fos.write(code);
    fos.close();
    Helloworld loader = new Helloworld();
    Class exampleClass = loader
        .defineClass("Example", code, 0, code.length);
    exampleClass.getMethods()[0].invoke(null, new Object[] { null });

    // ------------------------------------------------------------------------
    // Same example with a GeneratorAdapter (more convenient but slower)
    // ------------------------------------------------------------------------

    cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
    cw.visit(V1_1, ACC_PUBLIC, "Example", null, "java/lang/Object", null);
    Method m = Method.getMethod("void <init> ()");
    GeneratorAdapter mg = new GeneratorAdapter(ACC_PUBLIC, m, null, null,
        cw);
    mg.loadThis();
    mg.invokeConstructor(Type.getType(Object.class), m);
    mg.returnValue();
    mg.endMethod();
    m = Method.getMethod("void main (String[])");
    mg = new GeneratorAdapter(ACC_PUBLIC + ACC_STATIC, m, null, null, cw);
    mg.getStatic(Type.getType(System.class), "out", Type
        .getType(PrintStream.class));
    mg.push("Hello world!");
    mg.invokeVirtual(Type.getType(PrintStream.class), Method
        .getMethod("void println (String)"));
    mg.returnValue();
    mg.endMethod();
    cw.visitEnd();
    code = cw.toByteArray();
    loader = new Helloworld();
    exampleClass = loader.defineClass("Example", code, 0, code.length);
    exampleClass.getMethods()[0].invoke(null, new Object[] { null });
  }
}


我们看到上面的例子分别使用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:

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

  public void print() {
    System.out.println("I'm in MyClass.print!");
  }

}


Main.java:

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

public class Main {

  public static void main(String[] args) {

    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(MyClass.class);
    enhancer.setCallback(new MethodInterceptorImpl());
    MyClass my = (MyClass) enhancer.create();
    my.print();
  }

  private static class MethodInterceptorImpl implements MethodInterceptor {
    public Object intercept(Object obj, Method method, Object[] args,
        MethodProxy proxy) throws Throwable {
      // log something
      System.out.println(method + " intercepted!");

      proxy.invokeSuper(obj, args);
      return null;
    }
  }
}

 

分享到:
评论

相关推荐

    Java ClassLoader定制实例

    理解ClassLoader的工作原理以及如何定制它,对于深入学习Java的运行机制和进行高级应用开发具有重要意义。本篇文章将深入探讨Java ClassLoader的内部工作,并通过一个具体的实例来展示如何定制自己的ClassLoader。 ...

    java classloader

    深入Java 2 SDK.pdf`可能涉及的是Java与其他工具和技术的集成,如与微软Office的交互、使用Visual Studio .NET管理Java应用、Ant构建工具的使用以及对Java 2 SDK的深入理解,这些都可能间接地涉及到ClassLoader的...

    理解Java ClassLoader机制

    Java ClassLoader机制是Java运行时环境中的核心组件之一,它负责加载类到JVM(Java虚拟机)中,使得程序能够执行。理解ClassLoader的工作原理对于优化应用性能、处理类加载问题以及实现自定义加载器至关重要。 首先...

    Java Classloading Mechanism : ClassLoader & ASM & 动态字节码增强

    在本篇中,我们将详细探讨ClassLoader的工作原理、ASM库的使用以及如何利用这些工具进行动态字节码增强。 首先,我们来看Java的类加载机制。Java中的类加载主要由ClassLoader完成,它遵循“双亲委派模型”(Parents...

    了解Java ClassLoader

    理解ClassLoader的工作原理对于深入学习Java以及进行JVM优化、插件开发等高级技术至关重要。下面将详细介绍Java ClassLoader的基本概念、工作流程、类加载机制以及自定义ClassLoader。 1. **ClassLoader基本概念** ...

    java classloader classpath 张孝祥

    ### Java ClassLoader与ClassPath详解 #### 一、概述 在Java编程中,类加载机制是十分关键的一个环节。类加载器(`ClassLoader`)负责将编译后的`.class`文件加载到Java虚拟机(JVM)中执行,而类路径(`ClassPath...

    破解java加密的ClassLoader.java,在classloader植入破解代码

    破解java加密的ClassLoader.java,在classloader植入破解代码

    Java ClassLoader原理

    ### Java ClassLoader原理详解 #### 摘要 本文探讨了Java虚拟机(JVM)中的一个重要特性:动态类加载(Dynamic Class Loading)。...了解和掌握这些概念对于深入理解和高效利用Java平台至关重要。

    java ClassLoader机制及其在OSGi中的应用

    Java ClassLoader机制是Java虚拟机(JVM)中一个至关重要的组成部分,它的主要任务是将类的.class文件加载到JVM中,使得程序能够运行。ClassLoader不仅负责类的加载,还涉及类的验证、初始化等一系列过程。理解...

    Understanding the Java ClassLoader

    为了更好地理解和利用Java的这一特性,本篇将详细介绍Java ClassLoader的作用及其工作原理,并通过构建一个示例ClassLoader来帮助读者深入理解如何自定义ClassLoader,从而扩展JVM的功能。 #### 二、ClassLoader...

    Java ClassLoader学习总结

    了解 Java 类加载机制可以帮助我们更好地理解 Java 的运行机制,并且可以帮助我们更好地编写 Java 程序。 知识点总结: * Java 类加载机制是 Java 中一个非常重要的机制,它负责加载 Class 文件到 JVM,以供程序...

    Java ClassLoader Tutorial.zip

    这个教程将深入探讨ClassLoader的工作原理、类型以及如何自定义类加载器。 一、Java ClassLoader 基础 1. 类加载过程:Java中的类加载分为三个阶段——加载、验证、准备、解析和初始化。ClassLoader主要参与的是...

    java classloader讲义-淘宝网

    通过对Java ClassLoader的深入了解,我们可以更好地理解Java类的加载机制以及如何通过自定义ClassLoader来满足特定的应用需求。淘宝网的成功实践为我们提供了宝贵的参考案例,展示了ClassLoaders在实际项目中的重要...

    深入Java虚拟机_ClassLoader

    《深入Java虚拟机_ClassLoader》是一本专注于Java虚拟机(JVM)中ClassLoader部分的专著,旨在帮助读者深入理解Java程序如何加载、链接和初始化类。ClassLoader是Java平台核心特性的一部分,它负责查找和加载类到JVM...

    了解java classloader

    Java ClassLoader 是一个重要的、但又常常被人忽略的 Java 运行时系统组件。它是负责在运行时查找和装入类文件的类。创建自己的 ClassLoader 可以以实用且有趣的方式定制 JVM,这样可以让您彻底重新定义如何将类文件...

    ASM操作字节码,动态生成Java类class文件

    ASM可以被用来创建Java代理、实现元编程、甚至深入到Java虚拟机(JVM)层面进行性能优化。在Java开发中,ASM库允许我们直接操作字节码,这对于理解和实践AOP(面向切面编程)的概念尤其有用,就像Spring框架中的AOP...

    java classLoader 的全面讲解

    深入理解ClassLoader对于优化应用性能、处理类加载问题以及实现自定义加载策略至关重要。 一、ClassLoader 基本概念 1. 类加载器的层次结构:在Java中,类加载器形成了一个树形结构,通常由Bootstrap ClassLoader...

Global site tag (gtag.js) - Google Analytics