摘要：加載器種類啟動類加載器在中用來加載自身需要的類，實現(xiàn)，用來加載。那么就能保證的類會被優(yōu)先加載，限制了使用者對系統(tǒng)的影響。這種方式下就完成類加載器的雙親委派機制此處會將作為參數(shù)傳入進去實際上是調(diào)用了方法

加載 -> 連接 (驗證 -> 準備 -> 解析) -> 初始化 -> 使用 -> 卸載

加載階段，jvm 會通過類名獲取到此類的字節(jié)碼文件(.class 文件)，
然后將該文件中的數(shù)據(jù)結(jié)構(gòu)轉(zhuǎn)存到內(nèi)存里(轉(zhuǎn)化為運行時方法區(qū)內(nèi)的數(shù)據(jù)結(jié)構(gòu))，
最后在堆中生成一個代表該類的 Class 對象，用于后期使用者創(chuàng)建對象或者調(diào)用相關(guān)方法。

驗證階段用于保證 Class 文件符合 jvm 規(guī)范，如果驗證失敗會拋出 error。

在該階段虛擬機會給類對象的靜態(tài)成員變量配置內(nèi)存空間，并賦初始值。

將類/接口/字段/方法中的號引用替換為直接引用。

虛擬機會調(diào)用類對象的初始化方法來進行類變量的賦值。

必須要有類去主動使用該 Class。
方式有：
使用 new 關(guān)鍵字、反射、克隆、反序列化；
調(diào)用類的靜態(tài)方法；
調(diào)用一個類的子類的時候會初始化其父類；
包含 main() 方法的類。

被動使用則不會去裝載 Class。
方式有：
調(diào)用了其父類的靜態(tài)方法。

總結(jié)：

jvm 秉持了實用主義理念，對于沒有用到的 Class 不會進行裝載。
但是在 java 代碼的啟動環(huán)節(jié)會加載一些使用到的類。

在 jdk8 中用來加載 jvm 自身需要的類，c++ 實現(xiàn)，用來加載 rt.jar。
在 jdk9 之后的 jdk 中，Bootstrap ClassLoader 主要用來加載 java.base 中的核心系統(tǒng)類。

jdk8 中用來加載 ${JAVA_HOME}/lib/ext 目錄下的類。
在 jdk9 中已經(jīng)被移除。

jdk9 之后用來代替　ExtClassLoader 的加載器，用來加載 jdk 中的非核心模塊類。

用來加載一般的應用類。

使用者自己定義的，一般繼承 java.lang.ClassLoader 的類。

任意一個 ClassLoader 在嘗試加載一個類的時候，都會先嘗試調(diào)用其父類的相關(guān)方法去加載類，如果其父類不能加載該類，則交由子類去完成。

這樣的好處：對于任意使用者自定義的 ClassLoader，都會先去嘗試讓 jvm 的 Bootstrap ClassLoader 去嘗試加載(自定義的 ClassLoader 都繼承了它們)。那么就能保證 jvm 的類會被優(yōu)先加載，限制了使用者對 jvm 系統(tǒng)的影響。

源碼探究使用 jdk11，與 jdk8 中的有些許不同。

ClassLoader 是類加載器的頂級父類，其核心的方法主要是 loadClass(...) 方法：

// ClassLoader.class
protected Class loadClass(String name, boolean resolve) throws ClassNotFoundException{
    // 加鎖，保證線程安全
    synchronized (getClassLoadingLock(name)) {
        // 先去找一次 class 是否已經(jīng)被加載了，如果已經(jīng)被加載了就不用重復加載了
        // 此方法的核心邏輯由 c++ 實現(xiàn)
        Class c = findLoadedClass(name);
        // 沒有被加載的情況
        if (c == null) {
            long t0 = System.nanoTime(); // 記錄時間
            try {
                // 此處體現(xiàn)雙親委派機制
                // 如果該加載器存在父加載器，就會先去調(diào)用父加載器的相關(guān)方法
                // 如果沒有父加載器，就去調(diào)用 Bootstrap 加載器
                if (parent != null) {
                    c = parent.loadClass(name, false);
                } else {
                    // 調(diào)用 BootstrapClassLoader，此方法的核心邏輯是 c++ 實現(xiàn)的
                    c = findBootstrapClassOrNull(name);
                }
            } catch (ClassNotFoundException e) {

            }

            // 如果依舊加載不到，那么就說明父加載器仍然加載不到信息
            // 那么就需要指定的加載器自己去加載了
            if (c == null) {

                long t1 = System.nanoTime();
                
                // 該加載器加載類文件的核心邏輯
                // 該方法在 ClassLoader 中是留空的，需要子類按照自身的邏輯去實現(xiàn)
                c = findClass(name);

                // 此處做一些信息記錄，和主邏輯無關(guān)
                PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                PerfCounter.getFindClasses().increment();
            }
        }
        
        if (resolve) {
            // 解析 class，也是留空的，需要子類去實現(xiàn)
            resolveClass(c);
        }
        return c;
    }
}

BuiltinClassLoader 是 jdk9 中代替 URLClassLoader 的加載器，是 PlatformClassLoader 與 AppClassLoader 的父類。其繼承了 SecureClassLoader，其核心的方法主要是 loadClassOrNull(...) 方法：

// BuiltinClassLoader.class

// step 1
@Override
protected Class loadClass(String cn, boolean resolve) throws ClassNotFoundException{
    // 復寫了 loadClass(...) 方法，但是核心是調(diào)用 loadClassOrNull(...)
    Class c = loadClassOrNull(cn, resolve);
    if (c == null)
        throw new ClassNotFoundException(cn);
    return c;
}

