Java 类的加载，链接，初始化

更多 Java 虚拟机方面的文章，请参见文集《Java 虚拟机》

一个类 Person 从代码到使用：

编译器负责将 Person.java 源文件编译为 Person.class 字节码文件
类加载器 Class Loader 负责将 Person.class 字节码（表现形式为字节数组 byte[]）转换为 JVM 中的 Class 对象
随后 JVM 再利用 Class 对象实例化为 Person 对象

1. 类的加载

1.1 类加载器 Class Loader

作用：

将 .class 文件中的字节码转换为 JVM 中的 Class 对象（不是 Class 的实例）
为 JVM 中相同名称的类创建隔离空间。使得同一名称不同版本的两个 Java 类可以在 JVM 中同时存在，例如 OSGI。
在 JVM 中判断两个类是否相同：类的二进制名称相同并且类加载器相同

类加载器 Class Loader 具有层次组织结构，即每个类加载器都有一个父类加载器，通过 getParent() 可以获得父类加载器。

类加载器 Class Loader 使用代理模式，每个类加载器即可以自己完成 Java 类的定义工作，也可以代理给其他的类加载器来完成。

初始类加载器：启动一个类的加载过程
定义类加载器：负责最终定义这个类。
例如在下面的代码中，A 的定义类加载器负责启动 B 的加载过程：

class A {
    private B b;
}

1.2 类加载器 Class Loader 的加载策略

类加载器在尝试自己去加载某个类之前，会首先代理给父类加载器。当父类加载器在 class path 中找不到对应的 .class 字节码文件时，才会尝试自己加载。
一般的 Java 应用使用该策略。从 ClassLoader 的 loadClass() 方法中可以看出 c = parent.loadClass(name, false);：

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

相反策略，类加载器首先尝试自己去加载某个类，当其在 class path 中找不到对应的 .class 字节码文件时，再代理给父类加载器。
该策略在 Java Web 容器中比较常见。Apache Tomcat 为每个 Application 提供一个独立的类加载器 WebappClassLoader，使得 Application 自己的类的优先级高于 Web 容器提供的类，因此不同的 Application 可以使用不同版本的库。

1.3 JVM 自带的 Class Loader

SystemClassLoader：C++编写，加载核心库 java.*
ExtClassLoader：Java编写，加载扩展库 javax.*
AppClassLoader：Java编写，加载程序所在目录

通过 Thread.currentThread().getContextClassLoader() 获得当前类加载器

public static void main(String[] args) {
    ClassLoader cl = Thread.currentThread().getContextClassLoader();
    System.out.println(cl.toString());

    try {
        Class c = cl.loadClass("jvm.Person");
        System.out.println(c.getClassLoader());
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
}

输出：

sun.misc.LauncherAppClassLoader@75b84c92

1.4 自定义类加载器 Class Loader

继承父类 ClassLoader， ClassLoader 中包含如下方法：

final Class defineClass(String name, byte[] b, int off, int len)
- 将字节码数组转换为 Class 对象
- 该方法不能被 override
final Class findLoadedClass(String name)
- 查找已经加载过的 Class 对象，即 Java 类
- 一个类加载器不会重复加载同一个类
- 该方法不能被 override
Class findClass(String name)
- 根据名称查找并加载 Java 类
- 该方法需要被 override
Class loadClass(String name)
- 根据名称加载 Java 类
- 该方法不能被 override

例如我们可以自定义一个类加载器负责从网络中获取字节码，并转化为 Class 对象。

class MyClassLoader extends ClassLoader {
    protected Class findClass(String name) throws ClassNotFoundException {
        byte[] bytes = new byte[1024];
        // 从 网络中根据 name 读取 字节数组

        // 将字节码数组转换为 Class 对象
        return defineClass(name, bytes, 0, bytes.length);
    }
}

1.5 显示加载 VS 隐式加载

显示加载：
- 通过 Class c = Class.forName("Student");
- 通过 ClassLoader 的 loadClass() 方法，例如：

ClassLoader cl = Thread.currentThread().getContextClassLoader();
Class c = cl.loadClass("Student");

Class.forName() 与 ClassLoader.loadClass() 的区别
隐式加载：通过 new，例如 Student s = new Student("")

2. 类的链接

类的链接：将 Java 类的二进制代码合并到 JVM 的运行状态之中的过程。

包括三个步骤：

验证：确保 Java 类的二进制表示在结构上是合理的
准备：创建静态域并赋值
解析：确保当前类引用的其他类被正确地找到，该过程可能会触发其他类被加载。

关于解析，不同的 JVM 有不同的解析策略，例如：

public class A {
  public void main(String args[]) {
    B b = null;
  }
}

策略1：链接 A 的时候发现引用了 B，因此加载 B
策略2：链接 A 的时候发现引用了 B，但是 B 没有被使用，因此不加载 B。在真正使用 B 时才加载 B，例如 b = new B();

3. 类的初始化

类的初始化：当 Java 类第一次被真正使用的时候，JVM 会负责初始化该类。包括：

执行静态代码块
初始化静态域

注意：是类的初始化，不是对象的初始化。

例如：下面的代码不会初始化类 A，因为 A 没有真正被使用。

public static void main(String[] args) {
    A a;
}

static class A {
    static int i = 10;
    static {
        System.out.println("Init class A");
    }
}

例如：下面的代码会初始化类 A，因为 A 真正被使用，输出 Init class A

public static void main(String[] args) {
    int i = A.i;
}

static class A {
    static int i = 10;
    static {
        System.out.println("Init class A");
    }
}

引用：
Java深度历险（二）——Java类的加载、链接和初始化