类加载是java语言提供的最强大的机制之一。尽管类加载并不是讨论的热点话题，但所有的编程人员都应该了解其工作机制，明白如何做才能让其满足我们的需要。这能有效节省我们的编码时间，从不断调试classnotfoundexception, classcastexception的工作中解脱出来。

　　类加载是java语言提供的最强大的机制之一。尽管类加载并不是讨论的热点话题，但所有的编程人员都应该了解其工作机制，明白如何做才能让其满足我们的需要。这能有效节省我们的编码时间，从不断调试classnotfoundexception, classcastexception的工作中解脱出来。

　　这篇文章从基础讲起，比如代码与数据的不同之处是什么，他们是如何构成一个实例或对象的。然后深入探讨java虚拟机(jvm)是如何利用类加载器读取代码，以及java中类加载器的主要类型。接着用一个类加载的基本算法看一下类加载器如何加载一个内部类。本文的下一节演示一段代码来说明扩展和开发属于自己的类加载器的必要性。紧接着解释如何使用定制的类加载器来完成一个一般意义上的任务，使其可以加载任意远端客户的代码，在jvm中定义，实例化并执行它。本文包括了j2ee关于类加载的规范――事实上这已经成为了j2ee的标准之一。

　　类与数据

　　一个类代表要执行的代码，而数据则表示其相关状态。状态时常改变，而代码则不会。当我们将一个特定的状态与一个类相对应起来，也就意味着将一个类事例化。尽管相同的类对应的实例其状态千差万别，但其本质都对应着同一段代码。在java中，一个类通常有着一个.class文件，但也有例外。在java的运行时环境中(java runtime)，每一个类都有一个以第一类(first-class)的java对象所表现出现的代码，其是java.lang.class的实例。我们编译一个java文件，编译器都会嵌入一个public, static, final修饰的类型为java.lang.class，名称为class的域变量在其字节码文件中。因为使用了public修饰，我们可以采用如下的形式对其访问:

　　java.lang.class klass = myclass.class;

　　一旦一个类被载入jvm中，同一个类就不会被再次载入了(切记，同一个类)。这里存在一个问题就是什么是“同一个类”?正如一个对象有一个具体的状态，即标识，一个对象始终和其代码(类)相关联。同理，载入jvm的类也有一个具体的标识，我们接下来看。

　　在java中，一个类用其完全匹配类名(fully qualified class name)作为标识，这里指的完全匹配类名包括包名和类名。但在jvm中一个类用其全名和一个加载类classloader的实例作为唯一标识。因此，如果一个名为pg的包中，有一个名为cl的类，被类加载器klassloader的一个实例kl1加载，cl的实例，即c1.class在jvm中表示为(cl, pg, kl1)。这意味着两个类加载器的实例(cl, pg, kl1) 和 (cl, pg, kl2)是不同的，被它们所加载的类也因此完全不同，互不兼容的。那么在jvm中到底有多少种类加载器的实例?下一节我们揭示答案。

　　类加载器

　　在jvm中，每一个类都被java.lang.classloader的一些实例来加载.类classloader是在包中java.lang里，开发者可以自由地继承它并添加自己的功能来加载类。

　　无论何时我们键入java mymainclass来开始运行一个新的jvm，“引导类加载器(bootstrap class loader)”负责将一些关键的java类，如java.lang.object和其他一些运行时代码先加载进内存中。运行时的类在jre\lib\rt.jar包文件中。因为这属于系统底层执行动作，我们无法在java文档中找到引导类加载器的工作细节。基于同样的原因，引导类加载器的行为在各jvm之间也是大相径庭。

　　同理，如果我们按照如下方式:

　　log(java.lang.string.class.getclassloader());

　　来获取java的核心运行时类的加载器，就会得到null。

　　接下来介绍java的扩展类加载器。扩展库提供比java运行代码更多的特性，我们可以把扩展库保存在由java.ext.dirs属性提供的路径中。

　　(编辑注:java.ext.dirs属性指的是系统属性下的一个key，所有的系统属性可以通过system.getproperties()方法获得。在编者的系统中，java.ext.dirs的value是” c:\program files\java\jdk1.5.0_04\jre\lib\ext”。下面将要谈到的如java.class.path也同属系统属性的一个key。)

