一文读懂Java虚拟机类加载机制

阅读提示：本文较长，建议关注、收藏后再看。

Java虚拟机的类加载过程包括加载、连接和初始化三个阶段。

1. 加载（Loading）

类的加载是指从文件系统或网络中读取字节码文件，并将其转换为Java虚拟机内部使用的数据结构，以在运行时内存中生成一个表示此类的java.lang.Class对象。
加载阶段的具体步骤如下：

• 通过类的全限定名查找字节码文件。
• 将字节码文件的数据读取到内存，并形成Java虚拟机内部使用的数据结构。
• 在内存中生成一个java.lang.Class对象，作为方法区中表示此类的数据结构。

2. 连接（Linking）

连接阶段包括验证、准备和解析三个步骤。

2.1 验证（Verification）

验证阶段确保被加载的类满足Java虚拟机规范的要求，包括以下几个方面的验证：

• 文件格式验证：验证字节码文件是否符合Java class文件规范。
• 元数据验证：对字节码描述的信息进行语义分析，保证其符合Java虚拟机规范。
• 字节码验证：通过对字节码进行数据流和控制流分析，确保其语义正确性。
• 符号引用验证：验证符号引用中通过符号引用访问目标是否有效。

2.2 准备（Preparation）

准备阶段为类变量（静态变量）分配内存并设置默认初始值，这里将分配的内存初始化为零值。这里不包括对常量的初始化，常量的初始化将在初始化阶段进行。

2.3 解析（Resolution）

解析阶段是将常量池中的符号引用替换为直接引用的过程。符号引用指的是引用一个类或接口的全限定名、方法的名称和描述符等，而直接引用指的是内存中的地址值。Java虚拟机可以提供三种解析方式：类或接口的解析、字段解析和调用方法的解析。

3. 初始化（Initialization）

初始化阶段是类加载过程的最后一步，它是类加载过程的触发点，也是执行类构造器<clinit>()方法的步骤。在类的初始化阶段，虚拟机会按照以下顺序执行：

• 如果类的直接父类还没有被初始化，则先触发其初始化。
• 执行类的静态变量赋值语句和静态代码块，按照代码在源文件中的顺序执行。
• 执行类的构造器<clinit>()方法，包括静态变量的显式赋值和静态代码块中的语句。

以上是Java虚拟机的类加载过程，通过加载、连接和初始化三个阶段，将类加载到内存中，并进行验证、准备和解析等操作，最后执行初始化阶段的相关代码，使类能够被正确执行和使用。

在实际工作中，如何利用Java的类加载机制来解决问题

在实际工作中，可以利用Java的类加载机制来解决一些动态加载类的问题。例如，如果需要根据不同的配置文件来加载不同的类，可以通过利用类加载机制来实现。

首先，可以定义一个抽象的接口，表示所有配置文件要加载的类需要实现的操作：

public interface Processor {
    void process();
}

然后，可以创建两个具体的类实现该接口，分别表示不同的配置文件中要加载的类：

public class ConfigAProcessor implements Processor {
    @Override
    public void process() {
        System.out.println("Processing using Config A...");
    }
}

public class ConfigBProcessor implements Processor {
    @Override
    public void process() {
        System.out.println("Processing using Config B...");
    }
}

