Java的类加载机制

重新做人
151 阅读14分钟

概述

虚拟机将描述类的数据从Class文件加载到内存，并对数据进行校验，转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，就是虚拟机的类加载机制。

在Java语言中，类型的加载，连接和初始化过程都是在程序运行期间完成的，即动态加载，动态连接。

类加载时机

类从被加载到虚拟机内存开始，到卸载出内存为止，类的整个生命周期包括：加载，验证，准备，解析，初始化，使用和卸载。其中验证，准备，解析三阶段统称为连接。

image.png

虚拟机规范中没有对什么时候开始类加载进行强制约束，但是对于初始化阶段，虚拟机规范则严格规定了有且只有5种情况必须立即对类进行“初始化”

  1. 遇到new，getstatic，putstatic，invokestatic这4条字节码指令时，如果类没有进行过初始化，则需要先触发其初始化。分别对应的场景如下：

    • new：使用new关键字实例化对象的时候
    • getstatic，putstatic：读取或设置一个类的静态字段（被final修饰，已在编译期将结果放入常量池的静态字段除外）
    • invokestatic：调用一个类的静态方法的时候

  2. 使用java.lang.reflect包的方法对类进行反射调用时，如果类没有进行过初始化，则需要先触发其初始化。

  3. 当初始化一个类时，如果其父类没有进行过初始化，则需要先触发其父类的初始化。对于接口在初始化时，并不要求其父接口全部初始化，只有在真正使用到父类接口时才会初始化。

  4. 当虚拟机启动时，用户需要指定一个要执行的主类，虚拟机会先初始化这个主类

  5. 使用动态语言的特殊场景

这5种场景称为对一个类的主动引用，除此以外，所有引用类的方式都不会触发初始化，举例说明主动引用和备用引用的区别。

静态代码块：static声明，JVM加载类时，仅执行一次
构造代码块：类中用{}定义，每次创建对象时执行

执行顺序：
  无继承：静态代码块 —-> 构造代码块 —-> 构造方法
  有继承：父类静态代码块 —->子类静态代码块 —->父类构造代码块，构造函数 —->子类构造代码块，构造函数

主动引用

  1. 当虚拟机启动时，用户需要指定一个要执行的主类，虚拟机会先初始化这个主类 
    public class A {
    static {
        System.out.println("A");
    }
    public static void main(String[] args){
    }
}

//输出
A
  2. 使用new关键字实例化对象的时候 
    class B{
    static{
        System.out.println("B");
    }
}
public class A {
    public static void main(String[] args) {
        B b = new B();
    }
}

// 输出
B
  3. 读取或设置一个类的静态字段 
    class B{
    public static int b = 100;
    static {
        System.out.println("B");
    }
}
public class A {

    public static void main(String[] args){
        System.out.println(B.b);
    }
}

//输出
B
100
  4. 当初始化一个类时，如果其父类没有进行过初始化，则需要先触发其父类的初始化 
    class B{
    static {
        System.out.println("B");
    }
}
public class A extends B{
    static {
        System.out.println("A");
    }
    public static void main(String[] args){

    }
}

//输出
B
A

被动引用

  1. 对于静态字段，只有直接定义这个字段的类才会被初始化，因此通过子类引用父类的静态字段，只会触发父类的初始化，而不会触发子类的初始化 
    class B{
    public static int b = 100;
    static {
        System.out.println("B");
    }
}
class C extends B{
    static {
        System.out.println("C");
    }
}
public class A{
    public static void main(String[] args){
        System.out.println(C.b);
    }
}

//输出
B
100
  2. 通过数组定义来引用类，不会触发类的初始化 
    class B{
    static {
        System.out.println("B");
    }
}
public class A{
    public static void main(String[] args){
        B[] bs = new B[10];
    }
}

//无输出
  3. 在编译阶段通过常量传播优化，已经将常量值存储到调用类的常量池中，本质上并没有直接引用到定义常量的类，因此不会触发定义常量的类的初始化。 
    class B{
    public static final int b = 100;
    static {
        System.out.println("B");
    }
}
public class A{
    public static void main(String[] args){
        System.out.println(B.b);
    }
}

//输出
100

类加载过程

加载

在加载阶段，虚拟机需要完成3件事情

  1. 通过一个类的全限定名（包名+类型）来获取此类的二进制字节流
  2. 将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构
  3. 在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个可类的各种数据的访问入口

