JVM-01.JVM类加载机制

思维导图：点击查看思维导图.
类加载的过程：
加载： 在硬盘上通过IO读取字节码文件，使用类时才会进行加载。在内存中生成一个代表这个类的 java.lang.Class 对象，作为方法区这个类的各种数据的访问入口
验证： 验证格式是否正确、是否符合Java语言规范等
准备： 给类的静态变量分配内存，并赋默认值（非指定的值）
解析： 将符号引用替换为直接引用（内存地址）的过程。
该阶段会把一些静态方法（符号引用）替换为数据所在内存的指针或句柄等（直接引用）：即静态链接过程（类加载期间完成），动态链接程序运行期间将符号引用替换为直接引用
初始化： 对类的静态变量初始化为指定的值，执行静态代码块
使用
卸载： 执行了 System.exit() 方法，程序正常执行结束，执行过程遇到异常或错误而异常终止，操作系统错误导致 JVM 进程终止
程序正常执行结束

类加载器（实质是类）
引导类加载器BootStrapClassLoader：加载支撑 JVM 运行的位于 JRE 的 lib 目录下的核心类库（ C++生成对象）
扩展类加载器ExtClassLoader：加载支撑JVM运行的位于lib目录下的ext 扩展目录中的 jar 包
应用程序加载器AppClassLoader：加载 ClassPath 路径下的类包，主要加载我们自己编写的类
自定义加载器：加载用户自定义路径下的类

双亲委派模型
向上委派：实际是查找缓存，是否加载类该类，有则直接返回，没有继续向上
向下查找：委派到顶层后，缓存中没有，查找加载路径，有则加载返回，没有则继续向下查找

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;
    }
}

双亲委派模型源码解析

1. 检查指定名称的类是否被加载过，如果加载过直接返回
2. 该类没有被加载过，判断是否有父加载器，如果有则由父加载器加载（调用 parent.loadClass(name,false)），或者直接调用 bootStrapClassLoader 来加载
3. 如果父加载器和 bootStrapClassLoader 加载器都没有找到指定的类，则调用当前类加载器的 findClass() 方法来加载

设置双亲委派机制的好处：
沙箱安全机制：自己写的 java.lang.String.class 类不会被加载，这样便可以防止核心 API 库被随意篡改
避免类的重复加载：当父亲已经加载了该类时，就没有必要子 ClassLoader 再加载一次，保证被加载类的唯一性

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());
    }
}

打破双亲委派机制
1.在自定义加载器中重写 loadClass() 方法
2.JAVA 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(clazz1.getClassLoader());
}
// 重新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文件。
附：