Android中的动态加载机制

柔光的暖阳◎ 2022-08-02 09:35 214阅读 0赞

在目前的软硬件环境下，Native App与Web App在用户体验上有着明显的优势，但在实际项目中有些会因为业务的频繁变更而频繁的升级客户端，造成较差的用户体验，而这也恰恰是Web App的优势。本文对网上Android动态加载jar的资料进行梳理和实践在这里与大家一起分享，试图改善频繁升级这一弊病。

Android应用开发在一般情况下，常规的开发方式和代码架构就能满足我们的普通需求。但是有些特殊问题，常常引发我们进一步的沉思。我们从沉思中产生顿悟，从而产生新的技术形式。  
如何开发一个可以自定义控件的Android应用？就像eclipse一样，可以动态加载插件；如何让Android应用执行服务器上的不可预知的代码？如何对Android应用加密，而只在执行时自解密，从而防止被破解？……  
熟悉Java技术的朋友，可能意识到，我们需要使用类加载器灵活的加载执行的类。这在Java里已经算是一项比较成熟的技术了，但是在Android中，我们大多数人都还非常陌生。  
类加载机制  
       Dalvik虚拟机如同其他Java虚拟机一样，在运行程序时首先需要将对应的类加载到内存中。而在Java标准的虚拟机中，类加载可以从class文件中读取，也可以是其他形式的二进制流，因此，我们常常利用这一点，在程序运行时手动加载Class，从而达到代码动态加载执行的目的  
       然而Dalvik虚拟机毕竟不算是标准的Java虚拟机，因此在类加载机制上，它们有相同的地方，也有不同之处。我们必须区别对待

例如，在使用标准Java虚拟机时，我们经常自定义继承自ClassLoader的类加载器。然后通过defineClass方法来从一个二进制流中加载Class。然而，这在Android里是行不通的，大家就没必要走弯路了。参看源码我们知道，Android中ClassLoader的defineClass方法具体是调用VMClassLoader的defineClass本地静态方法。而这个本地方法除了抛出一个“UnsupportedOperationException”之外，什么都没做，甚至连返回值都为空

