Hook加载插件APK(ClassLoader方式)
前言
前面插件化一和二说了下插桩式加载未安装的APK，主要是重写了getResource和getClassloader两个方法来实现的。以及每个组件要实现一个接口，通过接口注入上下文来达到它的生命周期。
那么插桩式和hook式的实现方式有什么不同呢？
插桩式是怎么加载到插件中的class文件呢，是通过将将APK转化成插件的Classloader，然后想要加载插件的class文件，我们的去拿这个插件的classloader去loadClass。所以是有一个中间者的。
hook式呢是将插件apk融入到了我们的宿主apk，那直接在里面就可以直接loadClass了，在不用这个插件的ClassLoader了，这样的话对于插件和宿主就没什么区别了，不像插桩式有一个中间者。
那么要实现hook式 就要知道android中一个class文件式怎样被加载到内存中去的。其实就是通过PathClassLoader来加载的。
那么我们先看下ClassLoader
ClassLoader
任何一个java程序都是由一个或者多个class组成的，在程序运行时，需要将class文件加载到JVM中才可以使用，负责加载这些class文件的就是java的类加载机制。CLassLoader的作用就是加载class文件提供给程序运行时使用，每个Class对象内部都有一个ClassLoader来标示自己是有那个classLoade加载的。
Android app的所有的java文件都是通过PathClassLoader来加载的，那么它的父类是BaseDexClassLoader，还有一个兄弟类是DexClassLoader，那么他们有什么区别呢。
DexClassLoader类
public DexClassLoader(String dexPath, String optimizedDirectory, String librarySearchPath, ClassLoader parent) {
super((String)null, (File)null, (String)null, (ClassLoader)null);
throw new RuntimeException("Stub!");
}
PathClassLoader类
public PathClassLoader(String dexPath, ClassLoader parent) {
super((String)null, (File)null, (String)null, (ClassLoader)null);
throw new RuntimeException("Stub!");
}
public PathClassLoader(String dexPath, String librarySearchPath, ClassLoader parent) {
super((String)null, (File)null, (String)null, (ClassLoader)null);
throw new RuntimeException("Stub!");
}
从上面可以看出这两个类的构造函数不同。(在26的源码中DexClassLoader中的optimizedDirectory也废弃了)
PathClassLoader：用于Android应用程序类加载器。可以加载指定的dex，以及jar、zip、apk中的classes.dex
DexClassLoader：加载指定的dex以及jar、zip、apk中的classes.dex。
双亲委托机制
可以看到创建ClassLoader的时候需要接收一个CLassLoader parent的参数，这个parent的目的就在于实现类加载的委托。
某个类加载器在接到加载类的请求时，首先将加载任务委托给父类加载器，一次递归，如果父加载器可以完成加载任务，那么就返回，只有当父加载器无法完成加载任务时，才自己去加载。
protected Class loadClass(String name,boolean resolve) throws ClassNotFoundException{
//检查class是否有被加载过
Class c=findLoadedClass(name);
if(c=null){
long t0=System.nanoTime();
try {
// 父类不为null 调用父类的loadClass
if(parent！!=null){
c=parent.loadClass(name,false);
}{
//如果parent为null，则调用BootClassLoader进行加载
c=findBootstrapClassOrNull(name);
}
}catch{
}
//父类都没找到 那就自己找
if(c=null){
c=findClass(name);
}
}
return c;
}
因此我们自己创建的ClassLoader：newPathClassLoader("/sdcard/xx.dex",getClassLoader()),并不仅仅只能加载我们的xx.dex中的class。
需要注意的是，findBootstrapClassOrNull 这个方法，当parent为null的时候，去这个BootCLassLoader进行加载，
但是在Android当中的实现：
private Class findBootstrapClassOrNull(String name){
return null;
}
所以new PathClassLoader("/sdcard/xx.dex",null),是不能加载Activity.class的。
上面分析了加载了一个class，是利用了双亲委托机制，那么要是都找不到那就开始调用自己的findCLass方法
findClass实现机制
在ClassLoader类中findClass：
protected Class findClass(String name) throws ClassNotFoundException{
throw new ClassNotFoundException(name);
}
任何ClassLoader的子类，都可以重写loadClass和findClass。如果你不想使用双亲委托，就重写loadClas修改实现，重写findClass则表示在双亲委托机制下，父ClassLoader都找不到class的情况下，定义自己去查找一个class。
而我们的PathClassLoader会自己负责加载Activity这样的类，利用双亲委托父类去加载activity，而我们的PathClassLoader没有重写findClass，是在它的父类里面。因此我们可以看看父类的findClass是如何实现的。
public BaseDexClassLoader(String dexPath,File optimizedDirectory,
String librarySearchPath,ClassLoader parent){
super(parent);
this.pathList=new DexPathList(this,dexPath,librarySearchPath,optimizeDirectory);
}
@Override
protected Class findClass(String name) throws ClassNotFoundException{
List suppressedExceptions=new ArrayList();
//查找指定的class
Class c=pathList.findClass(name,suppressedExeptions);
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;
}
可以看到加载PathClassLoader加载class，转化为从DexPathList中加载class了，那么我们看看DexPathList中的findClass
public DexPathList(ClassLoader definingContext,String dexPath,
String librarySearchPath,File optimizedDirectory){
// splitDexPath 实现为返回的List .add(dexPath)
// makeDexElements会去List.add(dexPath)中使用DexFile加载Dex文件发挥Element数组
this.dexElements=makeDexElements(splitDexPath(dexpath),optimizedDirectory,
suppressedExceptions,definingContext);
}
public Class findClass(String name,List suppressed){
//从element中获得代表dex的dexFile
for(Element element : dexElements){
DexFile dex=element.dexFile;
if(dex!=null){
//查找class
Class clazz=dex.loadClassBinaryName(name,defingContext,suppressed);
if(clazz!=null){
reruen clazz;
}
}
if (dexElementsSuppressedExceptions != null) {
suppressed.addAll(Arrays.asList(dexElementsSuppressedExceptions));
}
return null;
}
}
那么从上面分析得到
- 在PathClassLoader加载class，在父类的委托下没有找到CLas下，会去BaseDexClassloader找
- 在调用父类的findClass的时候，创建了DexPathList，那我们的dex文件给传进去
- 在DexPathList中findClass的时候从数组中查找，如果查找到了直接返回，不会再往下查找。
到这里我们想要加载一个插件的apk ，其实最终加载的是一个dex文件(先说class文件，加载资源后面说)，有没有办法吧这个dex文件给转化成一个Element对象，给放到Elemeng数组当中，这样直接就可以加载我们插件中的类了。
DexElement数组合并(也就是热修复)
-
首先是要拿到插件的路径
String cachePath=context.getCacheDir.getAbsolutePath(); String apkPath=context.Environment.getExernaltorageDirectory.getAbsolutePath+"/plugin.apk"; DexClassLoader myClassLoaderObj=new DexClassLoader(apkPath,cachePath,cachePath,context.getClassLoader);
1、首先我们肯定是要得到插件APK的的中DexPathList对象中的dexElement数组
Class myBaseDexClassLoaderClass=Class.forName("dalvik.system.BaseDexClassLoader");
Field myPathListField=myBaseDexClassLoaderClass.getDeclaredField("pathList");
myPathListField.setAccessible(true);
//接着得到插件pathList的Obj
Object myPathListObj=myPathListField.get(myClassLoaderObj);
Class myPathListCLass=myPathListObj.getClass;
Field myDexElementField=myPathListClass.getDeclaredField("dexElements");
myDexElementField.setAccessible(true);
// 然后在从myPathListObj这个对象身上去dexElement数组
Object myDexElementArray=myDexElementField.get(myPathListObj);
//现在也拿到了插件的dex数组
2、插件的dexElements数组我们拿到了，那么是不是要开始拿我们系统里面的 ，我们反射获取，和上面的一样。
// 开始获取系统的，对象就是我们的上下文的classLoader
PathClassLoader sysClassLoader = (PathClassLoader) context.getClassLoader();
Class sysDexClassLoaderClass = Class.forName("dalvik.system.BaseDexClassLoader");
Field sysPathListField = sysDexClassLoaderClass.getDeclaredField("pathList"); sysPathListField.setAccessible(true);
//拿到我们系统的pathList的对象
Object sysPathListObj = sysPathListField.get(sysClassLoader);
Class sysPathListClazz = sysPathListObj.getClass();
Field sysDexElements = sysPathListClazz.getDeclaredField("dexElements");
sysDexElements.setAccessible(true);
// 然后在获取系统的Element数组
Object sysElementsArray = sysDexElements.get(sysPathListObj);
3、上面我们获取到了系统和我们插件的dexElement数组，然后我们将这个数组合并到一个新的数组里面去，并且给注入到系统里面
int myLength = Array.getLength(myDexElementArray);
int sysLength = Array.getLength(sysElementsArray);
int newLength = myLength + sysLength;// 这个就是咱们要融合的新数组的长度
// 然后我们创建一个新的数组，因为是Object类型，所以我们使用反射包下提供的工具类
// 这个拿到的就是系统dexElement数组中对象的class类型
Class sysElementClazz = sysElementsArray.getClass().getComponentType();
//创建一个新的数组 但是里面要穿一个数组里面的对象的class类型
Object newElementArray = Array.newInstance(sysElementClazz, newLength);
// 新数组创建好了，那么我开始合并
for (int i = 0; i < newLength; i++) {
if (i < myLength) {
// 插件的数组
Array.set(newElementArray, i, Array.get(myDexElementArray, i));
} else {
//系统的数组
Array.set(newElementArray, i, Array.get(sysElementsArray, i - myLength));
}
}
// 现在就将两个dexElement数组全部都放到我们的新数组中去了
sysDexElements.set(sysPathListObj,newElementArray);
至此，加载插件的一个流程基本就完成了。但是上面只是处理了class文件，没有处理资源。资源的话我们也是采用hook的方式去实现
String apkPath = Environment.getExternalStorageDirectory().getAbsolutePath() + "/plugin.apk";
try {
assetManager = AssetManager.class.newInstance();
Method assetPathMethod = assetManager.getClass().getDeclaredMethod("addAssetPath", String.class);
assetPathMethod.setAccessible(true);
assetPathMethod.invoke(assetManager, apkPath);
//手动实例化
Method ensureStringBlocksMethod = assetManager.getClass().getDeclaredMethod("ensureStringBlocks");
ensureStringBlocksMethod.setAccessible(true);
ensureStringBlocksMethod.invoke(assetManager);
resources = new Resources(assetManager, getResources().getDisplayMetrics(), getResources().getConfiguration());
} catch (Exception e) {
e.printStackTrace();
}
在宿主的Application中hook这个方法，然后去重写getAsserts和getResources两个方法：
@Override
public AssetManager getAssets() {
return assetManager == null ? super.getAssets() : assetManager;
}
@Override
public Resources getResources() {
return resources == null ? super.getResources() : resources;
}
然后在插件的BaseActivity中继续重写getAssets和getResources两个方法
@Override
public Resources getResources() {
if (getApplication()!=null && getApplication().getResources()!=null){
return getApplication().getResources();
}
return super.getResources();
}
@Override
public AssetManager getAssets() {
if (getApplication()!=null && getApplication().getAssets()!=null){
return getApplication().getAssets();
}
return super.getAssets();
}
这样就可以完成hook式加载一个未安装的APK了。至此基本就完成了插桩式和Hook式插件化的基本实现。(后面几篇是优化)。