主目錄見(jiàn)：Android高級(jí)進(jìn)階知識(shí)（這是總目錄索引）
框架地址：AndFix
在線源碼查看：AndroidXRef

?我們前面講了插件化的框架，今天我們來(lái)講講我們的熱修復(fù)框架假残，首先在選熱修復(fù)框架的時(shí)候有猶豫過(guò)裙士，到底是要講美團(tuán)的robust乘碑，微信的Tinker，還是阿里的AndFix等等那么這里用一張圖來(lái)做一個(gè)開(kāi)始：

熱修復(fù)框架對(duì)比

這里是缺少了美團(tuán)的robust炉旷，還有阿里的最新熱修復(fù)框架Sophix（這個(gè)框架也有借鑒了AndFix的思想）的對(duì)比楷兽，但是我們來(lái)想想地熄，熱修復(fù)最可能出現(xiàn)的時(shí)候應(yīng)該是方法邏輯的修復(fù)，而且修復(fù)包要盡量小且能即時(shí)生效芯杀，同時(shí)AndFix用C++中的指針?biāo)枷雭?lái)做方法的替換端考，這個(gè)代價(jià)也是非常小的。在這幾個(gè)方面來(lái)看看揭厚，AndFix還是很理想的却特。

一.AndFix的使用

怎么使用我們其實(shí)可以從GitHub的[AndFix]開(kāi)源地址獲取，但是這里還是列舉一下：
1.增加dependency依賴(lài)

dependencies {
    compile 'com.alipay.euler:andfix:0.5.0@aar'
}

2.初始化PatchManager

patchManager = new PatchManager(context);
patchManager.init(appversion);//current version

3.加載補(bǔ)丁包

patchManager.loadPatch();

框架推薦你要盡可能早地加載補(bǔ)丁包筛圆，最好是在應(yīng)用的初始化階段例如

Application.onCreate())

4.添加補(bǔ)丁包

patchManager.addPatch(path);//path of the patch file that was downloaded

當(dāng)一個(gè)新的補(bǔ)丁包下載下來(lái)核偿，通過(guò)addPath方法可以即時(shí)生效

5.補(bǔ)丁包生成
AndFix框架提供了一個(gè)補(bǔ)丁包生成工具apkpatch,可以到這里下載apkpatch。
使用的時(shí)候要準(zhǔn)備兩個(gè)apk文件顽染，其中一個(gè)是修復(fù)過(guò)的，然后生成.patch補(bǔ)丁文件：

usage: apkpatch -f <new> -t <old> -o <output> -k <keystore> -p <***> -a <alias> -e <***>
 -a,--alias <alias>     keystore entry alias.
 -e,--epassword <***>   keystore entry password.
 -f,--from <loc>        new Apk file path.
 -k,--keystore <loc>    keystore path.
 -n,--name <name>       patch name.
 -o,--out <dir>         output dir.
 -p,--kpassword <***>   keystore password.
 -t,--to <loc>          old Apk file path.

然后就可以把這個(gè)補(bǔ)丁包分發(fā)給客戶端了轰绵。
有時(shí)候團(tuán)隊(duì)的成員會(huì)修復(fù)各自的bug粉寞，會(huì)生成不止一個(gè)補(bǔ)丁包，這樣我們可以合并這多個(gè)補(bǔ)丁包：

usage: apkpatch -m <apatch_path...> -o <output> -k <keystore> -p <***> -a <alias> -e <***>
 -a,--alias <alias>     keystore entry alias.
 -e,--epassword <***>   keystore entry password.
 -k,--keystore <loc>    keystore path.
 -m,--merge <loc...>    path of .apatch files.
 -n,--name <name>       patch name.
 -o,--out <dir>         output dir.
 -p,--kpassword <***>   keystore password.

好啦左腔，使用起來(lái)并不是很難唧垦，我們接下來(lái)就從使用來(lái)分析源碼了。

二.AndFix框架源碼解析