加载阶段由类加载器完成，可以通过定义自己的类加载器控制字节流的获取方式。而对于数组类，其不通过类加载器创建，而是由Java虚拟机直接创建的。数组类的创建过程遵循以下规则：

  • 数组的组件类型为引用类型，则通过递归的方式，按照上述的类加载流程加载该组件类型，而数组将在加载该组件类型的类加载器的类名称空间上被标识。
  • 数组的组件类型不是引用类型（例如int[]数组），Java虚拟机将会把数组C标记为与引导类加载器关联
  • 数组类的可见性与它的组件类型可见性一致，如果组件类型不是引用类型，那数组类的可见性默认为public

验证

验证是连接阶段的第一步，这一阶段的目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身安全。

验证阶段大致完成下面4个阶段的检验工作

  1. 文件格式验证：验证字节码是否符合Class文件格式规范

    该验证阶段主要目的是保证输入的字节流能正确地解析并存储于方法区之内，格式上符合描述一个java类型信息的要求。该阶段的验证是基于二进制字节流进行的，只有通过了这个阶段地验证后，字节流才会进入内存的方法区中进行存储，后面的3个阶段全部是基于方法区的存储结构进行的，不会再直接操作字节流。

  2. 元数据验证：对字节码描述的信息进行语义分析

  3. 字节码验证：主要目的是通过数据流和控制流分析，确定程序语义是合法的，符合逻辑的

  4. 符号引用验证：最后一个阶段的校验发生在虚拟机将符号引用转化为直接引用时，该转化发生在连接的第三阶段解析阶段。符号引用验证可以看做是对类自身以外（常量池中的各种符号引用）的信息进行匹配性校验。

准备

准备阶段时正式为类变量分配内存并设置类变量初始值的阶段，这些变量所使用的内存都将在方法区中进行匹配。

  • 进行内存分配的仅包括类变量，而不包括实例变量，实例变量将在对象实例化时随着对象一起分配在Java堆中
  • 初始值为数据类型的零值（常量要初始化为对应的值）

解析

解析阶段是虚拟机将常量池内的符号引用替换为直接引用的过程

  • 符号引用：符号引用以一组符号来描述引用的目标，符号可以是任何形式的字面量，只要使用时能无歧义的定位到目标即可。
  • 直接引用：直接引用可以是指向目标的指针，相对偏移量或是一个能间接定位到目标的句柄。

初始化

到了初始化阶段，才真正开始执行类中定义的java程序代码。

初始化阶段是执行类构造器< clinit >()方法的过程，对< clinit >的要求有如下

  1. 方法由编译器自动收集类中的所有类变量的赋值动作和静态语句块（static{}块）中的语句合并产生，编译器收集的顺序是由语句在源文件中出现的顺序所决定的，静态语句块中只能访问到定义在静态语句块之前的变量，定义在它之后的变量，在前面的静态语句块可以赋值，但不能访问
  2. 方法于类的构造函数不同，它不需要显示地调用父类构造器，虚拟机会保证子类的<clinit>()方法执行之前，父类的<clinit>()方法已经执行完毕
  3. 方法对于类和接口来说并不是必须的，如果一个类中没有静态语句块，也没有对变量的赋值操作，则编译器不会生成该方法
  4. 接口中不能使用静态语句块，但仍然有变量初始化的赋值操作，因此也会生成<clinit>方法，但执行接口的方法时，不需要先执行父接口的<clinit>的方法，只有当父接口中定义的变量使用时，父接口的方法才会初始化
  5. 虚拟机会保证一个类的<clinit>方法在多线程环境下正确的执行

类加载器

类与类加载器

对于任意一个类，都需要由它的类加载器和这个类本身一同确立其在java虚拟机中的唯一性，每一个类加载器都拥有一个独立的类命名空间。

3种系统提供的类加载器

  1. 启动类加载器（Bootstrap ClassLoader） ：负责将存放在/lib的类库加载到虚拟机内存中
  2. 扩展类加载器（Extension ClassLoader） ：负责将存放在/lib/ext的类库加载到虚拟机内存中
  3. 应用程序类加载器（Application ClassLoader） ：负责加载用户路径（ClassPath）上所指定的类库

双亲委派模型

类加载器之间的层次关系，称为类加载器的双亲委派模型

双亲委派模型要求除了顶层的启动类加载器外，其余类加载器都应由自己的父类加载器

public class A{
    public static void main(String[] args) {
        ClassLoader loader = A.class.getClassLoader();
        while (loader != null) {
            System.out.println(loader.toString());
            loader = loader.getParent();//获取其父类加载器
        }
    }
}

