热更新是Android工程师必学的技能之一，其理论基础就是ClassLoader类加载器。
我们知道，在Java程序中JVM虚拟机通过类加载器ClassLoader来加载class文件和jar文件（本质还是class文件）。Android与Java类似，只不过Android使用的是Dalvik/ART虚拟机，加载的是dex文件，即一种对class文件优化的产物。Android中类加载器分为两种类型，分别是系统ClassLoader和自定义ClassLoader，其中系统ClassLoader包括三种分别是BootClassLoader、PathClassLoader和DexClassLoader。
一、Android中的ClassLoader
从上图中ClassLoader的继承关系可知：
- ClassLoader是一个抽象类，其中定义了ClassLoader的主要功能；
- BootClassLoader是ClassLoader的内部类，用于预加载preload()常用类以及一些系统Framework层级需要的类；
- BaseDexClassLoader继承ClassLoader，是抽象类ClassLoader的具体实现类，PathClassLoader和DexClassLoader都继承它；
- PathClassLoader加载系统类和应用程序的类，如果是加载非系统应用程序类，则会加载data/app/目录下的dex文件以及包含dex的apk文件或jar文件；
- DexClassLoader可以加载自定义的dex文件以及包含dex的apk文件或jar文件，也支持从SD卡进行加载。
1.1 抽象类ClassLoader
public abstract class ClassLoader {
private ClassLoader(Void unused, ClassLoader parent) {
this.parent = parent;
}
protected ClassLoader(ClassLoader parent) {
this(checkCreateClassLoader(), parent);
}
protected ClassLoader() {
this(checkCreateClassLoader(), getSystemClassLoader());
}
public static ClassLoader getSystemClassLoader() {
return SystemClassLoader.loader;
}
static private class SystemClassLoader {
public static ClassLoader loader = ClassLoader.createSystemClassLoader();
}
private static ClassLoader createSystemClassLoader() {
String classPath = System.getProperty("java.class.path", ".");
String librarySearchPath = System.getProperty("java.library.path", "");
return new PathClassLoader(classPath, librarySearchPath, BootClassLoader.getInstance());
}
public Class<?> loadClass(String name) throws ClassNotFoundException {
return loadClass(name, false);
}
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;
}
protected Class<?> findClass(String name) throws ClassNotFoundException {
throw new ClassNotFoundException(name);
}
}
从ClassLoader源码的可知，其构造函数分为2中，一种是显示传入一个父类构造器，另一种是无参默认构造。同时，在默认无父构造器传入的情况下，默认父构造器为一个PathClassLoader。
loadClass()方法是ClassLoader的核心方法，我们从中可以看到在加载类时，首先判断这个类之前是否已经被加载过，如果已经被加载过则直接返回，如果没有则委托其父加载器进行查找，这样依次的进行递归，直到委托到最顶层的BootClassLoader，如果BootClassLoader找到了该Class，就会直接返回，如果没找到，则继续依次向下查找，如果还没找到则最后会交由自身去查找，这就是所谓的双亲委派模型。
双亲委派模型优点：
- 可以避免重复加载，如果已经加载过一次Class，就不需要再次加载；
- 更加安全，因为只有两个类名一致并且被同一个类加载器加载的类，虚拟机才会认为它们是同一个类。
1.2 BootClassLoader
Android系统启动时会使用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;
}
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
return Class.classForName(name, false, null);
}
@Override
protected Class<?> loadClass(String className, boolean resolve)
throws ClassNotFoundException {
Class<?> clazz = findLoadedClass(className);
if (clazz == null) {
clazz = findClass(className);
}
return clazz;
}
}
由BootClassLoader源码可知，BootClassLoader是ClassLoader的内部类，并继承自ClassLoader。同时，BootClassLoader是一个单例，且访问修饰符是默认的，只有在同一个包中才可以访问，因此我们在应用程序中无法直接调用。
1.3 PathClassLoader
Android系统使用PathClassLoader来加载系统类和应用程序的类，也就是说App安装到手机后，apk里面的class.dex均是通过PathClassLoader来加载的，其源代码如下。
/**
* Provides a simple {@link ClassLoader} implementation that operates on a list
* of files and directories in the local file system, but does not attempt to
* load classes from the network. Android uses this class for its system class
* loader and for its application class loader(s).
*/
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);
}
}
由其源码可知，PathClassLoader继承自BaseDexClassLoader，构造方法都直接调用了其父类的构造方法，很明显PathClassLoader的方法实现都在BaseDexClassLoader中。
下面我们重点来分析一下BaseDexClassLoader，首先一起来看下它的核心源码。
public class BaseDexClassLoader extends ClassLoader {
private final DexPathList pathList;
public BaseDexClassLoader(String dexPath, File optimizedDirectory,
String librarySearchPath, ClassLoader parent) {
this(dexPath, optimizedDirectory, librarySearchPath, parent, false);
}
public BaseDexClassLoader(String dexPath, File optimizedDirectory,
String librarySearchPath, ClassLoader parent, boolean isTrusted) {
super(parent);
this.pathList = new DexPathList(this, dexPath, librarySearchPath, null, isTrusted);
...
}
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
...
Class c = pathList.findClass(name, suppressedExceptions);
...
return c;
}
}
首先解释一下BaseDexClassLoader的构造方法参数：
- dexPath：包含类和资源的jar / apk文件列表，由 File.pathSeparator分隔，在Android上默认为":"。
- optimizedDirectory：由于dex文件被包含在apk或者jar文件中，因此在类加载之前需要先从apk或jar文件中解压出dex文件，该参数就是制定解压出的dex 文件存放的路径。
- librarySearchPath：指目标类中所使用的C/C++库存放的路径，可以为null。
- parent：父ClassLoader引用。
我们可以看到，在BaseDexClassLoader的构造过程中，创建了一个DexPathList对象，并将其赋值给成员变量pathList。同时，BaseDexClassLoader重写了findClass()方法，通过该方法进行类查找的时候，会委托给pathList对象的findClass()方法进行相应的类查找。
那么，显然我们需要继续分析一下DexPathList的源码实现。
final class DexPathList {
private Element[] dexElements;
DexPathList(ClassLoader definingContext, String dexPath,
String librarySearchPath, File optimizedDirectory, boolean isTrusted) {
...
this.dexElements = makeDexElements(splitDexPath(dexPath), optimizedDirectory,
suppressedExceptions, definingContext, isTrusted);
...
}
private static Element[] makeDexElements(List<File> files, File optimizedDirectory,
List<IOException> suppressedExceptions, ClassLoader loader, boolean isTrusted) {
Element[] elements = new Element[files.size()];
int elementsPos = 0;
for (File file : files) {
if (file.isDirectory()) {
elements[elementsPos++] = new Element(file);
} else if (file.isFile()) {
String name = file.getName();
DexFile dex = null;
if (name.endsWith(DEX_SUFFIX)) {
// Raw dex file (not inside a zip/jar).
try {
dex = loadDexFile(file, optimizedDirectory, loader, elements);
if (dex != null) {
elements[elementsPos++] = new Element(dex, null);
}
} catch (IOException suppressed) {
System.logE("Unable to load dex file: " + file, suppressed);
suppressedExceptions.add(suppressed);
}
} else {
try {
dex = loadDexFile(file, optimizedDirectory, loader, elements);
} catch (IOException suppressed) {
suppressedExceptions.add(suppressed);
}
if (dex == null) {
elements[elementsPos++] = new Element(file);
} else {
elements[elementsPos++] = new Element(dex, file);
}
}
} else {
System.logW("ClassLoader referenced unknown path: " + file);
}
}
return elements;
}
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;
}
}
由DexPathList的源码可知，在DexPathList构造方法中，通过makeDexElements()方法初始化Element数组并将其赋值给成员变量dexElements。而且，通过makeDexElements()方法源码我们可以看到它所做的事情就是遍历传递过来的dexPath，然后依次加载每个dex文件。
那么，通过上面的分析，现在应该就很明了了，下面总结一下类加载过程：
- PathClassLoader调用父类BaseDexClassLoader的构造方法；
- BaseDexClassLoader构造方法创建DexPathList对象并赋值给成员变量pathList；
- DexPathList构造方法中通过makeDexElements()方法遍历传递过来的dexPath，然后依次加载每个dex文件，并把Element数组赋值给成员变量dexElements；
- BaseDexClassLoader通过findClass()方法进行类查找，实际是委托给pathList对象的findClass()方法进行类查找，最终是直接遍历DexPathList 类中成员变量dexElements，然后通过调用element.dexFile对象上的loadClassBinaryName方法来加载类，如果返回值不是null，就表示加载类成功，并将这个Class对象返回。
1.4 DexClassLoader
DexClassLoader可以加载自定义的dex文件以及包含dex的apk文件或jar文件，也支持从SD卡进行加载，其源码如下。
/**
* A class loader that loads classes from {@code .jar} and {@code .apk} files
* containing a {@code classes.dex} entry. This can be used to execute code not
* installed as part of an application.
*/
public class DexClassLoader extends BaseDexClassLoader {
public DexClassLoader(String dexPath, String optimizedDirectory,
String librarySearchPath, ClassLoader parent) {
super(dexPath, null, librarySearchPath, parent);
}
}
由其源码可知，DexClassLoader同样继承自BaseDexClassLoader，构造方法直接调用了其父类的构造方法，同样DexClassLoader的方法实现都在BaseDexClassLoader中。
那么，对比一下PathClassLoader，DexClassLoader与其不同的点就在于它可以加载任意目录下的dex/jar/apk/zip文件，比PathClassLoader更加灵活，是实现热修复和插件化技术的重点。
二、Android热更新实现原理
Android热更新技术是以ClassLoader类加载为基础的，经过上面对BootClassLoader、PathClassLoader、DexClassLoader、BaseDexClassLoader、DexPathList的分析，我们可以看出来DexPathList对象中的dexElements数组是类加载的一个核心。
通过以上对类加载流程的分析，可以看出一个类加载时会先从DexPathList对象中的dexElements数组中获取，如果一个类能够被成功加载，那么它的dex一定会出现在dexElements所对应的dex文件中。同时，由于采用的是数组遍历的方式，所以dexElements中dex出现的顺序也非常重要，在dexElements前面出现的dex会被优先加载，一旦Class被加载成功， 就会立即返回。也就是说，我们如果想实现热更新，就一定要保证我们的热更新dex文件出现在原先dexElements数组之前。
到此为止，那么我们的目标就很明确了，就是要在运行时去修改PathClassLoader.pathList.dexElements，具体实现步骤如下：
- 通过构造一个DexClassLoader对象来加载我们的热更新dex文件；
- 通过反射获取系统默认的PathClassLoader.pathList.dexElements；
- 将我们的热更新dex与系统默认的Elements数组合并，同时保证热更新dex在系统默认Elements数组之前；
- 将合并完成后的数组设置回PathClassLoader.pathList.dexElements。