　　类extclassloader专门用来加载所有java.ext.dirs下的.jar文件。开发者可以通过把自己的.jar文件或库文件加入到扩展目录的classpath，使其可以被扩展类加载器读取。

　　从开发者的角度，第三种同样也是最重要的一种类加载器是appclassloader。这种类加载器用来读取所有的对应在java.class.path系统属性的路径下的类。

　　sun的java指南中，文章“理解扩展类加载”(understanding extension class loading)对以上三个类加载器路径有更详尽的解释，这是其他几个jdk中的类加载器

　　●java.net.urlclassloader
　　●java.security.secureclassloader
　　●java.rmi.server.rmiclassloader
　　●sun.applet.appletclassloader

　　java.lang.thread，包含了public classloader getcontextclassloader()方法，这一方法返回针对一具体线程的上下文环境类加载器。此类加载器由线程的创建者提供，以供此线程中运行的代码在需要加载类或资源时使用。如果此加载器未被建立，缺省是其父线程的上下文类加载器。原始的类加载器一般由读取应用程序的类加载器建立。

　　类加载器如何工作?

　　除了引导类加载器，所有的类加载器都有一个父类加载器，不仅如此，所有的类加载器也都是java.lang.classloader类型。以上两种类加载器是不同的，而且对于开发者自订制的类加载器的正常运行也至关重要。最重要的方面是正确设置父类加载器。任何类加载器，其父类加载器是加载该类加载器的类加载器实例。(记住，类加载器本身也是一个类!)

　　使用loadclass()方法可以从类加载器中获得该类。我们可以通过java.lang.classloader的源代码来了解该方法工作的细节，如下:

protected synchronized class<?> loadclass
    (string name, boolean resolve)
    throws classnotfoundexception{

    // first check if the class is already loaded
    class c = findloadedclass(name);
    if (c == null) {
        try {
            if (parent != null) {
                c = parent.loadclass(name, false);
            } else {
                c = findbootstrapclass0(name);
            }
        } catch (classnotfoundexception e) {
            // if still not found, then invoke
            // findclass to find the class.
            c = findclass(name);
        }
    }
    if (resolve) {
            resolveclass(c);
    }
    return c;
}

　　我们可以使用classloader的两种构造方法来设置父类加载器:

public class myclassloader extends classloader{

    public myclassloader(){
        super(myclassloader.class.getclassloader());
    }
}

　　或

public class myclassloader extends classloader{

    public myclassloader(){
        super(getclass().getclassloader());
    }
}

　　第一种方式较为常用，因为通常不建议在构造方法里调用getclass()方法，因为对象的初始化只是在构造方法的出口处才完全完成。因此，如果父类加载器被正确建立，当要示从一个类加载器的实例获得一个类时，如果它不能找到这个类，它应该首先去访问其父类。如果父类不能找到它(即其父类也不能找不这个类，等等)，而且如果findbootstrapclass0()方法也失败了，则调用findclass()方法。findclass()方法的缺省实现会抛出classnotfoundexception，当它们继承java.lang.classloader来订制类加载器时开发者需要实现这个方法。findclass()的缺省实现方式如下:

    protected class<?> findclass(string name)
        throws classnotfoundexception {
        throw new classnotfoundexception(name);
    }

　　在findclass()方法内部，类加载器需要获取任意来源的字节码。来源可以是文件系统，url，数据库，可以产生字节码的另一个应用程序，及其他类似的可以产生java规范的字节码的来源。你甚至可以使用bcel (byte code engineering library:字节码工程库)，它提供了运行时创建类的捷径。bcel已经被成功地使用在以下方面:编译器，优化器，混淆器，代码产生器及其他分析工具。一旦字节码被检索，此方法就会调用defineclass()方法，此行为对不同的类加载实例是有差异的。因此，如果两个类加载实例从同一个来源定义一个类，所定义的结果是不同的。

　　java语言规范(java language specification)详细解释了java执行引擎中的类或接口的加载(loading)，链接(linking)或初始化(initialization)过程。

