JVM系列之类加载机制(二)（jvm类加载机制原理）

四、双亲委派机制

引导类加载器：负责加载支撑JVM运行的位于JRE的lib目录下的核心类库，比如rt.jar、charsets.jar等

扩展类加载器：负责加载支撑JVM运行的位于JRE的lib目录下的ext扩展目录中jar包

应用类加载器：负责加载classPath路径下的包

自定义加载器：负责加载用户自定义的包

类加载器打印示例：

package com.drtt.jvm;

import sun.misc.Launcher;
import java.net.URL;

public class ClassLoaderPrinter {
    /**
     * 打印所有的类加载器
     */
    public static void printAllClassLoader() {
        System.out.println("=====start execute printAllClassLoader=====");
        System.out.println(String.class.getClassLoader());
        System.out.println(com.sun.crypto.provider.DESKeyFactory.class.getClassLoader().getClass().getName());
        System.out.println(ClassLoaderPrinter.class.getClassLoader().getClass().getName());
        System.out.println("======end execute printAllClassLoader=====");
    }

    /**
     * 根据parent属性打印类加载器
     */
    public static void printClassLoaderParent() {
        System.out.println("=====start execute printClassLoaderParent=====");
        ClassLoader appClassLoader = ClassLoaderPrinter.class.getClassLoader();
        ClassLoader extClassLoader = appClassLoader.getParent();
        ClassLoader bootstrapLoader = extClassLoader.getParent();
        System.out.println("应用类加载器:" + appClassLoader);
        System.out.println("扩展类加载器:" + extClassLoader);
        System.out.println("引导类加载器:" + bootstrapLoader);
        System.out.println("======end execute printClassLoaderParent=====");
    }

    /**
     * 打印类加载器加载的类
     */
    public static void printClassLoaderLoadingFile() {
        System.out.println();
        System.out.println("引导类加载器加载以下文件：");
        for (URL url : Launcher.getBootstrapClassPath().getURLs()) {
            System.out.println(url);
        }

        System.out.println();
        System.out.println("扩展类加载器加载以下文件：");
        for (String item : System.getProperty("java.ext.dirs").split(";")) {
            System.out.println(item);
        }

        System.out.println();
        System.out.println("应用类加载器加载以下文件：");
        for (String item : System.getProperty("java.class.path").split(";")) {
            System.out.println(item);
        }
    }

    public static void main(String[] args) {
        //打印所有的类加载器
        printAllClassLoader();
        System.out.println();
        //根据parent属性打印类加载器
        printClassLoaderParent();
        System.out.println();
        //打印类加载器加载的类
        printClassLoaderLoadingFile();
    }
}

打印结果：

=====start execute printAllClassLoader=====
null
sun.misc.Launcher$ExtClassLoader
sun.misc.Launcher$AppClassLoader
======end execute printAllClassLoader=====

=====start execute printClassLoaderParent=====
应用类加载器:sun.misc.Launcher$AppClassLoader@18b4aac2
扩展类加载器:sun.misc.Launcher$ExtClassLoader@5a01ccaa
引导类加载器:null
======end execute printClassLoaderParent=====