從使用我們知道液样，我們的程序會(huì)首先初始化PatchManager振亮，所以我們看看初始化做了啥：

    public PatchManager(Context context) {
        mContext = context;
        //初始化AndFixManager
        mAndFixManager = new AndFixManager(mContext);
        //初始化存放patch補(bǔ)丁文件的目錄
        mPatchDir = new File(mContext.getFilesDir(), DIR);
       //初始化存在Patch類(lèi)的集合
        mPatchs = new ConcurrentSkipListSet<Patch>();
       //初始化存放類(lèi)對(duì)應(yīng)的類(lèi)加載器集合
        mLoaders = new ConcurrentHashMap<String, ClassLoader>();
    }

這里面有個(gè)比較重要的類(lèi)AndFixManager，我們來(lái)看看它的構(gòu)造函數(shù)：

public AndFixManager(Context context) {
        mContext = context;
        //兼容性判斷鞭莽，判斷AndFix是否適用
        mSupport = Compat.isSupport();
        if (mSupport) {
         //主要是對(duì)補(bǔ)丁包的安全檢測(cè)
            mSecurityChecker = new SecurityChecker(mContext);
         //初始化補(bǔ)丁包的路徑
            mOptDir = new File(mContext.getFilesDir(), DIR);
            if (!mOptDir.exists() && !mOptDir.mkdirs()) {// make directory fail
           //如果不定目錄不存在則把支持標(biāo)志設(shè)為false
                mSupport = false;
                Log.e(TAG, "opt dir create error.");
            } else if (!mOptDir.isDirectory()) {// not directory
           //如果不是目錄則標(biāo)志設(shè)置為false
                mOptDir.delete();
                mSupport = false;
            }
        }
    }

這個(gè)類(lèi)構(gòu)造函數(shù)做的工作很簡(jiǎn)單坊秸，就是Android系統(tǒng)兼容性的檢查，然后就是對(duì)補(bǔ)丁包安全性和路徑的檢驗(yàn)澎怒。接著我們看看兼容性判斷源碼：

public static synchronized boolean isSupport() {
        if (isChecked)
            return isSupport;

        isChecked = true;
        // not support alibaba's YunOs
               //寫(xiě)的很清楚褒搔，這里不支持阿里的YunOs,且會(huì)判斷Davilk還是art虛擬機(jī)，來(lái)注冊(cè)native方法
        if (!isYunOS() && AndFix.setup() && isSupportSDKVersion()) {
            isSupport = true;
        }
              //是否在黑名單中喷面，默認(rèn)是返回false
        if (inBlackList()) {
            isSupport = false;
        }

        return isSupport;
    }

判斷是不是YunOs系統(tǒng)和支持的Sdk版本這兩個(gè)方法比較簡(jiǎn)單星瘾，這里不深究，重點(diǎn)來(lái)看AndFix.setup()方法：

public static boolean setup() {
        try {
            final String vmVersion = System.getProperty("java.vm.version");
            boolean isArt = vmVersion != null && vmVersion.startsWith("2");
            int apilevel = Build.VERSION.SDK_INT;
            return setup(isArt, apilevel);
        } catch (Exception e) {
            Log.e(TAG, "setup", e);
            return false;
        }
    }

這個(gè)方法也是很簡(jiǎn)單惧辈，判斷vm的版本是不是以2開(kāi)頭琳状，如果是就是art虛擬機(jī)，然后將isArt和api的版本傳給了native的setup方法盒齿，這個(gè)方法在jni目錄的AndFix.cpp下面：

static jboolean setup(JNIEnv* env, jclass clazz, jboolean isart,
        jint apilevel) {
    isArt = isart;
    LOGD("vm is: %s , apilevel is: %i", (isArt ? "art" : "dalvik"),
            (int )apilevel);
    if (isArt) {
        return art_setup(env, (int) apilevel);
    } else {
        return dalvik_setup(env, (int) apilevel);
    }
}

