美团热修复Robust-源码篇

　　上一篇主要分析了Robust的使用方法，这一篇就来总结一下Robust的源码分析。

　　我个人倾向于将Robust框架分为两个部分，自动插入代码和动态加载Patch。

一、Robust源码分析

　　目前我的分析将Robust动态加载分为两个部分，一部分是插桩后的代码逻辑，一部分是拉取Patch的逻辑。

　　我们首先来看插桩后的代码（这里面套用的是官方的代码，可能有些过时了）

　　插桩前

public long getIndex() {
    return ;
}

　　插桩后

public static ChangeQuickRedirect changeQuickRedirect;
    public long getIndex() {
        if(changeQuickRedirect != null) {
            //PatchProxy中封装了获取当前className和methodName的逻辑，并在其内部最终调用了changeQuickRedirect的对应函数
            if(PatchProxy.isSupport(new Object[], this, changeQuickRedirect, false)) {
                return ((Long)PatchProxy.accessDispatch(new Object[], this, changeQuickRedirect, false)).longValue();
            }
        }
    return 100L;
}

　　我们可以看到Robust为我们的类添加了一个静态的ChangeQuickRedirect对象，我们可以看到当ChangeQuickRedirect为空时，证明此时没有补丁，走原逻辑。当它不为空时，我们可以看到它调用了PatchProxy中的isSupport方法和accessDispatch方法。我们具体来看一下PatchProxy中的这两个方法。

　　

   public static boolean isSupport(Object[] paramsArray, Object current, ChangeQuickRedirect changeQuickRedirect, boolean isStatic, int methodNumber, Class[] paramsClassTypes, Class returnType) {
         //Robust补丁优先执行，其他功能靠后
         if (changeQuickRedirect == null) {
             //不执行补丁，轮询其他监听者
             if (registerExtensionList == null || registerExtensionList.isEmpty()) {
                 return false;
             }
             for (RobustExtension robustExtension : registerExtensionList) {
                 if (robustExtension.isSupport(new RobustArguments(paramsArray, current, isStatic, methodNumber, paramsClassTypes, returnType))) {
                     robustExtensionThreadLocal.set(robustExtension);
                     return true;
                 }
             }
             return false;
         }
         String classMethod = getClassMethod(isStatic, methodNumber);
         if (TextUtils.isEmpty(classMethod)) {
             return false;
         }
         Object[] objects = getObjects(paramsArray, current, isStatic);
         try {
             return changeQuickRedirect.isSupport(classMethod, objects);
         } catch (Throwable t) {
             return false;
         }
     }

　　我们可以看到第22行，它调用了changeQuickRedirect.isSupport方法，这个changeQuickRedirect便是我们注入的对象。

