Tinker热修复原理与操作

类加载机制

要想了解Tinker热修复的原理我们就必须知道类加载机制。

首先，我们需要知道ClassLoader中的分类，ClassLoader：
BootClassLoader用于加载Android Framework层的class文件。
PathClassLoader用于Android应用程序类加载器。
DexClassLoader用于额外提供的动态类加载器。
PathClassLoader和DexClassLoader加载指定的dex、jar、zip以及apk中的class.dex。
代码入口：

pathClassLoader.loadClass()

然后进入的是ClassLoader中的loadClass()方法：

protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    {
            // First, check if the class has already been loaded
            Class<?> c = findLoadedClass(name);
            if (c == null) {
                try {
                    if (parent != null) {
                        c = parent.loadClass(name, false);
                    } else {
                        c = findBootstrapClassOrNull(name);
                    }
                } catch (ClassNotFoundException e) {
                    // ClassNotFoundException thrown if class not found
                    // from the non-null parent class loader
                }

                if (c == null) {
                    // If still not found, then invoke findClass in order
                    // to find the class.
                    c = findClass(name);
                }
            }
            return c;
    }

这里我们先分析parent，有源码可知，这里的parent就是一个ClassLoader，那么调用parent.loadClass又有什么用呢？这里我们就需要知道一个机制，双亲委托机制。
双亲委托机制：某个类加载器在加载类时，首先将加载任务委托给父类加载器，依次递归，如果父类加载器可以完成类加载任务，就成功返回，只有父类加载器无法完成此加载任务或没有父类加载器时，才自己去加载。
优点：
避免重复加载，当父类中已经加载了该类，没必要重复加载。
安全性考虑，防止核心API库被随意篡改。
分析完parent.loadClass，我们在分析findClass。这时候我们需要去PathClassLoader源码中找，里面并没有findClass方法，再去父类BaseDexClassLoader 中找。

protected Class<?> findClass(String name) throws ClassNotFoundException {
        List<Throwable> suppressedExceptions = new ArrayList<Throwable>();
        Class c = pathList.findClass(name, suppressedExceptions);
        if (c == null) {
            ClassNotFoundException cnfe = new ClassNotFoundException(
                    "Didn't find class \"" + name + "\" on path: " + pathList);
            for (Throwable t : suppressedExceptions) {
                cnfe.addSuppressed(t);
            }
            throw cnfe;
        }
        return c;
    }

这里的代码很简单，就是调用的pathList.findClass方法。

public Class<?> findClass(String name, List<Throwable> suppressed) {
        for (Element element : dexElements) {
            Class<?> clazz = element.findClass(name, definingContext, suppressed);
            if (clazz != null) {
                return clazz;
            }
        }

        if (dexElementsSuppressedExceptions != null) {
            suppressed.addAll(Arrays.asList(dexElementsSuppressedExceptions));
        }
        return null;
    }
public Class<?> findClass(String name, ClassLoader definingContext,
                List<Throwable> suppressed) {
            return dexFile != null ? dexFile.loadClassBinaryName(name, definingContext, suppressed)
                    : null;
        }

这里分析不难得到，我们通过遍历dexElements得到element，然后通过loadClassBinaryName()方法得到class，这里细节我们就不深究了，那么dexElements是什么呢？
其实dexElements就是classDex的数组，如Elments[] = {classes.dex,classes.dex2,classes.dex3}的结构。
通过上述代码，我们知道，只要在classes.dex中找到类便会直接返回，不会继续循环。
那么，我们热修复的关键点就来了，只要我们修改后的dex文件加到有BUG的dex文件前，那么就可以实现热修复。

热修复

热修复的优势：
1.无需重新发布新版本，省时省力。
2.用户无感知修复，也无需下载最新应用，代价小。
3.修复成功率高，把损失降到最低。

可以做代码修复，资源修复，so库的修复。
原理：插桩原理。
java通过javac到class，在通过sdk/build-tools/dx.bat打包成dex。

操作步骤：
1.创建BaseDexClassLoader子类DexClassLoader类加载器。
2.用自己创建的类加载器加载修复好的修复包。
3.将自有的dex和系统的dex合并，生成一个新的dexElements数组，并把自有的dex优先级设为最高，即索引为0。
4.通过反射将新的dexElements数组赋值给系统的pathList。

由于时间关系，这里我就不把所有代码贴出来，说下核心原理：
我们可以从原始的apk路径data/app/packageName-1/base.apk
PackageMannagerService拿到apk，然后从后台下载修复的查分包。注意，这里我们可能有多个dex文件需要更新。

