ClassLoader
    └── BaseDexClassLoader
        ├── DexClassLoader
        └── PathClassLoader

protected Class<?> loadClass(String name, boolean resolve)
    throws ClassNotFoundException
{
    // 首先檢查類是否已經(jīng)被加載
    Class<?> c = findLoadedClass(name);
    if (c == null) {
        try {
            // 如果父類加載器不為空，則委派給父類加載器加載
            if (parent != null) {
                c = parent.loadClass(name, false);
            } else {
                // 如果父類加載器為空，則委派給BootClassLoader加載
                c = findBootstrapClassOrNull(name);
            }
        } catch (ClassNotFoundException e) {
            // 父類加載器無(wú)法加載時(shí)，捕獲異常但不做處理
        }

        if (c == null) {
            // 父類加載器無(wú)法加載時(shí)，調(diào)用自身的findClass方法加載
            c = findClass(name);
        }
    }
    return c;
}

protected Class<?> findClass(String name) throws ClassNotFoundException {
    throw new ClassNotFoundException(name);
}

@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
    List<Throwable> suppressedExceptions = new ArrayList<Throwable>();
    // 通過(guò)pathList查找類
    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;
}

public Class<?> findClass(String name, List<Throwable> suppressed) {
    // 遍歷dexElements數(shù)組
    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;
}

import dalvik.system.DexClassLoader;
import java.io.File;

public class CustomClassLoader extends DexClassLoader {

    public CustomClassLoader(String dexPath, String optimizedDirectory,
                             String librarySearchPath, ClassLoader parent) {
        super(dexPath, optimizedDirectory, librarySearchPath, parent);
    }

    @Override
    protected Class<?> loadClass(String name, boolean resolve)
            throws ClassNotFoundException {
        // 打破雙親委派模型，優(yōu)先加載指定包名下的類
        if (name.startsWith("com.example.plugin.")) {
            return findClass(name);
        }
        // 其他類仍然遵循雙親委派模型
        return super.loadClass(name, resolve);
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        try {
            // 嘗試從自定義路徑加載類
            return super.findClass(name);
        } catch (ClassNotFoundException e) {
            // 自定義加載失敗時(shí)，交給父類加載器處理
            return getParent().loadClass(name);
        }
    }
}

import java.io.File;