　　我们接下来再看accessDispatch方法

  public static Object accessDispatch(Object[] paramsArray, Object current, ChangeQuickRedirect changeQuickRedirect, boolean isStatic, int methodNumber, Class[] paramsClassTypes, Class returnType) {

         if (changeQuickRedirect == null) {
             RobustExtension robustExtension = robustExtensionThreadLocal.get();
             robustExtensionThreadLocal.remove();
             if (robustExtension != null) {
                 notify(robustExtension.describeSelfFunction());
                 return robustExtension.accessDispatch(new RobustArguments(paramsArray, current, isStatic, methodNumber, paramsClassTypes, returnType));
             }
             return null;
         }
         String classMethod = getClassMethod(isStatic, methodNumber);
         if (TextUtils.isEmpty(classMethod)) {
             return null;
         }
         notify(Constants.PATCH_EXECUTE);
         Object[] objects = getObjects(paramsArray, current, isStatic);
         return changeQuickRedirect.accessDispatch(classMethod, objects);

　　可以看到第18行调用了changeQuickRedirect的accseeDispatch方法。

　　注入后的代码我们先看到这里，我们接下来看一看，我们拉取Patch的代码

   new PatchExecutor(getApplicationContext(), new PatchManpulateImp(), new RobustCallBack() {
                     @Override
                     public void onPatchListFetched(boolean result, boolean isNet, List<Patch> patches) {
                         Log.e("error-hot", "打印 onPatchListFetched：" + "isNet=" + isNet );
                     }
                     @Override
                     public void onPatchFetched(boolean result, boolean isNet, Patch patch) {
                         Log.e("error-hot", "打印 onPatchFetched：" + "result=" + result+"isNet="+isNet + "--->" + "patch=" + patch);
                     }
                     @Override
                     public void onPatchApplied(boolean result, Patch patch) {
                         Log.e("error-hot", "打印 onPatchApplied：" + "result=" + result + "--->" + "patch=" + patch);
                     }
                     @Override
                     public void logNotify(String log, String where) {
                         Log.e("error-hot", "打印 logNotify：" + "log=" + log + "--->" + "where=" + where);
                     }
                     @Override
                     public void exceptionNotify(Throwable throwable, String where) {
                         Log.e("error-hot", "打印 exceptionNotify：" + "throwable=" + throwable.toString() + "--->" + "where=" + where);
                     }
                 }).start();

　　进入PatchExecutor类中看一看，我们可以发现它继承了一个线程，那么直接去run方法看一下

    @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");
         }
     }

　　可以看到run方法中做了两件事，拉取补丁列表和应用补丁列表。

　　我们接着进入fetchPatchList方法

    protected List<Patch> fetchPatchList() {
         return patchManipulate.fetchPatchList(context);
     }

　　他返回了patchManipulate的fetchPatchList方法，这个对象便是我们在初始化的时候传进来的。我们进入看一看

     @Override
     protected List<Patch> fetchPatchList(Context context) {
         Patch patch = new Patch();
         patch.setName("test patch");
         patch.setLocalPath(Environment.getExternalStorageDirectory().getPath()+
                 File.separator+"robust"+File.separator+"patch");
         patch.setPatchesInfoImplClassFullName("com.example.tyr.testrobust.PatchesInfoImpl");
         List<Patch> patches = new ArrayList<>();
         patches.add(patch);
         return patches;
     }

　　我们将这个PatchesInfoImpl拉进到列表中，那么这个PatchInfoImpl是在哪里那？我们后面再说。

　　接着看applyPatchList方法

　　

protected void applyPatchList(List<Patch> patches) {
        if (null == patches || patches.isEmpty()) {
            return;
        }
        Log.d("robust", " patchManipulate list size is " + patches.size());
        for (Patch p : patches) {
            if (p.isAppliedSuccess()) {
                Log.d("robust", "p.isAppliedSuccess() skip " + p.getLocalPath());
                continue;
            }
            if (patchManipulate.ensurePatchExist(p)) {
                boolean currentPatchResult = false;
                try {
                    currentPatchResult = patch(context, p);
                } catch (Throwable t) {
                    robustCallBack.exceptionNotify(t, "class:PatchExecutor method:applyPatchList line:69");
                }
                if (currentPatchResult) {
                    //设置patch 状态为成功
                    p.setAppliedSuccess(true);
                    //统计PATCH成功率 PATCH成功
                    robustCallBack.onPatchApplied(true, p);

                } else {
                    //统计PATCH成功率 PATCH失败
                    robustCallBack.onPatchApplied(false, p);
                }

                Log.d("robust", "patch LocalPath:" + p.getLocalPath() + ",apply result " + currentPatchResult);

            }
        }
    }

