类加载机制
要想了解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数组通过反射的技术再次设置到程序中。
