JVM那些事儿(八)-----类加载器

一,什么是类加载器?

虚拟机设计团队把类加载阶段中的"通过一个类的全限定名来获取描述此类的二进制字节流"这个动作放到Java虚拟机外部去实现,以便让应用程序自己决定如何去获取所需要的类". 实现这个动作的代码模块称为"类加载器".

二,类加载器分类

ClassLoader 在加载类时有一定的层次关系和规则。在 Java 中，有四种类型的类加载器，分别为：BootStrapClassLoader、ExtClassLoader、AppClassLoader 以及用户自定义的 ClassLoader。这四种类加载器分别负责不同路径的类的加载，并形成了一个类加载的层次结构。

BootStrapClassLoader 处于类加载器层次结构的最高层，负责 sun.boot.class.path 路径下类的加载，默认为 jre/lib 目录下的核心 API 或 -Xbootclasspath 选项指定的 jar 包。
ExtClassLoader 的加载路径为 java.ext.dirs，默认为 jre/lib/ext 目录或者 -Djava.ext.dirs 指定目录下的 jar 包加载。
AppClassLoader 的加载路径为 java.class.path，默认为环境变量 CLASSPATH 中设定的值。也可以通过 -classpath 选型进行指定。
用户自定义 ClassLoader 可以根据用户的需要定制自己的类加载过程，在运行期进行指定类的动态实时加载。

loader.png

三,类加载的双亲委派模型

双亲委派模型是某个特定的类加载器在接到加载类的请求时，首先将加载任务委托给父类加载器，父类加载器再委托给父类加载器的父类加载器,依次递归，如果父类加载器可以完成类加载任务，就成功返回；只有父类加载器无法完成此加载任务时，才自己去加载。实现双亲委派模型的在ClassLoader类的loadClass(String name, boolean resolve)方法体现的淋漓尽致

