人生备份 - 读美团 Robust 热修复框架代码（二）

前言

使用

  客户端拿到补丁包后就可以进行 bug 修复了。Robust 使用补丁包的方式也是非常的简单，就是开启一个新的线程进行类加载，并且给之前留下的入口进行对象注入，从而控制客户端在运行时将调用流程流转到正确的补丁逻辑里。

private void runRobust() {
   new PatchExecutor(getApplicationContext(), new PatchManipulateMy(), new RobustCallBackSample()).start();
}

  PatchExecutor 是继承自 Thread的类，一切修复逻辑都运行在它的 run 方法中，可以看到构建这个对象需要三个参数

参数1️⃣：程序的上下文 Context 对象 参数2️⃣：第二个参数是 PatchManipulate 的子类，抽象定义了补丁的获取、验证过程，使用者需要自行定义 参数3️⃣：第三个参数是一个简单的 RobustCallabck 实现类对象，主要是将正在修复补丁时的状态回调出去，例如获取了什么补丁、应用补丁出现了什么异常等

读一下代码

1、补丁获取的过程

  首先看一下 PatchManipulate 类的定义：

/**
 * Created by hedex on 16/6/20.
 */
public abstract class PatchManipulate {
    /**
     * 获取补丁列表
     *
     * @param context
     * @return 相应的补丁列表
     */
    protected abstract List<Patch> fetchPatchList(Context context);

    /**
     * 验证补丁文件md5是否一致
     * 如果不存在，则动态下载
     *
     * @param context
     * @param patch
     * @return 校验结果
     */
    protected abstract boolean verifyPatch(Context context, Patch patch);

    /**
     * 努力确保补丁文件存在，验证md5是否一致。
     * 如果不存在，则动态下载
     *
     * @param patch
     * @return 是否存在
     */
    protected abstract boolean ensurePatchExist(Patch patch);
}

正如上面所说，这个类是抽象定义了补丁的获取和验证过程，使用时自行实现，下面给出一个我写的 Demo 的使用示例：

public class PatchManipulateMy extends PatchManipulate {
    @Override
    protected List<Patch> fetchPatchList(Context context) {
        List<Patch> list = new ArrayList<>();
        Patch patch = new Patch();
        patch.setName("Fix-1");
        //我把打包出来的补丁包 Patch.jar 放到了公共的 Download 目录下
        patch.setLocalPath(new File(Environment.getExternalStoragePublicDirectory(DIRECTORY_DOWNLOADS), "patch.jar").getAbsolutePath());
        //设置补丁信息的包名
        patch.setPatchesInfoImplClassFullName("com.meituan.sample.PatchesInfoImpl");
        list.add(patch);
        return list;
    }

    @Override
    protected boolean verifyPatch(Context context, Patch patch) {
        //放到app的私有目录
        patch.setTempPath(context.getCacheDir()+ File.separator+"robust"+File.separator + "patch");
        //in the sample we just copy the file (在这个示例中，我们只是简单的拷贝了一下文件)
        try {
            copy(patch.getLocalPath(), patch.getTempPath());
        }catch (Exception e){
            e.printStackTrace();
            throw new RuntimeException("copy source patch to local patch error, no patch execute in path "+patch.getTempPath());
        }

        return true;
    }

    @Override
    protected boolean ensurePatchExist(Patch patch) {
        //验证补丁包是否存在，这里简单的返回 true
        return true;
    }

   //省略文件拷贝代码...
}

使用时上面有两个问题需要注意一下 ：

1. 在生成 Patch 类对象时需要调用 setPatchesInfoImplClassFullName方法设置补丁信息类的完整类名，包名必须和 App 路径下 Robust.xml 配置文件中设置的一致。（在补丁包中会有一个 Robust 生成的类名为 “ PatchesInfoImpl ”，类名在框架中已经确定，使用者可以自定义前面的包名） 在我看来这个类就是用来提供补丁中一些信息用的，具体来说就是记录了在补丁包中，需要 Modify 的原始全类名和相对应生成的补丁全类名（下面给出一个示例）。
2. 在上面的 verifyPatch 方法中需要设置补丁的 TempPath ,因为在进行类加载时传给类加载器的路径就是调用补丁的 getTempPath 方法，这个方法还进行了文件名拼接，需要确保这个方法的路径下，补丁确实存在。这个地方当时困扰我一阵子，因为我想当然的以为 localPath 就是具体来应用补丁的路径。

PatchesInfoImpl 示例：

public class PatchesInfoImpl implements PatchesInfo {
  //生成这段代码的前提是在 MainActivity 中修改了一个方法（添加 @Modify 注释），并且进行补丁生成
  public List getPatchedClassesInfo() {
    ArrayList<PatchedClassInfo> arrayList = new ArrayList();
    arrayList.add(new PatchedClassInfo("com.meituan.sample.MainActivity", "com.meituan.sample.MainActivityPatchControl"));
    EnhancedRobustUtils.isThrowable = false;
    return arrayList;
  }
}

