打破双亲委派机制有什么用_啥是双亲委派机制？

JVM 类加载流程

其中classLoader.loadClass 分如下7步： 加载>验证>准备>解析>初始化>使用>卸载

1. 加载：再硬盘上通过io读入字节码文件，使用类时才会加载。比如：调用main方法new一个对象等。加载过程中会在内存中生成一个class对象，作为后续操作的入口。
2. 验证：验证字节码文件的是否正确
3. 准备：给类的静态变量分配内存空间，并赋予默认值
4. 解析：将符号引用替换成直接引用的过程。（将一些静态方法替换成指向内存的指针或句柄）。
5. 初始化：给类的静态变量赋值，加载静态方法。

类被加载到方法区中后主要包含 运行时常量池、类型信息、字段信息、方法信息、类加载器的引用、对应class实例的引用等信息。

主类在运行过程中如果使用到其它类，会逐步加载这些类。jar包或war包里的类不是一次性全部加载的，是使用到时才加载。

类加载器和双亲委派机制

类加载器

1. 引导类加载器：负责加载支撑jvm运行的核心类（jdk lib目录下的核心包）
2. 拓展类加载器：负责加载jdk 下的 lib/ext目录下的jar。
3. 应用程序类加载器：负责加载自己引入的 jar 和 项目中自定义的类。

双亲委派机制

*源码

ClassLoader.loadClass() 方法

protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    {
        synchronized (getClassLoadingLock(name)) {
            // 首先检查这个class是否被当前加载器加载过。
            Class<?> c = findLoadedClass(name);
            if (c == null) {
                long t0 = System.nanoTime();
                try {
                    if (parent != null) {
                        // 如果没有，检查父加载器是否加载过
                        c = parent.loadClass(name, false);
                    } else {
                        // 由于引导类加载器 由c++实现，所以拓展类加载器的parent 无法识别，其实就是引导类加载器。 
                        c = findBootstrapClassOrNull(name);
                    }
                } catch (ClassNotFoundException e) {
                    // ClassNotFoundException thrown if class not found
                    // from the non-null parent class loader
                }

                if (c == null) {
                    // 如果所有加载器都没有加载过，则先由引导类加载器尝试加载
                    // 加载顺序：引导类加载器》拓展类加载器》应用程序类加载器》自定义类加载器
                    long t1 = System.nanoTime();
                    c = findClass(name);

                    // this is the defining class loader; record the stats
                    sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                    sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                    sun.misc.PerfCounter.getFindClasses().increment();
                }
            }
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }

以上代码一句话归结就是：先找父亲加载，失败再由儿子加载。

如果想要分版本加载全限定名相同的类，需要打破双亲委派机制，如同一个容器中，需要加载不同版本的spring。

如何打破双亲委派机制？

继承 ClassLoader 并重写 loadClass 方法

例如

public class MyClassLoader extends ClassLoader{

    @Override
    protected Class<?> loadClass(String name, boolean resolve)
            throws ClassNotFoundException {
        synchronized (getClassLoadingLock(name)) {
            // First, check if the class has already been loaded
            Class<?> c = findLoadedClass(name);
            long t0 = System.nanoTime();
            if (c == null) {
                // If still not found, then invoke findClass in order
                // to find the class.
                long t1 = System.nanoTime();
                c = findClass(name);

                // this is the defining class loader; record the stats
                sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                sun.misc.PerfCounter.getFindClasses().increment();
            }

            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }
}

这样可以简单的打破双亲委派机制

双亲委派机制存在的意义

1. 沙箱安全：自定义的核心类不会加载，有效防止核心API库被篡改，保证了代码的安全性。
2. 避免不必要的类被重复加载：当父类加载过某个类，子类不需要再加载，确保内存中只存在一个实例。

全盘负责委托机制

当一个classLoader装载了一个类，该类的所依赖和引入的类都用这个加载器加载。除非显示的通过其他加载器手动加载。