一,什么是类加载器?

虚拟机设计团队把类加载阶段中的"通过一个类的全限定名来获取描述此类的二进制字节流"这个动作放到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类的一些重要方法

五,自定义类加载器实现

继承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