protected Class loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    {
        synchronized (getClassLoadingLock(name)) {
            // 1,检查类是否被加载过
            Class c = findLoadedClass(name);
           // 2,如果加载过则返回,如果没有加载过,则走下面的逻辑
            if (c == null) {
                long t0 = System.nanoTime();
                try {
                    //3,如果存在父类加载器,则委托给父类加载器进行加载,如果不存在父类加载器,则委托给虚拟机的内置类加载器
                    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
                }
                //4,如果委托给的所有父类都不能加载,那么该类加载就是自己加载
                if (c == null) {  
                    long t1 = System.nanoTime();
                    c = findClass(name);
                    sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                    sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                    sun.misc.PerfCounter.getFindClasses().increment();
                }
            }
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }

对于上面的双亲委托思路,在jdk文档的loadClass(String name,boolean resolve)方法也有如下说明:

使用指定的二进制名称来加载类。此方法的默认实现将按以下顺序搜索类：

1,调用 findLoadedClass(String) 来检查是否已经加载类。
2,在父类加载器上调用 loadClass 方法。如果父类加载器为 null，则使用虚拟机的内置类加载器。
3, 调用 findClass(String) 方法查找类。

loader2.png

四,ClassLoader类的一些重要方法

方法	作用
getParent()	返回该类加载器的父类加载器。
loadClass(String name)	加载名称为 name的类，返回的结果是 java.lang.Class类的实例。体现双亲委托机制思想
findClass(String name)	查找名称为 name的类，返回的结果是 java.lang.Class类的实例。一般用于从磁盘,网络读取字节流 ,实现类加载器的时必须要复写的方法
findLoadedClass(String name)	查找名称为 name的已经被加载过的类，返回的结果是 java.lang.Class类的实例。
defineClass(String name, byte[] b, int off, int len)	把字节数组 b中的内容转换成 Java 类，返回的结果是 java.lang.Class类的实例。这个方法被声明为 final的。
resolveClass(Class c)	链接指定的 Java 类。

五,自定义类加载器实现

继承ClassLoader,利用双亲委托模型,实现一个小的自定义类加载器

/**
 * 实现自定义类加载器,满足类加载的双亲委托思想
 * @author zhaolei
 *
 */
public class FooClassLoader extends ClassLoader {
        //class文件的完整路径
        String fileName;
        public FooClassLoader(String fileName){
            super(null);
            this.fileName = fileName;
        }
                
        @Override
        protected Class findClass(String name) throws ClassNotFoundException {
            File classFile = new File(fileName);  
            if(!classFile.exists()){  
                throw new ClassNotFoundException(fileName + " 不存在") ;  
            }  
            
            FileInputStream fis = null;
            try{
                fis = new FileInputStream(fileName);
                byte[] b = new byte[fis.available()];
                fis.read(b);
                return defineClass(name,b,0,b.length);
            }catch(Exception e){
                System.out.println(e.toString());
            }finally{
                if(fis != null){
                    try {
                        fis.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }finally{
                        fis = null;
                    }
                }
            }
            return null;
        }
}

六,java热替换

所谓的热替换,就是在java应用程序运行的过程中, 对其中的某个字节码文件进行替换,然后在无知无觉中新的字节码文件代替旧的字节码文件运行.
例如Foo类public void showMsg()方法循环进行输出"Hello, world", 如果正在的运行程序整体不进行重新的编译和应用重启, 将showMsg()方法输出为"Hello,China",那么我们就可以采用热替换, 就修改后的Foo.java编译,将其新的class文件覆盖旧的class文件即可

但是由于类加载机制的一些特点,将会有如下问题需要考虑?

两个类"相等"
只有来自同一个class文件,且被同一个虚拟机加载,且加载他们的类加载器是同一个,那么这两个类才相等.
由类加载的双亲委托机制可知, 也可以从ClassLoader的loadClass方法可知，对于同一个类加载器实例来说，名字相同的类只能存在一个，并且仅加载一次。不管该类有没有变化，下次再需要加载时，它只是从自己的缓存中直接返回已经加载过的类引用。

综上,我们要实现热替换,就必须要打破类加载的双亲委托机制,也就是说热替换的本质就是破坏类加载的双亲委托机制

小示例如下:
1,将要被加载的类

public class Foo {
    public Foo(){
        
    }
    //热替换输出不同的字符串, 将str改为str="Hello China"
    public void showMsg(){
        String str = "Hello World ";
        System.out.println("Foo showMsg method: "+str);
    }
}

2,破坏双亲委托机制的类加载器

public class Loader  {
    public static void main(String[] args) throws Exception {
        for(;;){
            
            CustomerLoader clzLoader = new CustomerLoader("/Users/code/Loader/bin/Foo.class");
            Class clz = (Class) clzLoader.loadClass("Foo");
            Object foo= clz.newInstance();
            /*Exception in thread "main" java.lang.ClassCastException: Foo cannot be cast to Foo
//          Foo foo=(Foo) clz.newInstance();
            foo.showMsg();
            System.out.println(clz.getClassLoader().toString());
            System.out.println(Foo.class.getClassLoader().toString());
            */
            Method showMsg = clz.getMethod("showMsg") ;  
            showMsg.invoke(foo) ;
            Thread.sleep(2000);
        }
    }

}

class CustomerLoader extends ClassLoader{
    String fileName;
    CustomerLoader(String fileName){
        super(null);
        this.fileName = fileName;
    }
    @Override
    public Class loadClass(String name) throws ClassNotFoundException {
        if(name.contains("java")){
            return super.loadClass(name);
        }
        return findClass(name);
    }
    
    @Override
    protected Class findClass(String name) throws ClassNotFoundException {
        File classFile = new File(fileName);  
        if(!classFile.exists()){  
            throw new ClassNotFoundException(fileName + " 不存在") ;  
        }  
        
        FileInputStream fis = null;
        try{
            fis = new FileInputStream(fileName);
            byte[] b = new byte[fis.available()];
            fis.read(b);
            return defineClass(name,b,0,b.length);
        }catch(Exception e){
            System.out.println(e.toString());
        }finally{
            if(fis != null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }finally{
                    fis = null;
                }
            }
        }
        return null;
    }
}

3,将Foo中的showMsg方法中的str改为 "Hello China",然后仅仅对Foo.java进行编译,然后替换旧的Foo.class,就可以看到热替换的效果了

4,留下一个问题
将Loader类中注释的代码打开,将会抛出一个异常Exception in thread "main" java.lang.ClassCastException: Foo cannot be cast to Foo
异常的信息是Foo不能转换为Foo, 为什么呢? (可以根据上面的类加载机制特点思考)

参考
1,<<深入理解Java虚拟机 JVM高级特性与最佳实践第二版周志明>>
2,http://www.ibm.com/developerworks/cn/java/j-lo-classloader/
3,http://blog.csdn.net/zhoudaxia/article/details/35824249
4,http://blog.csdn.net/is_zhoufeng/article/details/26602689
5,http://tool.oschina.net/apidocs/apidoc?api=jdk-zh