可以看到方法里面根據(jù)isArt這個(gè)標(biāo)志來(lái)調(diào)用不同的方法念逞，首先我們看下art_setup方法：

extern jboolean __attribute__ ((visibility ("hidden"))) art_setup(JNIEnv* env,
        int level) {
    apilevel = level;
    return JNI_TRUE;
}

可以看出這個(gè)方法就記錄了下apilevel然后直接返回了true困食。接著我們來(lái)看看dalvik_setup方法：

extern jboolean __attribute__ ((visibility ("hidden"))) dalvik_setup(
        JNIEnv* env, int apilevel) {
//打開(kāi)libdvm.so文件
    void* dvm_hand = dlopen("libdvm.so", RTLD_NOW);
    if (dvm_hand) {
 //獲取dvmDecodeIndirectRef_fnPtr和dvmThreadSelf_fnPtr兩個(gè)函數(shù),
 //這兩個(gè)函數(shù)可以通過(guò)類(lèi)對(duì)象獲取ClassObject結(jié)構(gòu)體
        dvmDecodeIndirectRef_fnPtr = dvm_dlsym(dvm_hand,
                apilevel > 10 ?
                        "_Z20dvmDecodeIndirectRefP6ThreadP8_jobject" :
                        "dvmDecodeIndirectRef");
        if (!dvmDecodeIndirectRef_fnPtr) {
            return JNI_FALSE;
        }
        dvmThreadSelf_fnPtr = dvm_dlsym(dvm_hand,
                apilevel > 10 ? "_Z13dvmThreadSelfv" : "dvmThreadSelf");
        if (!dvmThreadSelf_fnPtr) {
            return JNI_FALSE;
        }
      //這里用jni里面的方法來(lái)獲取Java層Method對(duì)象的getDeclaringClass方法
      //后續(xù)會(huì)調(diào)用該方法獲取某個(gè)方法所屬的類(lèi)對(duì)象
      //因?yàn)镴ava層只傳遞了Method對(duì)象到native層
        jclass clazz = env->FindClass("java/lang/reflect/Method");
        jClassMethod = env->GetMethodID(clazz, "getDeclaringClass",
                        "()Ljava/lang/Class;");

        return JNI_TRUE;
    } else {
        return JNI_FALSE;
    }
}

這里面我們先來(lái)看看Android虛擬機(jī)初始化方面的知識(shí)圖：

Android虛擬機(jī)初始化

1.跟java虛擬機(jī)不同，Android虛擬機(jī)執(zhí)行的是dex文件而不是class文件,同時(shí)在android版本4.4開(kāi)始就推出了art虛擬機(jī)肮柜，所以現(xiàn)在android的虛擬機(jī)分為dalvik虛擬機(jī)和art虛擬機(jī)陷舅。
2.虛擬機(jī)啟動(dòng)的時(shí)候會(huì)加載兩個(gè)很重要的動(dòng)態(tài)庫(kù)文件libdvm.so和libart.so，這就是dalvik虛擬機(jī)和art虛擬機(jī)的動(dòng)態(tài)庫(kù)文件
3.Java在虛擬機(jī)環(huán)境中執(zhí)行审洞，每個(gè)Java方法都會(huì)對(duì)應(yīng)一個(gè)底層的函數(shù)指針莱睁，當(dāng)Java方法被調(diào)用的時(shí)候，實(shí)質(zhì)虛擬機(jī)會(huì)找到這個(gè)函數(shù)指針然后去執(zhí)行底層的方法芒澜，從而Java方法被執(zhí)行仰剿。

接著我們繼續(xù)來(lái)分析dalvik_setup方法，首先這個(gè)方法會(huì)判斷apilevel是不是大于10來(lái)Hook不同的系統(tǒng)函數(shù)痴晦，在Hook成功了之后南吮，我們就可以調(diào)用我們自己的代碼進(jìn)行替換，這就是框架github上面說(shuō)的：

方法替換

替換方法我們留著后面具體說(shuō)誊酌，我們接著來(lái)看PatchManager類(lèi)中的init方法：