　　图一显示了一个主类称为mymainclass的应用程序。依照之前的阐述，mymainclass.class会被appclassloader加载。 mymainclass创建了两个类加载器的实例:customclassloader1 和 customclassloader2,他们可以从某数据源(比如网络)获取名为target的字节码。这表示类target的类定义不在应用程序类路径或扩展类路径。在这种情况下，如果mymainclass想要用自定义的类加载器加载target类，customclassloader1和customclassloader2会分别独立地加载并定义target.class类。这在java中有重要的意义。如果target类有一些静态的初始化代码，并且假设我们只希望这些代码在jvm中只执行一次，而这些代码在我们目前的步骤中会执行两次――分别被不同的customclassloaders加载并执行。如果类target被两个customclassloaders加载并创建两个实例target1和target2，如图一显示，它们不是类型兼容的。换句话说，在jvm中无法执行以下代码:

　　target target3 = (target) target2;

　　以上代码会抛出一个classcastexception。这是因为jvm把他们视为分别不同的类，因为他们被不同的类加载器所定义。这种情况当我们不是使用两个不同的类加载器customclassloader1 和 customclassloader2，而是使用同一个类加载器customclassloader的不同实例时，也会出现同样的错误。这些会在本文后边用具体代码说明。

　　图1. 在同一个jvm中多个类加载器加载同一个目标类

　　关于类加载、定义和链接的更多解释，请参考andreas schaefer的"inside class loaders."

　　为什么我们需要我们自己的类加载器

　　原因之一为开发者写自己的类加载器来控制jvm中的类加载行为，java中的类靠其包名和类名来标识，对于实现了java.io.serializable接口的类，serialversionuid扮演了一个标识类版本的重要角色。这个唯一标识是一个类名、接口名、成员方法及属性等组成的一个64位的哈希字段，而且也没有其他快捷的方式来标识一个类的版本。严格说来，如果以上的都匹配，那么则属于同一个类。

　　但是让我们思考如下情况:我们需要开发一个通用的执行引擎。可以执行实现某一特定接口的任何任务。当任务被提交到这个引擎，首先需要加载这个任务的代码。假设不同的客户对此引擎提交了不同的任务，凑巧，这些所有的任务都有一个相同的类名和包名。现在面临的问题就是这个引擎是否可以针对不同的用户所提交的信息而做出不同的反应。这一情况在下文的参考一节有可供下载的代码样例，samepath 和 differentversions，这两个目录分别演示了这一概念。

　　图2 显示了文件目录结构，有三个子目录samepath, differentversions, 和 differentversionspush，里边是例子:

　　图2. 文件夹结构组织示例

　　在samepath 中，类version.version保存在v1和v2两个子目录里，两个类具有同样的类名和包名，唯一不同的是下边这行:

    public void fx(){
        log("this = " + this + "; version.fx(1).");
    }

　　v1中，日志记录中有version.fx(1)，而在v2中则是version.fx(2)。把这个两个存在细微不同的类放在一个classpath下，然后运行test类:

　　set classpath=.;%current_root%\v1;%current_root%\v2

　　%java_home%\bin\java test

　　图3显示了控制台输出。我们可以看到对应着version.fx(1)的代码被执行了，因为类加载器在classpath首先看到此版本的代码。

　　图3. 在类路径中samepath测试排在最前面的version 1

　　再次运行，类路径做如下微小改动。

　　set classpath=.;%current_root%\v2;%current_root%\v1

　　%java_home%\bin\java test

　　控制台的输出变为图4。对应着version.fx(2)的代码被加载，因为类加载器在classpath中首先找到它的路径。

　　图4. 在类路径中samepath测试排在最前面的version 2

　　根据以上例子可以很明显地看出，类加载器加载在类路径中被首先找到的元素。如果我们在v1和v2中删除了version.version，做一个非version.version形式的.jar文件，如myextension.jar，把它放到对应java.ext.dirs的路径下，再次执行后看到version.version不再被appclassloader加载，而是被扩展类加载器加载。如图5所示。

　　图5. appclassloader及extclassloader

