列举一些你知道的打破双亲委派机制的例子。为什么要打破？思维导图代码示例（java 架构）

用心去追梦

于 2024-11-25 10:50:49 发布

阅读量422

点赞数 4

文章标签： java 架构开发语言

本文链接：https://blog.csdn.net/qq_33240556/article/details/144021550

版权

打破双亲委派机制的例子及原因

打破双亲委派机制的例子

OSGi (Open Service Gateway Initiative)
- 原因：OSGi 是一个模块化框架，允许多个版本的相同类库共存。传统的双亲委派模型无法满足这种需求，因为每个模块（Bundle）可能需要加载不同版本的类。
- 实现方式：OSGi 使用自定义的类加载器，每个 Bundle 有自己的类加载器，类加载器之间没有父子关系，而是平等的关系。通过复杂的类加载策略，确保每个 Bundle 可以独立加载所需的类。
Tomcat
- 原因：在 Web 应用服务器中，不同的 Web 应用可能需要加载相同名称但不同版本的类。传统的双亲委派模型会导致类冲突。
- 实现方式：Tomcat 使用自定义的类加载器层次结构，每个 Web 应用有自己的类加载器。类加载器的顺序是：Common、Catalina、Shared、WebApp。通过调整类加载顺序，确保 Web 应用可以优先加载自己的类。
Spring Boot DevTools
- 原因：Spring Boot DevTools 提供了热部署功能，需要重新加载修改后的类，而传统的双亲委派模型会导致类加载器缓存问题。
- 实现方式：Spring Boot DevTools 使用两个类加载器：一个用于加载不变的类，另一个用于加载可变的类。通过这种方式，可以实现类的热重载。
Java Plugin Framework (JPF)
- 原因：插件框架需要动态加载和卸载插件，传统的双亲委派模型会导致类加载器无法卸载已经加载的类。
- 实现方式：JPF 使用自定义的类加载器，每个插件有自己的类加载器。通过这种方式，可以动态加载和卸载插件，而不影响其他插件。

为什么要打破双亲委派机制

模块化需求：在模块化系统中，不同的模块可能需要加载不同版本的类库，传统的双亲委派模型无法满足这种需求。
类冲突解决：在多应用或插件系统中，不同的应用或插件可能需要加载相同名称但不同版本的类，传统的双亲委派模型会导致类冲突。
动态加载和卸载：在需要动态加载和卸载类的场景中，传统的双亲委派模型会导致类加载器无法卸载已经加载的类。
热部署和热重载：在需要热部署和热重载的场景中，传统的双亲委派模型会导致类加载器缓存问题，无法及时更新类。

思维导图

以下是一个文本形式的思维导图结构，你可以根据这个结构使用你喜欢的工具（如 MindNode, XMind 等）来绘制实际的思维导图。

打破双亲委派机制
│
├── 例子
│   ├── OSGi
│   │   ├── 原因
│   │   │   └── 模块化框架，允许多个版本的相同类库共存
│   │   └── 实现方式
│   │       └── 使用自定义的类加载器，每个 Bundle 有自己的类加载器
│   ├── Tomcat
│   │   ├── 原因
│   │   │   └── 不同的 Web 应用可能需要加载相同名称但不同版本的类
│   │   └── 实现方式
│   │       └── 使用自定义的类加载器层次结构，每个 Web 应用有自己的类加载器
│   ├── Spring Boot DevTools
│   │   ├── 原因
│   │   │   └── 热部署功能，需要重新加载修改后的类
│   │   └── 实现方式
│   │       └── 使用两个类加载器：一个用于加载不变的类，另一个用于加载可变的类
│   ├── Java Plugin Framework (JPF)
│   │   ├── 原因
│   │   │   └── 插件框架需要动态加载和卸载插件
│   │   └── 实现方式
│   │       └── 使用自定义的类加载器，每个插件有自己的类加载器
│
└── 为什么要打破
    ├── 模块化需求
    │   └── 不同的模块可能需要加载不同版本的类库
    ├── 类冲突解决
    │   └── 不同的应用或插件可能需要加载相同名称但不同版本的类
    ├── 动态加载和卸载
    │   └── 需要动态加载和卸载类的场景
    └── 热部署和热重载
        └── 需要热部署和热重载的场景

代码示例（Java 架构）

示例代码

以下是一个简单的 Java 示例，演示了如何自定义类加载器来打破双亲委派机制。

import java.io.ByteArrayOutputStream;
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 {
        String fileName = classPath + "/" + name.replace(".", "/") + ".class";
        byte[] classData = loadClassData(fileName);
        if (classData == null) {
            throw new ClassNotFoundException();
        }
        return defineClass(name, classData, 0, classData.length);
    }

    private byte[] loadClassData(String fileName) {
        try (FileInputStream fis = new FileInputStream(fileName);
             ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
            int bufferSize = 1024;
            byte[] buffer = new byte[bufferSize];
            int len = 0;
            while ((len = fis.read(buffer)) != -1) {
                baos.write(buffer, 0, len);
            }
            return baos.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    // 打破双亲委派机制
    @Override
    protected synchronized Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
        // 先检查是否已经加载过
        Class<?> clazz = findLoadedClass(name);
        if (clazz == null) {
            // 尝试自己加载
            clazz = findClass(name);
        }
        if (resolve) {
            resolveClass(clazz);
        }
        return clazz;
    }

    public static void main(String[] args) {
        CustomClassLoader loader = new CustomClassLoader("/path/to/classes");
        try {
            Class<?> clazz = loader.loadClass("com.example.MyClass");
            System.out.println("Class loaded: " + clazz.getName());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}