[关闭]
@Tyhj 2020-12-09T13:04:52.000000Z 字数 8295 阅读 269

Android热修复原理及实现(一)

Android


前言

自己之前也做过插件化换肤,涉及到的是插件资源文件的加载;最近看到同事培训的插件化涉及到具体代码的加载;想自己了解一下,就先从最常用的热修复开始看起,由于刚开始接触相关的概念,理解也不是很深,但是总体看下来还是比较简单的,这里记录一下自己的理解;

热修复的应用场景

热修复就是在APP上线以后,如果突然发现有缺陷了,如果重新走发布流程可能时间比较长,重新安装APP用户体验也不会太好;热修复就是通过发布一个插件,使APP运行的时候加载插件里面的代码,从而解决缺陷,并且对于用户来说是无感的(用户也可能需要重启一下APP)。

热修复的原理

先说结论吧,就是将补丁 dex 文件放到 dexElements 数组靠前位置,这样在加载 class 时,优先找到补丁包中的 dex 文件,加载到 class 之后就不再寻找,从而原来的 apk 文件中同名的类就不会再使用,从而达到修复的目的

理解这个原理,需要了解一下Android的代码加载的机制;

Android运行流程

简单来讲整体流程是这样的:
1、Android程序编译的时候,会将.java文件编译时.class文件
2、然后将.class文件打包为.dex文件
3、然后Android程序运行的时候,Android的Dalvik/ART虚拟机就加载.dex文件
4、加载其中的.class文件到内存中来使用

类加载器

负责加载这些.class文件的就是类加载器(ClassLoader),APP启动的时候,会创建一个自己的ClassLoader实例,我们可以通过下面的代码拿到当前的ClassLoader

  1. ClassLoader classLoader = getClassLoader();
  2. Log.i(TAG, "[onCreate] classLoader" + ":" + classLoader.toString());

ClassLoader加载类的方法就是loadClass可以看一下源码,是通过双亲委派模型(Parents Delegation Model),它首先不会自己去尝试加载这个类, 而是把这个请求委派给父类加载器去完成,当父加载器反馈自己无法完成这个加载请求(它的搜索范围中没有找到所需的类) 时, 子加载器才会尝试自己去完成加载,最后是调用自己的findClass方法完成的

  1. protected Class<?> loadClass(String name, boolean resolve)
  2. throws ClassNotFoundException
  3. {
  4. // First, check if the class has already been loaded
  5. Class<?> c = findLoadedClass(name);
  6. if (c == null) {
  7. try {
  8. if (parent != null) {
  9. c = parent.loadClass(name, false);
  10. } else {
  11. c = findBootstrapClassOrNull(name);
  12. }
  13. } catch (ClassNotFoundException e) {
  14. // ClassNotFoundException thrown if class not found
  15. // from the non-null parent class loader
  16. }
  17. if (c == null) {
  18. // If still not found, then invoke findClass in order
  19. // to find the class.
  20. c = findClass(name);
  21. }
  22. }
  23. return c;
  24. }

ClassLoader是一个抽象类,通过打印可以看出来当前的ClassLoader是一个PathClassLoader;看一下PathClassLoader的构造函数,可以看出,需要传入一个dexPath也就是dex包的路径,和父类加载器;

  1. //dexPath 包含 dex 的 jar 文件或 apk 文件的路径集,多个以文件分隔符分隔,默认是“:”
  2. public PathClassLoader(String dexPath, ClassLoader parent) {
  3. super((String)null, (File)null, (String)null, (ClassLoader)null);
  4. throw new RuntimeException("Stub!");
  5. }

PathClassLoader是BaseDexClassLoader的子类,除此之外BaseDexClassLoader还有一个子类是DexClassLoader,optimizedDirectory用来缓存优化的 dex 文件的路径,即从 apk 或 jar 文件中提取出来的 dex 文件;

  1. public DexClassLoader(String dexPath, String optimizedDirectory, String librarySearchPath, ClassLoader parent) {
  2. super((String)null, (File)null, (String)null, (ClassLoader)null);
  3. throw new RuntimeException("Stub!");
  4. }

这两个的区别,网上的答案是

1、DexClassLoader可以加载jar/apk/dex,可以从SD卡中加载未安装的apk
2、PathClassLoader只能加载系统中已经安装过的apk

从这个答案可以知道,我们想要加载更新的插件,肯定是使用 DexClassLoader;但是有点离谱的是其实我用两个都能成功,也许我加载的插件包名这些都和原APP一致导致的吧。

类加载器的运行流程

具体的实现都在BaseDexClassLoader里面,看一下里面的实现(源码看不了,网上搜一下),下面是一个构造方法

  1. public BaseDexClassLoader(String dexPath, File optimizedDirectory, String libraryPath, ClassLoader parent) {
  2. super(parent);
  3. this.originalPath = dexPath;
  4. this.pathList = new DexPathList(this, dexPath, libraryPath, optimizedDirectory);
  5. }

