【JVM系列】Java类加载器

一、默认类加载器

Java虚拟机中系统默认的类加载器有三个：BootStrap,ExtClassLoader,AppClassLoader

Java类都是被类加载器加载的，ExtClassLoader,AppClassLoader也是Java类，显然它们也需要被加载，所以必然有一个类加载器不是Java类，并且由它来加载ExtClassLoader,AppClassLoader这两个Java类加载器，这个类加载器就是BootStrap，BootStrap是使用C/C++代码写的，已经封装到JVM内核中了,当Java虚拟机启动的时候这个类就会被加载，然后BootStrap会加载ExtClassLoader，并将它的parent赋值为null，表示它的父类加载器是BootStrap，接着加载AppClassLoader，并将它的父类加载器赋值为ExtClassLoader，表示它的父类加载器是ExtClassLoader。

public class ClassLoaderTest {

public static void main(String[] args) {
ClassLoader cl = ClassLoaderTest.class.getClassLoader();
while(cl != null){
System.out.print(cl.getClass().getName()+"->");
cl = cl.getParent();
}
System.out.println(cl);

}

}

sun.misc.Launcher$AppClassLoader->sun.misc.Launcher$ExtClassLoader->null

从上面的执行结果可以很清楚的看出它们之间的关系。null表示加载器为BootStrap，因为它不是Java类，所以获取不到这个ClassLoader，BootStrap的子加载器为ExtClassLoader，ExtClassLoader的子加载器为AppClassLoader，另外，ExtClassLoader和AppClassLoader都是sun.misc.Launcher的内部类。

为什么它有三个默认的加载器，第一个BootStrap肯定是必须的，因为Java类必须被类加载器加载，那么肯定有一个不是Java类的加载器祖先来加载Java类，ExtClassLoader和AppClassLoader都是Java类，它们被定义主要是因为Java类分为很多类别，不同的类别由不同的加载器来加载，也就是为ExtClassLoader和AppClassLoader它们有自己的管辖加载范围。

二、类加载器的委托机制

当Java虚拟机要加载第一个类的时候，到底派出哪个类加载器去加载呢？

(1). 首先当前线程的类加载器去加载线程中的第一个类(当前线程的类加载器：Thread类中有一个get/setContextClassLoader(ClassLoader cl);方法，可以获取/指定本线程中的类加载器)

(2). 如果类A中引用了类B,Java虚拟机将使用加载类A的类加载器来加载类B

(3). 还可以直接调用ClassLoader.loadClass(String className)方法来指定某个类加载器去加载某个类

每个类加载器加载类时，又先委托给其上级类加载器当所有祖宗类加载器没有加载到类，回到发起者类加载器，还加载不了，则会抛出ClassNotFoundException

下面我们来具体看看每个加载器的加载范围和委托过程。



如上图所示： MyClassLoader->AppClassLoader->Ext->ClassLoader->BootStrap.自定定义的MyClassLoader首先会先委托给AppClassLoader,AppClassLoader会委托给ExtClassLoader,ExtClassLoader会委托给BootStrap，这时候BootStrap就去加载，如果加载成功，就结束了。如果加载失败，就交给ExtClassLoader去加载，如果ExtClassLoader加载成功了，就结束了，如果加载失败就交给AppClassLoader加载，如果加载成功，就结束了，如果加载失败，就交给自定义的MyClassLoader1类加载器加载，如果加载失败，就报ClassNotFoundException异常，结束。

三，自定义类加载器和加载过程

自定义类加载器必须继承自ClassLoader类。

在ClassLoader的构造方法中可以指定parent,没有指定的话，就使用默认的parent

protected ClassLoader()

protected ClassLoader(ClassLoader parent)

默认的parent是使用ClassLoader.getSystemClassLoader()来获的，它实际就是AppClassLoader。

也就是说不管我们使用ClassLoader.loadClass还是我们自定义的MyClassLoader.loadClass来加载类，它默认的父加载类都是AppClassLoader。

下面我们来定义一个MyClassLoader，使用MyClassLoader.loadClass来加载指定的类，我们来看看loadClass源码，看看它是执行过程。

public Class<?> loadClass(String name) throws ClassNotFoundException {
return loadClass(name, false);
}

