热修复原理与基础范例

原理

ClassLoader 与 双亲委托

热修复建立的基础是 ClassLoader 的加载机制。

Android 中的类是被 ClassLoader 加载进虚拟机的，具体是如何加载的呢？看下代码：

ClassLoader

    protected Class loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    {
            //1.首先查找是否已经被加载
            Class c = findLoadedClass(name);
            if (c == null) {
                try {
                    //2.如果没有被加载，且父ClassLoader不为空，则优先交给父ClassLoader加载
                    if (parent != null) {
                        c = parent.loadClass(name, false);
                    } else {
                        c = findBootstrapClassOrNull(name);
                    }
                } catch (ClassNotFoundException e) {
                }

                if (c == null) {
                    //3.父ClassLoader没有找到，则交给本ClassLoader查找
                    c = findClass(name);
                }
            }
            return c;
    }

这就是著名的双亲委托，Android 中的类不是由一个 ClassLoader 加载的，而是多个 ClassLoader 共同协作完成的。代码中的 parent 并不是指当前 ClassLoader 的父类，而是指当前 ClassLoader 的下一个委托对象，因为双亲委托的原理大致为向上委托，向下查找，所以这里命名为 parent。如下图：

双亲委托.png

当我们加载一个 Java 类时，由 PathClassLoader 先委托给 BootClassLoader 去查找，BootClassLoader 同样会委托给它的 "parent"，直到顶层 ClassLoader 没有委托对象了，才开始向下查找：顶层的 ClassLoader 没有查找到对象时，则交给它的下一级 ClassLoader 查找，直到 PathClassLoader。

BootClassLoader 通常用来预加载一些 Java 常用的类，PathClassLoader 通常用于加载系统类和应用程序的类（就是你的 apk，它可以从你的 apk 中解析出 class 对象），除此之外还有 DexClassLoader 可以加载外部 dex 文件以及包含 dex 的压缩文件（apk 和 jar）。

有关 ClassLoader 及双亲委托原理更详细的资料网上有很多，这里不再赘述。

热修复原理

热修复的方案有很多，这里给出其中一种方案的原理，之后会根据该原理实现具体代码。

上面说到双亲委托，其中有一点很重要：当 Class 已经被加载，则退出查找。这一点贯通整个 Class 加载流程：无论是在多个 ClassLoader 委托查找之间、还是单个 ClassLoader 内部 findClass 都适用。

下面看下单个 ClassLoader 内部是如何加载 findClass 的：

以 PathClassLoader 为例，其实现了 findClass 方法的是其父类：BaseDexClassLoader：

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

可见实际调用的是 pathList.findClass，这里 pathList 是 DexPathList 类型的，它的内部保存了一系列 dex 文件的加载地址，其中就包括 app 的 apk 地址。接着往下看 DexPathList.findClass：

    public Class findClass(String name, List 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;
   }

这里循环遍历 Element 查找类，dexElements 是个 Element 数组，而 Element 则是一个包含了 DexFile 对象的简单内部类。DexFile 内部存储了包含 Dex 的文件的地址。

综上，也就是说，只要我们在 Element 数组里，提前加入一个 elementA， elementA 包含我们要 fix 的 Class，那么根据类加载原则，有问题的类则不会被加载。

大致流程如图：

热修复原理之一.png

源码地址：

BaseDexClassLoader
DexPathList
DexFile

范例

知道了原理就可以实操了。首先新建工程，创建简单的 Test.java：

public class Test {

    public void say(Context context) {
        Toast.makeText(context, "yes", Toast.LENGTH_SHORT).show();
    }
}

然后在 MainActivity 中调用：

@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        Test test = new Test();
        test.say(this);
}

现在模拟热修复，在不更新 App 的情况下，将 Toast 输出的 yes 改为 no。

因为是模拟，所以我们不考虑如何下载，且为了方便，直接将修改为 no 后的项目打包成 apk，并将 apk push 到 sd 卡根目录。

下面开始代码部分：

1.在自定义 Application 中 attachBaseContext 方法中，加入热修复代码。原因是该方法比 onCreate 更快加载。

2.判断本地有没有更新包，没有则跳过，有则下一步。注意一定要授予 sd 卡读写权限！

File hotfixFile = new File(HOTFIX_APK_PATH);
if (!hotfixFile.exists()) {
    return;
}

3.开始热修复。

<1.利用反射获取 Element 数组。

