类加载器负责将 Java 类文件加载到 Java 虚拟机。
只有当类被加载进虚拟机内存，才能使用对应的类。
在 Java 中，类加载过程大概分为以下几步：
- 通过全限类名获取类文件字节数组。可来自本地文件、jar 包、网络等。
- 在方法区/元空间保存类的描述信息、静态属性。
- 在 JVM 堆中生成一个对应的 java.lang.Class 对象。
具体的加载过程为：
加载：在硬盘上查找并通过IO读入字节码文件，使用到类时才会加载，例如调用类的 main() 方法，new 对象等等，在加载阶段会在内存中生成一个代表这个类的 java.lang.Class 对象，作为方法区这个类的各种数据的访问入口。
验证：校验字节码文件的正确性。
准备：给类的静态变量分配内存，并赋予默认值。
解析：将符号引用替换为直接引用，该阶段会把一些静态方法(符号引用，比如 main() 方法)替换为指向数据所存内存的指针或句柄等(直接引用)，这是所谓的静态链接过 程(类加载期间完成)，动态链接是在程序运行期间完成的将符号引用替换为直接引用。
初始化：对类的静态变量初始化为指定的值，执行静态代码块。
Java 默认提供三个类加载器，分别为：
- Bootstrap ClassLoader
- Extension ClassLoader
- App ClassLoader
Bootstrap ClassLoader 负责加载Java基础类，主要是 %JRE_HOME%/lib/ 目录下的rt.jar、resources.jar、charsets.jar等。
Extension ClassLoader 负责加载Java扩展类，主要是 %JRE_HOME%/lib/ext 目录下的jar。
App ClassLoader 负责加载当前应用的ClassPath中的所有类。
类加载器加载的流程如下：
先简单的打印一下默认的加载器：
public class Hello {
public static void main(String[] args) {
ClassLoader classLoader = Hello.class.getClassLoader();
System.out.println(classLoader.getParent().getParent());
System.out.println(classLoader.getParent());
System.out.println(classLoader);
}
}
打印结果为：
null
sun.misc.Launcher$ExtClassLoader@61bbe9ba
sun.misc.Launcher$AppClassLoader@18b4aac2
由于引导类加载器由 c++ 实现 故为 null（加载器之间不是真正的继承关系）
类加载器初始化过程：
创建 JVM 启动器实例 sun.misc.Launcher。
sun.misc.Launcher 初始化使用了单例模式设计，保证一个 JVM 虚拟机内只有一个 sun.misc.Launcher 实例。
public Launcher() {
Launcher.ExtClassLoader var1;
try {
var1 = Launcher.ExtClassLoader.getExtClassLoader(); // 创建扩展类加载器
} catch (IOException var10) {
throw new InternalError("Could not create extension class loader", var10);
}
try {
this.loader = Launcher.AppClassLoader.getAppClassLoader(var1); // 创建应用类加载器，并把自己的parent引用指向扩展类加载器
} catch (IOException var9) {
throw new InternalError("Could not create application class loader", var9);
}
...其它代码省略
}
在Launcher构造方法内部，其创建了两个类加载器，分别是Launcher.ExtClassLoader (扩展类加载器) 和 Launcher.AppClassLoader (应用类加载器)。
JVM 默认使用 Launcher 的 getClassLoader() 方法返回的类加载器 AppClassLoader 的实例加载我们的应用程序。
双亲委派机制
加载器在加载某个类时会先委托父加载器寻找目标类，找不到再委托上层父加载器加载，如果所有父加载器在自己的加载类路径下都找不到目标类，则在自己的类加载路径中查找并载入目标类。部分实现如下：
protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
synchronized (getClassLoadingLock(name)) {
// First, check if the class has already been loaded
Class<?> c = findLoadedClass(name);
if (c == null) {
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
}
if (c == null) {
// If still not found, then invoke findClass in order
// to find the class
c = findClass(name);
}
}
if (resolve) {
resolveClass(c);
}
return c;
}
}
为什么要设计双亲委派机制？
沙箱安全机制：自己写的 java.lang.String.class 类不会被加载，这样便可以防止核心 API库被随意篡改。
避免类的重复加载：当父亲已经加载了该类时，就没有必要子 ClassLoader 再加载一 次，保证被加载类的唯一性。
若想打破双亲加载机制，重写此加载方法，实现自己的加载逻辑，不委派给双亲加载即可。
全盘负责委托机制
“全盘负责”是指当一个 ClassLoder 装载一个类时，除非显示的使用另外一个 ClassLoder ，该类所依赖及引用的类也由这个 ClassLoder 载入。
自定义类加载器
自定义类加载器则可以实现额外的需求，例如：
从网络文件加载类。
从任意目录加载类。
对字节码文件做加密处理，由自定义类加载器做解密。
下面是继承了 URLClassLoader 的一个简单自定义类加载器
public class MyClassLoader extends URLClassLoader {
private String classPath;
public MyClassLoader(URL[] urls){
super(urls);
}
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, MalformedURLException {
File file = new File("/opt"); // 自定义的加载根目录
URL[] URLs = new URL[] {file.toURI().toURL()};
MyClassLoader myClassLoader = new MyClassLoader(URLs);
Class<?> aClass = myClassLoader.loadClass("com.app.Hello"); // java文件的具体地址
Object object = aClass.newInstance(); // 通过反射来调用对象里的方法
Method method = aClass.getDeclaredMethod("sayHello", String.class);
method.invoke(object, "lilei");
System.out.println(object.getClass().getClassLoader().getParent());
System.out.println(object.getClass().getClassLoader());
}
}
打印结果为：
hello lilei
sun.misc.Launcher$AppClassLoader@18b4aac2
com.app.MyClassLoader@61bbe9ba
URLClassLoader 类中主要帮我们实现了 ClassLoader 的 findClass 方法，实现代码如下：
protected Class<?> findClass(final String name)
throws ClassNotFoundException
{
final Class<?> result;
try {
result = AccessController.doPrivileged(
new PrivilegedExceptionAction<Class<?>>() {
public Class<?> run() throws ClassNotFoundException {
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;
}
}
}, acc);
} catch (java.security.PrivilegedActionException pae) {
throw (ClassNotFoundException) pae.getException();
}
if (result == null) {
throw new ClassNotFoundException(name);
}
return result;
}
实现自定义类加载器的主要步骤为：
继承 ClassLoader 类。如果只是从目录或者jar包加载类，也可以选择继承 URLClassLoader 类。
重写 findClass 方法。
在重写的 findClass 方法中，无论用何种方法，获取类文件对应的字节数组，然后调用 defineClass 方法转换成类实例。
需要注意下，即使自己自定义了类加载器，并重写了 loadClass 方法打破双亲委派机制，也无法篡改 java 核心类，最后来看一下 ClassLoader 中 defineClass 的部分校验代码：
private ProtectionDomain preDefineClass(String name, ProtectionDomain pd) {
if (!checkName(name))
throw new NoClassDefFoundError("IllegalName: " + name);
// 防止篡改其核心类
if ((name != null) && name.startsWith("java.")) {
throw new SecurityException
("Prohibited package name: " +
name.substring(0, name.lastIndexOf('.')));
}
if (pd == null) {
pd = defaultDomain;
}
if (name != null) checkCerts(name, pd.getCodeSource());
return pd;
}
