Android动态加载之免安装运行程序

最新推荐文章于 2024-03-25 00:14:39 发布

晒干的老咸鱼

最新推荐文章于 2024-03-25 00:14:39 发布

阅读量1.5k

点赞数 2

分类专栏： Android 文章标签： android

原文链接：http://pwn4.fun/2016/08/26/Android%E5%8A%A8%E6%80%81%E5%8A%A0%E8%BD%BD%E4%B9%8B%E5%85%8D%E5%AE%89%E8%A3%85%E8%BF%90%E8%A1%8C%E7%A8%8B%E5%BA%8F/

版权

Android 专栏收录该内容

64 篇文章 5 订阅

订阅专栏

本文说的关于动态加载的内容与之前一篇Android动态加载之插件开发有关系，本文要说的加载有两种：

使用反射机制修改类加载器
使用代理的方式

这两种方式都由各自的优缺点。

技术介绍

使用反射机制修改类加载器来实现动态加载Activity

我们知道PathClassLoader是一个应用的默认加载器(而且它只能加载data/app/xxx.apk的文件)，但是我们加载插件一般使用DexClassLoader加载器，所以开始的时候，每个人都会很容易想到使用DexClassLoader来加载Activity获取到class对象，再使用Intent启动。但是实际上并不是想象的这么简单。因为Android中的四大组件都有一个特点就是他们有自己的启动流程和生命周期，我们使用DexClassLoader加载进来的Activity是不会涉及到任何启动流程和生命周期的概念，说白了，他就是一个普普通通的类。所以启动肯定会出错。
解决这个问题有两种思路：
思路1：替换LoadedApk中的mClassLoader
只要让加载进来的Activity有启动流程和生命周期就行了，所以这里需要看一下一个Activity的启动过程，当然不会详细介绍一个Activity启动过程的。可以将使用的DexClassLoader加载器绑定到系统加载Activity的类加载器上，这个是最重要的突破点。下面我们就来通过源码看看如何找到加载Activity的类加载器。
在找关于一个Apk或是Activity相关信息的时候，特别是启动流程的时候，肯定先找ActivityThread类，这个类很重要，也是关键突破口，它内部有很多的信息。
看一下ActivityThread.java的源码。
代码清单 /frameworks/base/core/java/android/app/ActivityThread.java

...
// set of instantiated backup agents, keyed by package name
final ArrayMap<String, BackupAgent> mBackupAgents = new ArrayMap<String, BackupAgent>();
/** Reference to singleton {@link ActivityThread} */
private static ActivityThread sCurrentActivityThread; // 获取到对象
Instrumentation mInstrumentation;
String mInstrumentationAppDir = null;
String mInstrumentationAppLibraryDir = null;
String mInstrumentationAppPackage = null;
String mInstrumentedAppDir = null;
String mInstrumentedAppLibraryDir = null;
boolean mSystemThread = false;
boolean mJitEnabled = false;

// These can be accessed by multiple threads; mPackages is the lock.
// XXX For now we keep around information about all packages we have
// seen, not removing entries from this map.
// NOTE: The activity and window managers need to call in to
// ActivityThread to do things like update resource configurations,
// which means this lock gets held while the activity and window managers
// holds their own lock.  Thus you MUST NEVER call back into the activity manager
// or window manager or anything that depends on them while holding this lock.
final ArrayMap<String, WeakReference<LoadedApk>> mPackages
        = new ArrayMap<String, WeakReference<LoadedApk>>(); // 获取到LoadedApk对象
final ArrayMap<String, WeakReference<LoadedApk>> mResourcePackages
        = new ArrayMap<String, WeakReference<LoadedApk>>();
final ArrayList<ActivityClientRecord> mRelaunchingActivities
        = new ArrayList<ActivityClientRecord>();
Configuration mPendingConfiguration = null;
...

我们看到ActivityThread类中有一个自己的static对象，然后还有一个ArrayMap存放Apk包名和LoadedApk映射关系的数据结构。
LoadedApk.java是加载Activity的时候一个很重要的类，这个类是负责加载一个Apk程序的，我们可以看一下它的源码：
代码清单 /frameworks/base/core/java/android/app/LoadedApk.java

/**
 * Local state maintained about a currently loaded .apk.
 * @hide
 */
