JVM类加载

卡白
103 阅读5分钟

Java虚拟机（JVM）的类加载过程是将类文件（.class）加载到内存中，并将其转化为Class对象的过程。这个过程由类加载器（ClassLoader）负责，分为以下几个阶段：

  1. 加载（Loading）：

    • 查找并导入类的二进制数据。
    • 将二进制数据转化为方法区中的内存结构。
    • 在堆中生成一个代表这个类的java.lang.Class对象，作为方法区这些数据的访问入口。

  2. 连接（Linking）：

    • 验证（Verification）：确保类的字节码符合JVM规范，保证不会破坏JVM的安全。
    • 准备（Preparation）：为类的静态变量分配内存，并将其初始化为默认值（如0、null等）。
    • 解析（Resolution）：将常量池中的符号引用（Symbolic Reference）替换为直接引用（Direct Reference）。

  3. 初始化（Initialization）：

    • 执行类的静态代码块和静态变量的初始化代码。该阶段是在类初始化时才进行的，确保所有的静态初始化块和静态变量的赋值都按顺序执行。

类加载器的类型

JVM中的类加载器主要有以下几种：

  1. 启动类加载器（Bootstrap ClassLoader）：

    • 负责加载Java核心库（如rt.jar），用本地代码实现。
    • 这是一个特例，由C++实现，而不是一个Java类。

  2. 扩展类加载器（Extension ClassLoader）：

    • 负责加载扩展库（位于jre/lib/ext目录或由java.ext.dirs系统属性指定的目录）。

  3. 应用程序类加载器（Application ClassLoader）：

    • 负责加载用户类路径（classpath）上的类。

类加载器的工作机制

类加载器遵循双亲委派模型（Parent Delegation Model）：

  1. 双亲委派模型：当一个类加载器收到加载类的请求时，首先将请求委派给它的父类加载器去完成。只有当父类加载器无法完成加载任务时，子类加载器才会尝试自己加载。

  2. 优点：双亲委派模型保证了Java核心库的安全性和稳定性，避免核心类被篡改。例如java.lang.Object类无论在哪个类加载器中都是同一个类。

自定义类加载器

在某些特殊场景下，用户可能需要自定义类加载器。自定义类加载器通常继承自java.lang.ClassLoader并重写findClass方法。

public class CustomClassLoader extends ClassLoader {
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        byte[] data = loadClassData(name);
        return defineClass(name, data, 0, data.length);
    }

    private byte[] loadClassData(String name) {
        // 读取类文件的字节码
    }
}

类加载的示例

public class Test {
    static {
        System.out.println("Class Test initialized");
    }

    public static void main(String[] args) throws ClassNotFoundException {
        ClassLoader classLoader = Test.class.getClassLoader();
        classLoader.loadClass("com.example.SomeClass");
    }
}

在上述示例中，Test类的静态块在第一次使用该类时会被执行，即类初始化时。classLoader.loadClass("com.example.SomeClass")会触发SomeClass类的加载。

通过类加载器，JVM可以动态加载类，实现按需加载和动态链接，提供了Java语言强大的动态扩展能力。

为什么要自定义类加载器?

自定义类加载器的主要目的是满足一些特定的需求，默认类加载器无法满足或处理不方便的场景。以下是一些常见的需要自定义类加载器的场景：

1. 从非标准位置加载类

默认类加载器通常从标准的类路径（classpath）加载类文件。如果需要从网络、数据库、加密文件等非标准位置加载类，自定义类加载器是必要的。

示例：从网络加载类

public class NetworkClassLoader extends ClassLoader {
    private String baseURL;

    public NetworkClassLoader(String baseURL) {
        this.baseURL = baseURL;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        try {
            String url = baseURL + name.replace('.', '/') + ".class";
            byte[] classData = downloadClassData(url);
            return defineClass(name, classData, 0, classData.length);
        } catch (IOException e) {
            throw new ClassNotFoundException("Class " + name + " not found", e);
        }
    }

    private byte[] downloadClassData(String url) throws IOException {
        // 下载类数据
        return new byte[0]; // 简化处理，实际应为下载的字节数组
    }
}

2. 实现插件机制

许多应用程序需要动态加载和卸载插件，这些插件通常在程序启动时未知，并且可能来自外部来源。自定义类加载器可以在运行时加载这些插件。

示例：插件加载器

public class PluginClassLoader extends ClassLoader {
    private List<Path> pluginPaths;

    public PluginClassLoader(List<Path> pluginPaths) {
        this.pluginPaths = pluginPaths;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        for (Path path : pluginPaths) {
            try {
                byte[] classData = Files.readAllBytes(path.resolve(name.replace('.', '/') + ".class"));
                return defineClass(name, classData, 0, classData.length);
            } catch (IOException e) {
                // Ignore and try next path
            }
        }
        throw new ClassNotFoundException("Class " + name + " not found");
    }
}

3. 应用程序隔离

在一些大型应用服务器（如Tomcat）中，不同的应用程序可能需要使用相同的类名但不同版本的类。自定义类加载器可以确保每个应用程序有自己的类加载器实例，隔离不同应用程序的类加载。

示例：应用程序隔离

public class AppClassLoader extends ClassLoader {
    private URLClassLoader appClassLoader;

    public AppClassLoader(URL[] urls, ClassLoader parent) {
        super(parent);
        this.appClassLoader = new URLClassLoader(urls, parent);
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        return appClassLoader.loadClass(name);
    }
}

4. 热部署

在开发和测试过程中，可能需要在不重启整个应用程序的情况下，重新加载某些类。自定义类加载器可以帮助实现热部署功能。

示例：热部署

public class HotSwapClassLoader extends ClassLoader {
    public HotSwapClassLoader(ClassLoader parent) {
        super(parent);
    }

    public Class<?> loadClassFromBytes(String name, byte[] classData) {
        return defineClass(name, classData, 0, classData.length);
    }
}

5. 实现代码增强

在一些框架（如Spring、Hibernate）中，需要对加载的类进行增强（如添加代理逻辑）。自定义类加载器可以在加载类时插入字节码增强逻辑。

示例：代码增强

public class EnhancingClassLoader extends ClassLoader {
    private ClassEnhancer enhancer;

    public EnhancingClassLoader(ClassLoader parent, ClassEnhancer enhancer) {
        super(parent);
        this.enhancer = enhancer;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        byte[] classData = enhancer.enhanceClass(name);
        return defineClass(name, classData, 0, classData.length);
    }
}

interface ClassEnhancer {
    byte[] enhanceClass(String className);
}

总结

自定义类加载器主要用于满足一些特定的需求，如从非标准位置加载类、实现插件机制、应用程序隔离、热部署和代码增强等。通过自定义类加载器，开发者可以灵活地控制类的加载过程，满足应用程序的特定需求。

avatar
文章
阅读
粉丝