public class ClassLoaderExample {
    public static void main(String[] args) {
        try {
            // 插件APK文件路徑
            File apkFile = new File("/sdcard/plugin.apk");
            
            // 優(yōu)化后的dex文件存儲(chǔ)路徑
            File optimizedDirectory = new File("/data/data/com.example.app/dex");
            if (!optimizedDirectory.exists()) {
                optimizedDirectory.mkdirs();
            }
            
            // 庫(kù)文件搜索路徑
            String librarySearchPath = null;
            
            // 創(chuàng)建自定義ClassLoader
            CustomClassLoader classLoader = new CustomClassLoader(
                    apkFile.getAbsolutePath(),
                    optimizedDirectory.getAbsolutePath(),
                    librarySearchPath,
                    ClassLoaderExample.class.getClassLoader()
            );
            
            // 加載插件類
            Class<?> pluginClass = classLoader.loadClass("com.example.plugin.PluginClass");
            
            // 創(chuàng)建實(shí)例并調(diào)用方法
            Object instance = pluginClass.newInstance();
            java.lang.reflect.Method method = pluginClass.getMethod("doSomething");
            method.invoke(instance);
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

import java.lang.reflect.Array;
import java.lang.reflect.Field;
import dalvik.system.DexClassLoader;
import dalvik.system.PathClassLoader;

public class HotFixUtil {
    public static void fix(Context context, File dexFile) {
        try {
            // 獲取應(yīng)用的PathClassLoader
            PathClassLoader pathClassLoader = (PathClassLoader) context.getClassLoader();
            
            // 創(chuàng)建修復(fù)dex的DexClassLoader
            File optimizedDirectory = new File(context.getCacheDir(), "hotfix");
            if (!optimizedDirectory.exists()) {
                optimizedDirectory.mkdirs();
            }
            DexClassLoader dexClassLoader = new DexClassLoader(
                    dexFile.getAbsolutePath(),
                    optimizedDirectory.getAbsolutePath(),
                    null,
                    pathClassLoader
            );
            
            // 獲取PathClassLoader的pathList字段
            Field pathListField = getField(pathClassLoader.getClass(), "pathList");
            Object pathList = pathListField.get(pathClassLoader);
            
            // 獲取DexClassLoader的pathList字段
            Object fixPathList = pathListField.get(dexClassLoader);
            
            // 獲取pathList中的dexElements字段
            Field dexElementsField = getField(pathList.getClass(), "dexElements");
            Object dexElements = dexElementsField.get(pathList);
            Object fixDexElements = dexElementsField.get(fixPathList);
            
            // 合并dexElements數(shù)組，將修復(fù)的dex放在前面
            Object mergedElements = combineArray(fixDexElements, dexElements);
            
            // 將合并后的數(shù)組設(shè)置回pathList
            dexElementsField.set(pathList, mergedElements);
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    private static Field getField(Class<?> clazz, String fieldName) throws NoSuchFieldException {
        Field field = clazz.getDeclaredField(fieldName);
        field.setAccessible(true);
        return field;
    }
    
    private static Object combineArray(Object array1, Object array2) {
        int length1 = Array.getLength(array1);
        int length2 = Array.getLength(array2);
        int newLength = length1 + length2;
        
        Class<?> componentType = array1.getClass().getComponentType();
        Object newArray = Array.newInstance(componentType, newLength);
        
        for (int i = 0; i < newLength; i++) {
            if (i < length1) {
                Array.set(newArray, i, Array.get(array1, i));
            } else {
                Array.set(newArray, i, Array.get(array2, i - length1));
            }
        }
        
        return newArray;
    }
}

import android.content.Context;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.res.AssetManager;
import android.content.res.Resources;
import dalvik.system.DexClassLoader;
import java.io.File;
import java.lang.reflect.Method;

public class PluginManager {
    private static PluginManager instance;
    private Context context;
    private DexClassLoader dexClassLoader;
    private Resources resources;
    private PackageInfo packageInfo;
    
    private PluginManager(Context context) {
        this.context = context.getApplicationContext();
    }
    
    public static PluginManager getInstance(Context context) {
        if (instance == null) {
            synchronized (PluginManager.class) {
                if (instance == null) {
                    instance = new PluginManager(context);
                }
            }
        }
        return instance;
    }
    
    public void loadPlugin(String pluginPath) {
        try {
            File pluginFile = new File(pluginPath);
            if (!pluginFile.exists()) {
                return;
            }
            
            // 創(chuàng)建插件的DexClassLoader
            File optimizedDirectory = new File(context.getCacheDir(), "plugin_dex");
            if (!optimizedDirectory.exists()) {
                optimizedDirectory.mkdirs();
            }
            dexClassLoader = new DexClassLoader(
                    pluginPath,
                    optimizedDirectory.getAbsolutePath(),
                    null,
                    context.getClassLoader()
            );
            
            // 加載插件的資源
            AssetManager assetManager = AssetManager.class.newInstance();
            Method addAssetPath = assetManager.getClass().getMethod("addAssetPath", String.class);
            addAssetPath.invoke(assetManager, pluginPath);
            resources = new Resources(
                    assetManager,
                    context.getResources().getDisplayMetrics(),
                    context.getResources().getConfiguration()
            );
            
            // 獲取插件的PackageInfo
            PackageManager packageManager = context.getPackageManager();
            packageInfo = packageManager.getPackageArchiveInfo(
                    pluginPath,
                    PackageManager.GET_ACTIVITIES | PackageManager.GET_SERVICES
            );
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    public DexClassLoader getClassLoader() {
        return dexClassLoader;
    }
    
    public Resources getResources() {
        return resources;
    }
    
    public PackageInfo getPackageInfo() {
        return packageInfo;
    }
}