public final class LoadedApk {

    private static final String TAG = "LoadedApk";

    private final ActivityThread mActivityThread;
    private final ApplicationInfo mApplicationInfo;
    final String mPackageName;
    private final String mAppDir;
    private final String mResDir;
    private final String[] mSharedLibraries;
    private final String mDataDir;
    private final String mLibDir;
    private final File mDataDirFile;
    private final ClassLoader mBaseClassLoader;
    private final boolean mSecurityViolation;
    private final boolean mIncludeCode;
    private final DisplayAdjustments mDisplayAdjustments = new DisplayAdjustments();
    Resources mResources;
    private ClassLoader mClassLoader; // 一个Apk加载的类加载器
    private Application mApplication;

    private final ArrayMap<Context, ArrayMap<BroadcastReceiver, ReceiverDispatcher>> mReceivers
        = new ArrayMap<Context, ArrayMap<BroadcastReceiver, LoadedApk.ReceiverDispatcher>>();
    private final ArrayMap<Context, ArrayMap<BroadcastReceiver, LoadedApk.ReceiverDispatcher>> mUnregisteredReceivers
        = new ArrayMap<Context, ArrayMap<BroadcastReceiver, LoadedApk.ReceiverDispatcher>>();
    private final ArrayMap<Context, ArrayMap<ServiceConnection, LoadedApk.ServiceDispatcher>> mServices
        = new ArrayMap<Context, ArrayMap<ServiceConnection, LoadedApk.ServiceDispatcher>>();
    private final ArrayMap<Context, ArrayMap<ServiceConnection, LoadedApk.ServiceDispatcher>> mUnboundServices
        = new ArrayMap<Context, ArrayMap<ServiceConnection, LoadedApk.ServiceDispatcher>>();

    int mClientCount = 0;

    Application getApplication() {
        return mApplication;
    }
    ...

我们可以看到它内部有一个mClassLoader变量，就是负责加载一个Apk程序的，所以只要获取到这个类加载器就可以了。mClassLoader变量不是static的，所以我们还得获取一个LoadedApk对象。

关于ActivityThread类为何如此重要，我们可以看看它的源码：

public static void main(String[] args) {
    SamplingProfilerIntegration.start();

    // CloseGuard defaults to true and can be quite spammy.  We
    // disable it here, but selectively enable it later (via
    // StrictMode) on debug builds, but using DropBox, not logs.
    CloseGuard.setEnabled(false);

    Environment.initForCurrentUser();

    // Set the reporter for event logging in libcore
    EventLogger.setReporter(new EventLoggingReporter());

    Security.addProvider(new AndroidKeyStoreProvider());

    Process.setArgV0("<pre-initialized>");

    Looper.prepareMainLooper();

    ActivityThread thread = new ActivityThread();
    thread.attach(false);

    if (sMainThreadHandler == null) {
        sMainThreadHandler = thread.getHandler();
    }

    AsyncTask.init();

    if (false) {
        Looper.myLooper().setMessageLogging(new
                LogPrinter(Log.DEBUG, "ActivityThread"));
    }

它有Java程序运行的入口main方法，所有的APP程序的执行入口就是这里。
回到主干上来，我们现在开始编写代码实现反射获取mClassLoader类，然后将其替换成我们的DexClassLoader类，看一下项目结构：

PluginActivity —— 插件项目
DynamicActivityForClassLoader —— 宿主项目

PluginActivity项目很简单，就一个Activity：

package com.example.dynamicactivityapk;

public class MainActivity extends Activity {
    private static View parentView;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        if(parentView == null) {
            setContentView(R.layout.activity_main);
        } else {
            setContentView(parentView);
        }
        
        findViewById(R.id.btn).setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View arg0) {
                Toast.makeText(getApplicationContext(), "I came from plugin~~", Toast.LENGTH_LONG).show();
            }});
        
    }
    
    public static void setLayoutView(View view){
        parentView = view;
    }
}

编译PluginActivity项目：

下面看一下宿主项目，宿主项目其实最大的功能就是加载上面的PluginActivity.apk，然后启动内部的MainActivity就可以了，这里的核心代码就是如何通过反射替换系统的mClassLoader类：

