[TOC]

• ClassLoader 简介
• APP启动流程简介
• 插件前提
• ClassLoader 修正的三种方式
  • 替换 Android 应用程序的类加载器
  • 将插件 Dex 文件插入到应用程序的 ClassLoader 中
  • 替换应用默认ClassLoader 的父类为插件ClassLoader

ClassLoader 简介

在 Android 中，ClassLoader（类加载器）是用于加载应用程序的类文件和资源的机制。Android 的类加载器与 Java 类加载器有些不同，因为 Android 应用程序是在 Dalvik 虚拟机或者更现在的 ART（Android Runtime）上运行的。

Android 中的 ClassLoader 主要有以下几种类型：

• PathClassLoader：这是 Android 应用程序默认的类加载器，用于加载应用程序的 APK 文件中的类。它会从 APK 文件的 classes.dex 中加载类，并根据类的依赖关系动态地加载其他类和资源。

• DexClassLoader：这是一个特殊的类加载器，可以加载非标准的 DEX 文件，即包含编译后的字节码的文件。通常用于实现插件化或动态加载功能，允许应用程序在运行时加载额外的类和资源。

• BaseDexClassLoader：这是一个抽象类，是 PathClassLoader 和 DexClassLoader 的基类，定义了一些共同的方法和属性。它们都继承自此类，并根据不同的需求实现具体的类加载逻辑。

• BootClassLoader：这是 Android 系统启动时创建的类加载器，负责加载 Android 系统核心库和系统服务等关键类。它是 Android 类加载器的根加载器，位于类加载器的层次结构顶端。

这些类加载器的作用是加载应用程序的类和资源。它们根据类的依赖关系，在运行时动态地加载需要的类，并将其转换成可执行的字节码。类加载器还负责处理类的链接、解析和初始化等步骤，确保类的正确加载和使用。

在 Android 开发中，开发者也可以自定义类加载器，继承自以上的类加载器，并实现自己的类加载逻辑。自定义类加载器可以用于加载非标准的类文件或资源，实现特定的需求，例如实现热修复、插件化等功能。

总结起来，Android 中的 ClassLoader 是用于加载应用程序的类和资源的机制。它根据不同的需求和场景，提供了不同的类加载器类型，用于加载 APK 文件中的类、非标准的 DEX 文件，以及系统核心库和系统服务等。

双亲委派（Parent Delegation）

在 Android 中，双亲委派（Parent Delegation）是一种类加载机制，用于保证类加载的安全和一致性。这个机制也被称为双亲优先模型。

具体来说，当一个类加载器收到加载类的请求时，它首先会把这个请求委托给它的父加载器去完成。只有当父加载器无法完成加载请求时，子加载器才会尝试自己去加载。这样的层层委派关系就构成了一个类加载器的层次结构。

在Android 中，PathClassLoader 是应用程序默认的类加载器，其父加载器是 BootClassLoader，后者负责加载系统核心库和系统服务等关键类。这意味着当一个类加载请求到达 PathClassLoader 时，PathClassLoader 会首先委派给 BootClassLoader 去完成加载。只有当 BootClassLoader 无法完成加载时，PathClassLoader 才会尝试自己加载类。

通过双亲委派模型，可以实现类加载的共享和隔离。共享指的是如果一个类已经被一个类加载器加载过了，那么其子加载器再次加载相同的类时会直接使用已经加载过的版本，而不会重复加载。隔禽指的是每个类加载器只能加载它所能访问到的类，从而实现了类的隔离性。

双亲委派模型在 Android 中起着重要的作用，保证了类加载的安全性和一致性，同时也促进了类加载的共享和隔离。这种机制也有利于避免类的重复加载和冲突，确保了应用程序的稳定性和安全性。

APP启动流程简介

1. 应用程序启动：
   应用程序的入口是 android.app.ActivityThread 类的 main() 方法。在该方法中，系统会创建 ActivityThread 对象并调用其 attach() 方法来初始化应用程序的上下文环境。
   ActivityThread 的 attach() 方法会创建应用程序的 Application 对象，并调用其 onCreate() 方法进行初始化，同时启动主 Activity。

2. Activity 启动：
   当主 Activity 启动后，会通过 Instrumentation 类的 execStartActivity() 方法来启动其他 Activity。Instrumentation 类是 Android 系统提供的用于管理与控制 Activity 生命周期的关键类。
   execStartActivity() 方法会处理 Activity 的启动过程，包括创建新的 Activity实例、设置 Intent 参数、加载布局等。最终，调用 Activity 类的 onCreate() 方法来完成 Activity 的创建和初始化。