public void init(String appVersion) {
//首先判斷補(bǔ)丁路徑是否存在或者是不是目錄
        if (!mPatchDir.exists() && !mPatchDir.mkdirs()) {// make directory fail
            Log.e(TAG, "patch dir create error.");
            return;
        } else if (!mPatchDir.isDirectory()) {// not directory
            mPatchDir.delete();
            return;
        }
//這里用sp來(lái)存儲(chǔ)補(bǔ)丁包的配置信息
        SharedPreferences sp = mContext.getSharedPreferences(SP_NAME,
                Context.MODE_PRIVATE);
        String ver = sp.getString(SP_VERSION, null);
//這里首先獲取本地補(bǔ)丁包的版本和傳入的版本號(hào)做對(duì)比
        if (ver == null || !ver.equalsIgnoreCase(appVersion)) {
//如果版本不同部凑，說(shuō)明本地的版本過(guò)久則要?jiǎng)h除存入新的補(bǔ)丁包版本
            cleanPatch();
            sp.edit().putString(SP_VERSION, appVersion).commit();
        } else {
//相同說(shuō)明本地有本地補(bǔ)丁包了，則初始化
            initPatchs();
        }
    }

我們看到這里如果本地已經(jīng)有補(bǔ)丁包且版本未更新碧浊，則初始化涂邀，我們來(lái)看這個(gè)initPatchs方法：

private void initPatchs() {
        File[] files = mPatchDir.listFiles();
        for (File file : files) {
            addPatch(file);
        }
    }

這個(gè)方法很簡(jiǎn)單，就是將補(bǔ)丁路徑下的所有補(bǔ)丁文件調(diào)用addPatch方法添加進(jìn)去箱锐，我們來(lái)看看addPatch方法：

private Patch addPatch(File file) {
        Patch patch = null;
        if (file.getName().endsWith(SUFFIX)) {
            try {
                patch = new Patch(file);
                mPatchs.add(patch);
            } catch (IOException e) {
                Log.e(TAG, "addPatch", e);
            }
        }
        return patch;
    }

我們看到這個(gè)方法主要就是判斷文件是不是以.patch結(jié)尾比勉，如果是的話就初始化一個(gè)Patch實(shí)例,這個(gè)是添加補(bǔ)丁包的關(guān)鍵，我們跟進(jìn)構(gòu)造函數(shù)看下:

public Patch(File file) throws IOException {
        mFile = file;
        init();
    }

@SuppressWarnings("deprecation")
    private void init() throws IOException {
        JarFile jarFile = null;
        InputStream inputStream = null;
        try {
//使用JarFile讀取Patch文件
            jarFile = new JarFile(mFile);
//獲取META-INF/PATCH.MF文件
            JarEntry entry = jarFile.getJarEntry(ENTRY_NAME);
            inputStream = jarFile.getInputStream(entry);
            Manifest manifest = new Manifest(inputStream);
            Attributes main = manifest.getMainAttributes();
//因?yàn)镻ATCH.MF里面是以鍵值對(duì)的形式存儲(chǔ)的驹止，這里是獲取鍵Patch-Name對(duì)應(yīng)的值
            mName = main.getValue(PATCH_NAME);
//這里是獲取創(chuàng)建的時(shí)間
            mTime = new Date(main.getValue(CREATED_TIME));

            mClassesMap = new HashMap<String, List<String>>();
            Attributes.Name attrName;
            String name;
            List<String> strings;
            for (Iterator<?> it = main.keySet().iterator(); it.hasNext();) {
                attrName = (Attributes.Name) it.next();
                name = attrName.toString();
//判斷name的后綴是否是-Classes浩聋，并把name對(duì)應(yīng)的值加入到集合中，對(duì)應(yīng)的值就是class類(lèi)名的列表
                if (name.endsWith(CLASSES)) {
                    strings = Arrays.asList(main.getValue(attrName).split(","));
                    if (name.equalsIgnoreCase(PATCH_CLASSES)) {
                        mClassesMap.put(mName, strings);
                    } else {
//  //為了移除掉"-Classes"的后綴
                        mClassesMap.put(
                                name.trim().substring(0, name.length() - 8),// remove
                                                                            // "-Classes"
                                strings);
                    }
                }
            }
        } finally {
            if (jarFile != null) {
                jarFile.close();
            }
            if (inputStream != null) {
                inputStream.close();
            }
        }

    }