@SuppressLint("NewApi")
private void loadApkClassLoader(DexClassLoader dLoader) {
    try {
        // 配置动态加载环境
        Object currentActivityThread = RefInvoke.invokeStaticMethod(
                "android.app.ActivityThread", "currentActivityThread",
                new Class[] {}, new Object[] {}); // 获取ActivityThread对象
        String packageName = this.getPackageName();// 当前apk的包名
        ArrayMap mPackages = (ArrayMap) RefInvoke.getFieldOjbect(
                "android.app.ActivityThread", currentActivityThread,
                "mPackages");
        WeakReference wr = (WeakReference) mPackages.get(packageName); // 获取到LoadedApk对象
        RefInvoke.setFieldOjbect("android.app.LoadedApk", "mClassLoader",
                wr.get(), dLoader); // 设置LoadedApk中的mClassLoader的值为DexClassLoader
        Log.i("demo", "classloader:"+dLoader);
    } catch(Exception e) {
        Log.i("demo", "load apk classloader error:"+Log.getStackTraceString(e));
    }
}

参数dLoader是需要替换的DexClassLoader，从外部传递过来，然后进行替换。我们看看外部定义的DexClassLoader类：

String filesDir = this.getCacheDir().getAbsolutePath();
String libPath = filesDir + File.separator +"PluginActivity.apk";
Log.i("inject", "fileexist:"+new File(libPath).exists());
        
loadResources(libPath);
        
DexClassLoader loader = new DexClassLoader(libPath, filesDir,filesDir, getClassLoader());

这里，需要注意的是，DexClassLoader的最后一个参数，是DexClassLoader的parent，这里需要设置成PathClassLoader类，因为我们上面虽然说是替换PathClassLoader为DexClassLoader。但是PathClassLoader是系统本身默认的类加载器(也就是mClassLoader变量的值，我们如果单独的将mClassLoader的值设置为DexClassLoader的话，就会出错的)，所以一定要将DexClassLoader的父加载器设置成PathClassLoader，因为类加载器是符合双亲委派机制的。
运行程序之前要在宿主项目的AndroidManifest.xml中声明插件的MainActivity

1
2
3

<activity
    android:name="com.example.dynamicactivityapk.MainActivity">
</activity>

下面运行一下这个程序，首先将PluginActivity.apk放到宿主项目的cache目录下：

1	$ adb push PluginActivity.apk /data/data/com.exmaple.testinjectdex/cache

再点击按钮就能看到效果了。

因为要加载插件中的资源，所以需要调用loadResources方法
在测试过程中，发现插件项目中setContentView方法没有效果了。所以要在插件项目中定义一个static的方法，用来提前设置视图的。

思路2：合并PathClassLoader和DexClassLoader中的dexElements数组
下面介绍另外一种设置类加载器的方式。
先来看一下PathClassLoader和DexClassLoader类加载器的父类BaseDexClassLoader的源码：
（需要注意的是PathClassLoader和DexClassLoader类的父加载器是BootClassLoader，它们的父类是BaseDexClassLoader）

/**
 * Base class for common functionality between various dex-based
 * {@link ClassLoader} implementations.
 */
public class BaseDexClassLoader extends ClassLoader {
    private final DexPathList pathList;