构造方法创建了一个DexPathLis,里面解析了dex文件的路径,并将解析的dex文件都存在this.dexElements里面

  1. public DexPathList(ClassLoader definingContext, String dexPath, String libraryPath, File optimizedDirectory) {
  2. //将解析的dex文件都存在this.dexElements里面
  3. this.dexElements = makeDexElements(splitDexPath(dexPath), optimizedDirectory);
  4. }
  5. //解析dex文件
  6. private static Element[] makeDexElements(ArrayList<File> files, File optimizedDirectory) {
  7. ArrayList<Element> elements = new ArrayList<Element>();
  8. for (File file : files) {
  9. ZipFile zip = null;
  10. DexFile dex = null;
  11. String name = file.getName();
  12. if (name.endsWith(DEX_SUFFIX)) {
  13. dex = loadDexFile(file, optimizedDirectory);
  14. } else if (name.endsWith(APK_SUFFIX) || name.endsWith(JAR_SUFFIX) || name.endsWith(ZIP_SUFFIX)) {
  15. zip = new ZipFile(file);
  16. }
  17. ……
  18. if ((zip != null) || (dex != null)) {
  19. elements.add(new Element(file, zip, dex));
  20. }
  21. } return elements.toArray(new Element[elements.size()]);
  22. }

然后我们再回头看一下ClassLoader加载类的方法,就是loadClass(),最后调用findClass方法完成的;BaseDexClassLoader 重写了该方法,如下

  1. @Override
  2. protected Class<?> findClass(String name) throws ClassNotFoundException {
  3. List<Throwable> suppressedExceptions = new ArrayList<Throwable>();
  4. // 使用pathList对象查找name类
  5. Class c = pathList.findClass(name, suppressedExceptions);
  6. return c;
  7. }

最终是调用 pathList的findClass方法,看一下方法如下

  1. public Class findClass(String name, List<Throwable> suppressed) {
  2. // 遍历从dexPath查询到的dex和资源Element
  3. for (Element element : dexElements) {
  4. DexFile dex = element.dexFile;
  5. // 如果当前的Element是dex文件元素
  6. if (dex != null) {
  7. // 使用DexFile.loadClassBinaryName加载类
  8. Class clazz = dex.loadClassBinaryName(name, definingContext, suppressed);
  9. if (clazz != null) {
  10. return clazz;
  11. }
  12. }
  13. }
  14. if (dexElementsSuppressedExceptions != null) {
  15. suppressed.addAll(Arrays.asList(dexElementsSuppressedExceptions));
  16. }
  17. return null;
  18. }

结论

所以整个类加载流程就是

1、类加载器BaseDexClassLoader先将dex文件解析放到pathList到dexElements里面
2、加载类的时候从dexElements里面去遍历,看哪个dex里面有这个类就去加载,生成class对象

所以我们可以将自己的dex文件加载到dexElements里面,并且放在前面,加载的时候就可以加载我们插件中的类,不会加载后面的,从而替换掉原来的class。

热修复的实现

知道了原理,实现就比较简单了,就添加新的dex对象到当前APP的ClassLoader对象(也就是BaseDexClassLoader)的pathList里面的dexElements;要添加就要先创建,我们使用DexClassLoader先加载插件,先生成插件的dexElements,然后再添加就好了。

当然整个过程需要使用反射来实现。除此以外,常用的两种方法是使用apk作为插件和使用dex文件作为插件;下面的两个实现都是对程序中的一个方法进行了修改,然后分别打了 dex包和apk包,程序运行起来执行的方法就是插件里面的方法而不是程序本身的方法;

dex插件

对于dex文件作为插件,和之前说的流程完全一致,先将修改了的类进行打包成dex包,将dex进行加载,插入到dexElements集合的前面即可;打包流程是先将.java文件编译成.class文件,然后使用SDK工具打包成dex文件人,然后APP下载,加载即可;

dex打包工具