双亲委派模型的工作过程：

如果一个类的加载器收到类加载请求，它首先不会自己尝试加载这个类，而是把这个请求委派给父类加载器完成，每一个层次的类加载器都是如此，因此所有的加载请求最终都传送到顶层的类加载器中，只有当父类加载器反馈自己无法完成这个请求时（它的搜索范围中没有找到需要的类）时，子加载器才会尝试自己去加载。

好处:

  • 核心类不会被篡改
  • 保证一些特殊类的唯一性，比如java.lang.Object，所有类的父类

双亲委派模型实现逻辑在java.lang.ClassLoader的loadClass()方法中，其过程为：先检查类是否已经被加载过，若没有加载则调用父类加载器的loadClass()方法，若父加载器为空则默认使用启动类加载器加载。如果父类加载失败，抛出ClassNotFoundException异常后，再调用自己的findClass()方法进行加载。

protected Class<?> loadClass(String name, boolean resolve)
    throws ClassNotFoundException
{
    synchronized (getClassLoadingLock(name)) {
        // 检查类是否被加载过
        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) {
               // 父类加载器加载失败，抛出异常
            }

            if (c == null) {
                // 父类加载失败，再调用本身的findClass方法加载
                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;
    }
}

类隔离

类隔离原理

在了解类隔离之前，先了解以下有关类加载的原理：

  1. 类加载器和类本身确认一个类的唯一性

    对于任意一个类，都由它的类加载器和这个类本身一同确立其在java虚拟机中的唯一性。即使两个类来源于同一个Class文件，被同一个虚拟机加载，只要加载它们的类加载器不同，那这两个类必定不相等。注意，这里的类加载器是指类加载实例，并不是一定要定义多个不同的类加载器。

  2. 类加载传导规则

    JVM会选择当前类的类加载器来加载所有该类的引用的类。例如我们定义了A和B两个类，类A引用类B，只要我们使用自定义的类加载器加载类A，那么在运行时，当类A调用到类B的时候，类B也会被JVM使用类A 的类加载器加载。

  3. 继承ClassLoader类即可实现自己的类加载器

    Java中ClassLoader中的loadClass()实现了双亲委派逻辑，findClass()实现了类加载器加载类的逻辑，defineClass()实现了定义类的逻辑。因此如果覆盖findClass()方法就可以实现自定义的类加载过程，例如从自定义的路径、压缩包中加载类；如果覆盖loadClass()方法，则可以打破双亲委派机制。

基于上述理论，通过定义自己的类加载器并覆盖findClass()方法或者loadClass()方法可以实现类隔离。类隔离就是让每个模块使用独立的类加载器来加载，模块就算使用到相同的类也不会互相影响。

类隔离实现

1. 打印类的加载器信息

先自定义两个类A和B，然后打印他们的类加载器信息

public class A {
    private B b = new B();
    public void printClassLoader(){
        System.out.println("A: " + this.getClass().getClassLoader());
        b.printClassLoader();
    }
}

public class B {
    public void printClassLoader(){
        System.out.println("B: " + this.getClass().getClassLoader());
    }
}

public class Main {
    public static void main(String[] args) {
        A a = new A();
        a.printClassLoader();
    }
}

// 输出
A: sun.misc.Launcher$AppClassLoader@18b4aac2
B: sun.misc.Launcher$AppClassLoader@18b4aac2

因为Main是由应用类加载器AppClassLader加载的，并且Main中引用了A，A引用了B，则A和B也均由AppClassLoader加载。

2. 实现loadClass()自定义类加载器

自定义类加载器MyClassLoader，覆盖findClass()实现，定义类的加载过程，但不打破双亲委派机制。然后在Main方法中加载类A，再通过反射的方式调用A的printClassLoader()方法。

public class A {
    private B b = new B();
    public void printClassLoader(){
        System.out.println("A: " + this.getClass().getClassLoader());
        b.printClassLoader();
    }
}

public class B {
    public void printClassLoader(){
        System.out.println("B: " + this.getClass().getClassLoader());
    }
}

自定义类加载器MyClassLoader覆盖findClass()方法，首先通过文件读取数据转为byte，然后再使用defineClass()定义类。

public class MyClassLoader extends ClassLoader {

    private Map<String, String> classPathMap = new HashMap<>();

    public MyClassLoader(){
        classPathMap.put("A", "test\out\production\Test\ClassLoaderTest\A.class");
        classPathMap.put("B", "test\out\production\Test\ClassLoaderTest\B.class");
    }

