你知道Android动态加载技术三个关键问题？

InfoQ 开设新栏目“品味书香”，精选技术书籍的精彩章节，以及分享看完书留下的思考和收获，欢迎大家关注。本文节选自任玉刚著《Android 开发艺术探索》中的章节“Android 的动态加载技术”，探讨了 Android 动态加载的三个关键问题。

动态加载技术（也叫插件化技术）在技术驱动型的公司中扮演着相当重要的角色，当项目越来越庞大的时候，需要通过插件化来减轻应用的内存和 CPU 占用，还可以实现热插拔，即在不发布新版本的情况下更新某些模块。动态加载是一项很复杂的技术，这里主要介绍动态加载技术中的三个基础性问题，至于完整的动态加载技术的实现请参考笔者发起的开源插件化框架 DL：。项目期间有多位开发人员一起贡献代码。

不同的插件化方案各有各的特色，但是它们都必须要解决三个基础性问题：资源访问、Activity 生命周期的管理和 ClassLoader 的管理。在介绍它们之前，首先要明白宿主和插件的概念，宿主是指普通的 apk，而插件一般是指经过处理的 dex 或者 apk，在主流的插件化框架中多采用经过特殊处理的 apk 来作为插件，处理方式往往和编译以及打包环节有关，另外很多插件化框架都需要用到代理 Activity 的概念，插件 Activity 的启动大多数是借助一个代理 Activity 来实现的。

1．资源访问

我们知道，宿主程序调起未安装的插件 apk，一个很大的问题就是资源如何访问，具体来说就是插件中凡是以 R 开头的资源都不能访问了。这是因为宿主程序中并没有插件的资源，所以通过 R 来加载插件的资源是行不通的，程序会抛出异常：无法找到某某 id 所对应的资源。

针对这个问题，有人提出了将插件中的资源在宿主程序中也预置一份，这虽然能解决问题，但是这样就会产生一些弊端。首先，这样就需要宿主和插件同时持有一份相同的资源，增加了宿主 apk 的大小；其次，在这种模式下，每次发布一个插件都需要将资源复制到宿主程序中，这意味着每发布一个插件都要更新一下宿主程序，这就和插件化的思想相违背了。

因为插件化的目的就是要减小宿主程序 apk 包的大小，同时降低宿主程序的更新频率并做到自由装载模块，所以这种方法不可取，它限制了插件的线上更新这一重要特性。还有人提供了另一种方式，首先将插件中的资源解压出来，然后通过文件流去读取资源，这样做理论上是可行的，但是实际操作起来还是有很大难度的。首先不同资源有不同的文件流格式，比如图片、XML 等，其次针对不同设备加载的资源可能是不一样的，如何选择合适的资源也是一个需要解决的问题，基于这两点，这种方法也不建议使用，因为它实现起来有较大难度。为了方便地对插件进行资源管理，下面给出一种合理的方式。

我们知道，Activity 的工作主要是通过 ContextImpl 来完成的， Activity 中有一个叫 mBase 的成员变量，它的类型就是 ContextImpl。注意到 Context 中有如下两个抽象方法，看起来是和资源有关的，实际上 Context 就是通过它们来获取资源的。这两个抽象方法的真正实现在 ContextImpl 中，也就是说，只要实现这两个方法，就可以解决资源问题。

	/** Return an AssetManager instance for your application's package. */
	public abstract AssetManager getAssets();
	/** Return a Resources instance for your application's package. */
	public abstract Resources getResources();

下面给出具体的实现方式，首先要加载 apk 中的资源，如下所示。

复制代码

	protected void loadResources() {
	try {
	AssetManager assetManager = AssetManager.class.newInstance();
	Method addAssetPath = assetManager.getClass().getMethod("addAssetPath", String.class);
	addAssetPath.invoke(assetManager, mDexPath);
	mAssetManager = assetManager;
	} catch (Exception e) {
	e.printStackTrace();
	}
	Resources superRes = super.getResources();
	mResources = new Resources(mAssetManager, superRes.getDisplayMetrics(),
	superRes.getConfiguration());
	mTheme = mResources.newTheme();
	mTheme.setTo(super.getTheme());
	}

从 loadResources() 的实现可以看出，加载资源的方法是通过反射，通过调用 AssetManager 中的 addAssetPath 方法，我们可以将一个 apk 中的资源加载到 Resources 对象中，由于 addAssetPath 是隐藏 API 我们无法直接调用，所以只能通过反射。下面是它的声明，通过注释我们可以看出，传递的路径可以是 zip 文件也可以是一个资源目录，而 apk 就是一个 zip，所以直接将 apk 的路径传给它，资源就加载到 AssetManager 中了。然后再通过 AssetManager 来创建一个新的 Resources 对象，通过这个对象我们就可以访问插件 apk 中的资源了，这样一来问题就解决了。

复制代码

	/**
	{1}
	* Add an additional set of assets to the asset manager. This can be
	{1}
	* either a directory or ZIP file. Not for use by applications. Returns
	{1}
	* the cookie of the added asset, or 0 on failure.
	{1}
	* {@hide}
	{1}
	*/
	public final int addAssetPath(String path) {
	synchronized (this) {
	int res = addAssetPathNative(path);
	makeStringBlocks(mStringBlocks);
	return res;
	}
	}

