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 的加载流程如下图所示：

---