插件化、组件化、热修复

2023-07-30  本文已影响0人  业精于勤_荒于嬉

一、Android插件化、组件化、热修复的区别

插件化
插件化是一种将应用程序按照模块或组件进行拆分，并以插件的方式动态加载和运行的技术。其主要原理包括以下几个步骤：

总之，Android插件化利用动态加载技术将应用程序切割成多个独立安装运行的组件，并借助合适框架管理各种资源及上下文环境等信息。

组件化
组件化是一种将应用程序按照功能模块拆分，并以组件的方式进行开发、管理和复用的技术。其主要原理包括以下几个步骤：

Android组件化旨在实现模块化开发，让不同团队可以并行开发不同模块，并且能够灵活地替换、新增或删除某些功能。

热修复
热修复是一种在应用程序运行时对已发布版本进行动态修复bug或更新功能的技术。其主要原理包括以下几个步骤：

总之，Android热修复技术利用补丁文件实现对已发布版本进行动态修复和更新。它可以快速响应问题并部署解决方案，而无须重新发布整个应用程序。

二、Tinker热修复的原理

热修复的方案有很多种，其中原理也各不相同。目前开源的比较有名的有阿里的AndFix、美团的Robust、qq的QZone以及Tinker等。

1、Tinker的优点

2、Tinker热修复的流程

（1）Tinker将新旧dex做了diff（差分算法），得到patch.dex
（2）然后将patch.dex下发到客户端，客户端将patch.dex与旧dex的classes.dex做合并，生成新的classes.dex
（3）在运行时通过反射将合成后的全量dex插入到dex elements前面（放在Element数组的第一个元素），完成修复。（饿了么的Amigo则是将补丁包中每个dex对应的Element取出来，之后组成新的Element数组，在运行时通过反射用新的Element数组替换掉现有的Element数组）。

在ClassLoader的加载过程中，其中一个环节就是调用DexPathList的findClass的方法，如下所示，libcore/dalvik/src/main/java/dalvik/system/DexPathList.java

public Class<?> findClass(String name, List<Throwable> suppressed) {
       for (Element element : dexElements) {//1
           Class<?> clazz = element.findClass(name, definingContext, suppressed);//2
           if (clazz != null) {
               return clazz;
           }
       }
       if (dexElementsSuppressedExceptions != null) {
           suppressed.addAll(Arrays.asList(dexElementsSuppressedExceptions));
       }
       return null;
   }

类加载方案需要重启App后让ClassLoader重新加载新的类，为什么要重启呢？这是因为类是无法被卸载的，因此想要重新加载类就需要重启App，因此采用类加载方案的热修复框架是不能即时生效的。

Tinker热修复的流程图.png

3、65536限制与LinearAlloc限制

类的加载方案基于Dex分包方案，什么是Dex分包方案？这个得先从65536限制和LinearAlloc限制说起。

65536限制

随着应用功能越来越复杂，代码量不断增大，引入的库也越来越多，可能会在编译时提示如下异常：

com.android.dex.DexIndexOverflowException:method ID not in [0,0xffff]:65536

这说明应用中引用的方法数超过了最大数65536个。产生这个问题的原因就是系统的65536限制，65536限制的主要原因是DVM Bytecode的限制。DVM指令集的方法调用指令 invoke-kind索引为16bits，最多能引用65536。

LinearAlloc限制

在安装应用时可能会提示INSTALL_FAILED_DEXOPT,产生的原因就是LinearAlloc限制，DVM中的LinearAlloc是一个固定的缓存区，当方法数超出了缓存区的大小时会报错。

为了解决65536限制和LinearAlloc限制，从而产生了Dex分包方案。Dex分包方案主要做的是在打包时将应用代码分成多个Dex，将应用启动时必须用到的类和这些类的直接引用类放到主Dex中，其他代码放到次Dex中。当应用启动时先加载主Dex，等到应用启动后再动态地加载次Dex，从而缓解了主Dex的65536限制和LinearAlloc限制。

Dex分包方案主要有两种，分别是Google官方方案、Dex自动拆包和动态加载方案。

4、PathClassLoader和DexClassLoader

Android系统中又两个应用程序类加载器，它们分别是PathClassLoader和DexClassLoader，它们都是继承于BaseDexClassLoader的，而BaseDexClassLoader继承ClassLoader。

BaseDexClassLoader类加载：

@Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        List<Throwable> suppressedExceptions = new ArrayList<Throwable>();
        //在自己的成员变量DexPathList中寻找，找不到抛异常
        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;
    }

public Class findClass(String name, List<Throwable> suppressed) {
        //循环遍历成员变量dexElements，调用DexFile.loadClassBinaryName加载class
        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;
    }

