JVM-3. 类加载器

字节码加载以及面向对象怎么往内存中塞，代码都要转化为java的类，被jvm加载到虚拟机中执行。加载的过程在类的生命周期中非常重要。

类的生命周期

前5步（加载、验证、准备、解析、初始化）统称为类加载。

1. 加载：找class文件。在文件系统中找class文件，找不到二进制classfile格式的就会抛出NoClassDefFound错误。

2. 校验：验证格式、依赖。

   校验过程检查 classfile 的语义，判断常量池中的符号，并执行类型检查， 主要目的是判断字节码的合法性，比如 magic number, 对版本号进行验证。

3. 准备：静态字段、方法表

   创建静态字段，将其初始化为标准的默认值（比如0或者null），分配方法表（在方法区中分配这些变量所使用的内存空间）

   请注意，准备阶段并未执行任何 Java 代码。

   例如：

   public static int i = 1；

   在准备阶段i的值会被初始化为 0，后面在类初始化阶段才会执行赋值为 1；但是下面如果使用 final 作为静态常量，某些 JVM 的行为就不一样了：

   public static final int i = 1； 对应常量 i，在准备阶段就会被赋值 1，其实这样还是比较 puzzle，例如其他语言（C#）有直接的常量关键字 const，让告诉编译器在编译阶段就替换成常量，类似于宏指令，更简单。

4. 解析：符号解析为引用。

   也就是解析常量池，主要有以下四种：类或接口的解析、字段解析、类方法解析、接口方法解析。

   简单的来说就是我们编写的代码中，当一个变量引用某个对象的时候，这个引用在 .class 文件中是以符号引用来存储的（相当于做了一个索引记录）。

   在解析阶段就需要将其解析并链接为直接引用（相当于指向实际对象）。如果有了直接引用，那引用的目标必定在堆中存在。

   加载一个 class 时, 需要加载所有的 super 类和 super 接口。

5. 初始化：构造器、静态变量赋值、静态代码块

6. 使用

7. 卸载

类的加载时机

哪些情况下会有类的加载行为呢？

1. 当虚拟机启动时，初始化用户指定的主类，就是启动执行的 main 方法所在的类；
2. 当遇到用以新建目标类实例的 new 指令时，初始化 new 指令的目标类，就是 new 一个类的时候要初始化；
3. 当遇到调用静态方法的指令时，初始化该静态方法所在的类；
4. 当遇到访问静态字段的指令时，初始化该静态字段所在的类；
5. 子类的初始化会触发父类的初始化；
6. 如果一个接口定义了 default 方法，那么直接实现或者间接实现该接口的类的初始化，会触发该接口的初始化；
7. 使用反射 API 对某个类进行反射调用时，初始化这个类，其实跟前面一样，反射调用要么是已经有实例了，要么是静态方法，都需要初始化；
8. 当初次调用 MethodHandle 实例时，初始化该 MethodHandle 指向的方法所在的类。

不会初始化

1. 通过子类引用父类的静态字段，只会触发父类的初始化，而不会触发子类的初始化。class a{static b} class aa extend a 使用a.b 和aa.b
2. 定义对象数组，不会触发该类的初始化。
3. 常量在编译期间会存入调用类的常量池中，本质上并没有直接引用定义常量的类，不会触发定义常量所在的类。
4. 通过类名获取 Class 对象，不会触发类的初始化，Hello.class 不会让 Hello 类初始化。
5. 通过 Class.forName 加载指定类时，如果指定参数 initialize 为 false 时，也不会触发类初始化，其实这个参数是告诉虚拟机，是否要对类进行初始化。Class.forName(“jvm.Hello”)默认会加载 Hello 类。
6. 通过 ClassLoader 默认的 loadClass 方法，也不会触发初始化动作（加载了，但是不初始化）。

示例: 诸如 Class.forName(), classLoader.loadClass() 等 Java API, 反射API, 以及 JNI_FindClass 都可以启动类加载。 JVM 本身也会进行类加载。 比如在 JVM 启动时加载核心类，java.lang.Object, java.lang.Thread 等等。

三类加载器

1. 启动类加载器（BootstrapClassLoader）

   加载Java的核心类，用原生C++实现的，并不继承自java.lang.ClassLoader（负责加载JDK中jre/lib/rt.jar里所有的class）。rt.jar中都是jvm系统的类，常见的java.lang、java.util。

