Android知识进阶(遥远的重头开始)

Android 热修复介绍之代码修复

2019-01-09  本文已影响0人  没走过的二丁目

什么是Android热修复技术

简单来说就是不重新安装apk的情况下，通过补丁，修复bug


正常开发流程
热修复开发流程

目前主流的热修复技术框架

关于热修复的技术积淀

本文重点介绍如何在项目中实现代码修复

通过类加载机制实现
通过底层替换方法实现

ClassLoader 简介

对于 Java 程序来说，编写程序就是编写类，运行程序也就是运行类（编译得到的 class 文件），其中起到关键作用的就是类加载器 ClassLoader。说起类加载器我就想到ClassLoader的双亲委托加载机制，接下来就介绍一下类加载的双亲机制

双亲机制

当类加载器收到加载类或资源的请求时，通常都是先委托给父类加载器加载，也就是说只有当父类加载器找不到指定类或资源时，自身才会执行实际的类加载过程，具体的加载过程如下：
1 源 ClassLoader 先判断该 Class 是否已加载，如果已加载，则直接返回 Class，如果没有则委托给父类加载器。

2 父类加载器判断是否加载过该 Class，如果已加载，则直接返回 Class，如果没有则委托给祖父类加载器。

3 依此类推，直到始祖类加载器（引用类加载器）。

4 始祖类加载器判断是否加载过该 Class，如果已加载，则直接返回 Class，如果没有则尝试从其对应的类路径下寻找 class 字节码文件并载入。如果载入成功，则直接返回 Class，如果载入失败，则委托给始祖类加载器的子类加载器。

5 始祖类加载器的子类加载器尝试从其对应的类路径下寻找 class 字节码文件并载入。如果载入成功，则直接返回 Class，如果载入失败，则委托给始祖类加载器的孙类加载器。

6 依此类推，直到源 ClassLoader。

7 源 ClassLoader 尝试从其对应的类路径下寻找 class 字节码文件并载入。如果载入成功，则直接返回 Class，如果载入失败，源 ClassLoader 不会再委托其子类加载器，而是抛出异常。

Android 中的ClassLoader

Android 的 Dalvik/ART 虚拟机如同标准 Java 的 JVM 虚拟机一样，也是同样需要加载 class 文件到内存中来使用，但是在 ClassLoader 的加载细节上会有略微的差别。

Android的dex文件
Android 应用打包成 apk 文件时，class 文件会被打包成一个或者多个 dex 文件，Android 中的 Dalvik/ART 无法像 JVM 那样 直接 加载 class 文件和 jar 文件中的 class，需要通过 dx 工具来优化转换成 Dalvik byte code 才行，只能通过 dex 或者 包含 dex 的jar、apk 文件来加载（注意 odex 文件后缀可能是 .dex 或 .odex，也属于 dex 文件），因此 Android 中的 ClassLoader 工作就交给了 BaseDexClassLoader 来处理。

如何通过类加载机制实现

首先需要认识BaseDexClassLoader、PathClassLoader和DexClassLoader

对比 PathClassLoader 只能加载已经安装应用的 dex 或 apk 文件，DexClassLoader 则没有此限制，可以从 SD 卡上加载包含 class.dex 的 .jar 和 .apk 文件，这也是插件化和热修复的基础，在不需要安装应用的情况下，完成需要使用的 dex 的加载。

BaseDexClassLoader查找类的源码：

@Override
    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;
    }

通过源码可以看到，BaseDexClassLoader通过pathList.findClass查找类的，这里出现一个 大Boss “PathList”
PathList：中保存类所有dex文件和信息，看一下它是怎么查找类的
PathList源码：

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;
    }

前方高能：

可以看到，PathList从dexElements中查找类，如果clazz != null直接return class，这就是我们可以利用的地方，从源码看，dexElements应该是个数组或者集合，设想：我们是不是可以把我们修复bug后的xx类，打包成dex，插入到dexElements的最前面，这样，系统通过PathClassLoader,查找bug类的时候，就会下找到我们的修复bug的xx类，然后直接返回，不去管后面有bug的那个xx类，达到热修复的功能

