Android热更新探究(二、美团Robust原理)

最新推荐文章于 2023-06-13 20:08:35 发布

绝望的涮羊肉

最新推荐文章于 2023-06-13 20:08:35 发布

阅读量1k

点赞数

分类专栏： android 组件学习

android 组件学习专栏收录该内容

4 篇文章 0 订阅

订阅专栏

我们来继续探究一下热更新的一些情况，这次是美团的Robust，它的原理主要参考来InstantRun,这里大概做一下介绍

从 InstantRun 说起

不得不说 InstantRun 真是个好东西。目前主流的热修复框架都有或多或少的参考 InstantRun 的某些技术点

InstantRun 对应三种更新机制：

冷插拔，我们称之为重启更新机制
温插拔，我们称之为重启Activity更新机制
热插拔，我们称之为热更新机制

InstantRun的实现原理

InstantRun主要分两部分，我这边就举个例子

gradle plugin 2.0.0-alpha1

gradle plugin 2.0.0-alpha1主要有两个作用：

1、第一次运行，应用transform API修改字节码

*给所有的类添加$change字段

$change为IncrementalChange类型，IncrementalChange是个接口

*修改类的全部方法

后续逻辑是：如果$change不为空，去调用$change的access$dispatch方法，参数为方法签名字符串和方法参数数组，否则调用原逻辑

2、后续运行，dx补丁类，生成补丁dex

被修改类对应的补丁类

补丁类，由gradle plugin自动生成，实现了IncrementalChange接口的类

该类类名在原名后面添加$override，复制修改后类的大部分方法，实现IncrementalChange 接口的access$dispatch方法

只要把原类的$change字段设置为该类，那就会调用该类的access$dispatch方法，就会使用修改后的方法了

被修改类的记录类

AppPatchesLoaderImpl记录了所有被修改的类，也会被打进补丁dex。

instant-run.jar

instant-run.jar的路径为Application/build/intermediates/incremental-runtime-classes/debug/instant-run.jar。

instant-run.jar是gradle plugin帮我们自动打到dex中去的，省去了compile dependency这一步。它的主要作用有两个：

设置原类的$change字段为补丁类
需要对被修改的类设置$change字段，那怎么知道哪些类被修改了？
AppPatchesLoaderImpl类不但记录了全部被修改的类，还提供load方法支持设置被修改原类$change字段，当收到补丁通知时，只需新建一个DexClassLoader，去反射加载补丁dex中的AppPatchesLoaderImpl类，调用load方法即可，load方法中会去加载全部补丁类，并赋值给对应原类的$change。
重启加载补丁类
重启后怎么办？原来的补丁文件需要加载进来。
IncrementalClassLoader会在Application中去加载该应用cache目录中的补丁dex，把它设置为默认PathClassLoader的parent，由于ClassLoader采用双亲委托模型，会先去parent查找类，所以就可以加载补丁类了。

Instant就先说到这里，至于冷插拔、温插拔、热插拔在另外的文章再去介绍，我们还是回到Robust

Robust 原理解析

Robust 的原理可以简单描述为：

打基础包时插桩，在每个方法前插入一段类型为 ChangeQuickRedirect 静态变量的逻辑
加载补丁时，从补丁包中读取要替换的类及具体替换的方法实现，新建 ClassLoader 加载补丁dex。

基础概念

1、在每个方法前插入一段类型为 ChangeQuickRedirect 静态变量的逻辑

打基础包时，Robust 为每个类新增了一个类型为 ChangeQuickRedirect 的静态变量，并且在每个方法前，增加判断该变量是否为空的逻辑，如果不为空，走打基础包时插桩的逻辑，否则走正常逻辑。我们反编译出基础包中的代码如下：

//SecondActivity
public static ChangeQuickRedirect u;
protected void onCreate(Bundle bundle) {
        if (u != null) {
            if (PatchProxy.isSupport(new Object[]{bundle}, this, u, false, 78)) {
                PatchProxy.accessDispatchVoid(new Object[]{bundle}, this, u, false, 78);
                return;
            }
        }
        super.onCreate(bundle);
        ...
    }

2、加载补丁

对应于补丁文件，需要有三个文件

-PatchesInfoImpl 用于记录修改的类，及其对应的 ChangeQuickRedirect 接口的实现，我们反编译补丁包得出以下结果，其中的类名是混淆后的。

