类加载的过程
- 加载： 在硬盘上通过 IO 读取字节码文件，使用类时才会进行加载。在内存中生成一个代表这个类的 java.lang.Class 对象，作为方法区中这个类的各种数据的访问入口
- 验证： 验证格式是否正确、是否符合 Java 语言规范等
- 准备： 给类的静态变量分配内存，并赋默认值（非指定的值）
- 解析： 将符号引用替换为直接引用（内存地址）。 该阶段会把一些静态方法（符号引用）替换为数据所在内存的指针或句柄等（直接引用）：即静态链接（类加载期间完成），动态链接程序运行期间将符号引用替换为直接引用
- 初始化： 对类的静态变量初始化为指定的值，执行静态代码块
- 使用
- 卸载： 执行了 System.exit() 方法，程序正常执行结束，执行过程遇到异常或错误而异常终止，操作系统错误导致 JVM 进程终止 程序正常执行结束
类加载器（实质是类）
- 引导类加载器 BootStrapClassLoader：加载支撑 JVM 运行的位于 JRE 的 lib 目录下的核心类库（ C++生成对象）
- 扩展类加载器 ExtClassLoader：加载支撑JVM运行的位于lib目录下的ext 扩展目录中的 jar 包
- 应用程序加载器 AppClassLoader：加载 ClassPath 路径下的类包，主要加载我们自己编写的类
- 自定义加载器：加载用户自定义路径下的类，需要用户编写一个类继承 ClassLoader 类
双亲委派模型
- 向上委派：实际是查找缓存，是否加载类该类，有则直接返回，没有继续向上委派
- 向下查找：委派到顶层后，缓存中没有，查找加载路径，有则加载返回，没有则继续向下查找
public abstract class ClassLoader {
// // The parent class loader for delegation
private final ClassLoader parent;
......
}
AppClassLoader 的 parent 属性是 ExtClassLoader ExtClassLoader 的 parent 属性是 BootStrapClassLoader MyClassLoader 的 parent 属性默认是 AppClassLoader
// 调用自定义ClassLoader先给parent赋值，parent由默认构造方法进行赋值
// ClassLoader的默认构造方法
protected ClassLoader() {
this(checkCreateClassLoader(), getSystemClassLoader());
}
/**
getSystemClassLoader->initSystemClassLoader方法中将parent赋值为
默认的AppClassLoader
sun.misc.Launcher l = sun.misc.Launcher.getLauncher();
scl = l.getClassLoader();
**/
下面是双亲委托模型源码：
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) {
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
}
if (c == null) {
// If still not found, then invoke findClass in order
// to find the class.
long t1 = System.nanoTime();
// 都会调用URLClassLoader::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.loadClass(name,false)），如果到顶层还未被加载，直接调用 bootStrapClassLoader 来尝试加载
- 如果父加载器和 bootStrapClassLoader 加载器都没有找到指定的类，则调用当前类加载器的 findClass() 方法来加载
设置双亲委派机制的好处：
- 沙箱安全机制：自己编写的JAVA核心类库同包同名的类不会被加载，这样便可以防止核心 API 库被随意篡改
- 避免类的重复加载：当父类加载器加载过后，子类加载器就不会再去加载一次
package java.lang;
// 自定义Math类
public class Math {
public static void main(String[] args) {
System.out.println("My Math Class");
}
}
自定义的 java.lang 包下面的 Math 方法中运行时返回的是 JDK 的自己的类，不是我们自定义的类，类中没有 Main 方法。
自定义类加载器
实现自定义类加载器只需要继承 ClassLoader 并重写 findClass() 方法即可，下面是一个简单的自定义类加载器：
/**
* 自定义类加载器
*/
public class MyClassLoaderTest{
static class MyClassLoader extends ClassLoader {
// 类路径
private String classPath;
public MyClassLoader(String classPath) {
this.classPath = classPath;
}
// 重写ClassLoader的findClass方法，ClassLoader类的findClass为空实现
protected Class<?> findClass(String name) throws ClassNotFoundException {
try {
byte[] data = loadByte(name);
//defineClass将一个字节数组转为Class对象，这个字节数组是class文件读取后最终的字节数组
return defineClass(name, data, 0, data.length);
} catch (Exception e) {
e.printStackTrace();
throw new ClassNotFoundException();
}
}
// 读取字节码文件为字节数组
private byte[] loadByte(String name) throws Exception {
name = name.replaceAll("\.", "/");
FileInputStream fileInputStream = new FileInputStream(classPath + File.separator + name + ".class");
int length = fileInputStream.available(); // 返回与之关联文件的字节数
byte[] data = new byte[length];
// 将字节码文件写入data并返回
fileInputStream.read(data);
fileInputStream.close();
return data;
}
}
// 测试
public static void main(String[] args) throws Exception{
// 初始化自定义类加载器，会先初始化parent属性ClassLoader设置为AppClassLoader
MyClassLoader classLoader = new MyClassLoader("E:/test");
// E盘创建文件 E:test/p01/jvm/TestClass.class
Class clazz = classLoader.loadClass("p01.jvm.TestClass");
// 调用加载类中的方法
Object obj = clazz.newInstance();
Method method = clazz.getDeclaredMethod("printMethod", null);
method.invoke(obj, null);
// 该项目下的p01.jvm.TestClass文件需要删除，否则会出现调用的是AppClassLoader
System.out.println(clazz.getClassLoader().getClass().getName());
}
}
打破双亲委派机制
- 方法一：在自定义加载器中重写 loadClass() 方法
- 方法二：SPI（Service Provider Interface）机制
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) {
long t1 = System.nanoTime();
if (!name.startsWith("p01.jvm")) {
c = this.getParent().loadClass(name);
}else {
c = findClass(name);
}
sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
sun.misc.PerfCounter.getFindClasses().increment();
}
if (resolve) {
resolveClass(c);
}
return c;
}
}
public static void main(String[] args) throws Exception {
// 初始化自定义类加载器，会先初始化 parent 属性 ClassLoader设置为 AppClassLoader
MyClassLoader classLoader = new MyClassLoader("E:/test");
// E盘创建文件 E:test/p01/jvm/TestClass.class
Class clazz = classLoader.loadClass("p01.jvm.TestClass");
// 调用加载类中的方法
Object obj = clazz.newInstance();
Method method = clazz.getDeclaredMethod("printMethod", null);
method.invoke(obj, null);
// 该项目下的p01.jvm.TestClass文件需要删除，否则会出现调用的是AppClassLoader
System.out.println(clazz.getClassLoader().getClass().getName());
// 非指定路径，使用JVM的引导类加载器
Class clazz1 = classLoader.loadClass("java.lang.String");
Object obj1 = clazz1.newInstance();
Method method1 = clazz1.getDeclaredMethod("isEmpty", null);
method1.invoke(obj1, null);
System.out.println(clazz.getClassLoader().getClass().getName());
// 重新new一个MyClassLoader
// classLoader = new MyClassLoader("E:/test2");
// Class clazz = classLoader.loadClass("p01.jvm.TestClass");
// 可以加载相同名称的类（与Tocat类似，可以实现加载不同版本的包中的相同类）
}
----------------------------------------------------------
执行结果：
----------------------------------------------------------
我加载了该类！ --> 加载了E盘的class文件
p01.jvm.MyClassLoaderTest$MyClassLoader --> 自定义加载器
true --> 调用的是rt.jar包下的String.class
null --> 引导类加载器
实际应用：
- Tomcat服务器
- mysql-conneator-java--x.x.xx.jar 、Dubbo（SPI机制）
SPI 机制是一种服务发现机制。它通过在 ClassPath 路径下的 META-INF/services 文件夹查找文件，自动加载文件里所定义的类。
Tomcat 里面可能有多个服务，多个服务可能依赖不同的版本的包，每个包要尽量的相互隔离。
Tomcat 服务器 JSP 热部署：jsp 文件加载后就是 class 文件，但是当我们修改后 class 文件并不会改变，每个 jsp 文件都对应一个类加载器，当我们修改后就会卸载该类加载器，重新创建类加载器加载class文件。 附：