**\[cpp\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **static** **void** Dalvik\_java\_lang\_VMClassLoader\_defineClass(**const** u4\* args,JValue\* pResult)\{  
2.      Object\* loader = (Object\*) args\[0\];  
3.      StringObject\* nameObj = (StringObject\*) args\[1\];  
4.      **const** u1\* data = (**const** u1\*) args\[2\];  
5.      **int** offset = args\[3\];  
6.      **int** len = args\[4\];  
7.      Object\* pd = (Object\*) args\[5\];  
8.      **char**\* name = NULL;  
9.      name = dvmCreateCstrFromString(nameObj);  
10.     LOGE("ERROR: defineClass(%p, %s, %p, %d, %d, %p)\\n",loader, name, data, offset, len, pd);  
11.     dvmThrowException("Ljava/lang/UnsupportedOperationException;","can't load this type of class file");  
12.     free(name);  
13.     RETURN\_VOID();  
14. \}

**Dalvik虚拟机类加载机制**  
       那如果在Dalvik虚拟机里，ClassLoader不好使，我们如何实现动态加载类呢？Android为我们从ClassLoader派生出了两个类：DexClassLoader和PathClassLoader。其中需要特别说明的是PathClassLoader中一段被注释掉的代码：

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  /\* --this doesn't work in current version of Dalvik-- 
2.      if (data != null) \{  
3.          System.out.println("--- Found class " + name 
4.              + " in zip\[" + i + "\] '" + mZips\[i\].getName() + "'"); 
5.          int dotIndex = name.lastIndexOf('.'); 
6.          if (dotIndex != -1) \{  
7.              String packageName = name.substring(0, dotIndex); 
8.              synchronized (this) \{  
9.                  Package packageObj = getPackage(packageName); 
10.                 if (packageObj == null) \{  
11.                     definePackage(packageName, null, null, 
12.                             null, null, null, null, null); 
13.                 \} 
14.             \} 
15.         \} 
16.         return defineClass(name, data, 0, data.length); 
17.     \} 
18. \*/

这从另一方面佐证了defineClass函数在Dalvik虚拟机里确实是被阉割了。而在这两个继承自ClassLoader的类加载器，本质上是重载了ClassLoader的findClass方法。在执行loadClass时，我们可以参看ClassLoader部分源码：

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **protected** Class<?> loadClass(String className, **boolean** resolve) **throws** ClassNotFoundException \{  
2.  Class<?> clazz = findLoadedClass(className);  
3.      **if** (clazz == **null**) \{  
4.          **try** \{  
5.              clazz = parent.loadClass(className, **false**);  
6.          \} **catch** (ClassNotFoundException e) \{  
7.              // Don't want to see this.  
8.          \}  
9.          **if** (clazz == **null**) \{  
10.             clazz = findClass(className);  
11.         \}  
12.     \}  
13.     **return** clazz;  
14. \}

因此DexClassLoader和PathClassLoader都属于符合双亲委派模型的类加载器（因为它们没有重载loadClass方法）。也就是说，它们在加载一个类之前，回去检查自己以及自己以上的类加载器是否已经加载了这个类。如果已经加载过了，就会直接将之返回，而不会重复加载。  
DexClassLoader和PathClassLoader其实都是通过DexFile这个类来实现类加载的。这里需要顺便提一下的是，Dalvik虚拟机识别的是dex文件，而不是class文件。因此，我们供类加载的文件也只能是dex文件，或者包含有dex文件的.apk或.jar文件。  
也许有人想到，既然DexFile可以直接加载类，那么我们为什么还要使用ClassLoader的子类呢？DexFile在加载类时，具体是调用成员方法loadClass或者loadClassBinaryName。其中loadClassBinaryName需要将包含包名的类名中的”.”转换为”/”我们看一下loadClass代码就清楚了：

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **public** Class loadClass(String name, ClassLoader loader) \{  
2.          String slashName = name.replace('.', '/');  
3.          **return** loadClassBinaryName(slashName, loader);  
4.  \}

在这段代码前有一段注释，截取关键一部分就是说：If you are not calling this from a class loader, this is most likely not going to do what you want. Use \{@link Class\#forName(String)\} instead. 这就是我们需要使用ClassLoader子类的原因。至于它是如何验证是否是在ClassLoader中调用此方法的，我没有研究，大家如果有兴趣可以继续深入下去。  
       有一个细节，可能大家不容易注意到。PathClassLoader是通过构造函数new DexFile(path)来产生DexFile对象的；而DexClassLoader则是通过其静态方法loadDex（path, outpath, 0）得到DexFile对象。**这两者的区别在于DexClassLoader需要提供一个可写的outpath路径，用来释放.apk包或者.jar包中的dex文件。换个说法来说，就是PathClassLoader不能主动从zip包中释放出dex，因此只支持直接操作dex格式文件，或者已经安装的apk（因为已经安装的apk在cache中存在缓存的dex文件）。而DexClassLoader可以支持.apk、.jar和.dex文件，并且会在指定的outpath路径释放出dex文件。**

另外，PathClassLoader在加载类时调用的是DexFile的loadClassBinaryName，而DexClassLoader调用的是loadClass。因此，在使用PathClassLoader时类全名需要用”/”替换”.”

**实际操作**

使用到的工具都比较常规：javac、dx、eclipse等其中dx工具最好是指明--no-strict，因为class文件的路径可能不匹配  
加载好类后，通常我们可以通过Java反射机制来使用这个类但是这样效率相对不高，而且老用反射代码也比较复杂凌乱。更好的做法是定义一个interface，并将这个interface写进容器端。待加载的类，继承自这个interface，并且有一个参数为空的构造函数，以使我们能够通过Class的newInstance方法产生对象然后将对象强制转换为interface对象，于是就可以直接调用成员方法了，下面是具体的实现步骤了:  
**第一步：**

编写好动态代码类：

![Center][]

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **package** com.dynamic.interfaces;  
2.  **import** android.app.Activity;  
3.  /\*\* 
4.   \* 动态加载类的接口 
5.   \*/  
6.  **public** **interface** IDynamic \{  
7.      /\*\*初始化方法\*/  
8.      **public** **void** init(Activity activity);  
9.      /\*\*自定义方法\*/  
10.     **public** **void** showBanner();  
11.     **public** **void** showDialog();  
12.     **public** **void** showFullScreen();  
13.     **public** **void** showAppWall();  
14.     /\*\*销毁方法\*/  
15.     **public** **void** destory();  
16. \}

实现类代码如下：

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **package** com.dynamic.impl;  
2.    
3.  **import** android.app.Activity;  
4.  **import** android.widget.Toast;  
5.    
6.  **import** com.dynamic.interfaces.IDynamic;  
7.    
8.  /\*\* 
9.   \* 动态类的实现 
10.  \* 
11.  \*/  
12. **public** **class** Dynamic **implements** IDynamic\{  
13.   
14.     **private** Activity mActivity;  
15.       
16.     @Override  
17.     **public** **void** init(Activity activity) \{  
18.         mActivity = activity;  
19.     \}  
20.       
21.     @Override  
22.     **public** **void** showBanner() \{  
23.         Toast.makeText(mActivity, "我是ShowBannber方法", 1500).show();  
24.     \}  
25.   
26.     @Override  
27.     **public** **void** showDialog() \{  
28.         Toast.makeText(mActivity, "我是ShowDialog方法", 1500).show();  
29.     \}  
30.   
31.     @Override  
32.     **public** **void** showFullScreen() \{  
33.         Toast.makeText(mActivity, "我是ShowFullScreen方法", 1500).show();  
34.     \}  
35.   
36.     @Override  
37.     **public** **void** showAppWall() \{  
38.         Toast.makeText(mActivity, "我是ShowAppWall方法", 1500).show();  
39.     \}  
40.   
41.     @Override  
42.     **public** **void** destory() \{  
43.     \}  
44.   
45. \}

这样动态类就开发好了

**第二步：**

将上面开发好的动态类打包成.jar，这里要注意的是只打包实现类Dynamic.java，不打包接口类IDynamic.java，

![Center 1][]

然后将打包好的**jar文件拷贝到android的安装目录中的platform-tools目录下**，使用dx命令:(我的jar文件是dynamic.jar)

**dx --dex --output=dynamic\_temp.jar dynamic.jar**

这样就生成了dynamic\_temp.jar，这个jar和dynamic.jar有什么区别呢？

其实这条命令主要做的工作是:首先将dynamic.jar编译成dynamic.dex文件(Android虚拟机认识的字节码文件)，然后再将dynamic.dex文件压缩成dynamic\_temp.jar，当然你也可以压缩成.zip格式的，或者直接编译成.apk文件都可以的，这个后面会说到。

到这里还不算完事，因为你想想用什么来连接动态类和目标类呢？那就是动态类的接口了，所以这时候还要打个.jar包，这时候只需要打接口类IDynamic.java了

![Center 2][]

然后将这个.jar文件引用到目标类中，下面来看一下目标类的实现：

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **package** com.jiangwei.demo;  
2.    
3.  **import** java.io.File;  
4.  **import** java.util.List;  
5.    
6.  **import** android.app.Activity;  
7.  **import** android.content.Intent;  
8.  **import** android.content.pm.ActivityInfo;  
9.  **import** android.content.pm.PackageManager;  
10. **import** android.content.pm.ResolveInfo;  
11. **import** android.os.Bundle;  
12. **import** android.os.Environment;  
13. **import** android.view.View;  
14. **import** android.widget.Button;  
15. **import** android.widget.Toast;  
16.   
17. **import** com.dynamic.interfaces.IDynamic;  
18.   
19. **import** dalvik.system.DexClassLoader;  
20. **import** dalvik.system.PathClassLoader;  
21.   
22. **public** **class** AndroidDynamicLoadClassActivity **extends** Activity \{  
23.       
24.     //动态类加载接口  
25.     **private** IDynamic lib;  
26.       
27.     @Override  
28.     **public** **void** onCreate(Bundle savedInstanceState) \{  
29.         **super**.onCreate(savedInstanceState);  
30.         setContentView(R.layout.main);  
31.         //初始化组件  
32.         Button showBannerBtn = (Button) findViewById(R.id.show\_banner\_btn);  
33.         Button showDialogBtn = (Button) findViewById(R.id.show\_dialog\_btn);  
34.         Button showFullScreenBtn = (Button) findViewById(R.id.show\_fullscreen\_btn);  
35.         Button showAppWallBtn = (Button) findViewById(R.id.show\_appwall\_btn);  
36.         /\*\*使用DexClassLoader方式加载类\*/  
37.         //dex压缩文件的路径(可以是apk,jar,zip格式)  
38.         String dexPath = Environment.getExternalStorageDirectory().toString() + File.separator + "Dynamic.apk";  
39.         //dex解压释放后的目录  
40.         //String dexOutputDir = getApplicationInfo().dataDir;  
41.         String dexOutputDirs = Environment.getExternalStorageDirectory().toString();  
42.         //定义DexClassLoader  
43.         //第一个参数：是dex压缩文件的路径  
44.         //第二个参数：是dex解压缩后存放的目录  
45.         //第三个参数：是C/C++依赖的本地库文件目录,可以为null  
46.         //第四个参数：是上一级的类加载器  
47.         DexClassLoader cl = **new** DexClassLoader(dexPath,dexOutputDirs,**null**,getClassLoader());  
48.           
49.         /\*\*使用PathClassLoader方法加载类\*/  
50.         //创建一个意图，用来找到指定的apk：这里的"com.dynamic.impl是指定apk中在AndroidMainfest.xml文件中定义的<action name="com.dynamic.impl"/>    
51.         Intent intent = **new** Intent("com.dynamic.impl", **null**);    
52.         //获得包管理器    
53.         PackageManager pm = getPackageManager();    
54.         List<ResolveInfo> resolveinfoes =  pm.queryIntentActivities(intent, 0);    
55.         //获得指定的activity的信息    
56.         ActivityInfo actInfo = resolveinfoes.get(0).activityInfo;    
57.         //获得apk的目录或者jar的目录    
58.         String apkPath = actInfo.applicationInfo.sourceDir;    
59.         //native代码的目录    
60.         String libPath = actInfo.applicationInfo.nativeLibraryDir;    
61.         //创建类加载器，把dex加载到虚拟机中    
62.         //第一个参数：是指定apk安装的路径，这个路径要注意只能是通过actInfo.applicationInfo.sourceDir来获取  
63.         //第二个参数：是C/C++依赖的本地库文件目录,可以为null  
64.         //第三个参数：是上一级的类加载器  
65.         PathClassLoader pcl = **new** PathClassLoader(apkPath,libPath,**this**.getClassLoader());  
66.         //加载类  
67.         **try** \{  
68.             //com.dynamic.impl.Dynamic是动态类名  
69.             //使用DexClassLoader加载类  
70.             //Class libProviderClazz = cl.loadClass("com.dynamic.impl.Dynamic");  
71.             //使用PathClassLoader加载类  
72.             Class libProviderClazz = pcl.loadClass("com.dynamic.impl.Dynamic");  
73.             lib = (IDynamic)libProviderClazz.newInstance();  
74.             **if**(lib != **null**)\{  
75.                 lib.init(AndroidDynamicLoadClassActivity.**this**);  
76.             \}  
77.         \} **catch** (Exception exception) \{  
78.             exception.printStackTrace();  
79.         \}  
80.         /\*\*下面分别调用动态类中的方法\*/  
81.         showBannerBtn.setOnClickListener(**new** View.OnClickListener() \{  
82.             **public** **void** onClick(View view) \{  
83.                **if**(lib != **null**)\{  
84.                    lib.showBanner();  
85.                \}**else**\{  
86.                    Toast.makeText(getApplicationContext(), "类加载失败", 1500).show();  
87.                \}  
88.             \}  
89.         \});  
90.         showDialogBtn.setOnClickListener(**new** View.OnClickListener() \{  
91.             **public** **void** onClick(View view) \{  
92.                **if**(lib != **null**)\{  
93.                    lib.showDialog();  
94.                \}**else**\{  
95.                    Toast.makeText(getApplicationContext(), "类加载失败", 1500).show();  
96.                \}  
97.             \}  
98.         \});  
99.         showFullScreenBtn.setOnClickListener(**new** View.OnClickListener() \{  
100.             **public** **void** onClick(View view) \{  
101.                **if**(lib != **null**)\{  
102.                    lib.showFullScreen();  
103.                \}**else**\{  
104.                    Toast.makeText(getApplicationContext(), "类加载失败", 1500).show();  
105.                \}  
106.             \}  
107.         \});  
108.         showAppWallBtn.setOnClickListener(**new** View.OnClickListener() \{  
109.             **public** **void** onClick(View view) \{  
110.                **if**(lib != **null**)\{  
111.                    lib.showAppWall();  
112.                \}**else**\{  
113.                    Toast.makeText(getApplicationContext(), "类加载失败", 1500).show();  
114.                \}  
115.             \}  
116.         \});  
117.     \}  
118. \}

这里面定义了一个IDynamic接口变量，同时使用了DexClassLoader和PathClassLoader来加载类，这里面先来说一说DexClassLoader方式加载:

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  //定义DexClassLoader  
2.  //第一个参数：是dex压缩文件的路径  
3.  //第二个参数：是dex解压缩后存放的目录  
4.  //第三个参数：是C/C++依赖的本地库文件目录,可以为null  
5.  //第四个参数：是上一级的类加载器  
6.  DexClassLoader cl = **new** DexClassLoader(dexPath,dexOutputDirs,**null**,getClassLoader());

上面已经说了，DexClassLoader是继承ClassLoader类的，这里面的参数说明：

第一个参数是:dex压缩文件的路径:这个就是我们将上面编译后的dynamic\_temp.jar存放的目录，当然也可以是.zip和.apk格式的

第二个参数是:dex解压后存放的目录:这个就是将.jar,.zip,.apk文件解压出的dex文件存放的目录，这个就和PathClassLoader方法有区别了，同时你也可以看到PathClassLoader方法中没有这个参数，这个也真是这两个类的区别:

PathClassLoader不能主动从zip包中释放出dex，因此只支持直接操作dex格式文件，或者已经安装的apk（因为已经安装的apk在手机的data/dalvik目录中存在缓存的dex文件）。而DexClassLoader可以支持.apk、.jar和.dex文件，并且会在指定的outpath路径释放出dex文件。

![Center 3][]

然而我们可以通过DexClassLoader方法指定解压后的dex文件的存放目录，但是我们一般不这么做，因为这样做无疑的暴露了dex文件，所以我们一般不会将.jar/.zip/.apk压缩文件存放到用户可以察觉到的位置，同时解压dex的目录也是不能让用户看到的。

第三个参数和第四个参数用到的不是很多，所以这里就不做太多的解释了。

这里还要注意一点就是PathClassLoader方法的时候，第一个参数是dex存放的路径，这里传递的是:

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  //获得apk的目录或者jar的目录    
2.  String apkPath = actInfo.applicationInfo.sourceDir;

指定的apk安装路径,这个值只能这样获取，不然会加载类失败的

**第三步：**

运行目标类:

要做的工作是:

如果用的是DexClassLoader方式加载类:这时候需要将.jar或者.zip或者.apk文件放到指定的目录中，我这里为了方便就放到sd卡的根目录中

如果用的是PathClassLoader方法加载类:这时候需要先将Dynamic.apk安装到手机中，不然找不到这个activity，同时要注意的是:

**\[java\]**  [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  //创建一个意图，用来找到指定的apk：这里的"com.dynamic.impl是指定apk中在AndroidMainfest.xml文件中定义的<action name="com.dynamic.impl"/>    
2.  Intent intent = **new** Intent("com.dynamic.impl", **null**);

这里的com.dynamic.impl是一个action需要在指定的apk中定义，这个名称是动态apk和目标apk之间约定好的 ![Center 4][]

**运行结果**

![Center 5][]

点击showBanner显示一个Toast，成功的运行了动态类中的代码！

其实更好的办法就是将动态的.jar.zip.apk文件从网络上获取，安全可靠，同时本地的目标项目不需要改动代码就可以执行不同的逻辑了

**关于代码加密的一些设想**  
    最初设想将dex文件加密，然后通过JNI将解密代码写在Native层。解密之后直接传上二进制流，再通过defineClass将类加载到内存中。  
    现在也可以这样做，但是由于不能直接使用defineClass，而必须传文件路径给dalvik虚拟机内核，因此解密后的文件需要写到磁盘上，增加了被破解的风险。  
    Dalvik虚拟机内核仅支持从dex文件加载类的方式是不灵活的，由于没有非常深入的研究内核，我不能确定是Dalvik虚拟机本身不支持还是Android在移植时将其阉割了。不过相信Dalvik或者是Android开源项目都正在向能够支持raw数据定义类方向努力。  
    我们可以在文档中看到Google说：Jar or APK file with "classes.dex". (May expand this to include "raw DEX" in the future.)；在Android的Dalvik源码中我们也能看到RawDexFile的身影（不过没有具体实现）  
    在RawDexFile出来之前，我们都只能使用这种存在一定风险的加密方式。需要注意释放的dex文件路径及权限管理，另外，在加载完毕类之后，除非出于其他目的否则应该马上删除临时的解密文件

[view plain]: http://blog.csdn.net/jiangwei0910410003/article/details/17679823#
[CODE]: https://code.csdn.net/assets/CODE_ico.png
[CODE_CODE]: https://code.csdn.net/snippets/134470
[ico_fork.svg]: https://code.csdn.net/assets/ico_fork.svg
[ico_fork.svg 1]: https://code.csdn.net/snippets/134470/fork
[Center]: /images/20220731/b096d6b99a0045fd92097a2081549448.png
[Center 1]: /images/20220731/bf23c488456a4bdaa558f3207dc89ce5.png
[Center 2]: /images/20220731/2d7c44d8295f468792d9f50bfeee168f.png
[Center 3]: /images/20220731/105522194c6a482b9be69aebf10e1a5c.png
[Center 4]: /images/20220731/e84f8b3466104bdbaf2816182d97ef1e.png
[Center 5]: /images/20220731/fdaf575bcdc141538108c65b95e0784f.png