终于建了一个自己个人小站：https://huangtianyu.gitee.io，以后优先更新小站博客，欢迎进站，O(∩_∩)O~~

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

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

[cpp]  view plain  copy

 

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. }  

[java]  view plain  copy

 

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

 

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. }  

[java]  view plain  copy

 

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

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

实际操作

编写好动态代码类：

[java]  view plain  copy

 

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

 

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，

然后将打包好的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了

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

[java]  view plain  copy

 

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. }  

[java]  view plain  copy

 

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

第一个参数是: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文件。

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

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

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

[java]  view plain  copy

 

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

第三步：

运行目标类:

要做的工作是:

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

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

[java]  view plain  copy

 

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

运行结果

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

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

关于代码加密的一些设想