ClassLoader编程实践

java 的类加载机制背景知识：

《Java 类加载器（ ClassLoader）浅析》

《Three principles of Classloader operation（Classloader操作三原则）》

以上博文中所提及的java类加载机制，都是java1.2及以后的版本，而在最早的java1.1中，是没有parent-child模式的。

这里，将分别对java1.1 和 java1.2及以后的 类加载版本进行展示。

java1.1中的实现

java1.1的类加载机制相对单一，而用户自定义加载器的重写却比较复杂。。

主要需要重写ClassLoader中一个方法：Class loadClass(String name)。

Class loadClass(String name)：loadClass(String name)(或者loadClass(String name , boolean resolve))这个方法是加载的核心，他将根据类名（全名，比如java.lang.String）获得对应类的二进制数据，然后通过Class defineClass(byte[] b)将二进制数据加载到JVM的方法区，defineClass返回对应类的Class 实例，并根据可选的参数resolve决定是否需要现在解析这个类，之后将这个Class实例作为 loadClass方法的返回值。

其中，若是没有办法实现加载和defineClass,即无法通过本加载器直接加载类的情况，则使用Class findSystemClass(String name)委派系统的加载器查找，如果能找到则加载，否则，抛出ClassNotFoundException。可见，这个方法必须放在 loadClass方法中自定义加载的代码之后。

重写loadClass方法还是相对复杂的，需要考虑到各种加载情况。

以下的例子实现了这一过程。

它是一个能直接由.java源文件实现类加载的 加载器：CompilingClassLoader。

就像之前说到的，只需要重写loadClass()方法，用户自定义的加载实现逻辑都在这个方法中。至于代码中的其中的

其他的方法，比如defineClass(String name),findSystemClass(String name)都是由loadClass调用的。

CompilingClassLoader类中还包含了执行对去字节码、编译java文件的方法，都为loadClass()方法所用。

在defineClass()或findSystemClass()执行结束前，可能返回的异常挺多的：NoClassDefFoundError ,ClassNotFoundError , ClassFormatError , UnsupportedClassVersionError , LinkageError , ClassCircularityError , IncompatibleClassChangeError . 详细信息请大家查阅java doc。

代码如下：

CompilingClassLoader.java

<span style="font-size: 16px;">import java.io.*;

/*

A CompilingClassLoader compiles your Java source on-the-fly.  It
checks for nonexistent .class files, or .class files that are older
than their corresponding source code.

*/

public class CompilingClassLoader extends ClassLoader
{
  // Given a filename, read the entirety of that file from disk
  // and return it as a byte array.
  private byte[] getBytes( String filename ) throws IOException {
    // Find out the length of the file
    File file = new File( filename );
    long len = file.length();

    // Create an array that's just the right size for the file's
    // contents
    byte raw[] = new byte[(int)len];

    // Open the file
    FileInputStream fin = new FileInputStream( file );

    // Read all of it into the array; if we don't get all,
    // then it's an error.
    int r = fin.read( raw );
    if (r != len)
      throw new IOException( "Can't read all, "+r+" != "+len );

    // Don't forget to close the file!
    fin.close();

    // And finally return the file contents as an array
    return raw;
  }

  // Spawn a process to compile the java source code file
  // specified in the 'javaFile' parameter.  Return a true if
  // the compilation worked, false otherwise.
  private boolean compile( String javaFile ) throws IOException {
    // Let the user know what's going on
    System.out.println( "CCL: Compiling "+javaFile+"..." );

    // Start up the compiler
    Process p = Runtime.getRuntime().exec( "javac "+javaFile );

    // Wait for it to finish running
    try {
      p.waitFor();
    } catch( InterruptedException ie ) { System.out.println( ie ); }

    // Check the return code, in case of a compilation error
    int ret = p.exitValue();

    // Tell whether the compilation worked
    return ret==0;
  }