接着在代理 Activity 中实现 getAssets() 和 getResources()，如下所示。关于代理 Activity 的含义请参看 DL 开源插件化框架的实现细节，这里不再详细描述了。

复制代码

	@Override
	public AssetManager getAssets() {
	return mAssetManager == null ? super.getAssets() : mAssetManager;
	}
	@Override
	public Resources getResources() {
	return mResources == null ? super.getResources() : mResources;
	}

通过上述这两个步骤，就可以通过 R 来访问插件中的资源了。

2．Activity 生命周期的管理

管理 Activity 生命周期的方式各种各样，这里只介绍两种：反射方式和接口方式。反射的方式很好理解，首先通过 Java 的反射去获取 Activity 的各种生命周期方法，比如 onCreate、onStart、onResume 等，然后在代理 Activity 中去调用插件 Activity 对应的生命周期方法即可，如下所示。

复制代码

	@Override
	protected void onResume() {
	super.onResume();
	Method onResume = mActivityLifecircleMethods.get("onResume");
	if (onResume != null) {
	try {
	onResume.invoke(mRemoteActivity, new Object[] { });
	} catch (Exception e) {
	e.printStackTrace();
	}
	}
	}
	@Override
	protected void onPause() {
	Method onPause = mActivityLifecircleMethods.get("onPause");
	if (onPause != null) {
	try {
	onPause.invoke(mRemoteActivity, new Object[] { });
	} catch (Exception e) {
	e.printStackTrace();
	}
	}
	super.onPause();
	}

使用反射来管理插件 Activity 的生命周期是有缺点的，一方面是反射代码写起来比较复杂，另一方面是过多使用反射会有一定的性能开销。下面介绍接口方式，接口方式很好地解决了反射方式的不足之处，这种方式将 Activity 的生命周期方法提取出来作为一个接口（比如叫 DLPlugin），然后通过代理 Activity 去调用插件 Activity 的生命周期方法，这样就完成了插件 Activity 的生命周期管理，并且没有采用反射，这就解决了性能问题。同时接口的声明也比较简单，下面是 DLPlugin 的声明：

复制代码

	public interface DLPlugin {
	public void onStart();
	public void onRestart();
	public void onActivityResult(int requestCode, int resultCode, Intent
	{1}
	data);
	public void onResume();
	public void onPause();
	public void onStop();
	public void onDestroy();
	public void onCreate(Bundle savedInstanceState);
	public void setProxy(Activity proxyActivity, String dexPath);
	public void onSaveInstanceState(Bundle outState);
	public void onNewIntent(Intent intent);
	public void onRestoreInstanceState(Bundle savedInstanceState);
	public boolean onTouchEvent(MotionEvent event);
	public boolean onKeyUp(int keyCode, KeyEvent event);
	public void onWindowAttributesChanged(LayoutParams params);
	public void onWindowFocusChanged(boolean hasFocus);
	public void onBackPressed();
	…
	}

在代理 Activity 中只需要按如下方式即可调用插件 Activity 的生命周期方法，这就完成了插件 Activity 的生命周期的管理。

复制代码

	...
	@Override
	protected void onStart() {
	mRemoteActivity.onStart();
	super.onStart();
	}
	@Override
	protected void onRestart() {
	mRemoteActivity.onRestart();
	super.onRestart();
	}
	@Override
	protected void onResume() {
	mRemoteActivity.onResume();
	super.onResume();
	}
	...

通过上述代码应该不难理解接口方式对插件 Activity 生命周期的管理思想，其中 mRemoteActivity 就是 DLPlugin 的实现。

3．插件 ClassLoader 的管理

为了更好地对多插件进行支持，需要合理地去管理各个插件的 DexClassLoader，这样同一个插件就可以采用同一个 ClassLoader 去加载类，从而避免了多个 ClassLoader 加载同一个类时所引发的类型转换错误。在下面的代码中，通过将不同插件的 ClassLoader 存储在一个 HashMap 中，这样就可以保证不同插件中的类彼此互不干扰。

复制代码

	public class DLClassLoader extends DexClassLoader {
	private static final String TAG = "DLClassLoader";
	private static final HashMap mPluginClassLoaders
	= new HashMap();
	protected DLClassLoader(String dexPath, String optimizedDirectory, String libraryPath, ClassLoader parent) {
	super(dexPath, optimizedDirectory, libraryPath, parent);
	}
	/**
	{1}
	* return a available classloader which belongs to different apk
	{1}
	*/
	public static DLClassLoader getClassLoader(String dexPath, Context
	context, ClassLoader parentLoader) {
	DLClassLoader dLClassLoader = mPluginClassLoaders.get(dexPath);
	if (dLClassLoader != null)
	return dLClassLoader;
	File dexOutputDir = context.getDir("dex", Context.MODE_PRIVATE);
	final String dexOutputPath = dexOutputDir.getAbsolutePath();
	dLClassLoader = new DLClassLoader(dexPath, dexOutputPath, null,
	parentLoader);
	mPluginClassLoaders.put(dexPath, dLClassLoader);
	return dLClassLoader;
	}
	}

事实上插件化的技术细节非常多，这绝非一个章节的内容所能描述清楚的，另外插件化作为一种核心技术，需要开发者有较深的开发功底才能够很好地理解，因此本节的内容更多是让读者对插件化开发有一个感性的了解，细节上还需要读者自己去钻研，也可以通过 DL 插件化框架去深入地学习。