【JVM】详解双亲委派机制

双亲委派机制是Java类加载器的一种工作模式，确保类加载的一致性和安全性。以下是详细的定义、优缺点以及如何破坏双亲委派机制的描述。

双亲委派机制的定义

双亲委派机制（Parent Delegation Model）是一种类加载器的工作模式。在这种模式下，类加载器在加载类时，会先将加载请求委派给父类加载器处理，只有当父类加载器无法完成类加载时，子类加载器才会尝试加载该类。

双亲委派机制的工作过程：

1. 检查缓存：类加载器首先检查是否已经加载过该类，如果已经加载过，则直接返回该类。
2. 委派父加载器：如果没有加载过该类，类加载器将加载请求委派给父类加载器。
3. 递归过程：父类加载器也按照相同的过程处理加载请求，直到委派到启动类加载器（Bootstrap ClassLoader）。
4. 启动类加载器加载：启动类加载器尝试加载类，如果加载成功，则返回该类，否则继续步骤5。
5. 逐级回退：如果启动类加载器无法加载该类，加载请求逐级回退到下一级类加载器，直至回退到最初的请求者。
6. 自行加载：最终，如果所有父类加载器都无法加载该类，子类加载器才会尝试自行加载。

双亲委派机制的优点

1. 安全性：双亲委派机制确保了核心类库（如java.lang.*包）不会被重复加载和篡改。只有启动类加载器能加载这些核心类库，避免了安全风险。
2. 避免类重复加载：通过委派机制，保证了类只会被加载一次，从而节省内存，提高性能。
3. 一致性：同一个类在整个Java应用中只有一个唯一的定义，避免了同名类不同实现的冲突问题。

双亲委派机制的缺点

1. 灵活性不足：双亲委派机制的严格层级关系使得子类加载器很难绕过父类加载器直接加载类，这在某些情况下限制了灵活性。
2. 复杂性：实现自定义类加载器时，需要理解和实现双亲委派机制，这增加了开发的复杂性。

如何破坏双亲委派机制

破坏双亲委派机制通常是为了满足某些特定需求，如加载自定义的类或版本不同的类库。以下是一些破坏双亲委派机制的方法：

1. 自定义类加载器

通过继承ClassLoader并覆盖loadClass方法，可以实现不使用双亲委派机制的类加载器。

public class CustomClassLoader extends ClassLoader {
    @Override
    public Class<?> loadClass(String name) throws ClassNotFoundException {
        // 不委派给父类加载器，直接加载类
        byte[] classData = getClassData(name);
        if (classData == null) {
            throw new ClassNotFoundException();
        }
        return defineClass(name, classData, 0, classData.length);
    }

    private byte[] getClassData(String className) {
        // 读取类文件的字节码
        String path = className.replace('.', '/') + ".class";
        try (InputStream is = getClass().getResourceAsStream(path)) {
            ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
            int nextValue = 0;
            while ((nextValue = is.read()) != -1) {
                byteStream.write(nextValue);
            }
            return byteStream.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }
}

2. 使用不同的类加载器加载不同版本的类

通过不同的类加载器加载不同版本的类库，避免类库冲突。

public class VersionClassLoader extends ClassLoader {
    private String version;

    public VersionClassLoader(String version) {
        this.version = version;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        String path = "/lib/" + version + "/" + name.replace('.', '/') + ".class";
        try (InputStream is = getClass().getResourceAsStream(path)) {
            if (is == null) {
                throw new ClassNotFoundException(name);
            }
            ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
            int nextValue = 0;
            while ((nextValue = is.read()) != -1) {
                byteStream.write(nextValue);
            }
            byte[] classData = byteStream.toByteArray();
            return defineClass(name, classData, 0, classData.length);
        } catch (IOException e) {
            throw new ClassNotFoundException(name, e);
        }
    }
}

3. 重写findClass方法

通过重写ClassLoader的findClass方法，自定义类加载逻辑，从而绕过父类加载器。

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

    private byte[] getClassData(String className) {
        String path = className.replace('.', '/') + ".class";
        try (InputStream is = getClass().getResourceAsStream(path)) {
            ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
            int nextValue = 0;
            while ((nextValue = is.read()) != -1) {
                byteStream.write(nextValue);
            }
            return byteStream.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }
}

总结

双亲委派机制通过递归委派机制确保了Java类加载的安全性、一致性和性能。但是，为了满足某些特定需求，有时需要破坏这一机制。通过自定义类加载器并覆盖loadClass或findClass方法，可以实现不依赖双亲委派机制的类加载逻辑。尽管如此，在破坏双亲委派机制时应谨慎操作，以避免潜在的类加载冲突和安全问题。