Java的类加载机制之双亲委派模型为什么叫双亲委派？

前言

学习java类加载机制是，常常因为各种奇怪名词而苦恼，比如这个双亲委派就让人非常疑惑，为什么叫双亲委派？
Java类加载器的工作模式中，类加载请求沿着类加载器的层级结构，从下至上（即从子类加载器到父类加载器）逐级传递。这里的“双亲”实际上指的是类加载器的父加载器，因为在类加载器的层级结构中，除了顶层的启动类加载器外，每个类加载器都有一个父加载器（那也是单亲啊（bushi））。

打个比方，“委派”就像是孩子遇到问题时，不是自己立即尝试解决，而是先问父母（即父类加载器），如果父母能解决就由他们处理；如果父母也不知道怎么办，再由孩子自己尝试解决。因此，这种类加载的层级传递和责任委托的方式，就被形象地称为“双亲委派模型”。

双亲委派模型（Parent Delegation Model）是Java类加载机制中非常重要的一部分，用于确保类的安全加载。这一机制主要体现在Java虚拟机（JVM）的类加载器层级结构中。在Java中，类加载器并不是孤立存在的，而是存在层次关系，大致可以分为启动类加载器（Bootstrap ClassLoader）、扩展类加载器（Extension ClassLoader）和应用程序类加载器（Application ClassLoader，也称系统类加载器），以及可能由应用程序自定义的类加载器。

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

1. 当一个类加载器收到类加载请求时，它首先不会自己尝试去加载这个类，而是将这个请求委托给它的父类加载器去完成。

2. 如果父类加载器还存在其自身的父类加载器，则进一步向上委托，直至委托到启动类加载器。因为启动类加载器是所有类加载器的最顶端，它负责加载Java的核心库（如rt.jar中的类）。

3. 如果父类加载器无法处理这个加载请求（即在其搜索范围内未找到所需的类），那么子类加载器会尝试自己加载这个类。

双亲委派流程图：

在Java中，ClassLoader类的loadClass(String name)方法实现了双亲委派的具体逻辑。当一个类加载器接收到加载请求时，它会先调用父加载器的loadClass()方法，如果父加载器加载成功，则直接返回；否则，再尝试自己加载。

目的和优势：

• 防止类的重复加载：确保每个类在整个应用程序中只被加载一次，有助于节省内存，并且避免了因重复加载而导致的类定义不一致问题。
• 保证核心库安全：通过委托给启动类加载器加载Java核心API，可以防止用户自定义类假冒核心类库的类，增强了系统的安全性和稳定性。
• 支持模块化和插件化：不同的类加载器可以为不同的模块或插件服务，它们之间互不影响，这有利于实现程序的模块化和热部署。

自定义双亲委派模型：

双亲委派的核心逻辑实现在java.lang.ClassLoader的loadClass(String name)方法中，但通常建议重写findClass(String name)方法来完成自定义加载逻辑，以保持双亲委派的机制。

public class MyClassLoader extends ClassLoader {
    
    private String classPath; // 自定义类加载路径
    
    public MyClassLoader(String classPath) {
        this.classPath = classPath;
    }
    
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        byte[] classData = getClassData(name);
        if (classData == null) {
            throw new ClassNotFoundException();
        } else {
            return defineClass(name, classData, 0, classData.length);
        }
    }
    
    private byte[] getClassData(String className) {
        // 实现从classPath中读取类的二进制数据逻辑
        // 这里省略具体实现细节
    }

    // 重写loadClass方法以维持双亲委派模型
    @Override
    protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
        synchronized (getClassLoadingLock(name)) {
            // 首先检查是否已被加载
            Class<?> c = findLoadedClass(name);
            if (c == null) {
                long t1 = System.nanoTime();
                try {
                    // 如果父类加载器不为空，尝试通过父类加载
                    if (getParent() != null) {
                        c = getParent().loadClass(name);
                    } else {
                        // 如果父加载器为空，使用启动类加载器加载
                        c = findBootstrapClassOrNull(name);
                    }
                } catch (ClassNotFoundException e) {
                    // 如果父加载器找不到，才由当前类加载器尝试加载
                    c = findClass(name);
                }
            }
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }
}

以上代码，当调用MyClassLoader的loadClass方法加载一个类时，它首先会委托给父类加载器尝试加载，如果父类加载器加载不到（抛出ClassNotFoundException），才会尝试自己加载。这就是双亲委派模型的核心逻辑。