這個(gè)方法的邏輯其實(shí)就是讀取補(bǔ)丁.patch文件,每個(gè)修復(fù)包apatch文件其實(shí)都是一個(gè)jarFile文件臊恋，然后獲得其中META-INF/PATCH.MF文件衣洁，PATCH.MF文件中都是鍵值對(duì)的形式，獲取key是-Classes的所有的value抖仅，這些value就是所有要修復(fù)的類(lèi)闸与，他們是以“，”進(jìn)行分割的岸售，將它們放入list列表践樱，將其存儲(chǔ)到一個(gè)集合中mClassesMap，list列表中存儲(chǔ)的就是所有要修復(fù)的類(lèi)名凸丸。我們看到我們還有一個(gè)addPatch方法：

public void addPatch(String path) throws IOException {
        File src = new File(path);
        File dest = new File(mPatchDir, src.getName());
        if(!src.exists()){
            throw new FileNotFoundException(path);
        }
        if (dest.exists()) {
            Log.d(TAG, "patch [" + path + "] has be loaded.");
            return;
        }
        FileUtil.copyFile(src, dest);// copy to patch's directory
        Patch patch = addPatch(dest);
        if (patch != null) {
            loadPatch(patch);
        }
    }

這個(gè)方法里面就多了一步將指定的路徑下的文件拷貝到補(bǔ)丁包路徑下面拷邢，這個(gè)方法的作用是什么呢？我們知道屎慢，我們第一次app下載下來(lái)的時(shí)候瞭稼，我們本地是沒(méi)有補(bǔ)丁包的忽洛，只有當(dāng)需要補(bǔ)丁修復(fù)的時(shí)候，我們才會(huì)從服務(wù)器下載補(bǔ)丁包下來(lái)环肘，這時(shí)候我們可以指定我們下載下來(lái)的補(bǔ)丁包的存放路徑欲虚，然后將它拷貝到補(bǔ)丁包路徑，然后進(jìn)行加載悔雹。
接下來(lái)复哆，我們來(lái)看看方法調(diào)用loadPatch()方法：

public void loadPatch() {
        mLoaders.put("*", mContext.getClassLoader());// wildcard
        Set<String> patchNames;
        List<String> classes;
//遍歷mPatchs中的所有Patch
        for (Patch patch : mPatchs) {
//遍歷補(bǔ)丁包中待修復(fù)的所有patch名
            patchNames = patch.getPatchNames();
            for (String patchName : patchNames) {
//獲取patch中的所有class
                classes = patch.getClasses(patchName);
//修復(fù)bug
                mAndFixManager.fix(patch.getFile(), mContext.getClassLoader(),
                        classes);
            }
        }
    }

我們看到這個(gè)方法主要就是最后的fix方法：

public synchronized void fix(String patchPath) {
        fix(new File(patchPath), mContext.getClassLoader(), null);
    }