protected Class<?> loadClass(String name, boolean resolve)throws ClassNotFoundException {
//加上锁，同步处理，因为可能是多线程在加载类
synchronized (getClassLoadingLock(name)) {
//检查，是否该类已经加载过了，如果加载过了，就不加载了
Class c = findLoadedClass(name);
if (c == null) {
long t0 = System.nanoTime();
try {
//如果自定义的类加载器的parent不为null,就调用parent的loadClass进行加载类
if (parent != null) {
c = parent.loadClass(name, false);
} else {
//如果自定义的类加载器的parent为null，就调用findBootstrapClass方法查找类，就是Bootstrap类加载器
c = findBootstrapClassOrNull(name);
}
} catch (ClassNotFoundException e) {
// ClassNotFoundException thrown if class not found
// from the non-null parent class loader
}

if (c == null) {
// If still not found, then invoke findClass in order
// to find the class.
long t1 = System.nanoTime();
//如果parent加载类失败，就调用自己的findClass方法进行类加载
c = findClass(name);

// this is the defining class loader; record the stats
sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
sun.misc.PerfCounter.getFindClasses().increment();
}
}
if (resolve) {
resolveClass(c);
}
return c;
}
}

可以看到，如果parent加载类失败，就调用自己的findClass方法进行类加载，下面我们来看看findClass方法。

protected Class<?> findClass(String name) throws ClassNotFoundException {
throw new ClassNotFoundException(name);
}

可以看到它就抛出了一个异常，如果我们希望使用这个类来进行加载，这个方法需要我们进行重写，它的作用就是查找指定位置的class文件，用来进行加载。

找个这个class文件之后，就需要对这个文件进行加载了，使用的是defineClass方法，返回类型为Class。它是一个native方法，不需要重写。

从上面可以看到，这三个方法的执行流程是：loadClass->findClass->defineClass，我们只需要重写findClass方法来查找指定位置的class文件，其他两个方法不需要重写。

下面我们来举个例子：

public class TestDemo {
public static void print() {
System.out.println("Hello World");
}
}

它是被加载的类，它的class文件位于目录：/Users/Documents/workspace/ClassLoaderTest/bin下面。

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;

public class MyClassLoader extends ClassLoader {
//需要加载类.class文件的目录
private String classDir;

//无参的构造方法，用于class.newInstance()构造对象使用
public MyClassLoader(){
}

public MyClassLoader(String classDir){
this.classDir = classDir;
}

protected Class<?> findClass(String name) throws ClassNotFoundException {
//class文件的路径
String classPathFile = classDir + "/" + name + ".class";
try {
FileInputStream fis = new FileInputStream(classPathFile);
ByteArrayOutputStream bos = new ByteArrayOutputStream();
byte[] classByte = bos.toByteArray();
//将字节流变成一个class
return defineClass(classByte,0,classByte.length);
} catch (Exception e) {
e.printStackTrace();
}
return super.findClass(name);

}
}

这个是我们自定义的ClassLoader，用来加载TestDemo类。

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class ClassLoaderTest {

public static void main(String[] args) {
MyClassLoader classLoader = new MyClassLoader("/Users/Documents/workspace/ClassLoaderTest/bin");
try {
Class testDemo = classLoader.loadClass("TestDemo");
Method method = testDemo.getMethod("print", null);
method.invoke(null, null);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (SecurityException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

}

这个类中，我们使用自定义的ClassLoader来加载TestDemo类，并且执行print方法。

三、使用ClassLoader的原因

先说说java中import的作用，import中所引用的类文件有两个特点：

（1）必须存在于本地，当程序运行时如果需要某个类，内部类装载器会自动装载该类。

（2）编译时必须存在，否则会因为找不到引用文件而不能正常编译。

但是有时，我们所需要的类不能满足上面两种条件，例如我们需要动态加载某个类，这个类是从远程服务器上下载下来的，它不参与编译，而是运行时动态调用的，这是我们就需要使用ClassLoader来动态的进行加载。

import是静态导入之后，就可以直接使用某个类，ClassLoader是动态加载某个类之后，然后就可以对该类进行实例化并且使用该类。

一般情况，应用程序不需要创建一个全新的ClassLoader对象，而是使用当前环境已经存在的ClassLoader，因为Java的Runtime环境初始化时，其内部会创建一个ClassLoader对象用来加载Runtime所需的各种Java类。