如何应对Android面试官-＞Android中的类加载机制，手写热修复框架（上）

前言

本章主要介绍 Android 中的类加载机制和 Java 中的类加载机制有什么不同？

ClassLoader

Android 中的顶层抽象基类也是 java.lang.ClassLoader；可以进入 Android SDK 中提供的 ClassLoader 看一下

可以看到，这个 ClassLoader 是一个抽象类

public abstract class ClassLoader {}

我们来看下 Android 中它都有哪些子类

构成如下关系图

BootClassLoader

除了这些之外，ClassLoader 内部还有一个 BootClassLoader 也直接继承了 ClassLoader

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;    
    }    
    public BootClassLoader() {        
        super(null);    
    }    
    
    @Override    
    protected Class<?> findClass(String name) throws ClassNotFoundException {        
        return Class.classForName(name, false, null);    
    }
    // 省略部分代码
    ...
    // 
}

BootClassLoader 就是用来加载 Android FrameWork 层的 class 文件；

那么，哪些类属于 Android FrameWork 层的类呢？

String.class.getClassLoader(); // 获取的就是用 BootClassLoader 进行加载的

Activity.class.getClassLoader(); // 获取的就是用 BootClassLoader 进行加载的

AppCompactActvity.class.getClassLoader(); // 这个获取的就不是 BootClassLoader，因为它不是 Android FrameWork 层的 class

PathClassLoader

Android应用程序类加载器，用来加载应用程序中的 class 文件；

MyActivity.class.getClassLoader(); // 获取的就是用 PathClassLoader 进行加载的

那么系统是怎么帮我们加载的这些类呢？

通过 PathClassLoader 的 loadClass 方法进行加载的；

Android 中的类加载器都是自己实现的，Java 中的类加载器加载的是 .class 文件，而 Android 中的类加载器加载的是 .dex 文件，所以其实类加载器就是用来连通这个真实的类文件与内存中的class对象的一个关联；

Java 的类加载器就是把这个 .class 文件解析出 JVM 中的一个 class 对象；Android 的类加载就是把这个 .dex 文件解析出 VM 中的一个 class 对象；

我们可以查看下 PathClassLoader 的源码，Android 源码下载地址，也可以使用 androidos 在线查看

public class PathClassLoader extends BaseDexClassLoader {
    
    public PathClassLoader(String dexPath, ClassLoader parent) {
        super(dexPath, null, null, parent);
    }

    public PathClassLoader(String dexPath, String librarySearchPath, ClassLoader parent) {
        super(dexPath, null, librarySearchPath, parent);
    }
}

发现，其实是没有 loadClass 方法，那么我们去 BaseDexClassLoader 中看一下，代码较多，这里就不贴源码了

BaseDexClassLoader 中也没有 loadClass 方法，那么我们继续去父类 ClassLoader 中查找

public abstract class ClassLoader { 
    // 
    ...
    // 省略其他代码
    protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException {
            // First, check if the class has already been loaded
            Class<?> c = findLoadedClass(name);
            if (c == null) {
                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.
                    c = findClass(name);
                }
            }
            return c;
    }
    //
    ...
    // 省略其他代码
}

参数 name：类的全类名；

第一步：

Class<?> c = findLoadedClass(name);

找缓存，在缓存查找是否已经加载过了这个类；找到了 return；这里加缓存是为了节省效率，因为 .class 文件的读取本质就是 IO 操作，很耗费性能，如果每次都进行 IO 操作，影响效率，所以加载过之后，就需要进行缓存；

protected final Class<?> findLoadedClass(String name) {
    ClassLoader loader;
    if (this == BootClassLoader.getInstance())
        loader = null;
    else
        loader = this;
       return VMClassLoader.findLoadedClass(loader, name);
}

findLoadedClass 最终调用到了 VMClassLoader 的 findLoadedClass

native static Class findLoadedClass(ClassLoader cl, String name);

最终调用的是 native 的 findLoadedClass 方法；

如果找不到，进入第二步：

if (parent != null) {
   c = parent.loadClass(name, false);
} else {
   c = findBootstrapClassOrNull(name);
}



c = parent.loadClass(name, false);

或者

c = findBootstrapClassOrNull(name);


private Class<?> findBootstrapClassOrNull(String name){
        return null;
}

取决于 parent 是否为空，这个 parent 在这里是对象的父类，不是类的父类；

public abstract class ClassLoader {
    // The parent class loader for delegation
    // Note: VM hardcoded the offset of this field, thus all new fields
    // must be added *after* it.
    private final ClassLoader parent;
}

parent 一个类中，有这个类的成员变量，它是这个当前对象的父类加载器；也就是说在 loadClass 的过程，会调用到它的 parent 加载器，而 PathClassLoader 的 parent 是 BootClassLoader；

也就是说 PathClassLoader 的父类是 BaseDexClassLoader，它的 parent 是 BootClassLoader；

