深入理解 Java 类加载器双亲委派模型

简介

在 Java 开发中，类加载器扮演着至关重要的角色，它负责将字节码文件加载到 JVM 中并创建对应的 Class 对象。双亲委派模型是 Java 类加载器的核心机制，理解它对于深入掌握 Java 虚拟机原理、解决类加载相关的问题以及进行高效的开发都具有重要意义。本文将详细介绍 Java 类加载器双亲委派模型的基础概念、使用方法、常见实践以及最佳实践。

基础概念
- 类加载器的层次结构
- 双亲委派模型的定义
使用方法
- 自定义类加载器
- 打破双亲委派模型
常见实践
- 应用服务器中的类加载
- 插件化开发中的类加载
最佳实践
- 遵循双亲委派模型的原则
- 合理使用自定义类加载器
小结
参考资料

基础概念

类加载器的层次结构

在 Java 中，类加载器主要分为以下几种： - 启动类加载器（Bootstrap ClassLoader）：负责加载 JVM 核心类库，如 java.lang 包下的类。它是用 C++ 实现的，在 JVM 启动时创建。 - 扩展类加载器（Extension ClassLoader）：负责加载 JRE 扩展目录（jre/lib/ext）下的类库。 - 应用程序类加载器（Application ClassLoader）：负责加载应用程序的 classpath 下的类。通常我们在开发中使用的类都是由它加载的。

这几种类加载器之间存在父子关系，形成了一个层次结构。启动类加载器是扩展类加载器的父类，扩展类加载器是应用程序类加载器的父类。

双亲委派模型的定义

双亲委派模型的工作过程如下：当一个类加载器收到类加载请求时，它首先不会自己尝试加载这个类，而是把请求委派给父类加载器去完成。只有当父类加载器无法加载这个类时，子类加载器才会尝试自己去加载。这种模型保证了类加载的层次性和安全性。

例如，当应用程序类加载器收到加载 java.lang.String 类的请求时，它会将请求委派给扩展类加载器，扩展类加载器又会委派给启动类加载器。由于启动类加载器能够加载 java.lang.String 类，所以它会完成加载，而不会再让子类加载器去尝试。

使用方法

自定义类加载器

在某些情况下，我们需要自定义类加载器来满足特殊的需求。自定义类加载器通常继承自 java.lang.ClassLoader 类。下面是一个简单的自定义类加载器的示例：

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class CustomClassLoader extends ClassLoader {
    private String classPath;

    public CustomClassLoader(String classPath) {
        this.classPath = classPath;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        byte[] classData = loadClassData(name);
        if (classData == null) {
            throw new ClassNotFoundException();
        } else {
            return defineClass(name, classData, 0, classData.length);
        }
    }

    private byte[] loadClassData(String name) {
        String fileName = classPath + File.separatorChar
                + name.replace('.', File.separatorChar) + ".class";
        try {
            FileInputStream fis = new FileInputStream(fileName);
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            int len;
            while ((len = fis.read(buffer))!= -1) {
                bos.write(buffer, 0, len);
            }
            fis.close();
            return bos.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }
}

使用自定义类加载器：

public class Main {
    public static void main(String[] args) throws Exception {
        CustomClassLoader classLoader = new CustomClassLoader("/path/to/classes");
        Class<?> clazz = classLoader.loadClass("com.example.MyClass");
        Object instance = clazz.newInstance();
        // 调用实例的方法
    }
}

打破双亲委派模型

在某些特殊场景下，我们可能需要打破双亲委派模型。例如，在 OSGi 框架中，每个模块都有自己独立的类加载器，需要根据模块的需求灵活加载类。打破双亲委派模型的方法是重写 loadClass 方法。下面是一个简单的示例：

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class CustomClassLoader extends ClassLoader {
    private String classPath;

    public CustomClassLoader(String classPath) {
        this.classPath = classPath;
    }

    @Override
    public Class<?> loadClass(String name) throws ClassNotFoundException {
        synchronized (getClassLoadingLock(name)) {
            // 首先检查类是否已经被加载
            Class<?> c = findLoadedClass(name);
            if (c == null) {
                try {
                    if (getParent()!= null) {
                        c = getParent().loadClass(name);
                    }
                } catch (ClassNotFoundException e) {
                    // 父类加载器无法加载，自己尝试加载
                    c = findClass(name);
                }
            }
            return c;
        }
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        byte[] classData = loadClassData(name);
        if (classData == null) {
            throw new ClassNotFoundException();
        } else {
            return defineClass(name, classData, 0, classData.length);
        }
    }

    private byte[] loadClassData(String name) {
        String fileName = classPath + File.separatorChar
                + name.replace('.', File.separatorChar) + ".class";
        try {
            FileInputStream fis = new FileInputStream(fileName);
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            int len;
            while ((len = fis.read(buffer))!= -1) {
                bos.write(buffer, 0, len);
            }
            fis.close();
            return bos.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }
}

常见实践

应用服务器中的类加载

在应用服务器（如 Tomcat）中，类加载器的设计非常复杂，以满足不同应用的隔离和共享需求。每个 Web 应用都有自己独立的类加载器，它的父类加载器是应用服务器的公共类加载器。这样可以保证不同 Web 应用之间的类相互隔离，同时又可以共享一些公共的类库。

插件化开发中的类加载

在插件化开发中，我们希望每个插件都有自己独立的类加载器，以便实现插件的动态加载和卸载。通过自定义类加载器，可以实现每个插件都有自己的命名空间，避免类冲突。

最佳实践

遵循双亲委派模型的原则

在大多数情况下，我们应该遵循双亲委派模型的原则。因为它提供了类加载的层次性和安全性，能够保证核心类库的稳定性。只有在确实需要打破模型的情况下，才进行相应的修改。

合理使用自定义类加载器

自定义类加载器应该谨慎使用，避免滥用。在设计自定义类加载器时，要充分考虑其职责和边界，确保不会对系统的稳定性和性能造成负面影响。

小结

本文详细介绍了 Java 类加载器双亲委派模型的基础概念、使用方法、常见实践以及最佳实践。理解和掌握双亲委派模型对于深入理解 Java 虚拟机原理和进行高效的开发具有重要意义。在实际开发中，我们应该根据具体的需求合理使用类加载器，遵循最佳实践原则，以确保系统的稳定性和性能。

参考资料

《深入理解 Java 虚拟机：JVM 高级特性与最佳实践》
Oracle 官方文档：Java Class Loading