//获取加载APK的PathDexClassLoader
ClassLoader classLoader = getClassLoader(); //dalvik.system.PathClassLoader
//获取BaseDexClassLoader的DexPathList
Field pathList = classLoader.getClass().getSuperclass().getDeclaredField("pathList");
pathList.setAccessible(true);
Object dexPathList = pathList.get(classLoader);

//获取DexPathList的Element[]
Field dexElements = dexPathList.getClass().getDeclaredField("dexElements");
dexElements.setAccessible(true);
Object[] dexElementsList = (Object[]) dexElements.get(dexPathList);

因为加载 Application 与加载 Test.java 用的是同一个 PathClassLoader（原因见 Activity 启动流程），所以直接在 Application 修改它的 ClassLoader 是没有问题的。

<2.创建包含修复 apk 的 DexFile。

//获取element类型
Class elementClass = dexElementsList.getClass().getComponentType();

//PathDexClassLoader也是可以加载外部Dex的，只要把DexFile传入即可
//创建DexFile
DexFile dexFile = new DexFile(hotfixFile);
//创建Element对象
Constructor constructor = elementClass.getConstructor(DexFile.class, File.class);
constructor.setAccessible(true);
Object elementHot = constructor.newInstance(dexFile, hotfixFile);

<3.替换 element 数组。

//替换element[]，将自定义dex加入到数组前位
Object[] array = (Object[]) Array.newInstance(elementClass, dexElementsList.length + 1);
array[0] = elementHot;
for (int i = 0; i < dexElementsList.length; i++) {
    array[i + 1] = dexElementsList[i];
}
dexElements.set(dexPathList, array);

再次运行，即可看到应用在未更新的情况下 Toast 输出从 yes 变为了 no。

代码不多，看起来很简单，总结实际操作中遇到的一些坑：

1.最初我尝试使用代理模式替换掉 PathDexClassLoader，最终以失败告终。
2.DexFile 的初始化，在传入我的 apk file 后仍然告知我不可用，后来发现是我没有授予 app 读取 sd 卡的权限...
3.PathClassLoader 虽然加载的是 App 本身的 Class，但是只要将对应 DexFile 传入，也是可以加载外部 sd 卡的 Class 的。

完整代码

public class MyApplication extends Application {

    @Override
    public void onCreate() {
        super.onCreate();
    }

    @Override
    protected void attachBaseContext(Context base) {
        super.attachBaseContext(base);
        hotfix();
    }

    private static final String HOTFIX_APK_PATH = "/storage/emulated/0/test.apk";

    private void hotfix() {
        File hotfixFile = new File(HOTFIX_APK_PATH);
        if (!hotfixFile.exists()) {
            return;
        }
        try {
            //获取加载APK的PathDexClassLoader
            ClassLoader classLoader = getClassLoader(); //dalvik.system.PathClassLoader
            //获取BaseDexClassLoader的DexPathList
            Field pathList = classLoader.getClass().getSuperclass().getDeclaredField("pathList");
            pathList.setAccessible(true);
            Object dexPathList = pathList.get(classLoader);

            //获取DexPathList的Element[]
            Field dexElements = dexPathList.getClass().getDeclaredField("dexElements");
            dexElements.setAccessible(true);
            Object[] dexElementsList = (Object[]) dexElements.get(dexPathList);

            //log 输出element[]
            for (int i = 0; i < dexElementsList.length; i++) {
                Log.e("hotfix_demo", dexElementsList[i].toString());
            }

            //获取element类型
            Class elementClass = dexElementsList.getClass().getComponentType();

            //PathDexClassLoader也是可以加载外部Dex的，只要把DexFile传入即可，注意读写权限！！！
            //创建DexFile
            DexFile dexFile = new DexFile(hotfixFile);
            //创建Element对象
            Constructor constructor = elementClass.getConstructor(DexFile.class, File.class);
            constructor.setAccessible(true);
            Object elementHot = constructor.newInstance(dexFile, hotfixFile);

            //替换element[]，将自定义dex加入到数组前位
            Object[] array = (Object[]) Array.newInstance(elementClass, dexElementsList.length + 1);
            array[0] = elementHot;
            for (int i = 0; i < dexElementsList.length; i++) {
                array[i + 1] = dexElementsList[i];
            }
            dexElements.set(dexPathList, array);

        } catch (NoSuchFieldException | IllegalAccessException | NoSuchMethodException | InstantiationException | InvocationTargetException | IOException e) {
            e.printStackTrace();
            Log.e("hotfix_demo", "error " + e.toString());
        }
    }
}