本文和大家聊聊Java类加载器这档子事。
什么是类加载器？
咱们先来给他下一个通俗点的定义：
将java字节码（.class文件）转换成类对象（java.lang.Class），加载到JVM内存。
Java中有哪几种类加载器？
类加载器可分为四种：
Bootstrap ClassLoader：由C++代码实现，加载sun.boot.class.path所指定的目录，或<JAVA_HOME>\lib目录中文件。
Ext ClassLoader：加载系统变量 java.ext.dirs所指定的目录，或<JAVA_HOME>\lib\ext 目录中的文件。
App ClassLoader：加载用户类路径下的文件。
Custom ClassLoader：开发者自己折腾的类加载器，按需进行类文件加载。（例如：网络类加载器，通过网络加载.class文件）
类加载器如何工作？
第一步，类加载器向JVM查询目标对象(请求加载的对象)是否已经加载过，若已经加载过，则直接返回此对象；否则，进行第二步。
第二步，获得当前类加载器的父类加载器，递归执行这一步骤，由下往上，直至到达顶级父类加载器(即Bootstrap ClassLoader)，进行第三步。
第三步，从顶级父类加载器，由上而下，在自己的搜索范围内检索目标对象的类文件(.class)，若检索到，则读取该文件的字节码转换成Class对象到JVM，返回目标对象；否则，抛出ClassNotFoundException。
有读者老爷说了，听你白扯了半天，对类加载器的认知还是不清楚，有没有实质性的东西？下面咱们来点实的。
类加载器的委派模式
从上文中类加载器的工作步骤，可以看出，递归获取父类加载器，由下往上，直达顶级父类加载器，在从顶级父类加载器，自上而下，逐级在自己的搜索范围内检索目标对象类文件，转换成Class对象（若检索到）的这种行为，称为类加载器的委派模式。
描述递归获取父类加载器，由下往上，直达顶级父类加载器的代码如下：
//代码段截取自ClassLoader.loadClass(String name, boolean resolve)
if (c == null) {
long t0 = System.nanoTime();
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
}
描述从顶级父类加载器，自上而下，逐级在自己的搜索范围内检索目标对象类文件，转换成Class对象的代码如下：
//代码段截取自ClassLoader.loadClass(String name, boolean resolve)
if (c == null) {
// If still not found, then invoke findClass in order
// to find the class.
long t1 = System.nanoTime();
c = findClass(name);//在自己的搜索范围内进行检索，若找到，转换成Class对象
.....................................
.....................................
}
if (resolve) {
resolveClass(c);
}
return c;
真正实现类加载的是defineClass方法，代码如下：
//代码段截取自URLClassLoader.findClass(final String name)
String path = name.replace('.', '/').concat(".class");
Resource res = ucp.getResource(path, false);
if (res != null) {
try {
return defineClass(name, res); //执行类加载工作
} catch (IOException e) {
throw new ClassNotFoundException(name, e);
}
} else {
return null;
}
回顾类加载器的委派模式，我们发现，发起类加载请求的类加载器，不一定会最终执行类的加载操作，可能其父类加载器来执行类加载。
发起类加载请求的类加载器称为初始类加载器；完成类加载操作的类加载器称为定义类加载器。（为啥叫定义类加载？因名而得呗-defineClass）
有读者老爷发问了，为什么要设计这种委派模式？
委派模式的作用
个人理解，设计这种委派模式的用意有两点：
第一，避免对象的重复加载
第二，保护Java基础类型的行为
关于第一点，自然不必多说。
对于第二点，咱们设想一下，在没有委派模式的场景中，用户自己编写了一个java.lang.String类，并将其放置在程式的类路径（ClassPath）中，那系统中就存在了多个不同的String类，这使得Java的基础类型的行为无法得到保证，程式也会变得很混乱。
细心的读者可能会从上面的例子中发现，同一个类被两个不同的类加载器加载会出现问题，产生这种问题的原因是什么？在后面的类加载器的隔离性中会进行解释
类加载器的层级结构是怎样的？
如下是类加载器层级示意图：
口说无凭，咱们来验证一下类加载器的层级结构，执行如下代码：
package com.hys;
public class Main {
public static void main(String[] args) {
ClassLoader c1 = User.class.getClassLoader();
System.out.println(c1);
ClassLoader c2 = c1.getParent();
System.out.println(c2);
ClassLoader c3 = c2.getParent();
System.out.println(c3);
}
}
执行结果：
sun.misc.Launcher$AppClassLoader@b4aac2
sun.misc.Launcher$ExtClassLoader@140e19d
null
Process finished with exit code 0
执行结果符合咱们的预期。
有读者老爷发问了，怎么就符合预期了？结果中有个值为null，是个啥？Bootstrap ClassLoader呢？
原因在于顶级类加载器是Bootstrap ClassLoader，此加载器是C++代码编写，所以，使用Java获取的时候，返回了null
类加载器的隔离性
JVM如何判断一个类的唯一性？
JVM通过加载该类的类加载器和类名称来确定一个类的唯一性。
这意味着我们使用两个不同的类加载器加载同一个类，而在JVM层面上却认为这是两个完全不同的类，从另一个层面看，相当于类被类加载器所包裹与另个类加载器中的类进行了隔离。
如何证明这种隔离的存在？执行如下代码：
package com.hys;
public class Main {
public static void main(String[] args) {
try{
User u1 = new User();
User u2 = new User();
// u1和u2都是同一个类加载器加载的
System.out.println("The same classloader: u1.isInstance(u2)" + u1.getClass().isInstance(u2));
MyClassLoader c1 = new MyClassLoader();
Class clazz = c1.loadClass("com.hys.User");
// clazz是MyClassLoader类加载器加载的
System.out.println("The different classloader: clazz.isInstance(u1)" + clazz.isInstance(u1));
}catch (Exception ex){
ex.printStackTrace();
}
}
}
执行结果：
The same classloader: u1.isInstance(u2)true
The different classloader: clazz.isInstance(u1)false
Process finished with exit code 0
自定义类加载器
自定义类加载器，一般是继承ClassLoader类，覆盖findClass(String name)方法，在此方法中做查询与读取.class文件的操作，如下代码：
package com.hys;
import java.io.*;
public class MyClassLoader extends ClassLoader {
private String mRootDir;
public MyClassLoader() {
}
public MyClassLoader(String rootDir) {
mRootDir = rootDir;
}
protected Class<?> findClass(String name) throws ClassNotFoundException {
byte[] data = loadClassData(name);
if (data == null) {
throw new ClassNotFoundException();
}else{
return defineClass(name, data, 0, data.length);
}
}
private byte[]loadClassData(String className) {
String path = classNameToPath(className);
try {
InputStream ins = new FileInputStream(path);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
int bufferSize = 4096;
byte[] buffer = new byte[bufferSize];
int bytesNumRead = 0;
while ((bytesNumRead = ins.read(buffer)) != -1) {
baos.write(buffer, 0, bytesNumRead);
}
return baos.toByteArray();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
private String classNameToPath(String className) {
String classPath;
if(mRootDir == null || mRootDir.isEmpty())
classPath = className.replace('.', File.separatorChar) + ".class";
else
classPath = mRootDir + File.separatorChar + className.replace('.', File.separatorChar) + ".class";
return classPath;
}
}
我是青岚之峰，如果读完后觉的有所收获，欢迎点赞加关注