理一下我们热修复的方案

项目中的实现

实现步骤

如何生成dex补丁包

用class文件生成”001dex”补丁
android在sdk/build-tools/文件件下提供了”dx”命令工具，帮助我们将class文件生成dex文件

生成方式如下：

dx –dex –output=<要生成的文件> <’class’文件路径>

例如：
dx –dex –output=001.dex …MainAtvity …Actvity2.class …People.class

核心代码

/**
 * 加载并安装补丁
 * @type {[type]}
 */
private void loadPatch(File file){
        Log.d(TAG, file.getAbsolutePath()) ;
        if(file.exists()){
            Log.d(TAG,"文件存在...") ;
        }else{
            Log.d(TAG, "文件不存在...") ;
        }
        //获取系统PathClassLoader
        PathClassLoader pLoader = (PathClassLoader) context.getClassLoader();
        //获取PathClassLoader中的PathList
        Object pPathList = getPathList(pLoader) ;
        if(pPathList == null){
            Log.d(TAG, "get PathClassLoader pathlist failed...") ;
            return ;
        }
        //加载补丁
        DexClassLoader dLoader = new DexClassLoader(file.getAbsolutePath(),optPath, null, pLoader) ;
        //获取DexClassLoader的pathLit，即BaseDexClassLoader中的pathList
        Object dPathList = getPathList(dLoader) ;
        if(dPathList == null){
            Log.d(TAG, "get DexClassLoader pathList failed...") ;
            return ;
        }
        //获取PathList和DexClassLoader的DexElements
        Object pElements = getElements(pPathList) ;
        Object dElements = getElements(dPathList) ;

        //将补丁dElements[]插入系统pElements[]的最前面
        Object newElements = insertElements(pElements, dElements) ;
        if(newElements == null){
            Log.d(TAG, "patch insert failed...") ;
            return ;
        }
        //用插入补丁后的新Elements[]替换系统Elements[]
        try {
            Field fElements = pPathList.getClass().getDeclaredField("dexElements") ;
            fElements.setAccessible(true);
            fElements.set(pPathList, newElements);
        } catch (Exception e) {
            e.printStackTrace();
            Log.d(TAG, "fixed failed....") ;
            return ;
        }
    }

    /**
     * 将补丁插入系统DexElements[]最前端，生成一个新的DexElements[]
     * @param pElements
     * @param dElements
     * @return
     */
    private Object insertElements(Object pElements, Object dElements){
        //判断是否为数组
        if(pElements.getClass().isArray() && dElements.getClass().isArray()){
            //获取数组长度
            int pLen = Array.getLength(pElements) ;
            int dLen = Array.getLength(dElements) ;
            //创建新数组
            Object newElements = Array.newInstance(pElements.getClass().getComponentType(), pLen+dLen) ;
            //循环插入
            for(int i=0; i<pLen+dLen;i++){
                if(i<dLen){
                    Array.set(newElements, i, Array.get(dElements, i));
                }else{
                    Array.set(newElements, i, Array.get(pElements, i-dLen)) ;
                }
            }
            return newElements ;
        }
        return null ;
    }

    /**
     *  获取DexElements
     * @param object
     * @return
     */
    private Object getElements(Object object){
        try {
            Class<?> c = object.getClass() ;
            Field fElements = c.getDeclaredField("dexElements") ;
            fElements.setAccessible(true);
            Object obj = fElements.get(object) ;
            return obj ;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null ;
    }

    /**
     * 通过反射机制获取PathList
     * @param loader
     * @return
     */
    private Object getPathList(BaseDexClassLoader loader){
        try {
            Class<?> c = Class.forName("dalvik.system.BaseDexClassLoader") ;
            //获取成员变量pathList
            Field fPathList = c.getDeclaredField("pathList") ;
            //抑制jvm检测访问权限
            fPathList.setAccessible(true);
            //获取成员变量pathList的值
            Object obj = fPathList.get(loader) ;
            return obj ;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null ;
    }
上一篇下一篇

猜你喜欢

热点阅读