双亲委派机制详解及代码示例_双亲委派代码-优快云博客

本文链接：https://blog.youkuaiyun.com/boydoy1987/article/details/141223553

一、引言

在Java编程语言中，类加载器（Class Loader）负责将.class文件加载到Java虚拟机（JVM）中。为了确保类型安全和类的唯一性，Java设计了一套独特的类加载机制——双亲委派模型（Parent Delegation Model）。本文将深入探讨这一机制，并通过代码示例来加深理解。

二、双亲委派机制概述

1. 定义

双亲委派模型要求除了顶层的启动类加载器（Bootstrap ClassLoader）外，其余的类加载器都应当有自己的父类加载器。类加载器在尝试自己加载类之前，首先委托给父类加载器进行加载，只有当父类加载器无法加载该类时，才由自己来加载。

2. 类加载器层次结构

Java中的类加载器大致可以分为以下几种：

Bootstrap ClassLoader：负责加载Java核心库，如rt.jar。
Extension ClassLoader：负责加载Java扩展库，如jre/lib/ext目录下的类库。
Application ClassLoader：负责加载用户类路径（ClassPath）上的类库。
Custom ClassLoader：用户自定义的类加载器。

三、双亲委派机制原理

1. 类加载过程

类加载过程包括：加载、链接、初始化。双亲委派机制主要体现在加载阶段。

2. 双亲委派机制实现

以下是双亲委派模型的简化实现：

public class ClassLoader {
    public Class<?> loadClass(String name) throws ClassNotFoundException {
        // 检查是否已经加载过
        Class<?> c = findLoadedClass(name);
        if (c == null) {
            try {
                if (parent != null) {
                    c = parent.loadClass(name); // 委派给父类加载器
                } else {
                    c = findBootstrapClassOrNull(name); // 委派给Bootstrap ClassLoader
                }
            } catch (ClassNotFoundException e) {
                // 如果父类加载器抛出ClassNotFoundException，则说明父类加载器无法完成加载请求
            }
            if (c == null) {
                c = findClass(name); // 在父类加载器无法加载时，自己尝试加载
            }
        }
        return c;
    }
}

四、代码示例

下面我们通过一个简单的自定义类加载器示例来演示双亲委派机制。

1. 自定义类加载器

public class CustomClassLoader extends ClassLoader {
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        try {
            byte[] classData = loadClassData(name);
            if (classData == null) {
                throw new ClassNotFoundException();
            } else {
                return defineClass(name, classData, 0, classData.length);
            }
        } catch (IOException e) {
            throw new ClassNotFoundException();
        }
    }
    private byte[] loadClassData(String className) throws IOException {
        // 读取类的二进制数据
        // 这里仅为示例，实际中需要从文件系统、网络或其他来源读取
        String path = className.replace('.', '/') + ".class";
        InputStream is = getClass().getClassLoader().getResourceAsStream(path);
        if (is == null) {
            return null;
        }
        ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
        int b;
        while ((b = is.read()) != -1) {
            byteStream.write(b);
        }
        return byteStream.toByteArray();
    }
}

2. 使用自定义类加载器

public class Main {
    public static void main(String[] args) {
        try {
            CustomClassLoader classLoader = new CustomClassLoader();
            Class<?> clazz = classLoader.loadClass("com.example.Test");
            Object instance = clazz.getDeclaredConstructor().newInstance();
            System.out.println(instance.getClass().getClassLoader());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在上面的示例中，我们创建了一个自定义类加载器CustomClassLoader，它继承自ClassLoader。在findClass方法中，我们尝试从某个来源读取类的二进制数据，并使用defineClass方法定义这个类。在main方法中，我们使用自定义类加载器加载了一个名为com.example.Test的类。

五、双亲委派机制的优点和缺点

1. 优点

避免类的重复加载。
保护程序安全，防止核心API被随意篡改。

2. 缺点

类加载器的实现灵活性

六、双亲委派机制的缺点及代码示例

缺点

类加载器的实现灵活性受限：双亲委派模型虽然简化了类加载器的实现，但也使得类加载器之间的交互变得复杂。例如，如果需要自定义类加载器加载某些特定的类，就必须重写loadClass方法，这可能会破坏双亲委派模型。
类加载的层次结构固定：在某些情况下，双亲委派模型可能不适用。例如，JDBC驱动加载、热部署等场景，需要打破双亲委派模型，实现自定义类加载器。

代码示例：打破双亲委派模型

在某些特殊情况下，我们需要打破双亲委派模型，下面通过一个简单的例子来演示如何打破双亲委派模型。

public class BreakParentDelegationClassLoader extends ClassLoader {
    public BreakParentDelegationClassLoader(ClassLoader parent) {
        super(parent);
    }
    @Override
    public Class<?> loadClass(String name) throws ClassNotFoundException {
        if ("com.example.BreakClass".equals(name)) {
            // 直接由自定义类加载器加载，不委派给父类加载器
            return findClass(name);
        }
        return super.loadClass(name);
    }
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        try {
            byte[] classData = loadClassData(name);
            if (classData == null) {
                throw new ClassNotFoundException(name);
            } else {
                return defineClass(name, classData, 0, classData.length);
            }
        } catch (IOException e) {
            throw new ClassNotFoundException(name);
        }
    }
    private byte[] loadClassData(String className) throws IOException {
        // 这里实现从特定位置读取类的二进制数据
        // 示例代码省略，实际应用中需要具体实现
        return null;
    }
}

在上面的代码中，我们重写了loadClass方法，对于特定的类com.example.BreakClass，我们直接使用自定义类加载器加载，而不是委派给父类加载器。

七、双亲委派机制的应用场景

1. SPI（Service Provider Interface）

Java的SPI机制允许第三方为接口提供实现。为了使第三方实现与Java核心库中的实现共存，SPI通常会使用线程上下文类加载器（Thread Context ClassLoader）来加载服务提供者，从而打破了双亲委派模型。

2. 热部署

在Web应用服务器中，为了实现热部署，通常会自定义类加载器，使得应用能够在不重启服务器的情况下替换类。

3. Tomcat类加载器

Tomcat为了实现Web应用的隔离，自定义了多个类加载器，每个Web应用都有自己的类加载器，这些类加载器之间的交互并不完全遵循双亲委派模型。

八、总结

双亲委派机制是Java虚拟机中一种重要的类加载机制，它通过委派的方式确保了类的唯一性和安全性。然而，在某些特殊场景下，我们需要打破这一机制，以实现更灵活的类加载策略。通过自定义类加载器，我们可以控制类的加载过程，满足特定的业务需求。
尽管本文未能达到5000字的长度要求，但希望通过以上的详细解释和代码示例，您能够对双亲委派机制有一个全面而深入的理解。在实际开发中，掌握类加载机制对于解决类加载相关的问题将大有裨益。