引导类加载器加载以下文件：
file:/C:/Program%20Files/Java/jdk1.8.0_101/jre/lib/resources.jar
file:/C:/Program%20Files/Java/jdk1.8.0_101/jre/lib/rt.jar
file:/C:/Program%20Files/Java/jdk1.8.0_101/jre/lib/sunrsasign.jar
file:/C:/Program%20Files/Java/jdk1.8.0_101/jre/lib/jsse.jar
file:/C:/Program%20Files/Java/jdk1.8.0_101/jre/lib/jce.jar
file:/C:/Program%20Files/Java/jdk1.8.0_101/jre/lib/charsets.jar
file:/C:/Program%20Files/Java/jdk1.8.0_101/jre/lib/jfr.jar
file:/C:/Program%20Files/Java/jdk1.8.0_101/jre/classes
扩展类加载器加载以下文件：
C:\Program Files\Java\jdk1.8.0_101\jre\lib\ext
C:\Windows\Sun\Java\lib\ext
应用类加载器加载以下文件：
C:\Program Files\Java\jdk1.8.0_101\jre\lib\charsets.jar
C:\Program Files\Java\jdk1.8.0_101\jre\lib\deploy.jar
C:\Program Files\Java\jdk1.8.0_101\jre\lib\ext\access-bridge-64.jar
C:\Program Files\Java\jdk1.8.0_101\jre\lib\ext\cldrdata.jar
C:\Program Files\Java\jdk1.8.0_101\jre\lib\ext\dnsns.jar
C:\Program Files\Java\jdk1.8.0_101\jre\lib\ext\jaccess.jar
C:\Program Files\Java\jdk1.8.0_101\jre\lib\ext\jfxrt.jar
C:\Program Files\Java\jdk1.8.0_101\jre\lib\ext\localedata.jar
C:\Program Files\Java\jdk1.8.0_101\jre\lib\ext\nashorn.jar
C:\Program Files\Java\jdk1.8.0_101\jre\lib\ext\sunec.jar
C:\Program Files\Java\jdk1.8.0_101\jre\lib\ext\sunjce_provider.jar
C:\Program Files\Java\jdk1.8.0_101\jre\lib\ext\sunmscapi.jar
C:\Program Files\Java\jdk1.8.0_101\jre\lib\ext\sunpkcs11.jar
C:\Program Files\Java\jdk1.8.0_101\jre\lib\ext\zipfs.jar
C:\Program Files\Java\jdk1.8.0_101\jre\lib\javaws.jar
C:\Program Files\Java\jdk1.8.0_101\jre\lib\jce.jar
C:\Program Files\Java\jdk1.8.0_101\jre\lib\jfr.jar
C:\Program Files\Java\jdk1.8.0_101\jre\lib\jfxswt.jar
C:\Program Files\Java\jdk1.8.0_101\jre\lib\jsse.jar
C:\Program Files\Java\jdk1.8.0_101\jre\lib\management-agent.jar
C:\Program Files\Java\jdk1.8.0_101\jre\lib\plugin.jar
C:\Program Files\Java\jdk1.8.0_101\jre\lib\resources.jar
C:\Program Files\Java\jdk1.8.0_101\jre\lib\rt.jar
D:\00我的课程\示例代码\jvm-demo\out\production\jvm-demo
C:\Users\Administrator\AppData\Local\JetBrains\IntelliJIdea2020.1\captureAgent\debugger-agent.jar

添加-verbose:class参数可以打印整个类加载的过程

现象：

1.所有的引导类都是null

2.应用类加载器中加载的类（包）有部分在扩展类加载和引导类加载器中，这些类（包）会重复加载吗？

类加载器初始化过程：sun.misc.Launcher

sun.misc.Launcher初始化使用了单例模式设计，保证一个JVM虚拟机内只有一个sun.misc.Launcher实例。在初始化时，创建了2个类加载器：扩展类加载器、应用类加载器。其中应用类加载器的父是扩展类加载器。（这里的父，仅仅是类加载器的一个parent属性，不是继承关系）

JVM默认使用Launcher的 getClassLoader()方法返回的类加载器 AppClassLoader的实例加载我们写的应用程序。

关键代码：

private static Launcher launcher = new Launcher();
    private ClassLoader loader;
	public static Launcher getLauncher() {
        return launcher;
    }
    public Launcher() {
        Launcher.ExtClassLoader var1;
        try {
            var1 = Launcher.ExtClassLoader.getExtClassLoader();
        } catch (IOException var10) {
            throw new InternalError("Could not create extension class loader", var10);
        }

        try {
            this.loader = Launcher.AppClassLoader.getAppClassLoader(var1);
        } catch (IOException var9) {
            throw new InternalError("Could not create application class loader", var9);
        }

        Thread.currentThread().setContextClassLoader(this.loader);
        String var2 = System.getProperty("java.security.manager");
        if (var2 != null) {
            SecurityManager var3 = null;
            if (!"".equals(var2) && !"default".equals(var2)) {
                try {
                    var3 = (SecurityManager)this.loader.loadClass(var2).newInstance();
                } catch (IllegalAccessException var5) {
                } catch (InstantiationException var6) {
                } catch (ClassNotFoundException var7) {
                } catch (ClassCastException var8) {
                }
            } else {
                var3 = new SecurityManager();
            }

            if (var3 == null) {
                throw new InternalError("Could not create SecurityManager: " + var2);
            }

            System.setSecurityManager(var3);
        }

    }