2、加载补丁进行修复

  加载补丁的线程启动之后，看一下它相对应的方法做了什么：

@Override
public void run() {
    try {
        //拉取补丁列表
        List<Patch> patches = fetchPatchList();
        //应用补丁列表
        applyPatchList(patches);
    } catch (Throwable t) {
        Log.e("robust", "PatchExecutor run", t);
        robustCallBack.exceptionNotify(t, "class:PatchExecutor,method:run,line:36");
    }
}
/**
 * 拉取补丁列表
 */
protected List<Patch> fetchPatchList() {
    return patchManipulate.fetchPatchList(context);
}

流程也如我想的一样，调用刚才传入的对象，获取补丁并且应用，在 applyPatchList 方法中进行一系列的校验后来到一个名为 patch 的方法中，也就是在这其中进行了补丁类的加载和运行时异常 class 的对象注入。

 protected boolean patch(Context context, Patch patch) {
        //代码省略...
        ClassLoader classLoader = null;
        try {
            File dexOutputDir = getPatchCacheDirPath(context, patch.getName() + patch.getMd5());
            //1️⃣构造类加载器加载补丁中的类
            classLoader = new DexClassLoader(patch.getTempPath(), dexOutputDir.getAbsolutePath(),
                    null, PatchExecutor.class.getClassLoader());
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        //代码省略...
        Class patchClass, sourceClass;
        Class patchesInfoClass;
        PatchesInfo patchesInfo = null;
        try {
            //2️⃣加载上面设置 setPatchesInfoImplClassFullName 的全类名类，拿到异常class 和 对应的补丁class的全类名
            patchesInfoClass = classLoader.loadClass(patch.getPatchesInfoImplClassFullName());
            patchesInfo = (PatchesInfo) patchesInfoClass.newInstance();
        } catch (Throwable t) {
            Log.e("robust", "patch failed 188 ", t);
        }
        //拿到异常的 class 的全类名 和 对应的补丁 class 的全类名 
        List<PatchedClassInfo> patchedClasses = patchesInfo.getPatchedClassesInfo(); 
        boolean isClassNotFoundException = false;
        for (PatchedClassInfo patchedClassInfo : patchedClasses) {
             //运行时异常 class 的全类名，也就是需要被打补丁的全类名
            String patchedClassName = patchedClassInfo.patchedClassName;
             //补丁的全类名
            String patchClassName = patchedClassInfo.patchClassName;
            try {
                try {
                    //3️⃣拿到运行时异常的 class 
                    sourceClass = classLoader.loadClass(patchedClassName.trim());
                } catch (ClassNotFoundException e) {
                    isClassNotFoundException = true;
                    continue;
                }
                //4️⃣获取编译时插入的 changeQuickRedirectField 
                Field[] fields = sourceClass.getDeclaredFields();
                Field changeQuickRedirectField = null;
                for (Field field : fields) {
                    if (TextUtils.equals(field.getType().getCanonicalName(), ChangeQuickRedirect.class.getCanonicalName()) && TextUtils.equals(field.getDeclaringClass().getCanonicalName(), sourceClass.getCanonicalName())) {
                        changeQuickRedirectField = field;
                        break;
                    }
                }
                //代码省略..
                try {
                    //5️⃣加载并构造对应补丁的 class 对象，并且为异常的 class 的changeQuickRedirectField 注入对象
                    patchClass = classLoader.loadClass(patchClassName);
                    Object patchObject = patchClass.newInstance();
                    changeQuickRedirectField.setAccessible(true);
                    changeQuickRedirectField.set(null, patchObject);
                } catch (Throwable t) {
                    Log.e("robust", "patch failed! ");
                }
            } catch (Throwable t) {
                Log.e("robust", "patch failed! ");
            }
        }
      
        return true;
    }

上面代码中删减了一些验证和打印的代码，保留了主流程，也就是注释中的 1️⃣ 到 5️⃣，查看代码可以发现这个流程还是很清晰的，跟日常中使用类加载器和反射的步骤一致，没有花里胡哨的东西。  其中我有一开始没搞懂的就是注释3️⃣那里，使用构造出来的 classLoader 并且指定的是 patch.jar 的路径去加载原始的异常 class 。这里应该是使用了 ClassLoader 的双亲委派机制的特性，这个加载器实际上不能加载异常的 class地 ，实际上是由构造 classLoader 时传进去的 PatchExecutor.class.getClassLoader()来加载拿到原始异常的 class 的。

总结

  分析了以上流程可以发现，Robust 框架只是在正常的使用类加载器和反射，就将 bug 进行了修复（运行时逻辑跳转），修复过程中没有使用 Hook 和其他的一些奇淫技巧，因此 Robust 的兼容性和稳定性都较高，同时兼具补丁生效的实时性。