　　可以看到for循环patches中的每一个patch并调用patch方法。我们接着进入patch方法。

 protected boolean patch(Context context, Patch patch) {
         if (!patchManipulate.verifyPatch(context, patch)) {
             robustCallBack.logNotify("verifyPatch failure, patch info:" + "id = " + patch.getName() + ",md5 = " + patch.getMd5(), "class:PatchExecutor method:patch line:107");
             return false;
         }

         DexClassLoader classLoader = new DexClassLoader(patch.getTempPath(), context.getCacheDir().getAbsolutePath(),
                 null, PatchExecutor.class.getClassLoader());
         patch.delete(patch.getTempPath());

         Class patchClass, oldClass;

         Class patchsInfoClass;
         PatchesInfo patchesInfo = null;
         try {
             Log.d("robust", "PatchsInfoImpl name:" + patch.getPatchesInfoImplClassFullName());
             patchsInfoClass = classLoader.loadClass(patch.getPatchesInfoImplClassFullName());
             patchesInfo = (PatchesInfo) patchsInfoClass.newInstance();
             Log.d("robust", "PatchsInfoImpl ok");
         } catch (Throwable t) {
             robustCallBack.exceptionNotify(t, "class:PatchExecutor method:patch line:108");
             Log.e("robust", "PatchsInfoImpl failed,cause of" + t.toString());
             t.printStackTrace();
         }

         if (patchesInfo == null) {
             robustCallBack.logNotify("patchesInfo is null, patch info:" + "id = " + patch.getName() + ",md5 = " + patch.getMd5(), "class:PatchExecutor method:patch line:114");
             return false;
         }

         //classes need to patch
         List<PatchedClassInfo> patchedClasses = patchesInfo.getPatchedClassesInfo();
         if (null == patchedClasses || patchedClasses.isEmpty()) {
             robustCallBack.logNotify("patchedClasses is null or empty, patch info:" + "id = " + patch.getName() + ",md5 = " + patch.getMd5(), "class:PatchExecutor method:patch line:122");
             return false;
         }

         for (PatchedClassInfo patchedClassInfo : patchedClasses) {
             String patchedClassName = patchedClassInfo.patchedClassName;
             String patchClassName = patchedClassInfo.patchClassName;
             if (TextUtils.isEmpty(patchedClassName) || TextUtils.isEmpty(patchClassName)) {
                 robustCallBack.logNotify("patchedClasses or patchClassName is empty, patch info:" + "id = " + patch.getName() + ",md5 = " + patch.getMd5(), "class:PatchExecutor method:patch line:131");
                 continue;
             }
             Log.d("robust", "current path:" + patchedClassName);
             try {
                 oldClass = classLoader.loadClass(patchedClassName.trim());
                 Field[] fields = oldClass.getDeclaredFields();
                 Log.d("robust", "oldClass :" + oldClass + "     fields " + fields.length);
                 Field changeQuickRedirectField = null;
                 for (Field field : fields) {
                     if (TextUtils.equals(field.getType().getCanonicalName(), ChangeQuickRedirect.class.getCanonicalName()) && TextUtils.equals(field.getDeclaringClass().getCanonicalName(), oldClass.getCanonicalName())) {
                         changeQuickRedirectField = field;
                         break;
                     }
                 }
                 if (changeQuickRedirectField == null) {
                     robustCallBack.logNotify("changeQuickRedirectField  is null, patch info:" + "id = " + patch.getName() + ",md5 = " + patch.getMd5(), "class:PatchExecutor method:patch line:147");
                     Log.d("robust", "current path:" + patchedClassName + " something wrong !! can  not find:ChangeQuickRedirect in" + patchClassName);
                     continue;
                 }
                 Log.d("robust", "current path:" + patchedClassName + " find:ChangeQuickRedirect " + patchClassName);
                 try {
                     patchClass = classLoader.loadClass(patchClassName);
                     Object patchObject = patchClass.newInstance();
                     changeQuickRedirectField.setAccessible(true);
                     changeQuickRedirectField.set(null, patchObject);
                     Log.d("robust", "changeQuickRedirectField set sucess " + patchClassName);
                 } catch (Throwable t) {
                     Log.e("robust", "patch failed! ");
                     t.printStackTrace();
                     robustCallBack.exceptionNotify(t, "class:PatchExecutor method:patch line:163");
                 }
             } catch (Throwable t) {
                 Log.e("robust", "patch failed! ");
                 t.printStackTrace();
                 robustCallBack.exceptionNotify(t, "class:PatchExecutor method:patch line:169");
             }
         }
         Log.d("robust", "patch finished ");
         return true;
     }