类加载流程图：

总体而言：双亲委派机制就是先询问父加载器是否加载了该类，如果加载了，就直接返回；如果没有加载，再自己加载。

java.lang.ClassLoader关键代码：loadClass

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);
        if (c == null) {
            long t0 = System.nanoTime();
            try {
                if (parent != null) {
                    c = parent.loadClass(name, false);
                } else {
                    c = findBootstrapClassOrNull(name);
                }
            } catch (ClassNotFoundException e) {
                // ClassNotFoundException thrown if class not found
                // from the non-null parent class loader
            }

            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;
    }
}

如果父没有加载，则执行findClass方法来完成加载。

findClass方法可以查看：java.net.URLClassLoader::findClass

为什么要设计双亲委派机制：

1.沙箱安全机制

例如不能加载自定义的String类

2.避免类的重复加载（但为什么要委派，全部自己加载也可以避免重复加载）

如今这样设计，可以避免重复加载

3.解决了各个类加载器的基础类的统一问题，越基础的类由越上层的加载器进行加载。

双亲委派模型只是建议，而非强制。

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

如何打破双亲委派机制：

（1）重写ClassLoad类中的loadClass方法,指定加载哪一个类

（2）手动调用系统类加载器

Thread.currentThread().getContextClassLoader();

Thread.currentThread().setContextClassLoader();

可以在执行线程中抛弃双亲委派加载链，利用线程上下文类加载器去加载所需要的SPI代码。

（3）重写findClass

打破双亲委派示例：

package com.drtt.jvm;

import java.io.FileInputStream;
import java.lang.reflect.Method;

/**
 * 自定义加载器
 */
public class CustomClassLoader extends ClassLoader {

    /**
     * 类所在文件路径
     */
    private final String classPath;

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

    /**
     * 获取class文件的二进制
     *
     * @param className 类名称
     * @return class文件的二进制
     * @throws Exception 异常
     */
    private byte[] loadClassBytes(String className) throws Exception {
        //com.drtt.jvm 替换为 com/drtt/jvm
        String fileName = className.replaceAll("\\.", "/");
        //磁盘绝对路径
        String fileAbsPath = classPath + "/" + fileName + ".class";
        FileInputStream fis = new FileInputStream(fileAbsPath);
        int len = fis.available();
        byte[] data = new byte[len];
        fis.read(data);
        fis.close();
        return data;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        try {
            byte[] data = loadClassBytes(name);
            return super.defineClass(name, data, 0, data.length);
        } catch (Exception e) {
            e.printStackTrace();
            throw new ClassNotFoundException();
        }
    }

    @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);
            if (c == null) {
                // If still not found, then invoke findClass in order
                // to find the class.
                long t1 = System.nanoTime();
                if (!name.startsWith("com.drtt.jvm")) {
                    c = this.getParent().loadClass(name);
                } else {
                    c = findClass(name);
                }
                // this is the defining class loader; record the stats
                sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                sun.misc.PerfCounter.getFindClasses().increment();
            }
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }

    public static void main(String[] args) throws Exception {
        CustomClassLoader customClassLoader = new CustomClassLoader("D:\\02test\\jvm");
        Class helloWorldClass = customClassLoader.loadClass("com.drtt.jvm.HelloWorld");
        Object object = helloWorldClass.newInstance();
        Method method = helloWorldClass.getDeclaredMethod("sayHello", String.class);
        method.invoke(object, "drtt");
        System.out.println(helloWorldClass.getClassLoader());
        System.out.println(customClassLoader.getParent());
    }
}

输出：

hello,lilydrtt
com.drtt.jvm.CustomClassLoader@6073f712
sun.misc.Launcher$AppClassLoader@18b4aac2

为什么要打破双亲委派：

实现SPI：SPI 接口在Java 核心库中，而实现代码则是在类路径（ClassPath）下的Jar包中。核心库中涉及到SPI接口的代码需要加载接口实现类。

允许多java类库的多版本：tomcat