public static void loadFixedDex(Context context) {
        if (context == null) return;
        // Dex文件目录（私有目录中，存在之前已经复制过来的修复包）
        File fileDir = context.getDir(Constants.DEX_DIR, Context.MODE_PRIVATE);
        File[] listFiles = fileDir.listFiles();
        // 遍历私有目录中所有的文件
        for (File file : listFiles) {
            // 找到修复包，加入到集合
            if (file.getName().endsWith(Constants.DEX_SUFFIX) && !"classes.dex".equals(file.getName())) {
                loadedDex.add(file);
            }
        }

        // 模拟类加载器
        createDexClassLoader(context, fileDir);
    }

这个方法的作用就是找到dex文件存在的位置并遍历dex文件然后保存在一个集合中。然后调用createDexClassLoader方法。

private static void createDexClassLoader(Context context, File fileDir) {
        // 创建临时的解压目录（先解压到该目录，再加载java）
        String optimizedDir = fileDir.getAbsolutePath() + File.separator + "opt_dex";
        // 不存在就创建
        File fopt = new File(optimizedDir);
        if (!fopt.exists()) {
            // 创建多级目录
            fopt.mkdirs();
        }
        for (File dex : loadedDex) {
            // 每遍历一个要修复的dex文件，就需要插桩一次
            DexClassLoader classLoader = new DexClassLoader(dex.getAbsolutePath(),
                    optimizedDir, null, context.getClassLoader());
            hotfix(classLoader, context);
        }
    }  

···
private static void hotfix(DexClassLoader classLoader, Context context) {
// 获取系统PathClassLoader类加载器
PathClassLoader pathLoader = (PathClassLoader) context.getClassLoader();

    try {
        // 获取自有的dexElements数组对象
        Object myDexElements = ReflectUtils.getDexElements(ReflectUtils.getPathList(classLoader));

        // 获取系统的dexElements数组对象
        Object systemDexElements = ReflectUtils.getDexElements(ReflectUtils.getPathList(pathLoader));

        // 合并成新的dexElements数组对象
        Object dexElements = ArrayUtils.combineArray(myDexElements, systemDexElements);

        // 通过反射再去获取   系统的pathList对象
        Object systemPathList = ReflectUtils.getPathList(pathLoader);

        // 重新赋值给系统的pathList属性  --- 修改了pathList中的dexElements数组对象
        ReflectUtils.setField(systemPathList, systemPathList.getClass(), dexElements);
    } catch (Exception e) {
        e.printStackTrace();
    }
}  

···

public class ReflectUtils {

    /**
     * 通过反射获取某对象，并设置私有可访问
     *
     * @param obj   该属性所属类的对象
     * @param clazz 该属性所属类
     * @param field 属性名
     * @return 该属性对象
     */
    private static Object getField(Object obj, Class<?> clazz, String field)
            throws NoSuchFieldException, IllegalAccessException, IllegalArgumentException {
        Field localField = clazz.getDeclaredField(field);
        localField.setAccessible(true);
        return localField.get(obj);
    }

    /**
     * 给某属性赋值，并设置私有可访问
     *
     * @param obj   该属性所属类的对象
     * @param clazz 该属性所属类
     * @param value 值
     */
    public static void setField(Object obj, Class<?> clazz, Object value)
            throws NoSuchFieldException, IllegalAccessException, IllegalArgumentException {
        Field localField = clazz.getDeclaredField("dexElements");
        localField.setAccessible(true);
        localField.set(obj, value);
    }

    /**
     * 通过反射获取BaseDexClassLoader对象中的PathList对象
     *
     * @param baseDexClassLoader BaseDexClassLoader对象
     * @return PathList对象
     */
    public static Object getPathList(Object baseDexClassLoader)
            throws NoSuchFieldException, IllegalAccessException, IllegalArgumentException, ClassNotFoundException {
        return getField(baseDexClassLoader, Class.forName("dalvik.system.BaseDexClassLoader"), "pathList");
    }

    /**
     * 通过反射获取BaseDexClassLoader对象中的PathList对象，再获取dexElements对象
     *
     * @param paramObject PathList对象
     * @return dexElements对象
     */
    public static Object  getDexElements(Object paramObject)
            throws NoSuchFieldException, IllegalAccessException, IllegalArgumentException {
        return getField(paramObject, paramObject.getClass(), "dexElements");
    }
}

最后将合并后的dex数组通过反射的技术再次设置到程序中。