Java类加载机制的深入研究

类加载机制

类加载是Java程序运行的首要步骤，研究类的加载有助于了解JVM执行过程，并指导开发者采取更有效的措施配合程序执行，同时让程序能动态的控制类加载，比如热部署等，提高程序的灵活性和适应性。

类加载过程

Java程序运行的场所是内存。
当在命令行执行java HelloWorld的时候，JVM会将HelloWorld.class加载到内存中，形成一个class对象：HelloWorld.class，具体过程如下：
1.找到jre目录，找到jvm.dll文件，并且初始化JVM
2.产生一个Bootstrap Loader（引导程序，轻量级的应用程序，它定义了应用程序之间想要共享的类）
3.Bootstrap Loader自动加载Extended Loader（标准扩展类加载器），并将其父Loader设为Bootstrap Loader
4.Bootstrap Loader自动加载AppClass Loader（系统类加载器），并将其父Loader设为Extended Loader。
5.最后由AppClass Loader加载HelloWorld类
Bootstrap Loader——>Extended Loader——>AppClass Loader
以上就是类加载的最一般的过程。

类加载器各自搜索的目录

1、Bootstrap Loader（启动类加载器）：加载System.getProperty(“sun.boot.class.path”)所指定的路径或jar。

2、Extended Loader（标准扩展类加载器ExtClassLoader）：加载System.getProperty(“java.ext.dirs”)所指定的路径或jar。在使用Java运行程序时，也可以指定其搜索路径，例如：java -Djava.ext.dirs=d:\projects\testproj\classes HelloWorld

3、AppClass Loader（系统类加载器AppClassLoader）：加载System.getProperty(“java.class.path”)所指定的路径或jar。在使用Java运行程序时，也可以加上-cp来覆盖原有的Classpath设置，例如： java -cp ./lavasoft/classes HelloWorld

ExtClassLoader和AppClassLoader在JVM启动后，会在JVM中保存一份，并且在程序运行中无法改变其搜索路径。如果想在运行时从其他搜索路径加载类，就要产生新的类加载器。

类加载器的特点

1、运行一个程序时，总是由AppClass Loader（系统类加载器）开始加载指定的类。
2、在加载类时，每个类加载器会将加载任务上交给其父，如果其父找不到，再由自己去加载。
3、Bootstrap Loader（启动类加载器）是最顶级的类加载器了，其父加载器为null.

类加载器的获取

看下面例子

public class HelloWorldClass {

    public static void main(String[] args) {
        HelloWorldClass hello = new HelloWorldClass();
        Class c= hello.getClass();
        ClassLoader loader = c.getClassLoader();
        System.out.println("loader:"+loader);
        System.out.println("loader.getParent():"+loader.getParent());
        System.out.println("loader.getParent().getParent():"+loader.getParent().getParent());


    }

}

运行结果：

loader:sun.misc.Launcher$AppClassLoader@47415dbf
loader.getParent():sun.misc.Launcher$ExtClassLoader@1471cb25
loader.getParent().getParent():null

从上面的结果可以看出，并没有获取到ExtClassLoader的父Loader，原因是Bootstrap Loader（启动类加载器）是用C语言实现的，找不到一个确定的返回父Loader的方式，于是就返回null。

类的加载

类加载有三种方式：
1、命令行启动应用时候由JVM初始化加载
2、通过Class.forName()方法动态加载
3、通过ClassLoader.loadClass()方法动态加载
三种方式区别比较大，看个例子就明白了：

public class HelloWorld { 
        public static void main(String[] args) throws ClassNotFoundException { 
                ClassLoader loader = HelloWorld.class.getClassLoader(); 
                System.out.println(loader); 
                //使用ClassLoader.loadClass()来加载类，不会执行初始化块 
                loader.loadClass("Test2"); 
                //使用Class.forName()来加载类，默认会执行初始化块 
//                Class.forName("Test2"); 
                //使用Class.forName()来加载类，并指定ClassLoader，初始化时不执行静态块 
//                Class.forName("Test2", false, loader); 
        } 
}

public class Test2 { 
        static { 
                System.out.println("静态初始化块执行了！"); 
        } 
}

分别切换加载方式，会有不同的输出结果。

自定义ClassLoader

为了说明问题，先看例子：

package test; 

import java.net.MalformedURLException; 
import java.net.URL; 
import java.net.URLClassLoader; 

/** 
* 自定义ClassLoader 
* 
* 
*/ 
public class MyClassLoader {
    public static void main(String[] args) throws MalformedURLException,
            ClassNotFoundException, IllegalAccessException,
            InstantiationException {
        URL url = new URL(
                "file:/E:\\projects\\testScanner\\out\\production\\testScanner");
        ClassLoader myloader = new URLClassLoader(new URL[] { url });
        Class c = myloader.loadClass("test.Test3");
        System.out.println("----------");
        Test3 t3 = (Test3) c.newInstance();
    }
}

public class Test3 {
    static {
        System.out.println("Test3的静态初始化块执行了！");
    }
}

运行后：

Test3的静态初始化块执行了！

Process finished with exit code 0

可以看出自定义了ClassLoader myloader = new URLClassLoader(new URL[]{url});已经成功将类Test3加载到内存了，并通过默认构造方法构造了对象Test3 t3 = (Test3) c.newInstance();

有关ClassLoader还有很重要一点：
同一个ClassLoader加载的类文件，只有一个Class实例。但是，如果同一个类文件被不同的ClassLoader载入，则会有两份不同的ClassLoader实例（前提是着两个类加载器不能用相同的父类加载器）。

引用：
1.love_Javc_you的专栏：深入研究Java类加载机制
2.sysu_2010的专栏：BootStrap Loader