public synchronized void fix(File file, ClassLoader classLoader,
            List<String> classes) {
        if (!mSupport) {
            return;
        }
//檢測(cè)patch包的簽名，檢查是不是安全的
        if (!mSecurityChecker.verifyApk(file)) {// security check fail
            return;
        }

        try {
//判斷優(yōu)化后的文件是否存在腌零，如果存在則檢測(cè)optfile的安全性
            File optfile = new File(mOptDir, file.getName());
            boolean saveFingerprint = true;
            if (optfile.exists()) {
                // need to verify fingerprint when the optimize file exist,
                // prevent someone attack on jailbreak device with
                // Vulnerability-Parasyte.
                // btw:exaggerated android Vulnerability-Parasyte
                // http://secauo.com/Exaggerated-Android-Vulnerability-Parasyte.html
                if (mSecurityChecker.verifyOpt(optfile)) {
                    saveFingerprint = false;
                } else if (!optfile.delete()) {
                    return;
                }
            }
//加載補(bǔ)丁文件包中的dex文件
            final DexFile dexFile = DexFile.loadDex(file.getAbsolutePath(),
                    optfile.getAbsolutePath(), Context.MODE_PRIVATE);

            if (saveFingerprint) {
                mSecurityChecker.saveOptSig(optfile);
            }
//這里重寫(xiě)了ClassLoader中的findClass方法梯找，并且實(shí)例化它
            ClassLoader patchClassLoader = new ClassLoader(classLoader) {
                @Override
                protected Class<?> findClass(String className)
                        throws ClassNotFoundException {
                    Class<?> clazz = dexFile.loadClass(className, this);
                    if (clazz == null
                            && className.startsWith("com.alipay.euler.andfix")) {
                        return Class.forName(className);// annotation’s class
                                                        // not found
                    }
                    if (clazz == null) {
                        throw new ClassNotFoundException(className);
                    }
                    return clazz;
                }
            };
//遍歷dex然后加載有bug的類(lèi)文件
            Enumeration<String> entrys = dexFile.entries();
            Class<?> clazz = null;
            while (entrys.hasMoreElements()) {
                String entry = entrys.nextElement();
                if (classes != null && !classes.contains(entry)) {
                    continue;// skip, not need fix
                }
                clazz = dexFile.loadClass(entry, patchClassLoader);
                if (clazz != null) {
//對(duì)有bug的文件進(jìn)行替換
                    fixClass(clazz, classLoader);
                }
            }
        } catch (IOException e) {
            Log.e(TAG, "pacth", e);
        }
    }

我們看見(jiàn)我們?yōu)槭裁匆肈exFile來(lái)加載補(bǔ)丁文件呢？這個(gè)得從補(bǔ)丁包.patch文件來(lái)看：

Patch包信息

META-INF

這個(gè)文件就是我們前面說(shuō)的PATCH.MF,里面存放補(bǔ)丁包的一些配置信息。上面的方法就是加載dex闲询，然后獲取到所有要修復(fù)的類(lèi)久免，然后進(jìn)行替換，所以我們接下來(lái)看fixClass()方法：

private void fixClass(Class<?> clazz, ClassLoader classLoader) {
        Method[] methods = clazz.getDeclaredMethods();
        MethodReplace methodReplace;
        String clz;
        String meth;
//遍歷要修復(fù)類(lèi)中的所有方法
        for (Method method : methods) {
//獲取帶有MethodReplace注解的方法
            methodReplace = method.getAnnotation(MethodReplace.class);
            if (methodReplace == null)
                continue;
            clz = methodReplace.clazz();
            meth = methodReplace.method();
//獲取注解中的class信息和method信息
            if (!isEmpty(clz) && !isEmpty(meth)) {
//然后調(diào)用replaceMethod方法進(jìn)行替換
                replaceMethod(classLoader, clz, meth, method);
            }
        }
    }

我們看到上面方法會(huì)獲取帶有MethodReplace注解的所有方法扭弧，這是在補(bǔ)丁包生成的時(shí)候添加上去的妄壶，然后獲取class和method的信息之后，通過(guò)調(diào)用方法repalceMethod方法進(jìn)行方法替換：

