转载自http://www.iteye.com/topic/98178

 

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

MyApp.java:

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

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. }

1. 漱壕   1 +
2. <init> ()V Code LineNumberTable main ([Ljava/lang/String;)V
3. SourceFile   Test.java
4. ! " 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 !
5. *                      >     '<  Y

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

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

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

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

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. public class Main {
6. public static void main(String[] args) {
7. Enhancer enhancer = new Enhancer();
8. enhancer.setSuperclass(MyClass.class);
9. enhancer.setCallback(new MethodInterceptorImpl());
10. MyClass my = (MyClass) enhancer.create();
11. my.print();
12. }
13. private static class MethodInterceptorImpl implements MethodInterceptor {
14. public Object intercept(Object obj, Method method, Object[] args,
15. MethodProxy proxy) throws Throwable {
16. // log something
17. System.out.println(method + " intercepted!");
18. proxy.invokeSuper(obj, args);
19. return null;
20. }
21. }
22. }

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