  // The heart of the ClassLoader -- automatically compile
  // source as necessary when looking for class files
  public Class loadClass( String name, boolean resolve )
      throws ClassNotFoundException {

    // Our goal is to get a Class object
    Class clas = null;

    // First, see if we've already dealt with this one
    clas = findLoadedClass( name );

    //System.out.println( "findLoadedClass: "+clas );

    // Create a pathname from the class name
    // E.g. java.lang.Object => java/lang/Object
    String fileStub = name.replace( '.', '/' );

    // Build objects pointing to the source code (.java) and object
    // code (.class)
    String javaFilename = fileStub+".java";
    String classFilename = fileStub+".class";

    File javaFile = new File( javaFilename );
    File classFile = new File( classFilename );

    //System.out.println( "j "+javaFile.lastModified()+" c "+
    //  classFile.lastModified() );

    // First, see if we want to try compiling.  We do if (a) there
    // is source code, and either (b0) there is no object code,
    // or (b1) there is object code, but it's older than the source
    if (javaFile.exists() &&
         (!classFile.exists() ||
          javaFile.lastModified() > classFile.lastModified())) {

      try {
        // Try to compile it.  If this doesn't work, then
        // we must declare failure.  (It's not good enough to use
        // and already-existing, but out-of-date, classfile)
        if (!compile( javaFilename ) || !classFile.exists()) {
          throw new ClassNotFoundException( "Compile failed: "+javaFilename );
        }
      } catch( IOException ie ) {

        // Another place where we might come to if we fail
        // to compile
        throw new ClassNotFoundException( ie.toString() );
      }
    }

    // Let's try to load up the raw bytes, assuming they were
    // properly compiled, or didn't need to be compiled
    try {

      // read the bytes
      byte raw[] = getBytes( classFilename );

      // try to turn them into a class
      clas = defineClass( name, raw, 0, raw.length );
    } catch( IOException ie ) {
      // This is not a failure!  If we reach here, it might
      // mean that we are dealing with a class in a library,
      // such as java.lang.Object
    }

    //System.out.println( "defineClass: "+clas );

    // Maybe the class is in a library -- try loading
    // the normal way
    if (clas==null) {
      clas = findSystemClass( name );
    }

    //System.out.println( "findSystemClass: "+clas );

    // Resolve the class, if any, but only if the "resolve"
    // flag is set to true
    if (resolve && clas != null)
      resolveClass( clas );

    // If we still don't have a class, it's an error
    if (clas == null)
      throw new ClassNotFoundException( name );

    // Otherwise, return the class
    return clas;
  }
}</span>

CCLRun.java

<span style="font-size: 16px;">import java.lang.reflect.*;

/*

CCLRun executes a Java program by loading it through a
CompilingClassLoader.

*/

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

    // The first argument is the Java program (class) the user
    // wants to run
    String progClass = args[0];

    // And the arguments to that program are just
    // arguments 1..n, so separate those out into
    // their own array
    String progArgs[] = new String[args.length-1];
    System.arraycopy( args, 1, progArgs, 0, progArgs.length );

    // Create a CompilingClassLoader
    CompilingClassLoader ccl = new CompilingClassLoader();

    // Load the main class through our CCL
    Class clas = ccl.loadClass( progClass );

    // Use reflection to call its main() method, and to
    // pass the arguments in.

    // Get a class representing the type of the main method's argument
    Class mainArgType[] = { (new String[0]).getClass() };

    // Find the standard main method in the class
    Method main = clas.getMethod( "main", mainArgType );

    // Create a list containing the arguments -- in this case,
    // an array of strings
    Object argsArray[] = { progArgs };

    // Call the method
    main.invoke( null, argsArray );
  }
}</span>

Foo.java

<span style="font-size: 16px;">public class Foo
{
  static public void main( String args[] ) throws Exception {
    System.out.println( "foo! "+args[0]+" "+args[1] );
  }
}
</span>

执行如下：

<span style="font-size: 16px;">% java CCLRun Foo arg1 arg2
CCL: Compiling Foo.java...
foo! arg1 arg2
		</span>

具体参见资料

来自IBM DeveloperWorks ：Understanding the Java ClassLoader

