双亲委派模型及如何打破

双亲委派模型是Java中的类加载机制，它采用一种层级结构的方式进行类加载，主要有以下特点：

1. 当一个类加载器（称为子加载器）收到加载类的请求时，首先会将加载任务委派给其父加载器（父加载器为其上层加载器）。
2. 父加载器会继续将加载任务委派给其父加载器，直到到达顶层启动类加载器（Bootstrap ClassLoader）。
3. 如果顶层加载器无法找到类，再依次向下层加载器逐级查找。只有在所有的父加载器都找不到该类时，才由子加载器自行尝试加载。

这种双亲委派模型的好处是可以避免类的重复加载，保证类的唯一性，并确保类加载的安全性。例如，系统核心类库由Bootstrap ClassLoader加载，而用户自定义类由Application ClassLoader加载，这样用户自定义类无法覆盖系统核心类库。

如果要打破双亲委派模型，即自定义类加载器可以加载Java核心类库中已有的类，可以通过重写loadClass方法来实现。loadClass方法是ClassLoader的一个关键方法，用于控制类的加载过程。默认情况下，loadClass方法采用双亲委派模型。

下面是一个示例，展示了如何打破双亲委派模型：

import java.io.*;

public class CustomClassLoader extends ClassLoader {
    private String path;

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

    @Override
    protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
        // 首先检查类是否已经被加载
        Class<?> loadedClass = findLoadedClass(name);
        if (loadedClass != null) {
            return loadedClass;
        }

        // 如果类不在Java核心类库中，则尝试由当前类加载器加载
        if (!name.startsWith("java.")) {
            try {
                byte[] classData = getClassData(name);
                if (classData != null) {
                    return defineClass(name, classData, 0, classData.length);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        // 如果类不在Java核心类库中或者当前类加载器加载失败，则由父类加载器加载
        return super.loadClass(name, resolve);
    }

    private byte[] getClassData(String className) throws IOException {
        String classPath = path + File.separator + className.replace('.', File.separatorChar) + ".class";
        try (InputStream inputStream = new FileInputStream(classPath);
             ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = inputStream.read(buffer)) != -1) {
                outputStream.write(buffer, 0, bytesRead);
            }
            return outputStream.toByteArray();
        }
    }

    public static void main(String[] args) {
        String classPath = "/path/to/your/class/files"; // 替换为你的类文件所在的路径
        CustomClassLoader customClassLoader = new CustomClassLoader(classPath);

        try {
            // 尝试加载Java核心类库中的类
            Class<?> systemClass = customClassLoader.loadClass("java.lang.String");
            System.out.println("系统核心类库中的类加载成功：" + systemClass.getName());
        } catch (ClassNotFoundException e) {
            System.err.println("系统核心类库中的类加载失败：" + e.getMessage());
        }

        try {
            // 尝试加载自定义类
            Class<?> customClass = customClassLoader.loadClass("com.example.MyClass");
            System.out.println("自定义类加载成功：" + customClass.getName());
        } catch (ClassNotFoundException e) {
            System.err.println("自定义类加载失败：" + e.getMessage());
        }
    }
}

在这个示例中，我们通过重写loadClass方法，先检查类是否在Java核心类库中，如果不在，则尝试由当前类加载器加载，否则由父类加载器加载。这样就打破了双亲委派模型，使得自定义类加载器可以加载Java核心类库中已有的类。请注意，这种打破双亲委派模型的做法一般是不推荐的，因为容易导致类的冲突和安全问题。只有在特定的需求下，才应该考虑打破双亲委派模型。