// step 2
protected Class loadClassOrNull(String cn, boolean resolve) {
    // 加鎖，保證線程安全
    synchronized (getClassLoadingLock(cn)) {
        // 先去找一次 class 是否已經(jīng)被加載了，此方法是 ClassLoader 中的
        Class c = findLoadedClass(cn);

        if (c == null) {

            // 這里會需要去先加載模塊信息
            LoadedModule loadedModule = findLoadedModule(cn);
            if (loadedModule != null) {
                BuiltinClassLoader loader = loadedModule.loader();
                if (loader == this) {
                    if (VM.isModuleSystemInited()) {
                        c = findClassInModuleOrNull(loadedModule, cn);
                    }
                } else {
                    c = loader.loadClassOrNull(cn);
                }
            } else {

                // 先調(diào)用父加載器的相關(guān)方法去加載一次
                if (parent != null) {
                    c = parent.loadClassOrNull(cn);
                }

                // 如果沒加載到，則用當前加載器去加載
                if (c == null && hasClassPath() &&　VM.isModuleSystemInited(){
                    // 此方法內(nèi)會調(diào)用到 defineClass(...) 方法去加載類文件
                    c = findClassOnClassPathOrNull(cn);
                }
            }

        }

        // 解析 class
        if (resolve && c != null)
            resolveClass(c);

        return c;
    }
}

該加載器中還有一個加載 class 字節(jié)碼的方法：

// BuiltinClassLoader.class
private Class defineClass(String cn, Resource res) throws IOException{
    
    URL url = res.getCodeSourceURL();

    // 先解析這個 class 的路徑
    int pos = cn.lastIndexOf(".");
    if (pos != -1) {
        String pn = cn.substring(0, pos);
        Manifest man = res.getManifest();
        defineOrCheckPackage(pn, man, url);
    }

    // 這里會將 class 讀取出來成一個 byte[] 字符串，并通過 jvm 的相關(guān)方法去加載
    ByteBuffer bb = res.getByteBuffer();
    if (bb != null) {
        CodeSigner[] signers = res.getCodeSigners();
        CodeSource cs = new CodeSource(url, signers);
        // 該方法最后會調(diào)用 ClassLoader 內(nèi)的 native 方法
        return defineClass(cn, bb, cs);
    } else {
        byte[] b = res.getBytes();
        CodeSigner[] signers = res.getCodeSigners();
        CodeSource cs = new CodeSource(url, signers);
        // 該方法最后會調(diào)用 ClassLoader 內(nèi)的 native 方法
        return defineClass(cn, b, 0, b.length, cs);
    }
}

BootClassLoader 是 ClassLoaders 的一個靜態(tài)內(nèi)部類，雖然它從代碼實現(xiàn)上是 BuiltinClassLoader 的子類，但是從功能上說它是 PlatformClassLoader 的 parent 類：

// ClassLoader.class
private static class BootClassLoader extends BuiltinClassLoader {
    BootClassLoader(URLClassPath bcp) {
        super(null, null, bcp);
    }

    // 復寫了 BuiltinClassLoader 中的 loadClassOrNull(...) 方法
    @Override
    protected Class loadClassOrNull(String cn) {
        return JLA.findBootstrapClassOrNull(this, cn);
    }
};

PlatformClassLoader 也是 ClassLoaders 的一個靜態(tài)內(nèi)部類，從功能上說它是 BootClassLoader 的子類，同時也是 AppClassLoader 的 parent 類。PlatformClassLoader 主要用來加載一些 module：

// ClassLoader.class
private static class PlatformClassLoader extends BuiltinClassLoader {
    static {
        if (!ClassLoader.registerAsParallelCapable())
            throw new InternalError();
    }

    // 此處會將 BootClassLoader 作為 parent 參數(shù)傳入進去
    PlatformClassLoader(BootClassLoader parent) {
        super("platform", parent, null);
    }

    // 加載 module
    private Package definePackage(String pn, Module module) {
        return JLA.definePackage(this, pn, module);
    }
}

AppClassLoader 的核心方法是 loadClass(...)，最終會調(diào)用到 BuiltinClassLoader.loadClassOrNull(...) 方法，而此方法內(nèi)部又會調(diào)用到 PlatformClassLoader.loadClass(...) 方法；然后實際上 PlatformClassLoader 內(nèi)部又會去調(diào)用 BootClassLoader 的 loadClassOrNull(...) 方法。這種方式下就完成類加載器的雙親委派機制：

// ClassLoader.class
private static class AppClassLoader extends BuiltinClassLoader {
    static {
        if (!ClassLoader.registerAsParallelCapable())
            throw new InternalError();
    }

    final URLClassPath ucp;

    // 此處會將 PlatformClassLoader 作為 parent 參數(shù)傳入進去
    AppClassLoader(PlatformClassLoader parent, URLClassPath ucp) {
        super("app", parent, ucp);
        this.ucp = ucp;
    }

    @Override
    protected Class loadClass(String cn, boolean resolve) throws ClassNotFoundException{
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            int i = cn.lastIndexOf(".");
            if (i != -1) {
                sm.checkPackageAccess(cn.substring(0, i));
            }
        }
        // 實際上是調(diào)用了 BuiltinClassLoader.loadClassOrNull(...) 方法
        return super.loadClass(cn, resolve);
    }

    @Override
    protected PermissionCollection getPermissions(CodeSource cs) {
        PermissionCollection perms = super.getPermissions(cs);
        perms.add(new RuntimePermission("exitVM"));
        return perms;
    }


    void appendToClassPathForInstrumentation(String path) {
        ucp.addFile(path);
    }


    private Package definePackage(String pn, Module module) {
        return JLA.definePackage(this, pn, module);
    }


    protected Package defineOrCheckPackage(String pn, Manifest man, URL url) {
        return super.defineOrCheckPackage(pn, man, url);
    }
}