PathClassLoader和DexClassLoader的区别

总结起来：

4、核心原理

PackageManagerService拿到apk，然后从后台下载修复的patch.dex包。注意，这里我们可能有多个dex文件需要更新

public static void loadFixedDex(Context context) {
        if (context == null) return;
        // Dex文件目录（私有目录中，存在之前已经复制过来的修复包）
        File fileDir = context.getDir(Constants.DEX_DIR, Context.MODE_PRIVATE);
        File[] listFiles = fileDir.listFiles();
        // 遍历私有目录中所有的文件
        for (File file : listFiles) {
            // 找到修复包，加入到集合
            if (file.getName().endsWith(Constants.DEX_SUFFIX) && !"classes.dex".equals(file.getName())) {
                loadedDex.add(file);
            }
        }

        // 模拟类加载器
        createDexClassLoader(context, fileDir);
    }

这个方法的作用是找到dex文件存在的位置并遍历dex文件然后保存在一个集合中。然后调用createDexClassLoader方法。

private static void createDexClassLoader(Context context, File fileDir) {
        // 创建临时的解压目录（先解压到该目录，再加载java）
        String optimizedDir = fileDir.getAbsolutePath() + File.separator + "opt_dex";
        // 不存在就创建
        File fopt = new File(optimizedDir);
        if (!fopt.exists()) {
            // 创建多级目录
            fopt.mkdirs();
        }
        for (File dex : loadedDex) {
            // 每遍历一个要修复的dex文件，就需要插桩一次
            DexClassLoader classLoader = new DexClassLoader(dex.getAbsolutePath(),
                    optimizedDir, null, context.getClassLoader());
            hotfix(classLoader, context);
        }
    }  


private static void hotfix(DexClassLoader classLoader, Context context) {
// 获取系统PathClassLoader类加载器
PathClassLoader pathLoader = (PathClassLoader) context.getClassLoader();
try {
        // 获取自有的dexElements数组对象
        Object myDexElements = ReflectUtils.getDexElements(ReflectUtils.getPathList(classLoader));

        // 获取系统的dexElements数组对象
        Object systemDexElements = ReflectUtils.getDexElements(ReflectUtils.getPathList(pathLoader));

        // 合并成新的dexElements数组对象
        Object dexElements = ArrayUtils.combineArray(myDexElements, systemDexElements);

        // 通过反射再去获取   系统的pathList对象
        Object systemPathList = ReflectUtils.getPathList(pathLoader);

        // 重新赋值给系统的pathList属性  --- 修改了pathList中的dexElements数组对象
        ReflectUtils.setField(systemPathList, systemPathList.getClass(), dexElements);
    } catch (Exception e) {
        e.printStackTrace();
    }
}  

public class ReflectUtils {

    /**
     * 通过反射获取某对象，并设置私有可访问
     *
     * @param obj   该属性所属类的对象
     * @param clazz 该属性所属类
     * @param field 属性名
     * @return 该属性对象
     */
    private static Object getField(Object obj, Class<?> clazz, String field)
            throws NoSuchFieldException, IllegalAccessException, IllegalArgumentException {
        Field localField = clazz.getDeclaredField(field);
        localField.setAccessible(true);
        return localField.get(obj);
    }

    /**
     * 给某属性赋值，并设置私有可访问
     *
     * @param obj   该属性所属类的对象
     * @param clazz 该属性所属类
     * @param value 值
     */
    public static void setField(Object obj, Class<?> clazz, Object value)
            throws NoSuchFieldException, IllegalAccessException, IllegalArgumentException {
        Field localField = clazz.getDeclaredField("dexElements");
        localField.setAccessible(true);
        localField.set(obj, value);
    }

    /**
     * 通过反射获取BaseDexClassLoader对象中的PathList对象
     *
     * @param baseDexClassLoader BaseDexClassLoader对象
     * @return PathList对象
     */
    public static Object getPathList(Object baseDexClassLoader)
            throws NoSuchFieldException, IllegalAccessException, IllegalArgumentException, ClassNotFoundException {
        return getField(baseDexClassLoader, Class.forName("dalvik.system.BaseDexClassLoader"), "pathList");
    }

    /**
     * 通过反射获取BaseDexClassLoader对象中的PathList对象，再获取dexElements对象
     *
     * @param paramObject PathList对象
     * @return dexElements对象
     */
    public static Object  getDexElements(Object paramObject)
            throws NoSuchFieldException, IllegalAccessException, IllegalArgumentException {
        return getField(paramObject, paramObject.getClass(), "dexElements");
    }
}

参考：https://www.jianshu.com/p/e6c4eedd83ab和https://www.jianshu.com/p/6e412b0115f1

上一篇 下一篇

猜你喜欢

热点阅读