ClassLoader (一) — Android 中的 ClassLoader 體系

一、概述

Android 中， DVM 或 ART虛擬機加載的是 Dex 文件，因此 Androd 中自定義了部分 ClassLoader 來實現類的加載。

Android 中的 ClassLoader 類型分爲兩種：

1. 系統類加載器。系統類加載器主要包括 3 種，分別是BootClassLoader 、 PathClassLoader 和 DexClassLoader。
2. 自定義加載器。

版本： Android 28

---

二、ClassLoader 體系

Android 中 ClassLoader 的繼承關係如下圖所示。

我們知道，系統類加載器主要包括 3 種，分別是 BootClassLoader 、 PathClassLoader 和 DexClassLoader。

下面就來分析一下它們：

1. BootClassLoader 類加載器

Android 系統啓動時會使用 BootClassLoader 來預加載常用類，它是由 Java 實現的，BootClassLoader 是一個單例。

class BootClassLoader extends ClassLoader {

    private static BootClassLoader instance;

    @FindBugsSuppressWarnings("DP_CREATE_CLASSLOADER_INSIDE_DO_PRIVILEGED")
    public static synchronized BootClassLoader getInstance() {
        if (instance == null) {
            instance = new BootClassLoader();
        }

        return instance;
    }
}

2. PathClassLoader 與 DexClassLoader 類加載器

淺析 PathClassLoader 和 DexClassLoader 的區別

---

三、ClassLoader 的雙親委託模式

類加載器查找 Class 所採用的是雙親委託模式。

雙親委託模式：就是在查找一個 Class 時，首先判斷該 Class 是否已經加載，如果沒有則先委託給父加載器進行查找，這樣依次進行遞歸，直到委託到最頂層的 ClassLoader，如果頂層的 ClassLoader 找到了該 Class，就會直接返回；如果沒找到，則繼續依次向下查找，如果還沒找到則最後會交由自身去查找。如下圖所示：

代碼如下：
ClassLoader.loadClass() 內分爲3步，對應雙親委託模式的三個步驟。

protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
	// First, check if the class has already been loaded
	// 1.先查找該 Class 是否已經加載過，若加載過，則直接返回。
    Class<?> c = findLoadedClass(name);
    if (c == null) {
        try {
            if (parent != null) {
            	// 2.委託給父加載器進行加載。
                c = parent.loadClass(name, false);
            } else {
            	// 當執行到頂層的類加載器時，parent = null
                c = findBootstrapClassOrNull(name);
            }
        } catch (ClassNotFoundException e) {
            // ClassNotFoundException thrown if class not found
            // from the non-null parent class loader
        }

        if (c == null) {
            // 3.如果父加載器也沒有找到，則自己嘗試加載。該方法的邏輯由具體子加載器實現。
            c = findClass(name);
        }
    }
    return c;
}

雙親委託模式的優點：

1. 避免重複加載。如果已經加載過一次 Class ，就不需要再次加載，而是直接讀取已經加載的 Class 。
2. 安全性。如果不使用雙親委託模式，當用戶自定義一個系統類 (如String) 來替代系統的類 (如String) 時，系統類就可能被替換，造成安全隱患。採用雙親委託模式，父類加載器會優先加載系統類，所以自定義的系統類就不再被加載，保證了安全性。只有兩個類名一致並且被同一個類加載器加載的類， Java 虛擬機纔會認爲它們是同一個類 。

---

四、ClassLoader 的加載流程

1. 源碼分析

ClassLoader

protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
	// First, check if the class has already been loaded
	// 1.先查找該 Class 是否已經加載過，若加載過，則直接返回。
    Class<?> c = findLoadedClass(name);
    if (c == null) {
        try {
            if (parent != null) {
            	// 2.委託給父加載器進行加載。
                c = parent.loadClass(name, false);
            } else {
            	// 當執行到頂層的類加載器時，parent = null
                c = findBootstrapClassOrNull(name);
            }
        } catch (ClassNotFoundException e) {
            // ClassNotFoundException thrown if class not found
            // from the non-null parent class loader
        }

        if (c == null) {
            // 3.如果父加載器也沒有找到，則自己嘗試加載。該方法的邏輯由具體子加載器實現。
            c = findClass(name);
        }
    }
    return c;
}

// 由子類自己實現
protected Class<?> findClass(String name) throws ClassNotFoundException {
    throw new ClassNotFoundException(name);
}

下面我們看一下 ClassLoader 的子類 BaseDexClassLoader 是如何實現 findClass 方法的。

BaseDexClassLoader

protected Class<?> findClass(String name) throws ClassNotFoundException {
    List<Throwable> suppressedExceptions = new ArrayList<Throwable>();
    // pathList是DexPathList，是具體存放代碼的地方。
    Class c = pathList.findClass(name, suppressedExceptions);
    if (c == null) {
        ClassNotFoundException cnfe = new ClassNotFoundException(
                "Didn't find class \"" + name + "\" on path: " + pathList);
        for (Throwable t : suppressedExceptions) {
            cnfe.addSuppressed(t);
        }
        throw cnfe;
    }
    return c;
}

DexPathList

public Class<?> findClass(String name, List<Throwable> suppressed) {
    for (Element element : dexElements) {
        Class<?> clazz = element.findClass(name, definingContext, suppressed);
        if (clazz != null) {
            return clazz;
        }
    }

    if (dexElementsSuppressedExceptions != null) {
        suppressed.addAll(Arrays.asList(dexElementsSuppressedExceptions));
    }
    return null;
}

DexPathList.Element

public Class<?> findClass(String name, ClassLoader definingContext,
        List<Throwable> suppressed) {
    return dexFile != null ? dexFile.loadClassBinaryName(name, definingContext, suppressed) : null;
}

DexFile

public Class loadClassBinaryName(String name, ClassLoader loader, List<Throwable> suppressed) {
    return defineClass(name, loader, mCookie, this, suppressed);
}

private static Class defineClass(String name, ClassLoader loader, Object cookie,
                                 DexFile dexFile, List<Throwable> suppressed) {
    Class result = null;
    try {
        result = defineClassNative(name, loader, cookie, dexFile);
    } catch (NoClassDefFoundError e) {
        if (suppressed != null) {
            suppressed.add(e);
        }
    } catch (ClassNotFoundException e) {
        if (suppressed != null) {
            suppressed.add(e);
        }
    }
    return result;
}

// 調用 Native 層代碼
private static native Class defineClassNative(String name, ClassLoader loader, Object cookie, DexFile dexFile)

2. 流程圖

ClassLoader 的加載流程如下圖所示：

---