2. 扩展类加载器（ExtClassLoader）

   负责加载JRE的扩展目录，jdk可以配置扩展类路径。lib/ext或者由java.ext.dirs系统属性指定目录中的jar包的类，代码里直接获取他的父类加载器为null（因为无法拿到启动类加载器）

3. 应用类加载器（AppClassLoader）

   加载我们自己写的业务类

加载器特点：

1. 双亲委托

   当一个自定义类加载器需要加载一个类，比如 java.lang.String，它很懒，不会一上来就直接试图加载它，而是先委托自己的父加载器去加载，父加载器如果发现自己还有父加载器，会一直往前找，这样只要上级加载器，比如启动类加载器已经加载了某个类比如 java.lang.String，所有的子加载器都不需要自己加载了。如果几个类加载器都没有加载到指定名称的类，那么会抛出 ClassNotFountException 异常。

2. 负责依赖

   如果一个加载器在加载某个类的时候，发现这个类依赖于另外几个类或接口，也会去尝试加载这些依赖项。

3. 缓存加载

   为了提升加载效率，消除重复加载，一旦某个类被一个类加载器加载，那么它会缓存这个加载结果，不会重复加载。

自定义ClassLoader

// todo 暂时用不到，先跳过了，以后来补充

添加引用类的几种方式

1. 放到JDK的lib/ext下，或者-Djava.ext.dirs

2. java -cp/classpath或者class文件放到当前路径

3. 自定义ClassLoader加载，可以从任何地方读取字节码。

4. 拿到当前执行类的ClassLoader，反射调用addUrl方法添加Jar或者路径（JDK9无效）

   public class JvmAppClassLoaderAddURL {
       public static void main(String[] args) {
           String appPath = "file:/d:app/";
           URLClassLoader urlClassLoader = (URLClassLoader) JvmAppClassLoaderAddURL.class.getClassLoader();
           try {
               Method addUrl = URLClassLoader.class.getDeclaredMethod("addURL", URL.class);
               addUrl.setAccessible(true);
               URL url = new URL(appPath);
               addUrl.invoke(urlClassLoader, url);
               Class.forName("jvm.Hello"); // 效果根Class.forName("jvm.Hello").newInstance()一样
           } catch (Exception e) {
               e.printStackTrace();
           }
       }
   }
   

   jdk9之后更简单，直接用一行搞定使用Class.forName(类名，要不要初始化, new ClassLoader("file:/d:app/")) 直接代替上边的main方法的这么多行代码。

常见问题

1. 显示当前ClassLoader加载了哪些jar

​ 有时候我们明明已经把某个jar加入到了环境里，可以运行的时候还是找不到。可以直接看到各个类加载器加载了哪些jar

代码如下

package jvm;

import java.lang.reflect.Field;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;

public class JvmClassLoaderPrintPath {

    public static void main(String[] args) {

        // 启动类加载器
        URL[] urls = sun.misc.Launcher.getBootstrapClassPath().getURLs();
        System.out.println("启动类加载器");
        for(URL url : urls) {
            System.out.println(" ==> " +url.toExternalForm());
        }

        // 扩展类加载器
        printClassLoader("扩展类加载器", JvmClassLoaderPrintPath.class.getClassLoader().getParent());

        // 应用类加载器
        printClassLoader("应用类加载器", JvmClassLoaderPrintPath.class.getClassLoader());

    }

    public static void printClassLoader(String name, ClassLoader CL){
        if(CL != null) {
            System.out.println(name + " ClassLoader -> " + CL.toString());
            printURLForClassLoader(CL);
        }else{
            System.out.println(name + " ClassLoader -> null");
        }
    }

    public static void printURLForClassLoader(ClassLoader CL){

        Object ucp = insightField(CL,"ucp");
        Object path = insightField(ucp,"path");
        ArrayList ps = (ArrayList) path;
        for (Object p : ps){
            System.out.println(" ==> " + p.toString());
        }
    }

    private static Object insightField(Object obj, String fName) {
        try {
            Field f = null;
            if(obj instanceof URLClassLoader){
                f = URLClassLoader.class.getDeclaredField(fName);
            }else{
                f = obj.getClass().getDeclaredField(fName);
            }
            f.setAccessible(true);
            return f.get(obj);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

2. 怎么看到加载了哪些类，以及加载顺序？

只需要在类的启动命令行参数加上-XX:+TraceClassLoading 或者 -verbose 即可，注意需要加载 Java 命令之后，要执行的类名之前，不然不起作用。例如：

java -XX:+TraceClassLoading jvm.HelloClassLoader 

就能看到类的加载先后顺序，以及是从哪个 jar 里加载的。