private void replaceMethod(ClassLoader classLoader, String clz,
            String meth, Method method) {
        try {
            String key = clz + "@" + classLoader.toString();
//判斷這個(gè)類(lèi)是否已經(jīng)被修復(fù)了
            Class<?> clazz = mFixedClass.get(key);
//如果class還沒(méi)有被類(lèi)加載加載進(jìn)來(lái)寄狼，則去加載
            if (clazz == null) {// class not load
                Class<?> clzz = classLoader.loadClass(clz);
                // initialize target class
                clazz = AndFix.initTargetClass(clzz);
            }
            if (clazz != null) {// initialize class OK
                mFixedClass.put(key, clazz);
//根據(jù)反射獲取到有bug的類(lèi)的方法
                Method src = clazz.getDeclaredMethod(meth,
                        method.getParameterTypes());
//src是有bug的方法，method是補(bǔ)丁方法
                AndFix.addReplaceMethod(src, method);
            }
        } catch (Exception e) {
            Log.e(TAG, "replaceMethod", e);
        }
    }

我們看到通過(guò)注解中的method信息獲取到有bug的方法氨淌，然后調(diào)用AndFix.addReplaceMethod(src, method)進(jìn)行替換泊愧，這里是native來(lái)實(shí)現(xiàn)的，我們來(lái)看看：

static void replaceMethod(JNIEnv* env, jclass clazz, jobject src,
        jobject dest) {
    if (isArt) {
        art_replaceMethod(env, src, dest);
    } else {
        dalvik_replaceMethod(env, src, dest);
    }
}

我們的看到dalvik和art虛擬機(jī)的替換方法不同盛正，我們先來(lái)看看dalvik虛擬機(jī)上面的：

extern void __attribute__ ((visibility ("hidden"))) dalvik_replaceMethod(
        JNIEnv* env, jobject src, jobject dest) {
//這里通過(guò)jni獲取jobject對(duì)象
    jobject clazz = env->CallObjectMethod(dest, jClassMethod);
//我們看到剛才Hook的系統(tǒng)的函數(shù)删咱，通過(guò)這個(gè)系統(tǒng)函數(shù)我們可以獲取class的ClassObject對(duì)象指針
    ClassObject* clz = (ClassObject*) dvmDecodeIndirectRef_fnPtr(
            dvmThreadSelf_fnPtr(), clazz);
//更改狀態(tài)為類(lèi)初始化完成的狀態(tài)
    clz->status = CLASS_INITIALIZED;
//通過(guò)java層傳遞的方法對(duì)象，在native層獲得他們的結(jié)構(gòu)體
    Method* meth = (Method*) env->FromReflectedMethod(src);
    Method* target = (Method*) env->FromReflectedMethod(dest);
    LOGD("dalvikMethod: %s", meth->name);

//  meth->clazz = target->clazz;
替換method結(jié)構(gòu)體中的accessFlags
    meth->accessFlags |= ACC_PUBLIC;
//替換method結(jié)構(gòu)體中的方法的索引methodIndex
    meth->methodIndex = target->methodIndex;
// 替換method結(jié)構(gòu)體的緩存的JNI參數(shù)jniArgInfo
    meth->jniArgInfo = target->jniArgInfo;
    meth->registersSize = target->registersSize;
    meth->outsSize = target->outsSize;
//替換method結(jié)構(gòu)體的insSize
    meth->insSize = target->insSize;
// 替換method結(jié)構(gòu)體的方法原型描述prototype
    meth->prototype = target->prototype;
// 替換method結(jié)構(gòu)體的真實(shí)代碼insns
    meth->insns = target->insns;
//替換method結(jié)構(gòu)體的真實(shí)函數(shù)或者JNI橋接函數(shù)
    meth->nativeFunc = target->nativeFunc;
}

我們看到這里就是指針指向了修復(fù)完的方法的結(jié)構(gòu)體信息豪筝，這樣就達(dá)到了修復(fù)的目的痰滋，所以說(shuō)指針還是一個(gè)非常有用的東西，這也是c和c++的精髓所在续崖，接著我們來(lái)看看art虛擬機(jī)的replaceMethod方法：