　　可以看到我们的类加载器在这里加载了我们的patch，我们接下来可以看到classloader加载了我们的PatchInfoImpl类。在这个类中继承了Robust的PatchInfo接口，这里只有一个方法

 public interface PatchesInfo {
     List<PatchedClassInfo> getPatchedClassesInfo();
 }　　

　　他拉取了我们需要修改的类的信息。

　　这里面的PatchedClassInfo中保存了两个类的信息，一个是我们需要修改的类PatchedClass和修改他的类PatchClass。

　　第39，40行Robust拿到了这两个类的名字。

　　第48行通过反射获取了我们需要修改的类的所有field

　　接下来是一个for循环获取到我们注入代码中的静态ChangeQuickRedirect对象。

　　获取到对象后我们看第64行他加载了我们PatchClass的类

　　接下来的65，66，67三行，我们可以看到他通过反射将我们PatchedClass即oldClass中的changeQuickRedirect字段赋值为我们的PatchClass。至于这个PatchClass是什么。我们接下来说。

　　到目前为止，我们可以看到，插桩后的逻辑已经说完了，不得不说Robust的原理还是比较通俗易懂的。我们接下来回答前面的两个剩余问题，PatchInfoImpl和PatchClass在哪里。我们顺着我们的Patch.jar去寻找。反编译后得到如下列表。

　　

　　找到了我们的PatchesInfoImpl，而我们的PatchClass就是RobustActivityPatchControl了

　　我们先来看一看PatchesInfoImpl做了什么

 import com.meituan.robust.PatchedClassInfo;
 import com.meituan.robust.PatchesInfo;
 import java.util.ArrayList;
 import java.util.List;

 public class PatchesInfoImpl
   implements PatchesInfo
 {
   public List getPatchedClassesInfo()
   {
     ArrayList localArrayList = new ArrayList();
     localArrayList.add(new PatchedClassInfo("com.example.tyr.testrobust.RobustActivity", "com.example.tyr.testrobust.RobustActivityPatchControl"));
     com.meituan.robust.utils.EnhancedRobustUtils.isThrowable = false;
     return localArrayList;
   }
 }

　　可以看到他把我们的patchedClass和patchClass加入了list中，也就是上面返回的信息。

　　我们接着看我们注入的这个patchClass中的方法

 public class RobustActivityPatchControl
   implements ChangeQuickRedirect
 {
   public static final String MATCH_ALL_PARAMETER = "(\\w*\\.)*\\w*";
   private static final Map<Object, Object> keyToValueRelation = new WeakHashMap();

   private static Object fixObj(Object paramObject)
   {
     Object localObject = paramObject;
     if ((paramObject instanceof Byte))
       if (((Byte)paramObject).byteValue() == 0)
         break label32;
     label32: for (boolean bool = true; ; bool = false)
     {
       localObject = new Boolean(bool);
       return localObject;
     }
   }

   public Object accessDispatch(String paramString, Object[] paramArrayOfObject)
   {
     label134:
     while (true)
       try
       {
         if (!paramString.split(":")[2].equals("false"))
           continue;
         if (keyToValueRelation.get(paramArrayOfObject[(paramArrayOfObject.length - 1)]) != null)
           continue;
         RobustActivityPatch localRobustActivityPatch = new RobustActivityPatch(paramArrayOfObject[(paramArrayOfObject.length - 1)]);
         keyToValueRelation.put(paramArrayOfObject[(paramArrayOfObject.length - 1)], null);
         break label134;
         if (!"12".equals(paramString.split(":")[3]))
           break;
         localRobustActivityPatch.onCreate((Bundle)paramArrayOfObject[0]);
         return null;
         localRobustActivityPatch = (RobustActivityPatch)keyToValueRelation.get(paramArrayOfObject[(paramArrayOfObject.length - 1)]);
         break label134;
         localRobustActivityPatch = new RobustActivityPatch(null);
         continue;
       }
       catch (Throwable paramString)
       {
         paramString.printStackTrace();
         return null;
       }
     return null;
   }

   public Object getRealParameter(Object paramObject)
   {
     Object localObject = paramObject;
     if ((paramObject instanceof RobustActivity))
       localObject = new RobustActivityPatch(paramObject);
     return localObject;
   }

   public boolean isSupport(String paramString, Object[] paramArrayOfObject)
   {
     paramString = paramString.split(":")[3];
     return ":12:".contains(":" + paramString + ":");
   }
 }