    @Override
    public Class<?> findClass(String name) throws ClassNotFoundException {
        String classPath = classPathMap.get(name);
        File file = new File(classPath);
        if (!file.exists()) {
            throw new ClassNotFoundException();
        }
        byte[] classBytes = getClassData(file);
        if (classBytes == null || classBytes.length == 0) {
            throw new ClassNotFoundException();
        }
        return defineClass(classBytes, 0, classBytes.length);
    }

    private byte[] getClassData(File file) {
        try (InputStream ins = new FileInputStream(file); ByteArrayOutputStream classBytes = new
                ByteArrayOutputStream()) {
            byte[] buffer = new byte[4096];
            int bytesNumRead = 0;
            while ((bytesNumRead = ins.read(buffer)) != -1) {
                classBytes.write(buffer, 0, bytesNumRead);
            }
            return classBytes.toByteArray();
        } catch (FileNotFoundException  e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return new byte[] {};
    }
}

在Main方法中加载类A，再通过反射的方式调用A的printClassLoader()方法。

public class Main {
    public static void main(String[] args) throws Exception {
        MyClassLoader myClassLoader = new MyClassLoader();
        Class aClass = myClassLoader.findClass("A");
        Object object = aClass.newInstance();
        Method mainMethod = aClass.getDeclaredMethod("printClassLoader");
        mainMethod.invoke(object);
    }
}

// 输出
A: ClassLoaderTest.MyClassLoader@4554617c
B: sun.misc.Launcher$AppClassLoader@18b4aac2

可以看出A是由自定义的类加载器加载的，而B则是AppClassLoader加载器加载的。出现这个的原因是双亲委派机制，先看下B被加载时的堆栈。 image.png 可以看出，A在初始化时，触发了类B的加载，而加载B的正是MyClassLoader，但是因为双亲委派的机制，类B由MyClassLoader的父类加载器加载。

如果想让类B也由自定义的类加载器MyClassLoader加载，可以提前主动加载类B或者覆盖ClassLoad的loadClass()打破双亲委派机制。

3. 提前加载类B

只需要初始化A之前，使用自定义类加载器主动加载类B，则类B的加载器就变成了我们自定义的加载器，实现如下：

public class Main {
    public static void main(String[] args) throws Exception {
        MyClassLoader myClassLoader = new MyClassLoader();
        Class aClass = myClassLoader.findClass("A");
        // 主动加载类B
        myClassLoader.findClass("B");
        Object object = aClass.newInstance();
        Method mainMethod = aClass.getDeclaredMethod("printClassLoader");
        mainMethod.invoke(object);
    }
}

// 输出
A: ClassLoaderTest.MyClassLoader@4554617c
B: ClassLoaderTest.MyClassLoader@4554617c

4. 覆盖loadClass()方法打破双亲委派机制

再以白名单方式指定类由自定义加载器加载和与某类相关的全部类均有自定义加载器加载两种方式验证覆盖loadClass()打破双亲委派模型。

首先定义一个类C，并由A依赖。

public class A {
    private B b = new B();
    private C c = new C();
    public void printClassLoader(){
        System.out.println("A: " + this.getClass().getClassLoader());
        b.printClassLoader();
        c.printClassLoader();
    }
}

public class B {
    public void printClassLoader(){
        System.out.println("B: " + this.getClass().getClassLoader());
    }
}

public class C {
    public void printClassLoader(){
        System.out.println("C: " + this.getClass().getClassLoader());
    }
}
白名单方式指定类由自定义加载器加载

仅让类A和类B由自定义加载器加载，而类C仍然由AppClassLoader加载，在初始化类MyClassLoader时需要传入AppClassLoader。具体实现如下：

import java.io.*;
import java.util.HashMap;
import java.util.Map;

public class MyClassLoader extends ClassLoader {

    private Map<String, String> classPathMap = new HashMap<>();

    private ClassLoader jdkClassLoader;

    public MyClassLoader(ClassLoader classLoader){
        this.jdkClassLoader = classLoader;
        classPathMap.put("A", "D:\Work\Study\Test\out\production\Test\ClassLoaderTest\A.class");
        classPathMap.put("B", "D:\Work\Study\Test\out\production\Test\ClassLoaderTest\B.class");
    }

