初探Java类加载机制

一、在jdk1.2以后，类加载是通过委托来完成的，这意味着如果 classloader 不能找到类，它会请求父代 classloader 来执行此项任务，所有 classloaders 的根是系统 classloader，它会以缺省方式装入类 -- 即，从本地文件系统。今天我们就来探讨一下在jvm中这些机制是怎样运行的。让我们假设有一个class字节码文件（比如hello.class文件），那么在应用程序中，他是如何被加载进来，并形成一个类对象的呢？我们这篇文章的目的就是为了解释这个问题。

　　在java.lang包里有个classloader类，classloader 的基本目标是对类的请求提供服务。当 jvm 需要使用类时，它根据名称向 classloader 请求这个类，然后 classloader 试图返回一个表示这个类的 class 对象。通过覆盖对应于这个过程不同阶段的方法，可以创建定制的 classloader。其中有个loadclass(string name, boolean resolve)方法，该方法为classloader的入口点，在jdk1.2以后，loadclass方法将缺省调用findclass方法，详细内容可以参考api文档，我们编写的classloader主要就是为了覆盖以上两个方法。回到我们刚才的问题，怎样读进字节码文件，并把它构成一个类对象呢？在classloader里有个方法，class defineclass(string name, byte[] b, int off, int len)，答案就在这里了，我们根据把class字节码文件（如hello.class)读进一个字节数组里，byte[] b,并把它转化为class对象，而这些数据可以来源于文件，网络等，神奇吧:)

　　defineclass管理 jvm 的许多复杂、神秘和倚赖于实现的方面 -- 它把字节码分析成运行时数据结构、校验有效性等等。不必担心，您无需亲自编写它。事实上，即使您想要这么做也不能覆盖它，因为它已被标记成最终的。

　　其他一些方法：

　　findsystemclass方法：从本地文件系统装入文件。它在本地文件系统中寻找类文件，如果存在，就使用 defineclass 将原始字节转换成 class 对象，以将该文件转换成类。

　　findclass方法：jdk1.2以后loadclass 的缺省实现调用这个新方法。findclass 的用途包含您的 classloader 的所有特殊代码，而无需要复制其它代码（例如，当专门的方法失败时，调用系统 classloader）。

　　getsystemclassloader： 如果覆盖 findclass 或 loadclass，getsystemclassloader 使您能以实际 classloader 对象来访问系统 classloader（而不是固定的从 findsystemclass 调用它）。

　　getparent：为了将类请求委托给父代 classloader，这个新方法允许 classloader 获取它的父代 classloader。当使用特殊方法，定制的 classloader 不能找到类时，可以使用这种方法。

　　resolveclass: 可以不完全地（不带解析）装入类，也可以完全地（带解析）装入类。当编写我们自己的 loadclass 时，可以调用 resolveclass，这取决于 loadclass 的 resolve 参数的值。
　　findloadedclass:充当一个缓存,当请求 loadclass 装入类时，它调用该方法来查看 classloader 是否已装入这个类，这样可以避免重新装入已存在类所造成的麻烦。应首先调用该方法。

　　二、工作流程：

　　1)调用 findloadedclass(string) 来查看是否存在已装入的类,如果没有，那么采用那种特殊的神奇方式来获取原始字节。

　　2）通过父类classloader调用loadclass方法，如果父类classloader是null，那么按缺省方式装入类，即系统classloader。

　　3）调用findclass(string)去查找类并获取类；

　　4）如果loadclass 的 resolve 参数的值为true，那么调用 resolveclass 解析 class 对象.

　　5）如果还没有类，返回 classnotfoundexception。

　　6）否则，将类返回给调用程序。

　　三、一个实现了classloader的例子：

　　/**
　　*compilingclassloader.java
　　*copyright 2005-2-12
　　*/
　　import java.io.*;

　　public class compilingclassloader extends classloader{
　　//读取一个文件的内容
　　private byte[] getbytes(string filename) throws ioexception{
　　file file=new file(filename);
　　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 boolean compile(string javafile) throws ioexception{
　　system.out.println("ccl:compiling "+javafile+"...");
　　//调用系统的javac命令
　　process p=runtime.getruntime().exec("javac "+javafile);
　　try{
　　//其他线程都等待这个线程完成
　　p.waitfor();
　　}catch(interruptedexception ie){
　　system.out.println(ie);
　　}
　　int ret=p.exitvalue();

　　return ret==0;
　　}

　　public class loadclass(string name,boolean resovle) throws classnotfoundexception{
　　class clas=null;

　　clas=findloadedclass(name);

　　//这里说明了包的表示
　　string filestub=name.replace('.','/');

　　string javafilename=filestub+".java";
　　string classfilename=filestub+".class";

　　file javafile=new file(javafilename);
　　file classfile=new file(classfilename);

　　//如果存在class文件就不编译
　　if(javafile.exists()&&(!classfile.exists()||javafile.lastmodified()>classfile.lastmodified())){
　　try{
　　　if(!compile(javafilename)||!classfile.exists()){
　　　　throw new classnotfoundexception("classnotfoundexcetpion:"+javafilename);
　　　}
　　}catch(ioexception ie){
　　　throw new classnotfoundexception(ie.tostring());
　　}
　　}

　　try{
　　byte[] raw=getbytes(classfilename);

　　//通过读入数据来构造一个类结构，这是核心
　　clas=defineclass(name,raw,0,raw.length);
　　}catch(ioexception ie){
　　//
　　}

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

　　system.out.println("findsystemclass:"+clas);

　　if(resovle && clas!=null){
　　resolveclass(clas);
　　}

　　if(clas==null){
　　throw new classnotfoundexception(name);
　　}

　　return clas;
　　}
　　}
　　测试该loader：
　　/**
　　*testrun.java
　　*copyright 2005-2-11
　　*/
　　import java.lang.reflect.*;

　　public class testrun{
　　public static void main(string[] args) throws exception{
　　string progclass=args[0];

　　string progargs[]=new string[args.length-1];
　　system.arraycopy(args,1,progargs,0,progargs.length);

　　compilingclassloader ccl=new compilingclassloader();

　　class clas=ccl.loadclass(progclass);

　　//返回一个class的type
　　class[] mainargtype={(new string[0]).getclass()};
　　method main=clas.getmethod("main",mainargtype);

　　object argsarray[]={progargs};

　　main.invoke(null,argsarray);

　　}
　　}

　　以上的核心内容已经编写完了，编译后，我们得到两个文件：

　　compilingclassloader.class,testrun.class

　　四、编写一个例子，然后运行我们的classloader

　　/**
　　*hello.java
　　*/
　　public class hello{
　　public static void main(string[] args){
　　if(args.length!=1){
　　　system.err.println("error,exit!");
　　　system.exit(1);
　　}
　　string name=args[0];
　　system.out.println("hello,"+name);
　　}
　　}

　　好了，运行java testrun hello 阿飞

　　....
　　....
　　....
　　hello,阿飞