public class PatchesInfoImpl implements PatchesInfo {
    public List getPatchedClassesInfo() {
        List arrayList = new ArrayList();
        arrayList.add(new PatchedClassInfo("com.meituan.sample.robusttest.l", "com.meituan.robust.patch.SampleClassPatchControl"));
        arrayList.add(new PatchedClassInfo("com.meituan.sample.robusttest.p", "com.meituan.robust.patch.SuperPatchControl"));
        arrayList.add(new PatchedClassInfo("com.meituan.sample.SecondActivity", "com.meituan.robust.patch.SecondActivityPatchControl"));
        EnhancedRobustUtils.isThrowable = false;
        return arrayList;
    }
}

-xxxPatchControl 是 ChangeQuickRedirect 接口的具体实现，是一个代理，具体的替换方法是在 xxxPatch 类中

public class SecondActivityPatchControl implements ChangeQuickRedirect {
...
    public boolean isSupport(String methodName, Object[] paramArrayOfObject) {
        return "78:79:90:".contains(methodName.split(":")[3]);
    }
    public Object accessDispatch(String methodName, Object[] paramArrayOfObject) {
        try {
            SecondActivityPatch secondActivityPatch;
            ...
            Object obj = methodName.split(":")[3];
            if ("78".equals(obj)) {
                secondActivityPatch.onCreate((Bundle) paramArrayOfObject[0]);
            }
            if ("79".equals(obj)) {
                return secondActivityPatch.getTextInfo((String) paramArrayOfObject[0]);
            }
            if ("90".equals(obj)) {
                secondActivityPatch.RobustPubliclambda$onCreate$0((View) paramArrayOfObject[0]);
            }
            return null;
        } catch (Throwable th) {
            th.printStackTrace();
        }
    }
}

最终调用 accessDispatch 方法，该方法会根据传递过来的方法签名，调用xxxPatch的修改过的方法。

xxxPatch 具体的替换实现类，代码就不贴了。

其过程可以简单描述为，下发补丁包后，新建 DexClassLoader 加载补丁 dex 文件，反射得到 PatchesInfoImpl class，并创建其对象，调用 getPatchedClassesInfo() 方法得到哪些修改的类（比如 SecondActivity），然后再通过反射循环拿到每个修改类在当前环境中的的class，将其中类型为 ChangeQuickRedirect 的静态变量反射修改为 xxxPatchControl.java 这个class new 出来的对象。

用官方的一种图很好的表达了替换原理。

补丁加载过程分析

demo中的补丁加载就一句

new PatchExecutor(getApplicationContext(), new PatchManipulateImp(),  new Callback()).start();

PatchExecutor 是个 Thread