    @Override
    public Class<?> loadClass(String name) throws ClassNotFoundException {
        // 传入的name是全限定名（包名+类名）
        String simpleName = name.substring(name.lastIndexOf(".")+1);
        if (classPathMap.containsKey(simpleName)){
            String classPath = classPathMap.get(simpleName);
            File file = new File(classPath);
            if (!file.exists()) {
                throw new ClassNotFoundException();
            }
            byte[] classBytes = getClassData(file);
            if (classBytes == null || classBytes.length == 0) {
                throw new ClassNotFoundException();
            }
            return defineClass(classBytes, 0, classBytes.length);
        }else{
            return jdkClassLoader.loadClass(name);
        }
    }

    private byte[] getClassData(File file) {
        try (InputStream ins = new FileInputStream(file); ByteArrayOutputStream classBytes = new
                ByteArrayOutputStream()) {
            byte[] buffer = new byte[4096];
            int bytesNumRead = 0;
            while ((bytesNumRead = ins.read(buffer)) != -1) {
                classBytes.write(buffer, 0, bytesNumRead);
            }
            return classBytes.toByteArray();
        } catch (FileNotFoundException  e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return new byte[] {};
    }
}


public class Main {
    public static void main(String[] args) throws Exception {
        // 获取AppClassLoader类加载器
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        MyClassLoader myClassLoader = new MyClassLoader(classLoader);
        Class aClass = myClassLoader.loadClass("A");
        Object object = aClass.newInstance();
        Method mainMethod = aClass.getDeclaredMethod("printClassLoader");
        mainMethod.invoke(object);
    }
}

// 输出
A: ClassLoaderTest.MyClassLoader@4554617c
B: ClassLoaderTest.MyClassLoader@4554617c
C: sun.misc.Launcher$AppClassLoader@18b4aac2
与某类相关的全部类均有自定义加载器加载

如果类A、类B、类C全由自定义加载器加载，即将和A相关的所有类均由自定义加载器加载，但同时Java的一些基础类不使用自定义加载器。想实现该要求，可以在初始化MyClassLoader时，传入ExtClassLoader类加载器，由ExtClassLoader加载那些基础类，其余的类则由自定义类加载器MyClassLoader加载，具体实现如下：

public class MyClassLoader extends ClassLoader {

    private Map<String, String> classPathMap = new HashMap<>();

    private ClassLoader jdkClassLoader;

    public MyClassLoader(ClassLoader classLoader) {
        this.jdkClassLoader = classLoader;
        classPathMap.put("A", "D:\Work\Study\Test\out\production\Test\ClassLoaderTest\A.class");
        classPathMap.put("B", "D:\Work\Study\Test\out\production\Test\ClassLoaderTest\B.class");
        classPathMap.put("C", "D:\Work\Study\Test\out\production\Test\ClassLoaderTest\c.class");
    }

    @Override
    public Class<?> loadClass(String name) throws ClassNotFoundException {
        // 传入的name是全限定名（包名+类名）
        Class zClass = null;
        try {
            zClass = jdkClassLoader.loadClass(name);
        } catch (Exception e) {
            // 忽略异常
        }
        if (zClass != null) {
            return zClass;
        }

        // 传入的name是全限定名（包名+类名）
        String simpleName = name.substring(name.lastIndexOf(".") + 1);
        String classPath = classPathMap.get(simpleName);
        File file = new File(classPath);
        if (!file.exists()) {
            throw new ClassNotFoundException();
        }
        byte[] classBytes = getClassData(file);
        if (classBytes == null || classBytes.length == 0) {
            throw new ClassNotFoundException();
        }
        return defineClass(classBytes, 0, classBytes.length);
    }

    private byte[] getClassData(File file) {
        try (InputStream ins = new FileInputStream(file); ByteArrayOutputStream classBytes = new
                ByteArrayOutputStream()) {
            byte[] buffer = new byte[4096];
            int bytesNumRead = 0;
            while ((bytesNumRead = ins.read(buffer)) != -1) {
                classBytes.write(buffer, 0, bytesNumRead);
            }
            return classBytes.toByteArray();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return new byte[]{};
    }
}


public class Main {
    public static void main(String[] args) throws Exception {
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader().getParent();
        MyClassLoader myClassLoader = new MyClassLoader(classLoader);
        Class aClass = myClassLoader.loadClass("A");
        Object object = aClass.newInstance();
        Method mainMethod = aClass.getDeclaredMethod("printClassLoader");
        mainMethod.invoke(object);
    }
}

// 输出
A: ClassLoaderTest.MyClassLoader@4554617c
B: ClassLoaderTest.MyClassLoader@4554617c
C: ClassLoaderTest.MyClassLoader@4554617c
avatar
文章
阅读
粉丝