美團熱修復Robust-源碼篇

　　上一篇主要分析了Robust的使用方法，這一篇就來總結一下Robust的源碼分析。

　　我個人傾向於將Robust框架分為兩個部分，自動插入代碼和動態加載Patch。

一、Robust源碼分析

　　目前我的分析將Robust動態加載分為兩個部分，一部分是插樁后的代碼邏輯，一部分是拉取Patch的邏輯。

　　我們首先來看插樁后的代碼（這里面套用的是官方的代碼，可能有些過時了）

　　插樁前

public long getIndex() {
    return 100;
}

　　插樁后

public static ChangeQuickRedirect changeQuickRedirect;
    public long getIndex() {
        if(changeQuickRedirect != null) {
            //PatchProxy中封裝了獲取當前className和methodName的邏輯，並在其內部最終調用了changeQuickRedirect的對應函數
            if(PatchProxy.isSupport(new Object[0], this, changeQuickRedirect, false)) {
                return ((Long)PatchProxy.accessDispatch(new Object[0], 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