    /**
     * Constructs an instance.
     *
     * @param dexPath the list of jar/apk files containing classes and
     * resources, delimited by {@code File.pathSeparator}, which
     * defaults to {@code ":"} on Android
     * @param optimizedDirectory directory where optimized dex files
     * should be written; may be {@code null}
     * @param libraryPath the list of directories containing native
     * libraries, delimited by {@code File.pathSeparator}; may be
     * {@code null}
     * @param parent the parent class loader
     */
    public BaseDexClassLoader(String dexPath, File optimizedDirectory,
            String libraryPath, ClassLoader parent) {
        super(parent);
        this.pathList = new DexPathList(this, dexPath, libraryPath, optimizedDirectory);
    }

这里有一个DexPathList对象，再来看一下DexPathList.java源码：

/**
 * A pair of lists of entries, associated with a {@code ClassLoader}.
 * One of the lists is a dex/resource path &mdash; typically referred
 * to as a "class path" &mdash; list, and the other names directories
 * containing native code libraries. Class path entries may be any of:
 * a {@code .jar} or {@code .zip} file containing an optional
 * top-level {@code classes.dex} file as well as arbitrary resources,
 * or a plain {@code .dex} file (with no possibility of associated
 * resources).
 *
 * <p>This class also contains methods to use these lists to look up
 * classes and resources.</p>
 */
/*package*/ final class DexPathList {
    private static final String DEX_SUFFIX = ".dex";
    private static final String JAR_SUFFIX = ".jar";
    private static final String ZIP_SUFFIX = ".zip";
    private static final String APK_SUFFIX = ".apk";

    /** class definition context */
    private final ClassLoader definingContext;

    /**
     * List of dex/resource (class path) elements.
     * Should be called pathElements, but the Facebook app uses reflection
     * to modify 'dexElements' (http://b/7726934).
     */
    private final Element[] dexElements;

    /** List of native library directories. */
    private final File[] nativeLibraryDirectories;

首先看一下这个类的描述，还有一个Elements数组，这个变量是专门存放加载的dex文件的路径的。系统默认的类加载器是PathClassLoader，本身一个程序加载之后会释放一个dex出来，这时候会将dex路径放到里面，当然DexClassLoader也是一样的，那么我们会想到，我们可以将DexClassLoader中的dexElements和PathClassLoader中的dexElements进行合并，然后再设置给PathClassLoader中。我们来看代码：

// 以下是另一种实现
private void inject(DexClassLoader loader){
    PathClassLoader pathLoader = (PathClassLoader) getClassLoader();
    
    try {
        Object dexElements = combineArray(
                getDexElements(getPathList(pathLoader)),
                getDexElements(getPathList(loader)));
        Object pathList = getPathList(pathLoader);
        setField(pathList, pathList.getClass(), "dexElements", dexElements);
    } catch (IllegalArgumentException e) {
        e.printStackTrace();
    } catch (NoSuchFieldException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
}

private static Object getPathList(Object baseDexClassLoader)
        throws IllegalArgumentException, NoSuchFieldException, IllegalAccessException, ClassNotFoundException {
    ClassLoader bc = (ClassLoader)baseDexClassLoader;
    return getField(bc, Class.forName("dalvik.system.BaseDexClassLoader"), "pathList");
}

private static Object getField(Object obj, Class<?> cl, String field)
        throws NoSuchFieldException, IllegalArgumentException, IllegalAccessException {
    Field localField = cl.getDeclaredField(field);
    localField.setAccessible(true);
    return localField.get(obj);
}

private static Object getDexElements(Object paramObject)
        throws IllegalArgumentException, NoSuchFieldException, IllegalAccessException {
    return getField(paramObject, paramObject.getClass(), "dexElements");
}
private static void setField(Object obj, Class<?> cl, String field,
        Object value) throws NoSuchFieldException,
        IllegalArgumentException, IllegalAccessException {

    Field localField = cl.getDeclaredField(field);
    localField.setAccessible(true);
    localField.set(obj, value);
}

private static Object combineArray(Object arrayLhs, Object arrayRhs) {
    Class<?> localClass = arrayLhs.getClass().getComponentType();
    int i = Array.getLength(arrayLhs);
    int j = i + Array.getLength(arrayRhs);
    Object result = Array.newInstance(localClass, j);
    for (int k = 0; k < j; ++k) {
        if (k < i) {
            Array.set(result, k, Array.get(arrayLhs, k));
        } else {
            Array.set(result, k, Array.get(arrayRhs, k - i));
        }
    }
    return result;
}

再运行宿主项目，可以正常运行，效果和前面一样。
这两个思路的原理都是为了让我们动态加载进来的Activity能够具备正常的启动流程和生命周期。
项目下载

使用静态代理的方式来动态加载Activity

原理：

这里的ProxyActivity就是代理对象，而每个插件Activity都是被代理对象，每个插件Activity对象中都会有一个代理Activity的对象引用，这个就是静态代理，原理就很简单了，就是插件Activity实际上不是真正意义上的Activity了，而是它们把所有Activity中的任务用代理对象Activity来执行了，所以我们只需要在宿主项目中声明一个ProxyActivity，然后用反射的方法设置到每个动态加载的Activity中去就可以了，比如：Plugin1中Activity执行setContentView方法的时候，其实就是执行ProxyActivity中的setContentView方法了。
因此，这种方式来加载Activity的话，其实真正意义上每个插件的Activity都不再是像方式一中的那样，没有声明周期，没有启动流程了，它们就是一个普通的Activity类，然后将其生命周期的所有任务都交给代理Activity去执行就可以了。
下面我们来看一下项目：

DynamicActivityForProxy —— 宿主项目
PluginActivity —— 插件项目

看一下插件项目：

package com.example.dynamicactivity;

public class BaseActivity extends Activity {
    protected Activity mProxyActivity;

    public void setProxy(Activity proxyActivity) { 
        mProxyActivity = proxyActivity;
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
    }

    @Override
    public void setContentView(int layoutResID) { 
        if (mProxyActivity != null && mProxyActivity instanceof Activity) {
             mProxyActivity.setContentView(layoutResID);
            mProxyActivity.findViewById(R.id.btn).setOnClickListener(
                    new OnClickListener() {
                        @Override
                        public void onClick(View v) {
                            Toast.makeText(mProxyActivity, "我是插件，你是谁!",Toast.LENGTH_LONG).show();
                        }
                    });
        }
    }
}

这里重写了setContentView的方法，同时有一个setProxy方法。
再来看一下MainActivity.java

public class MainActivity extends BaseActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }

    @Override
    protected void onDestroy() {
        //这里需要注意的是，不能调用super.onDestroy的方法了，不然报错，原因也很简单，这个Activity实质上不是真正的Activity了，没有生命周期的概念了，调用super的方法肯定报错
        Log.i("demo", "onDestory");
    }

    @Override
    protected void onPause() {
        Log.i("demo", "onPause");
    }

    @Override
    protected void onResume() {
        Log.i("demo", "onResume");
    }

    @Override
    protected void onStart() {
        Log.i("demo", "onStart");
    }

    @Override
    protected void onStop() {
        Log.i("demo", "onStop");
    }
}

这里打印一下生命周期中的每个方法，待会需要验证。
运行插件项目，得到一个PluginActivity.apk。
下面看一下宿主项目：
首先看一下重要的代理对象ProxyActivity

package com.example.dynamic.activity;

public class ProxyActivity extends BaseActivity {
    