这是一篇2001年的文章，是早年java1.1的实现方式。如今的java已经改变了 很多，变得更加人性化，多功能化，鲁棒性也更强了。

java1.2以后的实现

具体参见资料

改版以后，ClassLoader实现了parent-child模型，更好的控制安全性方面的问题。

为了延续parent-first的模式，通常在继承ClassLoader时不用重写loadClass()方法，而是重写findClass()方法。

findClass() ：方法中需要定义如何获取类的字节码，并使用defineClass()完成加载（仅仅加载，没有resolve等步骤）。

对应的有一个findLoadedClass() ，这个方法用来实现对查找当前加载器是否有加载某类。由于findClass是从原来的loadClass方法中抽离的代码，重写也简单很多，省去了开发者对流程控制的很多顾虑。

loadClass()：如果使用parent-first的加载模型，loadClass（）方法是不用重写的。它通过向父亲加载器迭代实现了parent-first的委托关系。每次加载一个类时，先调findLoadedClass()，如果没有找到，则调用父亲加载器的loadClass()，如果找到了就返回Class实例，没有找到则父亲加载器会产生一个ClassNotFoundException，捕捉到这个Exception后，加载器会自己调用findClass()尝试实现对类的加载。如果依然没有成功加载，则产生一个ClassNotFoundException.