接下来，可以创建一个类加载器，通过读取配置文件的信息来动态加载具体的类。假设的配置文件是一个 properties 文件，其中保存了要加载的类的全限定名：

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class ConfigurableClassLoader extends ClassLoader {
    private Properties properties;

    public ConfigurableClassLoader(String configFile) {
        properties = new Properties();
        try (InputStream is = new FileInputStream(configFile)) {
            properties.load(is);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public Processor createProcessor() throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        String className = properties.getProperty("class");
        Class<?> processorClass = Class.forName(className);
        return (Processor) processorClass.newInstance();
    }
}

最后，可以使用这个类加载器来加载具体的类并进行操作：

public class Main {
    public static void main(String[] args) {
        ConfigurableClassLoader classLoader = new ConfigurableClassLoader("config.properties");
        try {
            Processor processor = classLoader.createProcessor();
            processor.process();
        } catch (ClassNotFoundException | IllegalAccessException | InstantiationException e) {
            e.printStackTrace();
        }
    }
}

运行上述代码，假设 config.properties 文件的内容为 class=ConfigBProcessor，那么输出结果将是：

Processing using Config B...

通过利用Java的类加载机制，们可以根据配置文件的不同来动态加载不同的类，从而解决了需要动态加载类的问题。

Java虚拟机中，类加载器的类型

1. 启动类加载器（Bootstrap ClassLoader）：它是虚拟机的一部分，负责加载JDK的核心类库，如java.lang包中的类。它是虚拟机的内置类加载器，由本地代码实现。

2. 扩展类加载器（Extension ClassLoader）：它负责加载Java的扩展类库，即在JRE的lib/ext目录下的jar包。它是由sun.misc.Launcher$ExtClassLoader实现的，并继承自ClassLoader类。

3. 应用程序类加载器（Application ClassLoader）：也称为系统类加载器，它负责加载应用程序classpath上指定的类库。它由sun.misc.Launcher$AppClassLoader实现，并继承自ClassLoader类。

除了以上三种常见的类加载器，用户还可以自定义类加载器。用户自定义的类加载器需要继承自抽象类ClassLoader，并实现findClass()方法。

类加载器之间的关系和区别

1. 类加载器之间形成了一个层次结构，以父子关系存在。启动类加载器位于最顶端，它没有父加载器，但它能加载核心类库。扩展类加载器和应用程序类加载器都有一个共同的父加载器，即启动类加载器。

2. 当需要加载一个类时，虚拟机会先让启动类加载器尝试加载。如果加载不成功，扩展类加载器会尝试加载。如果仍然加载不成功，应用程序类加载器会尝试加载。如果所有的加载器都无法加载该类，则会抛出ClassNotFoundException。

3. 类加载器之间的顶级父加载器是启动类加载器，它由C++代码实现，不是Java类。因此，在虚拟机中，原生的Java类加载器都继承自ClassLoader类，而这个类是由启动类加载器加载的。

类加载器的类型包括启动类加载器、扩展类加载器和应用程序类加载器，它们按照父子关系形成了一个层次结构。它们根据加载类的特定规则来尝试加载类，最终如果无法加载则抛出ClassNotFoundException。

自定义类Java加载器

在Java中可以通过继承ClassLoader类来自定义类加载器。自定义类加载器需要重写findClass()方法，在该方法中实现自定义的类加载逻辑，并调用defineClass()方法加载类的字节码。

以下是一个简单的自定义类加载器的示例：

public class MyClassLoader extends ClassLoader {
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        // 自定义类加载逻辑
        byte[] bytes = loadClassBytes(name);
        return defineClass(name, bytes, 0, bytes.length);
    }

    private byte[] loadClassBytes(String name) {
        // 从文件、网络等地方获取类的字节码
        // 省略具体实现
        return null;
    }
}

自定义类加载器的使用场景：

1. 实现类加载的特殊需求：例如实现热部署、动态更新等功能，可以通过自定义类加载器在加载类时自定义加载逻辑。
2. 安全性增强：可以通过自定义类加载器来控制哪些类可以被加载、从哪些位置加载等，实现类加载的安全性保护。
3. 加载非标准的类文件格式：有些特殊的类文件格式可能无法被默认的类加载器加载，可以借助自定义类加载器来实现加载。
4. 加载加密/混淆的类：可以通过自定义类加载器来解密/解混淆类字节码，然后再加载到Java虚拟机中。

自定义类加载器可以根据不同的需求来实现各种特殊的类加载逻辑，可以使应用程序具备更灵活和强大的能力。

Java虚拟机在处理动态加载和卸载类时是如何工作的

当Java虚拟机处理动态加载和卸载类时，涉及以下几个步骤：