public class PatchExecutor extends Thread {

@Override

public void run() {

...

applyPatchList(patches);

...

}

/**

* 应用补丁列表

protected void applyPatchList(List<Patch> patches) {

...

for (Patch p : patches) {

...

currentPatchResult = patch(context, p);

...

}

protected boolean patch(Context context, Patch patch) {

...

DexClassLoader classLoader = new DexClassLoader(patch.getTempPath(), context.getCacheDir().getAbsolutePath(),

null, PatchExecutor.class.getClassLoader());

patch.delete(patch.getTempPath());

...

try {

patchsInfoClass = classLoader.loadClass(patch.getPatchesInfoImplClassFullName());

patchesInfo = (PatchesInfo) patchsInfoClass.newInstance();

} catch (Throwable t) {

...

}

...

for (PatchedClassInfo patchedClassInfo : patchedClasses) {

...

try {

oldClass = classLoader.loadClass(patchedClassName.trim());

Field[] fields = oldClass.getDeclaredFields();

for (Field field : fields) {

if (TextUtils.equals(field.getType().getCanonicalName(), ChangeQuickRedirect.class.getCanonicalName()) && TextUtils.equals(field.getDeclaringClass().getCanonicalName(), oldClass.getCanonicalName())) {

changeQuickRedirectField = field;

break;

}

...

try {

patchClass = classLoader.loadClass(patchClassName);

Object patchObject = patchClass.newInstance();

changeQuickRedirectField.setAccessible(true);

changeQuickRedirectField.set(null, patchObject);

} catch (Throwable t) {

...

}

} catch (Throwable t) {

...

}

return true;

}

开启一个子线程，通过指定的路径去读patch文件的jar包，patch文件可以为多个，每个patch文件对应一个 DexClassLoader 去加载，每个patch文件中存在PatchInfoImp，通过遍历其中的类信息进而反射修改其中 ChangeQuickRedirect 对象的值。

基础包插桩过程分析

类似 InstantRun ， Robust 也是使用 Transform API 修改字节码文件，该 API 允许第三方插件在 .class 文件打包为 dex 文件之前操作编译好的 .class 字节码文件。

Robust 中的 Gradle-Plugin 就是操作字节码的名为 robust 的 gradle 插件项目。我们来简单看下实现。

class RobustTransform extends Transform implements Plugin<Project> {
    ...
    @Override
    void apply(Project target) {
            //解析项目下robust.xml配置文件
            robust = new XmlSlurper().parse(new File("${project.projectDir}/${Constants.ROBUST_XML}"))
            ...
            project.android.registerTransform(this)
            project.afterEvaluate(new RobustApkHashAction())
        }
        
    @Override
    void transform(Context context, Collection<TransformInput> inputs, Collection<TransformInput> referencedInputs, TransformOutputProvider outputProvider, boolean isIncremental) throws IOException, TransformException, InterruptedException {
    ...
    ClassPool classPool = new ClassPool()
    project.android.bootClasspath.each {
        logger.debug "android.bootClasspath   " + (String) it.absolutePath
        classPool.appendClassPath((String) it.absolutePath)
    }
    ...
    def box = ConvertUtils.toCtClasses(inputs, classPool)
    insertRobustCode(box, jarFile)
    writeMap2File(methodMap, Constants.METHOD_MAP_OUT_PATH)
    ...
    }
}

首先读取 robust.xml 配置文件并初始化，可配置选项包括：

一些开关选项
需要热补丁的包名或者类名，这些包名下的所有类都被会插入代码
不需要热补的包名或者类名，可以在需要热补的包中剔除指定的类或者包

然后通过 Transform API 调用 transform() 方法，扫描所有类加入到 classPool 中，调用 insertRobustCode() 方法。

def insertRobustCode(List<CtClass> box, File jarFile) {
    ZipOutputStream outStream=new JarOutputStream(new FileOutputStream(jarFile));
    new ForkJoinPool().submit {
        box.each { ctClass ->
            if (isNeedInsertClass(ctClass.getName())) {
               //将class设置为public ctClass.setModifiers(AccessFlag.setPublic(ctClass.getModifiers()))
                boolean addIncrementalChange = false;
                ctClass.declaredBehaviors.findAll {
                //规避接口和无方法类
                    if (ctClass.isInterface() || ctClass.declaredMethods.length < 1) {
                        return false;
                    }
                    if (!addIncrementalChange) {
                    //插入 public static ChangeQuickRedirect changeQuickRedirect;
                        addIncrementalChange = true;
                        ClassPool classPool = it.declaringClass.classPool
                        CtClass type = classPool.getOrNull(Constants.INTERFACE_NAME);
                        CtField ctField = new CtField(type, Constants.INSERT_FIELD_NAME, ctClass);
                        ctField.setModifiers(AccessFlag.PUBLIC | AccessFlag.STATIC)
                        ctClass.addField(ctField)
                        logger.debug "ctClass: " + ctClass.getName();
                    }
                    if (it.getMethodInfo().isStaticInitializer()) {
                        return false
                    }
                    // synthetic 方法暂时不aop 比如AsyncTask 会生成一些同名 synthetic方法,对synthetic 以及private的方法也插入的代码，主要是针对lambda表达式
                    if ((it.getModifiers() & AccessFlag.SYNTHETIC) != 0 && !AccessFlag.isPrivate(it.getModifiers())) {
                        return false
                    }
                    //不支持构造方法
                    if (it.getMethodInfo().isConstructor()) {
                        return false
                    }
                    //规避抽象方法
                    if ((it.getModifiers() & AccessFlag.ABSTRACT) != 0) {
                        return false
                    }
                    //规避NATIVE方法
                    if ((it.getModifiers() & AccessFlag.NATIVE) != 0) {
                        return false
                    }
                    //规避接口
                    if ((it.getModifiers() & AccessFlag.INTERFACE) != 0) {
                        return false
                    }
                    if (it.getMethodInfo().isMethod()) {
                        if (AccessFlag.isPackage(it.modifiers)) {
                            it.setModifiers(AccessFlag.setPublic(it.modifiers))
                        }
                        //判断是否有方法调用，返回是否插庄
                        boolean flag = modifyMethodCodeFilter(it)
                        if (!flag) {
                            return false
                        }
                    }
                    //方法过滤
                    if (isExceptMethodLevel && exceptMethodList != null) {
                        for (String exceptMethod : exceptMethodList) {
                            if (it.name.matches(exceptMethod)) {
                                return false
                            }
                        }
                    }
                    if (isHotfixMethodLevel && hotfixMethodList != null) {
                        for (String name : hotfixMethodList) {
                            if (it.name.matches(name)) {
                                return true
                            }
                        }
                    }
                    return !isHotfixMethodLevel
                }.each { ctBehavior ->
                    // methodMap must be put here
                    methodMap.put(ctBehavior.longName, insertMethodCount.incrementAndGet());
                    try {
                    if (ctBehavior.getMethodInfo().isMethod()) {
                            boolean isStatic = ctBehavior.getModifiers() & AccessFlag.STATIC;
                            CtClass returnType = ctBehavior.getReturnType0();
                            String returnTypeString = returnType.getName();
                            def body = "if (${Constants.INSERT_FIELD_NAME} != null) {"
                            body += "Object argThis = null;"
                            if (!isStatic) {
                                body += "argThis = \$0;"
                            }
                            body += "   if (com.meituan.robust.PatchProxy.isSupport(\$args, argThis, ${Constants.INSERT_FIELD_NAME}, $isStatic, " + methodMap.get(ctBehavior.longName) + ")) {"
                            body += getReturnStatement(returnTypeString, isStatic, methodMap.get(ctBehavior.longName));
                            body += "   }"
                            body += "}"
                            ctBehavior.insertBefore(body);
                        }
                    } catch (Throwable t ) {
                        logger.error "ctClass: " + ctClass.getName() + " error: " + t.toString();
                    }
                }
                }
            zipFile(ctClass.toBytecode(),outStream,ctClass.name.replaceAll("\\.","/")+".class");
        }
    }.get()
    outStream.close();
    logger.debug "robust insertMethodCount: " + insertMethodCount.get()
}

该方法做了以下几件事：

将class设置为public
规避接口
规避无方法类
规避构造方法
规避抽象方法
规避 native方法
规避 synthetic方法
过滤配置文件中不需要修复的类
通过 javassist 在类中插入 public static ChangeQuickRedirect changeQuickRedirect;
通过 javassist 在方法中插入逻辑代码段
通过 zipFile() 方法写回class文件

最后调用 writeMap2File() 将插桩的方法信息写入 robust/methodsMap.robust 文件中，此文件和混淆的mapping文件需要备份。

总结

到这里本篇文章结束，主要讲了下基础原理、补丁加载流程和插桩过程。我们也可以简单的对 Robust 做下总结。

优点：

由于使用多ClassLoader方案（补丁中无新增Activity，所以不算激进类型的动态加载，无需hook system），兼容性和稳定性更好，不存在preverify的问题
由于采用 InstantRun 的热更新机制，所以可以即时生效，不需要重启
支持Android2.3-7.X版本
对性能影响较小，不需要合成patch
支持方法级别的修复，支持静态方法
支持新增方法和类
支持ProGuard的混淆、内联、编译器优化后引起的问题(桥方法、lambda、内部类等)等操作

当然，有优点就会有缺点：

暂时不支持新增字段，但可以通过新增类解决
暂时不支持修复构造方法，已经在内测
暂时不支持资源和 so 修复，不过这个问题不大，因为独立于 dex 补丁，已经有很成熟的方案了，就看怎么打到补丁包中以及 diff 方案。
对于返回值是 this 的方法支持不太好
没有安全校验，需要开发者在加载补丁之前自己做验证
可能会出现深度方法内联导致的不可预知的错误(几率很小可以忽略)

总的来说，Robust是可用的、高稳定性的、成功率很高（官方说99.9%）的、无侵入的一款优秀的热修复框架。

绝望的涮羊肉

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Android热更新探究(二、美团Robust原理)

我们来继续探究一下热更新的一些情况，这次是美团的Robust，它的原理主要参考来InstantRun,这里大概做一下介绍从 InstantRun 说起不得不说 InstantRun 真是个好东西。目前主流的热修复框架都有或多或少的参考 InstantRun 的某些技术点InstantRun 对应三种更新机制：冷插拔，我们称之为重启更新机制温插拔，我们称之为重启Activity更新机制热插拔，我们称...
复制链接

扫一扫