d8 作为独立工具纳入了 Android 构建工具 28.0.1 及更高版本中:C:\Users\hanpei\AppData\Local\Android\Sdk\build-tools\29.0.2\d8.bat;输入字节码可以是 *.class 文件或容器(例如 JAR、APK 或 ZIP 文件)的任意组合。您还可以添加 DEX 文件作为 d8 的输入,以将这些文件合并到 DEX 输出中

  1. d8 MyProject/app/build/intermediates/classes/debug/*/*.class

具体的代码实现

代码的注释已经很详细了,就不再进行说明了

  1. //在Application中进行替换
  2. public class MApplication extends Application {
  3. @Override
  4. public void onCreate() {
  5. super.onCreate();
  6. //dex作为插件进行加载
  7. dexPlugin();
  8. }
  9. ...
  10. /**
  11. * dex作为插件加载
  12. */
  13. private void dexPlugin(){
  14. //插件包文件
  15. File file = new File("/sdcard/FixTest.dex");
  16. if (!file.exists()) {
  17. Log.i("MApplication", "插件包不在");
  18. return;
  19. }
  20. try {
  21. //获取到 BaseDexClassLoader 的 pathList字段
  22. // private final DexPathList pathList;
  23. Field pathListField = BaseDexClassLoader.class.getDeclaredField("pathList");
  24. //破坏封装,设置为可以调用
  25. pathListField.setAccessible(true);
  26. //拿到当前ClassLoader的pathList对象
  27. Object pathListObj = pathListField.get(getClassLoader());
  28. //获取当前ClassLoader的pathList对象的字节码文件(DexPathList )
  29. Class<?> dexPathListClass = pathListObj.getClass();
  30. //拿到DexPathList 的 dexElements字段
  31. // private final Element[] dexElements;
  32. Field dexElementsField = dexPathListClass.getDeclaredField("dexElements");
  33. //破坏封装,设置为可以调用
  34. dexElementsField.setAccessible(true);
  35. //使用插件创建 ClassLoader
  36. DexClassLoader pathClassLoader = new DexClassLoader(file.getPath(), getCacheDir().getAbsolutePath(), null, getClassLoader());
  37. //拿到插件的DexClassLoader 的 pathList对象
  38. Object newPathListObj = pathListField.get(pathClassLoader);
  39. //拿到插件的pathList对象的 dexElements变量
  40. Object newDexElementsObj = dexElementsField.get(newPathListObj);
  41. //拿到当前的pathList对象的 dexElements变量
  42. Object dexElementsObj=dexElementsField.get(pathListObj);
  43. int oldLength = Array.getLength(dexElementsObj);
  44. int newLength = Array.getLength(newDexElementsObj);
  45. //创建一个dexElements对象
  46. Object concatDexElementsObject = Array.newInstance(dexElementsObj.getClass().getComponentType(), oldLength + newLength);
  47. //先添加新的dex添加到dexElement
  48. for (int i = 0; i < newLength; i++) {
  49. Array.set(concatDexElementsObject, i, Array.get(newDexElementsObj, i));
  50. }
  51. //再添加之前的dex添加到dexElement
  52. for (int i = 0; i < oldLength; i++) {
  53. Array.set(concatDexElementsObject, newLength + i, Array.get(dexElementsObj, i));
  54. }
  55. //将组建出来的对象设置给 当前ClassLoader的pathList对象
  56. dexElementsField.set(pathListObj, concatDexElementsObject);
  57. } catch (Exception e) {
  58. e.printStackTrace();
  59. }
  60. }

apk插件

apk作为插件,就是我们重新打了一个新的apk包作为插件,打包很简单方便,缺点就是文件大;使用apk的话就没必要是将dex插入dexElements里面去,直接将之前的dexElements替换就可以了;

具体的实现

代码的注释已经很详细了,就不再进行说明了

  1. /**
  2. * apk作为插件加载
  3. */
  4. private void apkPlugin() {
  5. //插件包文件
  6. File file = new File("/sdcard/FixTest.apk");
  7. if (!file.exists()) {
  8. Log.i("MApplication", "插件包不在");
  9. return;
  10. }
  11. try {
  12. //获取到 BaseDexClassLoader 的 pathList字段
  13. // private final DexPathList pathList;
  14. Field pathListField = BaseDexClassLoader.class.getDeclaredField("pathList");
  15. //破坏封装,设置为可以调用
  16. pathListField.setAccessible(true);
  17. //拿到当前ClassLoader的pathList对象
  18. Object pathListObj = pathListField.get(getClassLoader());
  19. //获取当前ClassLoader的pathList对象的字节码文件(DexPathList )
  20. Class<?> dexPathListClass = pathListObj.getClass();
  21. //拿到DexPathList 的 dexElements字段
  22. // private final Element[] dexElements;
  23. Field dexElementsField = dexPathListClass.getDeclaredField("dexElements");
  24. //破坏封装,设置为可以调用
  25. dexElementsField.setAccessible(true);
  26. //使用插件创建 ClassLoader
  27. DexClassLoader pathClassLoader = new DexClassLoader(file.getPath(), getCacheDir().getAbsolutePath(), null, getClassLoader());
  28. //拿到插件的DexClassLoader 的 pathList对象
  29. Object newPathListObj = pathListField.get(pathClassLoader);
  30. //拿到插件的pathList对象的 dexElements变量
  31. Object newDexElementsObj = dexElementsField.get(newPathListObj);
  32. //将插件的 dexElements对象设置给 当前ClassLoader的pathList对象
  33. dexElementsField.set(pathListObj, newDexElementsObj);
  34. } catch (Exception e) {
  35. e.printStackTrace();
  36. }
  37. }

总结

思路还是很清晰的,主要是要先了解类加载的原理,整体来讲还是比较简单的;采用类加载方案的主要是以腾讯系为主,包括微信的Tinker、QQ空间的超级补丁、手机QQ的QFix、饿了么的Amigo和Nuwa等等;也有一些其他的方法来实现热修复,有空再进行总结分享。

添加新批注
在作者公开此批注前,只有你和作者可见。
回复批注