    private Object pluginActivity;
    private Class<?> pluginClass;
    
    private HashMap<String, Method> methodMap = new HashMap<String, Method>();

    @SuppressLint("NewApi")
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        try {
            DexClassLoader loader = initClassLoader();
            
            //动态加载插件Activity
            pluginClass = loader.loadClass("com.example.dynamicactivity.MainActivity");
            Constructor<?> localConstructor = pluginClass.getConstructor(new Class[] {});
            pluginActivity = localConstructor.newInstance(new Object[] {});

            //将代理对象设置给插件Activity
            Method setProxy = pluginClass.getMethod("setProxy",new Class[] { Activity.class }); 
            setProxy.setAccessible(true);
            setProxy.invoke(pluginActivity, new Object[] { this });
            
            initMethodMap();

            //调用它的onCreate方法
            Method onCreate = pluginClass.getDeclaredMethod("onCreate",
                    new Class[] { Bundle.class });
            onCreate.setAccessible(true);
            onCreate.invoke(pluginActivity, new Object[] { new Bundle() });
            
        } catch (Exception e) {
            Log.i("demo", "load activity error:" + Log.getStackTraceString(e));
        }
    }
    
    /**
     * 存储每个生命周期的方法
     */
    private void initMethodMap(){
        methodMap.put("onPause", null);
        methodMap.put("onResume", null);
        methodMap.put("onStart", null);
        methodMap.put("onStop", null);
        methodMap.put("onDestroy", null);
        
        for(String key : methodMap.keySet()){
            try{
                Method method = pluginClass.getDeclaredMethod(key);
                method.setAccessible(true);
                methodMap.put(key, method);
            }catch(Exception e){
                Log.i("demo", "get method error:" + Log.getStackTraceString(e));
            }
        }
        
    }
    
