Java中的所有的java都需要先编译成class文件，再通过类加载器来加载class，在前几篇的热修复的文章都提到了ClassLoader，趁着周末就写了这篇关于Java ClassLoader的文章，希望能对热修复的相关的知识进行补充。为了更好查看源码，本文是基于Java 7的源码来分析的，如有不正取请扔砖告知。

ClassLoader

什么是ClassLoader

在java的源码中，官方是这么给出定义的:

A class loader is an object that is responsible for loading classes. Theclass ClassLoader is an abstract class.Given the binary name of a class,a class loader should attempt to locate or generate data that constitutes a definition for the class. A typical strategy is to transform the name intoa file name and then read a “class file” of that name from a file system.

意思就是：

class loader 是一个负责加载class的对象，ClassLoader 类是一个抽象类。

若是给出一个类的二进制文件，class loader就会尝试定位到相关的位置或者生成这个类的数据。

一个典型的策略是把二进制名字转换成文件名，然后从文件系统中读取这个文件名的class file。

ClassLoader分类

Java应用环境中不同的class分别由不同的ClassLoader负责加载。从一个JVM启动到加载咱们的主程序入口，以下ClassLoader是必须要加载的。

Bootstrap ClassLoader 负责加载java基础类，主要是 %JRE_HOME/lib/ 目录下的rt.jar、resources.jar、charsets.jar和class等
Extension ClassLoader 负责加载java扩展类，主要是 %JRE_HOME/lib/ext 目录下的jar和class
App ClassLoader 负责加载当前java应用的classpath中的所有类。
Custom ClassLoader 当然由于类加载器也是可以自己定义，因为ClassLoader是一个抽象类。

当我们去load一个class时，会经历这么曲折的路程：

为什么加载一个class需要这么麻烦，直接加载不就行了么？
这就是我们下面将要提到的ClassLoader的双亲委托模型。

ClassLoader的双亲委托模型

在介绍之前我们还是先来看下ClassLoader中一个很重要的方法：

    protected Class<?> loadClass(String name, boolean resolve) {
        ……

         try {
               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
                }

          ……

}

好了，上代码尝试打印下看看parent是何方神圣吧:

public static void main(String[] args) {
        ClassLoader mClassLoader = Main.class.getClassLoader();
        while (mClassLoader != null) {
            System.out.println(mClassLoader);
            mClassLoader = mClassLoader.getParent();
        }
    }

输出结果:

Launcher$AppClassLoader 就是加载项目文件的ClassLoader，ExtClassLoader是AppClassLoader的parent。

在加载一个class时，他会先去他的parent的ClassLoader有没有，实在没有才调用'findBootstrapClassOrNull.
这就是我们要说的ClassLoader的双亲委托模型
在上图介绍中, 先委托父类装载器寻找目标类，只有在找不到的情况下才从自己的类路径中查找并装载目标类。
可是为什么需要这种双亲委托模型呢，我们不是说好的import呢？

关于自定义ClassLoader

说了这么多ClassLoader,就是为了更好的使用，由于一些特殊的需求，我们可能需要定制ClassLoader，这时候就需要自定义ClassLoader了.

还记得不，ClassLoader是一个抽象类，当继承ClassLoader时，我们可以重写一些方法。主要可以扩展的方法有：

findClass 定义查找Class的方式
defineClass 将类文件字节码加载为jvm中的class
findResource 定义查找资源的方式

好了，翠花上代码，自己用了20分钟写了一个自定义的ClassLoader，里面有注释就不再一一解释了。

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;

/**
 * @Author: cyning
 * @Desc : 加载本地的文件
 */
public class CustomClassLoader extends ClassLoader {
    private String rootUrl;

    public CustomClassLoader(String rootUrl) {
        this.rootUrl = rootUrl;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        Class clazz = null;//this.findLoadedClass(name); // 父类已加载
        byte[] classData = getClassData(name);  //根据类的二进制名称,获得该class文件的字节码数组
        if (classData == null) {
            throw new ClassNotFoundException();
        }
        clazz = defineClass(name, classData, 0, classData.length);  //将class的字节码数组转换成Class类的实例
        //}
        return clazz;
    }


    private  byte[]  getClassData(String name) {
        InputStream is = null;
        try {
            String path = classNameToPath(name);
            URL url = new URL(path);
            byte[] buff = new byte[1024*4];
            int len = -1;
            is = url.openStream();
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            while((len = is.read(buff)) != -1) {
                baos.write(buff,0,len);
            }
            return baos.toByteArray();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (is != null) {
                try {
                    is.close();
                } catch(IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return null;
    }

    private   String classNameToPath(String name) {
        return rootUrl + "/" + name.replace(".", "/") + ".class";
    }
}

怎么使用呢：

try {
            // 文件路径
            String rootUrl = "/Users/cyning/Downloads";
            CustomClassLoader mCustomClassLoader = new CustomClassLoader(rootUrl);
            String classname = "com.ownwell.Test";
            Class clazz = mCustomClassLoader.loadClass(classname);
            Object object = clazz.newInstance();
            Method mMethod  = clazz.getMethod("add", int.class, int.class);//然后我们就可以用反射做些事情了
            mMethod.invoke(object,1,1);

            //反射调用Test中的add方法
            System.out.println(clazz.getClassLoader());
        } catch (Exception e) {
            e.printStackTrace();
        }

总结

ClassLoader是一个抽象类，对外允许继承。
ClassLoader有自己的双亲委托模型，从下到上层层检查。

Classloader源码探究