　　我们可以看到它实现了Robust的ChangeQuickRedirect接口，并实现了他们的两个方法accessDispatch和isSupport的两个方法，也就是PatchProxy中调用的这两个方法。

　　先说isSupport方法

　　这里的isSupport方法是混淆后的，我们可以看到在PatchProxy类中，他传入了classMethod的名字和这个方法所需要的参数。校验后进行判断。

　　在PatchProxy中他传入了的classMethod格式为className：methodName：isStatic：methodNumber。这里只校验了方法的number。这里是在accessDispatch中传入，目测插桩后的代码有所改动。

　　继续说accessPatch方法。

　　第26行校验了是否为静态方法。将参数数组传给了RobustActivityPatch这个类，并调用了它的onCreat方法，莫名的熟悉感，这个就是我们标注为Modify标签的那个类。

　　我们接下来看一看RobustActivityPatch这个类

　　

 import android.os.Bundle;
 import android.support.v7.app.c;
 import android.view.View;
 import android.widget.TextView;
 import com.meituan.robust.utils.EnhancedRobustUtils;

 public class RobustActivityPatch
 {
   RobustActivity originClass;

   public RobustActivityPatch(Object paramObject)
   {
     this.originClass = ((RobustActivity)paramObject);
   }

   public static void staticRobustonCreate(RobustActivityPatch paramRobustActivityPatch, RobustActivity paramRobustActivity, Bundle paramBundle)
   {
     RobustActivityPatchRobustAssist.staticRobustonCreate(paramRobustActivityPatch, paramRobustActivity, paramBundle);
   }

   public Object[] getRealParameter(Object[] paramArrayOfObject)
   {
     if ((paramArrayOfObject == null) || (paramArrayOfObject.length < 1))
       return paramArrayOfObject;
     Object[] arrayOfObject = new Object[paramArrayOfObject.length];
     int i = 0;
     if (i < paramArrayOfObject.length)
     {
       if ((paramArrayOfObject[i] instanceof Object[]))
         arrayOfObject[i] = getRealParameter((Object[])paramArrayOfObject[i]);
       while (true)
       {
         i += 1;
         break;
         if (paramArrayOfObject[i] == this)
         {
           arrayOfObject[i] = this.originClass;
           continue;
         }
         arrayOfObject[i] = paramArrayOfObject[i];
       }
     }
     return arrayOfObject;
   }

   protected void onCreate(Bundle paramBundle)
   {
     staticRobustonCreate(this, this.originClass, paramBundle);
     EnhancedRobustUtils.invokeReflectMethod("setContentView", ((RobustActivityPatch)this).originClass, getRealParameter(new Object[] { new Integer(2131296284) }), new Class[] { Integer.TYPE }, c.class);
     paramBundle = (View)EnhancedRobustUtils.invokeReflectMethod("findViewById", ((RobustActivityPatch)this).originClass, getRealParameter(new Object[] { new Integer(2131165307) }), new Class[] { Integer.TYPE }, c.class);
     if (paramBundle == this);
     for (paramBundle = ((RobustActivityPatch)paramBundle).originClass; ; paramBundle = (TextView)paramBundle)
     {
       String str = (String)EnhancedRobustUtils.invokeReflectMethod("RobustPublicgetString", new RobustActivityInLinePatch(getRealParameter(new Object[] { this })[0]), getRealParameter(new Object[0]), null, null);
       Object localObject = paramBundle;
       if (paramBundle == this)
         localObject = ((RobustActivityPatch)paramBundle).originClass;
       EnhancedRobustUtils.invokeReflectMethod("setText", localObject, getRealParameter(new Object[] { str }), new Class[] { CharSequence.class }, TextView.class);
       return;
     }
   }
 }