1. 类加载：在Java虚拟机中，类的加载是由类加载器（ClassLoader）完成的。当程序需要使用某个类时，如果该类尚未被加载到虚拟机中，类加载器将会执行以下操作：

   • 加载：根据类的全限定名，查找类文件并将其二进制数据加载到内存中。
   • 验证：验证类的格式、依赖关系等，以确保类文件的正确性。
   • 准备：为静态变量分配内存空间，并设置默认初始值。
   • 解析：将符号引用转换为直接引用，以保证程序能正确访问到所需的类、字段、方法等。

2. 链接：在类加载后，将进行一系列的链接操作，包括验证、准备和解析。链接过程的具体内容包括：

   • 验证：确保加载的类符合Java虚拟机规范，不会造成安全问题。
   • 准备：为静态变量分配内存空间，并设置默认初始值。
   • 解析：将符号引用转换为直接引用，以保证程序能正确访问到所需的类、字段、方法等。

3. 初始化：在类加载和链接完成后，虚拟机将执行类的初始化操作。初始化过程包括静态变量的赋值和静态代码块的执行，这些操作会按照顺序依次执行。

4. 卸载：在某些情况下，当类不再被引用时，虚拟机可能会对其进行卸载操作。类卸载的条件包括：类的所有实例都被垃圾回收，类的类加载器被回收，类的引用被置为null。当满足这些条件时，虚拟机将对类进行卸载操作，释放其占用的内存空间。

需要注意的是，类的动态加载和卸载通常是由应用程序自己通过反射等机制来实现的，并不是Java虚拟机的直接操作。Java虚拟机只负责类加载、链接和初始化等底层操作，具体的动态加载和卸载逻辑由应用程序开发者编写。

【问题】类加载过程中，为什么会有类未找到异常（ClassNotFoundException）和无类定义错误（NoClassDefFoundError）

ClassNotFoundException

ClassNotFoundException是一个检查异常，意味着在编译时不会被捕获，而是在运行时抛出。它表示在运行时无法找到某个类。

当Java虚拟机（JVM）在类加载过程中通过类加载器（ClassLoader）尝试加载指定类时，如果找不到该类（无法在类路径或指定的加载路径中找到对应的字节码文件），就会抛出ClassNotFoundException。

可能的原因包括：

• 类不存在
• 类文件路径错误
• 类文件被更改或删除
• 类文件所在的JAR包不存在或位置错误
• 类文件名不正确

NoClassDefFoundError

NoClassDefFoundError是一个错误（Error），而不是异常，它表示类在编译时存在，但在运行时无法被找到。

当某个类成功加载，并且在类加载过程中发现其依赖的某个类无法被找到时，就会抛出NoClassDefFoundError。通常情况下，这意味着编译时存在依赖关系，但在运行时找不到所需的类。

可能的原因包括：

• 编译时存在依赖关系，但在运行时依赖的类不存在
• 依赖的类被其他类库替换或删除
• 类加载器无法找到依赖的类
• 依赖的类文件被更改或损坏

区别

总结来说，ClassNotFoundException表示某个类在运行时无法找到，而NoClassDefFoundError表示某个类在运行时的依赖无法找到。

具体区别如下：

• 异常和错误类型不同：ClassNotFoundException是一个异常，NoClassDefFoundError是一个错误。
• 引发条件不同：ClassNotFoundException表示加载某个类时无法找到它，而NoClassDefFoundError表示在某个类加载成功后所依赖的类无法找到。
• 捕获方式不同：ClassNotFoundException是一个检查异常，可以使用try-catch块捕获或抛出给调用方处理；NoClassDefFoundError是一个错误，通常无法通过代码捕获和处理，只能由JVM抛出给调用方。
• 发生时间不同：ClassNotFoundException在编译时不会被捕获，只会在运行时抛出；NoClassDefFoundError在类加载完成后才会抛出。

备注：上述信息适用于Java语言的标准语义和JVM实现，不同的语言和环境可能会有一些细微差异。