    @SuppressLint("NewApi")
    private DexClassLoader initClassLoader(){
        String filesDir = this.getCacheDir().getAbsolutePath();
        String libPath = filesDir + File.separator + "PluginActivity.apk";
        Log.i("inject", "fileexist:"+new File(libPath).exists());
        loadResources(libPath);
        DexClassLoader loader = new DexClassLoader(libPath, filesDir, null , getClass().getClassLoader());
        return loader;
    }
    
    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.i("demo", "proxy onDestroy");
        try{
            methodMap.get("onDestroy").invoke(pluginActivity, new Object[]{});
        }catch(Exception e){
            Log.i("demo", "run destroy error:" + Log.getStackTraceString(e));
        }
    }

    @Override
    protected void onPause() {
        super.onPause();
        Log.i("demo", "proxy onPause");
        try{
            methodMap.get("onPause").invoke(pluginActivity, new Object[]{});
        }catch(Exception e){
            Log.i("demo", "run pause error:" + Log.getStackTraceString(e));
        }
    }

    @Override
    protected void onResume() {
        super.onResume();
        Log.i("demo", "proxy onResume");
        try{
            methodMap.get("onResume").invoke(pluginActivity, new Object[]{});
        }catch(Exception e){
            Log.i("demo", "run resume error:" + Log.getStackTraceString(e));
        }
    }

    @Override
    protected void onStart() {
        super.onStart();
        Log.i("demo", "proxy onStart");
        try{
            methodMap.get("onStart").invoke(pluginActivity, new Object[]{});
        }catch(Exception e){
            Log.i("demo", "run start error:" + Log.getStackTraceString(e));
        }
    }

    @Override
    protected void onStop() {
        super.onStop();
        Log.i("demo", "proxy onStop");
        try{
            methodMap.get("onStop").invoke(pluginActivity, new Object[]{});
        }catch(Exception e){
            Log.i("demo", "run stop error:" + Log.getStackTraceString(e));
        }
    }
}

这里主要就是：

加载插件Activity
使用反射将代理对象设置给插件Activity
测试插件Activity中的生命周期方法

运行程序，将上面的PluginActivity.apk放到宿主项目的cache目录下：

1	$ adb push PluginActivity.apk /data/data/com.example.dynamic.activity/cache

运行宿主项目就能看到效果了。同时我们打印一下Log：

$ adb logcat -s demo
...
I/demo    (27983): proxy onStart
I/demo    (27983): onStart
I/demo    (27983): proxy onResume
I/demo    (27983): onResume
I/demo    (27983): proxy onPause
I/demo    (27983): onPause
I/demo    (27983): proxy onStop
I/demo    (27983): onStop
I/demo    (27983): proxy onDestroy
I/demo    (27983): onDestory
I/demo    (28565): proxy onStart
I/demo    (28565): onStart
I/demo    (28565): proxy onResume
I/demo    (28565): onResume
I/demo    (28565): proxy onPause
I/demo    (28565): onPause
I/demo    (28565): proxy onStop
I/demo    (28565): onStop
I/demo    (28565): proxy onDestroy
I/demo    (28565): onDestory

插件Activity的每个生命周期的方法也是都执行了。
项目下载

两种方式的比较

第一种方式：使用反射机制来实现
优点：可以不用太多的关心插件中的Activity的生命周期方法，因为他加载进来之后就是一个真正意义上的Activity了
缺点：需要在宿主工程中进行声明，如果插件中的Activity多的话，那么就不灵活了。
第二种方式：使用代理机制来实现
优点：不需要在宿主工程中进行声明太多的Activity了，只需要有一个代理Activity的声明就可以了，很灵活
缺点：需要管理手动的去管理插件中Activity的生命周期方法，难度复杂。
reference
http://blog.csdn.net/jiangwei0910410003/article/details/48104455

晒干的老咸鱼

关注

2
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
Android动态加载之免安装运行程序

本文说的关于动态加载的内容与之前一篇Android动态加载之插件开发有关系，本文要说的加载有两种：使用反射机制修改类加载器使用代理的方式这两种方式都由各自的优缺点。技术介绍使用反射机制修改类加载器来实现动态加载Activity我们知道PathClassLoader是一个应用的默认加载器(而且它只能加载data/app/xxx.apk的文件)，但是我们加载插件一般使用DexClassLoader加载器，所以开始的时候，每个人都会很容易想到使用DexClassLoader来加载Activi
复制链接

扫一扫