　　看到onCreate方法，第48行，这里我们可以看到他特殊处理了一下我们在RobustActivity的onCreate方法，感觉有点怪怪的，这里似乎是又执行了一边RobustActivity的OnCreate方法，而不是super.onCreate。

　　ps：看了看美团官方关于super的解析，似乎是这样的，他通过调用RobustActivity的OnCreate，将class文件中的invokevirtual指令替换为invokesuper指令，从而达到super的效果，这里面还有个问题，如果这样调用会出现这样的问题

Caused by: java.lang.NoSuchMethodError: No super method thisIsSuper()V in class Lcom/meituan/sample/TestSuperClass; or its super classes (declaration of 'com.meituan.sample.TestSuperClass' appears in /data/app/com.meituan.robust.sample-3/base.apk)

　　Robust的解决方案是使这个类也继承RobustActivity的父类，我们可以看到RobustActivityPatchRobustAssist类果然继承了一个类，但是由于混淆我们看到的是他继承了一个c的类，猜测它应该就是RobustActivity的父类AppCompatActivity。

　　验证一下打印dex文件

　　

　　看到invoke-super指令，现在可以确定了

　　再看一下RobustActivityPatchRobustAssist的父类，这绝对就是android.support.v7.app.AppcompatActivity了。

　　

　　然后我们可以看到他执行了setContentView，findViewById这里传入的两串数字便是我们的布局和空间在R类的数字。

　　然后我们可以看到它执行到了我们修改代码的地方。

　　第54行它调用了RobustPublicgetString方法，又是莫名的熟悉感，，

　　进入RobustActivityInLinePatch看一看。

 public class RobustActivityInLinePatch
 {
   RobustActivity originClass;

   public RobustActivityInLinePatch(Object paramObject)
   {
     this.originClass = ((RobustActivity)paramObject);
   }

   private String getString()
   {
     return "hello robust";
   }

   public String RobustPublicgetString()
   {
     return getString();
   }

   public Object[] getRealParameter(Object[] paramArrayOfObject)
   {
     if ((paramArrayOfObject == null) || (paramArrayOfObject.length < 1))
       return paramArrayOfObject;
     Object[] arrayOfObject = new Object[paramArrayOfObject.length];
     int i = 0;
     if (i < paramArrayOfObject.length)
     {
       if ((paramArrayOfObject[i] instanceof Object[]))
         arrayOfObject[i] = getRealParameter((Object[])paramArrayOfObject[i]);
       while (true)
       {
         i += 1;
         break;
         if (paramArrayOfObject[i] == this)
         {
           arrayOfObject[i] = this.originClass;
           continue;
         }
         arrayOfObject[i] = paramArrayOfObject[i];
       }
     }
     return arrayOfObject;
   }
 }

　　可以看到我们传入的getString方法出现在了这里。

二、总结

　　到目前为止，Robust的逻辑算是走通了。

　　目前为止，我认为Robust的核心应该算是它自动插桩的那一部分，目前暂时不涉及了，下一篇将会了解一下热修复背后的动态加载。

参考资料：

　　Android中热修复框架Robust原理解析+并将框架代码从"闭源"变成"开源"(上篇)

　　Android热更新方案Robust