tinker热修复是基于类的
1）Tinker是一个java技术
2）使用java技术实现不会遇到兼容性问题，因为java完全是跨平台的
因为Tinker是一个java技术，通过dex插队的方式来进行热修复的，所以必须要对安卓系统加载类有所了解。
相关的几个类在系统源码中的位置：
\libcore\dalvik\src\main\java\dalvik\system
Android系统的类加载器是PathClassLoader,它继承自BaseDexClassLoader,BaseDexClassLoader继承自ClassLoader，
我们要使用Android系统的加载类，使用的是PathClassLoader
PathClassLoader pathClassLoader = (PathClassLoader) getClassLoader();
pathClassLoader.loadClass("全类名");
点进loadClass可以看到，pathClassLoader调用的是ClassLoader的loadClass，PathClassLoader没有重写loadClass这个方法。
然后点击loadClass这个方法，进入到了ClassLoader类中：
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;
}
主要看父类不存在的情况下：
if (c == null) {
c = findClass(name);
}
此时会调用ClassLoader本类的findClass方法：
protected Class<?> findClass(String name) throws ClassNotFoundException {
throw new ClassNotFoundException(name);
}
ClassLoader本类的findClass方法抛出了一个异常，抛异常不会真的会抛，意味着子类会去重写。
BaseDexClassLoader会去重写这个方法，那它重写的作用是：寻找类，返回这个类。
在这个重写方法中将查找类的工作交给了pathList
@Override
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是DexPathList
private final DexPathList pathList;
查看DexPathList中的findClass方法,可以看到做了循环操作，有个Element对象，这个Element就是加载到内存后的对象，然后通过得到DexFile去加载一个类，使用的loadClassBinaryName（其实就是loadClass）来得到dex中的类。
方法中的这个Element就是dex被加载到内存中的一个对象，就好比解析json数据放到了JavaBean中，dex解析后放到了Element中，
public Class findClass(String name, List<Throwable> suppressed) {
for (Element element : dexElements) {
DexFile dex = element.dexFile;
if (dex != null) {
Class clazz = dex.loadClassBinaryName(name, definingContext, suppressed);
if (clazz != null) {
return clazz;
}
}
}
if (dexElementsSuppressedExceptions != null) {
suppressed.addAll(Arrays.asList(dexElementsSuppressedExceptions));
}
return null;
}
其中下面这句很关键，如果clazz不为空，则直接返回，不会再去遍历后面的类
if (clazz != null) {
return clazz;
}
可以查看Element这个对象的属性
private final File dir;
private final boolean isDirectory;
private final File zip;
private final DexFile dexFile;
private ZipFile zipFile;
private boolean initialized;
那我们实不是要自己组装Element呢，这个是不需要的，下面是DexPathList中的一个重要方法，可以看到系统帮我们做了组装的工作。
private static Element[] makePathElements(List<File> files, File optimizedDirectory,
List<IOException> suppressedExceptions) {
List<Element> elements = new ArrayList<>();
/*
* Open all files and load the (direct or contained) dex files
* up front.
*/
for (File file : files) {
File zip = null;
File dir = new File("");
DexFile dex = null;
String path = file.getPath();
String name = file.getName();
if (path.contains(zipSeparator)) {
String split[] = path.split(zipSeparator, 2);
zip = new File(split[0]);
dir = new File(split[1]);
} else if (file.isDirectory()) {
// We support directories for looking up resources and native libraries.
// Looking up resources in directories is useful for running libcore tests.
elements.add(new Element(file, true, null, null));
} else if (file.isFile()) {
if (name.endsWith(DEX_SUFFIX)) {
// Raw dex file (not inside a zip/jar).
try {
dex = loadDexFile(file, optimizedDirectory);
} catch (IOException ex) {
System.logE("Unable to load dex file: " + file, ex);
}
} else {
zip = file;
try {
dex = loadDexFile(file, optimizedDirectory);
} catch (IOException suppressed) {
suppressedExceptions.add(suppressed);
}
}
} else {
System.logW("ClassLoader referenced unknown path: " + file);
}
if ((zip != null) || (dex != null)) {
elements.add(new Element(dir, false, zip, dex));
}
}
return elements.toArray(new Element[elements.size()]);
}
所以我们自己得到Element就可以了，那如何得到呢？
需要先将对象还原，得到对象成员变量，再得到对象的成员变量中的数组 通过反射调用。
那我们可以得出结论：
1）dexpathlist是在BaseDexCalssLoader中作为引用的，而PathDexClassLoader是持有了dexpathlist的引用。
2） dex加到element中，是不需要我们去解析，实例化BaseClassLoader就帮我们做好相关的工作了。
3）实例化DexPathList调用了makePathElements，makePathElements这个方法里面做了组装dex文件的工作：先将一个dex文件装载为 一个DexFile，然后将DexFile装载为一个Element，返回给this.dexElements,this.dexElements是在DexPathList这个对象手中。
如何得到Element数组？
只有得到对象成员变量，才能将对象还原，才能获得Element数组，然后可以反射调用。
PathClassLoader是BaseDexClassLoader的子类，PathClassLoader持有了DexPathList的引用。
复制Element
创建一个新的数组，把从网络下载的dex通过转为element，放在新的数组的前面，系统的dex放在后面。
通过看源码得知：
dex文件到element，实例化BaseClassLoader就可以，直接上代码：
public void loadDex(Context context) {
if (context == null) {
return;
}
File filesDir = context.getDir("odex", Context.MODE_PRIVATE);
File[] listFiles = filesDir.listFiles();
for (File file : listFiles) {
if (file.getName().endsWith(".dex")) {
loaded.add(file);
}
}
//修复
String optimizeDir = filesDir.getAbsolutePath() + File.separator + "opt_dex";
File fopt = new File(optimizeDir);
if (!fopt.exists()) {
fopt.mkdirs();
}
for (File dex : loaded) {
DexClassLoader dexClassloader = new DexClassLoader(dex.getAbsolutePath(), optimizeDir,
null, context.getClassLoader());
//BaseClassLoader ----dexPathList ---->dexElements;
try {
Class myDexClazzLoader = Class.forName("dalvik.system.BaseDexClassLoader");
Field myPathListFiled = myDexClazzLoader.getDeclaredField("pathList");
myPathListFiled.setAccessible(true);
//dexPathList
Object myPathListObject = myPathListFiled.get(dexClassloader);
Class myPathClazz = myPathListObject.getClass();
Field myElementsField = myPathClazz.getDeclaredField("dexElements");//dexElements
myElementsField.setAccessible(true);
Object myElements = myElementsField.get(myPathListObject);// Element[] dexElements
Class elemnt = systemElements.getClass().getComponentType();
int systemLength = Array.getLength(systemElements);
int myLength = Array.getLength(myElements);
// 生成一个新的数组,类型为Element类型
Object newElementArray = Array.newInstance(elemnt, systemLength + myLength);
for (int i = 0; i < myLength + systemLength; i++) {
if (i < myLength) {
//先插入修复包的dex
Array.set(newElementArray, i, Array.get(myElements, i));
} else {
//系统的
Array.set(newElementArray, i, Array.get(systemElements, i - myLength));
}
}
Field elementsField = pathListObject.getClass().getDeclaredField("dexElements");
elementsField.setAccessible(true);
elementsField.set(pathListObject, newElementArray);
} catch (Exception e) {
e.printStackTrace();
}
}
}
最后说一下PathClassLoader和DexClassLoader的区别：
pathclassloader 加载的是apk中的类 /data/app/包名/apk 。
dexclassloader 可以加载任意路径 dex apk 中的类。
二者都继承自BaseClassLoader，BaseClassLoader继承自ClassLoader