extern void __attribute__ ((visibility ("hidden"))) art_replaceMethod(
        JNIEnv* env, jobject src, jobject dest) {
    if (apilevel > 23) {
        replace_7_0(env, src, dest);
    } else if (apilevel > 22) {
        replace_6_0(env, src, dest);
    } else if (apilevel > 21) {
        replace_5_1(env, src, dest);
    } else if (apilevel > 19) {
        replace_5_0(env, src, dest);
    }else{
        replace_4_4(env, src, dest);
    }
}

這個(gè)地方還是比較蛋疼的敲街，我們看見(jiàn)根據(jù)api的不同版本來(lái)做了好幾個(gè)適配，現(xiàn)在8.0出來(lái)了严望，可想而知也可能要做適配多艇，我們先來(lái)看下4.4的這個(gè)方法：

void replace_4_4(JNIEnv* env, jobject src, jobject dest) {
    art::mirror::ArtMethod* smeth =
            (art::mirror::ArtMethod*) env->FromReflectedMethod(src);

    art::mirror::ArtMethod* dmeth =
            (art::mirror::ArtMethod*) env->FromReflectedMethod(dest);
//替換 ArtMethod的class_loader指針
    dmeth->declaring_class_->class_loader_ =
            smeth->declaring_class_->class_loader_; //for plugin classloader
//替換ArtMethod的clinit_thread_id_指針
    dmeth->declaring_class_->clinit_thread_id_ =
            smeth->declaring_class_->clinit_thread_id_;
//替換ArtMethod的status_指針
    dmeth->declaring_class_->status_ = smeth->declaring_class_->status_-1;
    //for reflection invoke
    reinterpret_cast<art::mirror::Class*>(dmeth->declaring_class_)->super_class_ = 0;
//替換ArtMethod的declaring_class_指針
    smeth->declaring_class_ = dmeth->declaring_class_;
    smeth->dex_cache_initialized_static_storage_ = dmeth->dex_cache_initialized_static_storage_;
//替換ArtMethod的access_flags_指針
    smeth->access_flags_ = dmeth->access_flags_  | 0x0001;
    smeth->dex_cache_resolved_types_ = dmeth->dex_cache_resolved_types_;
    smeth->dex_cache_resolved_methods_ = dmeth->dex_cache_resolved_methods_;
    smeth->dex_cache_strings_ = dmeth->dex_cache_strings_;
    smeth->code_item_offset_ = dmeth->code_item_offset_;
    smeth->core_spill_mask_ = dmeth->core_spill_mask_;
    smeth->fp_spill_mask_ = dmeth->fp_spill_mask_;
    smeth->method_dex_index_ = dmeth->method_dex_index_;
    smeth->mapping_table_ = dmeth->mapping_table_;
//替換ArtMethod的method_index_指針
    smeth->method_index_ = dmeth->method_index_;
    smeth->gc_map_ = dmeth->gc_map_;
    smeth->frame_size_in_bytes_ = dmeth->frame_size_in_bytes_;
    smeth->native_method_ = dmeth->native_method_;
    smeth->vmap_table_ = dmeth->vmap_table_;

    smeth->entry_point_from_compiled_code_ = dmeth->entry_point_from_compiled_code_;
    
    smeth->entry_point_from_interpreter_ = dmeth->entry_point_from_interpreter_;
    
    smeth->method_index_ = dmeth->method_index_;

    LOGD("replace_4_4: %d , %d", smeth->entry_point_from_compiled_code_,
            dmeth->entry_point_from_compiled_code_);

}

我們看到這里要替換的東西還是比較多的，大家可以通過(guò)查看虛擬機(jī)中的方法結(jié)構(gòu)體來(lái)查看像吻，這里也就不詳細(xì)列出了峻黍。

總結(jié):AndFix的源碼還是比較好理解复隆，但是想到用這種方法還是非常fashion的有沒(méi)有，而且需要我們了解你虛擬機(jī)相關(guān)的知識(shí)姆涩，這方面我也是有欠缺挽拂，可以適當(dāng)補(bǔ)充了，希望大家一起進(jìn)步骨饿。