控制流程如图：这里显示了一个类未能成功加载所要经历的流程。（来自参考资料http://stackoverflow.com/questions/3544614/how-is-the-control-flow-to-findclass-of）

               A.loadClass()
                    |
                (not-found?) (by findLoadedClass)
                    |
               B.loadClass()
                    |
                (not found?) (by findLoadedClass)
                    |
         systemclassloader.loadClass  (Bs parent, also can be 
                    |                  called classpath classloader)
                    |
                (not found?) (by findLoadedClass)
                    |
        bootstrap classloader.loadClass (the bootstrap classloader, 
                    |                   (this has no parent)
                    |
                (not found?)
                    |
         systemclassloader.findClass  (on system classloader, 
                    |                   will try to "find" class in "classpath")
                    |
                (not found?) ClassNotFoundException
                    |
                B.findClass
                    |
                (not found?) ClassNotFoundException
                    |
                A.findClass
                    |
                 (not found?)
                    |
            ClassNotFoundException

注意，对于extensions class loader ，它的parent加载器是null，因为bootstrap加载器是本地实现的，并非java实现，于是，如何从extension 加载器向上回溯呢？答案如下：

try {
    if (parent != null) {
       c = parent.loadClass(name, false);
    } else {
       c = findBootstrapClassOrNull(name);
    }
} catch (ClassNotFoundException e) {
   // ClassNotFoundException thrown if class not found
     // from the non-null parent class loader
}

这是 ClassLoader的源代码，对于 parent 为null的情况，会直接调用findBootstrapClassOrNull方法尝试用bootstrap加载器加载 。通过源代码，能够很好的理解这里的parent-child 模型了。

另注意对于基于parent-child模型的类加载器实现，都需要定义一个以parent类加载器作为参数的构造函数，以指定父加载器。如果直接调用没有参数的构造函数，则默认制定的是systemclassloader作为parent。

以下为编程实例

下面的例子是我用来实现动态分析java类关系的加载器代码。具体方法是：调用ASM api ， 在加载器中加载类时，修改.class文件中的字节码，加入相应语句，让对象在创建或执行相应指令时，在trace文件中记录自己的行为。不过实现的方式不是重点，重点是使用了自定义的类加载器的实现！

在编码的过程中，我遇到的一个错误是，将需要使用自定义加载器加载的类文件直接放在了eclipse工程中的bin目录下。而这个目录是可以通过appclassloader即systemclassloader找到路径并加载的。根据parent-first的实现，这些类直接被systemclassloader加载了，也就绕过了自定义加载器的处理机制。修改过路径以后没有出现相应问题了。

ASMClassLoader.java

package biaobiaoqi.classLoader;
import java.io.*;

import org.objectweb.asm.ClassReader;
import org.objectweb.asm.ClassWriter;

import biaobiaoqi.asm.*;


public class ASMClassLoader extends ClassLoader
{
	String basePath ;
	
	/**reference to System Classloader as the parent class loader
	 * @param path <br> the path of .class files will be loaded
	 */
	public ASMClassLoader(String path){
		basePath = path ;
	}
 
	/**
	 * reference to parent as it's parent classloader
	 * @param path
	 * @param parent
	 */
	public ASMClassLoader(String path , ClassLoader parent){
		super(parent);
		basePath = path ;
	}

	@Override
	public Class findClass(String name) throws ClassNotFoundException{
		System.out.println("findClass");
		byte[] raw;
		try {
			raw = getBytesFromBasePath( name );
		} catch (IOException e) {
			e.printStackTrace();
			throw new ClassNotFoundException();
		}
	
		byte[] transformed = instrumentBtyeCode(raw);
	 	/*
		try{
	 		FileOutputStream file = new FileOutputStream( "/home/biaobiaoqi/" +name.replace( '.', '/' )+".class");
	 		file.write( transformed);
	 		file.close();
	 	}
		catch (IOException e) {
			e.printStackTrace();
		}
		*/
		if (transformed == null){
			throw new ClassNotFoundException();
		}
	  
		
		return defineClass(name, transformed, 0, transformed.length );
	}
  
	private byte[] getBytesFromBasePath( String className ) throws IOException ,ClassNotFoundException{
		String fileStub = className.replace( '.', '/' );
		String classFileName = basePath +fileStub+".class";
		File file = new File( classFileName );
		
		long len = file.length();
		byte raw[] = new byte[(int)len];
		FileInputStream fin = new FileInputStream( file );
		
		int r = fin.read( raw );
		if (r != len)
			throw new IOException( "Can't read all, "+r+" != "+len );
		
		fin.close();
		return raw;
	}
	
	private byte[] instrumentBtyeCode(byte[] raw){
	  	ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
  		ASMClassAdapter mca = new ASMClassAdapter(cw); 
  		ClassReader cr = new ClassReader(raw);
  		cr.accept(mca, 0);
  		return cw.toByteArray();
	}	
	
	@Override
	public Class loadClass( String name, boolean resolve )
		throws ClassNotFoundException {
		System.out.println("loadClass_resolve");
		  return super.loadClass(name ,resolve);
	}
	
	
	@Override
	public Class loadClass( String name )
		throws ClassNotFoundException {
		System.out.println("loadClass");
		  return super.loadClass(name );
	}
	
	 // The heart of the ClassLoader -- automatically compile
	/*  // source as necessary when looking for class files
	  public Class loadClass( String name, boolean resolve )
	      			throws ClassNotFoundException {
		
	    Class clas = null;
	    clas = findLoadedClass( name );
	    String fileStub = name.replace( '.', '/' );
	    
	    //TODO setting paths to the bin directory in the eclipse project
	    String classFilename = "./bin/"+fileStub+".class";
	    File classFile = new File( classFilename );
	    
		
	    if (classFile.exists() && !name.endsWith("Trace")){  //instrument the codes except for Trace.class
		    try {
		    	byte[] raw = getBytesFromBasePath( name );
		    	byte[] transformed = instrumentBtyeCode(raw);
		    	//for test
		    	try{
					FileOutputStream file = new FileOutputStream(classFilename);
					file.write( cw.toByteArray());
					file.close();
				}
				catch(FileNotFoundException ex)
				{
					System.out.println("FileNotFoundException : " + ex);
				}

				clas = defineClass( name, transformed, 0, transformed.length );
				
		    } catch( IOException ie ) {
		    }
	    }
	    

	    if (clas==null) {
	    	clas = findSystemClass( name );
	    }

	    if (resolve && clas != null)
	      resolveClass( clas );

	    if (clas == null)
	      throw new ClassNotFoundException( name );

	    return clas;
	  }*/
	
}