3. 布局和界面显示：
   Activity 的布局和界面显示由 WindowManager 和 View 类负责。WindowManager 负责管理窗口的显示和布局，而 View 类则用于定义界面元素和交互逻辑。
   通过 XML 布局文件或者代码方式，可以定义界面元素的结构和样式。在 Activity 的 onCreate() 方法中，会使用 setContentView() 方法将布局文件与 Activity 关联起来，从而实现界面的显示。

插件前提

要启动插件的组件，首先要在宿主的清单文件中声明该组件。
加载插件DEX后，需要对ClassLoader进行修正，才能让该组件拥有完整的生命周期。

ClassLoader 修正

1. 替换 Android 应用程序的类加载器

替换 Android 应用程序的类加载器，以加载插件ClassLoader 中包含的类，而不是默认的应用程序类加载器。

具体来说，该函数首先通过反射获取当前应用程序的 ActivityThread 对象，并通过反射获取其私有成员变量 mPackages。然后，通过 context.getPackageName() 获取当前应用程序的包名，并从 mPackages 中获取对应的 WeakReference<LoadedApk> 对象。接着，通过反射获取 LoadedApk 对象中的 mClassLoader 成员变量，并将其值设置成插件ClassLoader。

 public static void replaceClassLoader(Context context, ClassLoader dexclassloader) {
    // 获取当前类的类加载器作为路径类加载器
    ClassLoader pathclassloader = MainActivity.class.getClassLoader();
    try {
        // 通过反射加载 android.app.ActivityThread 类
        Class ActivityThread = pathclassloader.loadClass("android.app.ActivityThread");
        // 调用 ActivityThread 的 currentActivityThread 方法获取当前 ActivityThread 对象
        Method currentActivityMethod = ActivityThread.getDeclaredMethod("currentActivityThread");
        Object activityThreadObj = currentActivityMethod.invoke(null);
        
        // 获取 ActivityThread 中的 mPackages 字段
        Field mPackagesField = ActivityThread.getDeclaredField("mPackages");
        mPackagesField.setAccessible(true);
        ArrayMap mPackagesObj = (ArrayMap) mPackagesField.get(activityThreadObj);
        
        // 获取当前应用的包名
        String packagename = context.getPackageName();
        // 从 mPackages 中获取对应包名的 WeakReference 对象
        WeakReference wr = (WeakReference) mPackagesObj.get(packagename);
        Object loadedapkobj = wr.get();
        
        // 通过反射加载 android.app.LoadedApk 类
        Class LoadedApkClass = pathclassloader.loadClass("android.app.LoadedApk");
        // 获取 LoadedApk 中的 mClassLoader 字段
        Field mClassLoaderField = LoadedApkClass.getDeclaredField("mClassLoader");
        mClassLoaderField.setAccessible(true);
        
        // 获取当前 LoadedApk 对象中的类加载器对象
        Object mClassLoader = mClassLoaderField.get(loadedapkobj);
        Log.e("mClassLoader", mClassLoader.toString());
        
        // 将当前 LoadedApk 对象中的 mClassLoader 字段替换为传入的 dexclassloader 类加载器对象
        mClassLoaderField.set(loadedapkobj, dexclassloader);

    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (InvocationTargetException e) {
        e.printStackTrace();
    } catch (NoSuchFieldException e) {
        e.printStackTrace();
    }
}

最终实现效果就是在当前应用程序的运行期间，使用了一个新的类加载器（即传入的插件 dexclassloader），以加载代码中需要的类和资源。
使用方法：

String dexpath = "/插件/plugin.dex";
ClassLoader pathClassLoader = MainActivity.class.getClassLoader();
DexClassLoader dexClassLoader = new DexClassLoader(dexpath, this.getApplication().getCacheDir().getAbsolutePath(), null, pathClassLoader);
replaceClassLoader(this.getApplicationContext(),dexClassLoader);

try {
    Class 插件Class =MainActivity.class.getClassLoader().loadClass("插件里的组件路径.MainActivity");
   this.startActivity(new Intent(MainActivity.this, 插件Class));
} catch (ClassNotFoundException e) {
  e.printStackTrace();
}

2. 将插件 Dex 文件插入到应用程序的 ClassLoader 中

通过反射获取 ClassLoader 中的 DexPathList 对象，再通过反射获取 DexPathList 对象中的 dexElements 数组，该数组包含了所有加载的 Dex 文件。然后通过合并两个 dexElements 数组来实现加载插件组件的目的，最后通过反射设置新的 dexElements 数组到 DexPathList 对象中。
方便多个插件的同时加载。

public static Object getDexElementsInClassLoader(ClassLoader classLoader) {
    try {
        // 通过反射加载 BaseDexClassLoader 类
        Class BaseDexClassLoaderClass = classLoader.loadClass("dalvik.system.BaseDexClassLoader");
        // 获取 pathList 字段
        Field pathListField = BaseDexClassLoaderClass.getDeclaredField("pathList");
        pathListField.setAccessible(true);
        // 获取 pathList 对象
        Object pathListobj = pathListField.get(classLoader);
        // 通过反射加载 DexPathList 类
        Class DexPathListClass = classLoader.loadClass("dalvik.system.DexPathList");
        // 获取 dexElements 字段
        Field dexElementsField = DexPathListClass.getDeclaredField("dexElements");
        dexElementsField.setAccessible(true);
        // 获取 dexElements 数组
        Object dexElements = dexElementsField.get(pathListobj);
        return dexElements;
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (NoSuchFieldException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
    return null;
}

public static void setDexElementsInClassLoader(ClassLoader classLoader, Object newdexElements) {
    try {
        // 通过反射加载 BaseDexClassLoader 类
        Class BaseDexClassLoaderClass = classLoader.loadClass("dalvik.system.BaseDexClassLoader");
        // 获取 pathList 字段
        Field pathListField = BaseDexClassLoaderClass.getDeclaredField("pathList");
        pathListField.setAccessible(true);
        // 获取 pathList 对象
        Object pathListobj = pathListField.get(classLoader);
        // 通过反射加载 DexPathList 类
        Class DexPathListClass = classLoader.loadClass("dalvik.system.DexPathList");
        // 获取 dexElements 字段
        Field dexElementsField = DexPathListClass.getDeclaredField("dexElements");
        dexElementsField.setAccessible(true);
        // 设置新的 dexElements 数组到 DexPathList 对象中
        dexElementsField.set(pathListobj, newdexElements);
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    } catch (NoSuchFieldException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
}

public static Object combileDexElements(Object dexElements1, Object dexElements2) {
    // 获取两个数组的长度
    int length1 = Array.getLength(dexElements1);
    int length2 = Array.getLength(dexElements2);
    int length = length1 + length2;
    // 创建一个新的数组来存储合并后的结果
    Object newDexElements = Array.newInstance(dexElements1.getClass().getComponentType(), length);
    for (int i = 0; i < length; i++) {
        if (i < length1) {
            // 将第一个数组的元素复制到新数组中
            Array.set(newDexElements, i, Array.get(dexElements1, i));
        } else {
            // 将第二个数组的元素复制到新数组中
            Array.set(newDexElements, i, Array.get(dexElements2, i - length1));
        }
    }
    return newDexElements;
}


public static void insertDexClassloader(Context context, ClassLoader dexclassloader) {
    // 获取当前 Context 的 ClassLoader
    ClassLoader pathclassloader = context.getClassLoader();
    // 获取当前 Context 和新的 Dex 文件的 DexElements
    Object dexElements1 = getDexElementsInClassLoader(pathclassloader);
    Object dexElements2 = getDexElementsInClassLoader(dexclassloader);
    // 合并两个 DexElements
    Object newdexElements = combileDexElements(dexElements1, dexElements2);
    // 将合并后的 DexElements 设置回原来的 ClassLoader 中
    setDexElementsInClassLoader(pathclassloader, newdexElements);
}

使用方法：

ClassLoader pathClassLoader = MainActivity.class.getClassLoader();
ClassLoader bootClassloader = pathClassLoader.getParent();
DexClassLoader dexClassLoader = new DexClassLoader(dexpath, this.getCacheDir().getAbsolutePath(), null, bootClassloader);
insertDexClassloader(this,dexClassLoader);
        
try {
    Class 插件Class =MainActivity.class.getClassLoader().loadClass("插件里的组件路径.MainActivity");
   this.startActivity(new Intent(MainActivity.this, 插件Class));
} catch (ClassNotFoundException e) {
  e.printStackTrace();
}

3. 替换应用默认ClassLoader 的父类为插件ClassLoader

将插件的 DexClassLoader 设置为当前应用程序默认的类加载器的父级加载器，使得当前 Context 可以使用新的 DexClassLoader 中加载的类和资源。

首先获取当前 Context 的 ClassLoader 对象 pathClassLoaderobj，然后通过反射获取到 ClassLoader 类中的 parent 字段，并设置其 accessible 属性为 true，使其可以被访问。接着，我们将 pathClassLoaderobj 对象的 parent 属性设置为 dexclassloader，即将新的 DexClassLoader 对象设置为当前 Context 所使用的 ClassLoader 的父级加载器。这样，当我们在当前 Context 中使用类和资源时，就可以使用插件的 DexClassLoader 加载的内容了。

   public static void insertClassLoader2PathClassloaderParent(Context context, ClassLoader dexclassloader) {

        ClassLoader pathClassLoaderobj = context.getClassLoader();
        Class ClassLoaderClass = ClassLoader.class;
        try {
            Field parent = ClassLoaderClass.getDeclaredField("parent");
            parent.setAccessible(true);
            parent.set(pathClassLoaderobj, dexclassloader);

        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }


    }