而 PathClassLoader 是由 BootClassLoader 加载的，而 BootClassLoader 是由启动类加载的；

双亲委派机制

PathClassLoader 在构造方法中传入的就是 BootClassLoader，用来加载 FrameWork 层的class 文件，并且这个 BootClassloader 会赋值给顶层抽象基类 ClassLoader 中的 ClassLoader parent，当调用 loadClass 中 findLoadedClass 找不到已经加载过的类，则调用BootClassLoader 的 loadClass 方法查找，如果找不到，则调用自己的 finClass 方法（这也是责任链模式）；

双亲委派机制带来的好处：避免重复加载，parent 已经加载过了，自身就不需要再加载了；安全，防止核心 API 被随意篡改；

核心 API 被篡改，是指：假设程序中也声明了一个 java.lang.String 类，如果没有双亲委派机制，在每次 loadClass 的时候 findClass，找到了自己声明的 java.lang.String，那么这个自己声明的 java.lang.String 就会替换系统的 String 类，导致系统的不能被加载了，API 自然就能被随意篡改了；

如果第二步找不到，则进入第三步：

if (c == null) {
   // If still not found, then invoke findClass in order
   // to find the class.
   c = findClass(name);
}

PathClassLoader 中没有 findClass 方法，进入 BaseDexClassLoader 看下：

protected Class<?> findClass(String name) throws ClassNotFoundException {
    List<Throwable> suppressedExceptions = new ArrayList<Throwable>();
    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;
}



Class c = pathList.findClass(name, suppressedExceptions);

pathList 就是 DexPathList，在 BaseDexClassLoader 的构造方法中创建：

private final DexPathList pathList;
public BaseDexClassLoader(String dexPath, File optimizedDirectory,
            String librarySearchPath, ClassLoader parent, boolean isTrusted) {
    super(parent);
    this.pathList = new DexPathList(this, dexPath, librarySearchPath, null, isTrusted);

    if (reporter != null) {
        reportClassLoaderChain();
    }
}

进入 DexPathList 中看下：

我们可以先看下 DexPathList 的构造方法

public class DexPathList {
    DexPathList(ClassLoader definingContext, String dexPath,
            String librarySearchPath, File optimizedDirectory, boolean isTrusted) {
        //
        ... 省略部分代码
        // 
        ArrayList<IOException> suppressedExceptions = new ArrayList<IOException>();
        // save dexPath for BaseDexClassLoader
        this.dexElements = makeDexElements(splitDexPath(dexPath), optimizedDirectory,
                                           suppressedExceptions, definingContext, isTrusted);
    }
}

makeDexElemnents 生成 dexElements；我们来看下这个方法的几个参数，分别代表什么含义

splitDexPath(dexPath)

拆组，dexPath 代表的是 dex 的地址，如果想操作多个 dex，那么这个路径值就需要传递的格式为：/file/a.dex : /file/b.dex 以 : 分割开，拆分出一个 List 集合；

private static List<File> splitPaths(String searchPath, boolean directoriesOnly) {
    List<File> result = new ArrayList<>();

    if (searchPath != null) {
        for (String path : searchPath.split(File.pathSeparator)) {
            if (directoriesOnly) {
                try {
                    StructStat sb = Libcore.os.stat(path);
                    if (!S_ISDIR(sb.st_mode)) {
                        continue;
                    }
                } catch (ErrnoException ignored) {
                    continue;
                }
            }
            result.add(new File(path));
        }
    }
    return result;
}

一个 dex 对应一个 Element，多个 dex 对应的是 Element[]；

进入 findClass 看下：

public Class findClass(String name, List<Throwable> suppressed) {
    for (Element element : dexElements) {
        DexFile dex = element.dexFile;

        if (dex != null) {
            Class clazz = dex.loadClassBinaryName(name, definingContext, suppressed);
            if (clazz != null) {
                return clazz;
            }
        }
    }
    if (dexElementsSuppressedExceptions != null) {
        suppressed.addAll(Arrays.asList(dexElementsSuppressedExceptions));
    }
    return null;
}

就用到了我们上面刚刚创建的 dexElements，遍历这个数组，从数组中获取 DexFile，然后由 DexFile loadClassBinaryName 获取 class；

所以 Element[] 中，存放的就是 classes1.dex，classes2.dex，classes3.dex 等所有的 dex 文件；

查找过程就是去 classes1.dex 中找，找不到去 classes2.dex 中查找，找不到去 classes3.dex 中找，直到找到或者循环结束；

热修复实现原理

热修复实现核心：就是将修复的 patch 包(dex文件)插入到 Elements[] 数组的最前面，让它优先被加载，这样才能加载到修复后的类，已经被加载过的类就不能被修复了，因为走不到这里，在 findLoadedClass 的时候就 return 了，所以这就是 Tinker 和 Qzone 为什么要重启才生效的原因；

主要分成下面七个步骤：