　　继续这个例子，文件夹differentversions包含了一个rmi执行引擎，客户端可以提供给执行引擎任何实现了common.taskintf接口的任务。子文件夹client1 和 client2包含了类client.taskimpl有个细微不同的两个版本。两个类的区别在以下几行:

    static{
        log("client.taskimpl.class.getclassloader
        (v1) : " + taskimpl.class.getclassloader());
    }

    public void execute(){
        log("this = " + this + "; execute(1)");
    }

　　在client1和client2里分别有getclassloader(v1) 与 execute(1)和getclassloader(v2) 与 execute(2)的的log语句。并且，在开始执行引擎rmi服务器的代码中，我们随意地将client2的任务实现放在类路径的前面。

　　classpath=%current_root%\common;%current_root%\server;

　　%current_root%\client2;%current_root%\client1

　　%java_home%\bin\java server.server

　　如图6，7，8的屏幕截图，在客户端vm，各自的client.taskimpl类被加载、实例化，并发送到服务端的vm来执行。从服务端的控制台，可以明显看到client.taskimpl代码只被服务端的vm执行一次，这个单一的代码版本在服务端多次生成了许多实例，并执行任务。

　　图6. 执行引擎服务器控制台

　　图6显示了服务端的控制台，加载并执行两个不同的客户端的请求，如图7，8所示。需要注意的是，代码只被加载了一次(从静态初始化块的日志中也可以明显看出)，但对于客户端的调用这个方法被执行了两次。

　　图7. 执行引擎客户端 1控制台

　　图7中，客户端vm加载了含有client.taskimpl.class.getclassloader(v1)的日志内容的类taskimpl的代码，并提供给服务端的执行引擎。图8的客户端vm加载了另一个taskimpl的代码，并发送给服务端。

　　图8. 执行引擎客户端 2控制台

　　在客户端的vm中，类client.taskimpl被分别加载，初始化，并发送到服务端执行。图6还揭示了client.taskimpl的代码只在服务端的vm中加载了一次，但这“唯一的一次”却在服务端创造了许多实例并执行。或许客户端1该不高兴了因为并不是它的client.taskimpl(v1)的方法调用被服务端执行了，而是其他的一些代码。如何解决这一问题?答案就是实现定制的类加载器。

　　定制类加载器

　　要较好地控制类的加载，就要实现定制的类加载器。所有自定义的类加载器都应继承自java.lang.classloader。而且在构造方法中，我们也应该设置父类加载器。然后重写findclass()方法。differentversionspush文件夹包含了一个叫做filesystemclassloader的自订制的类加载器。其结构如图9所示。

　　图9. 定制类加载器关系

　　以下是在common.filesystemclassloader实现的主方法:

public byte[] findclassbytes(string classname){

        try{
            string pathname = currentroot +
                file.separatorchar + classname.
                replace('.', file.separatorchar)
                + ".class";
            fileinputstream infile = new
                fileinputstream(pathname);
            byte[] classbytes = new
                byte[infile.available()];
            infile.read(classbytes);
            return classbytes;
        }
        catch (java.io.ioexception ioex){
            return null;
        }
    }

    public class findclass(string name)throws
        classnotfoundexception{

        byte[] classbytes = findclassbytes(name);
        if (classbytes==null){
            throw new classnotfoundexception();
        }
        else{
            return defineclass(name, classbytes,
                0, classbytes.length);
        }
    }

    public class findclass(string name, byte[]
        classbytes)throws classnotfoundexception{

        if (classbytes==null){
            throw new classnotfoundexception(
                "(classbytes==null)");
        }
        else{
            return defineclass(name, classbytes,
                0, classbytes.length);
        }
    }

    public void execute(string codename,
        byte[] code){

        class klass = null;
        try{
            klass = findclass(codename, code);
            taskintf task = (taskintf)
                klass.newinstance();
            task.execute();
        }
        catch(exception exception){
            exception.printstacktrace();
        }
    }

　　这个类供客户端把client.taskimpl(v1)转换成字节数组，之后此字节数组被发送到rmi服务端。在服务端，一个同样的类用来把字节数组的内容转换回代码。客户端代码如下:

public class client{

    public static void main (string[] args){

        try{
            byte[] code = getclassdefinition
                ("client.taskimpl");
            serverintf.execute("client.taskimpl",
                code);
            }
            catch(remoteexception remoteexception){
                remoteexception.printstacktrace();
            }
        }

    private static byte[] getclassdefinition
        (string codename){
        string userdir = system.getproperties().
            getproperty("bytepath");
        filesystemclassloader fscl1 = null;

        try{
            fscl1 = new filesystemclassloader
                (userdir);
        }
        catch(filenotfoundexception
            filenotfoundexception){
            filenotfoundexception.printstacktrace();
        }
        return fscl1.findclassbytes(codename);
    }
}

　　在执行引擎中，从客户端收到的代码被送到定制的类加载器中。定制的类加载器把其从字节数组定义成类，实例化并执行。需要指出的是，对每一个客户请求，我们用类filesystemclassloader的不同实例来定义客户端提交的client.taskimpl。而且，client.taskimpl并不在服务端的类路径中。这也就意味着当我们在filesystemclassloader调用findclass()方法时，findclass()调用内在的defineclass()方法。类client.taskimpl被特定的类加载器实例所定义。因此，当filesystemclassloader的一个新的实例被使用，类又被重新定义为字节数组。因此，对每个客户端请求类client.taskimpl被多次定义，我们就可以在相同执行引擎jvm中执行不同的client.taskimpl的代码。

public void execute(string codename, byte[] code)throws remoteexception{

        filesystemclassloader filesystemclassloader = null;

        try{
            filesystemclassloader = new filesystemclassloader();
            filesystemclassloader.execute(codename, code);
        }
        catch(exception exception){
            throw new remoteexception(exception.getmessage());
        }
    }

　　示例在differentversionspush文件夹下。服务端和客户端的控制台界面分别如图10，11，12所示:

　　图10. 定制类加载器执行引擎

　　图10显示的是定制的类加载器控制台。我们可以看到client.taskimpl的代码被多次加载。实际上针对每一个客户端，类都被加载并初始化。

　　图11. 定制类加载器，客户端1

　　图11中，含有client.taskimpl.class.getclassloader(v1)的日志记录的类taskimpl的代码被客户端的vm加载，然后送到服务端。图12 另一个客户端把包含有client.taskimpl.class.getclassloader(v1)的类代码加载并送往服务端。

　　图12. 定制类加载器，客户端1

　　这段代码演示了我们如何利用不同的类加载器实例来在同一个vm上执行不同版本的代码。

　　j2ee的类加载器

　　j2ee的服务器倾向于以一定间隔频率，丢弃原有的类并重新载入新的类。在某些情况下会这样执行，而有些情况则不。同样，对于一个web服务器如果要丢弃一个servlet实例，可能是服务器管理员的手动操作，也可能是此实例长时间未相应。当一个jsp页面被首次请求，容器会把此jsp页面翻译成一个具有特定形式的servlet代码。一旦servlet代码被创建，容器就会把这个servlet翻译成class文件等待被使用。对于提交给容器的每次请求，容器都会首先检查这个jsp文件是否刚被修改过。是的话就重新翻译此文件，这可以确保每次的请求都是及时更新的。企业级的部署方案以.ear, .war, .rar等形式的文件，同样需要重复加载，可能是随意的也可能是依照某种配置方案定期执行。对所有的这些情况――类的加载、卸载、重新加载……全部都是建立在我们控制应用服务器的类加载机制的基础上的。实现这些需要扩展的类加载器，它可以执行由其自身所定义的类。brett peterson已经在他的文章 understanding j2ee application server class loading architectures给出了j2ee应用服务器的类加载方案的详细说明，详见网站theserverside.com。

　　结要

　　本文探讨了类载入到虚拟机是如何进行唯一标识的，以及类如果存在同样的类名和包名时所产生的问题。因为没有一个直接可用的类版本管理机制，所以如果我们要按自己的意愿来加载类时，需要自己订制类加载器来扩展其行为。我们可以利用许多j2ee服务器所提供的“热部署”功能来重新加载一个新版本的类，而不改动服务器的vm。即使不涉及应用服务器，我们也可以利用定制类加载器来控制java应用程序载入类时的具体行为。ted neward的书server-based java programming中详细阐述java的类加载，j2ee的api以及使用他们的最佳途径。