Android 动态类加载实现免安装更新

随着Html5技术成熟，轻应用越来越受欢迎，特别是其更新成本低的特点。与Native App相比，Web App不依赖于发布下载，也不需要安装使用，兼容多平台。目前也有不少Native App使用原生嵌套WebView的方式开发。但由于Html渲染特性，其执行效率不及Native App好，在硬件条件不佳的机子上流畅度很低，给用户的体验也比较差。反观Native App，尽管其执行效率高，但由于更新频率高而导致频繁下载安装，这一点也令用户很烦恼。本文参考java虚拟机的类加载机制，以及网上Android动态加载jar的例子，提出一种不依赖于重新安装而更新Native App的方式。

 

目的：利用Android类加载原理，实现免安装式更新Native App

 

1. 先回顾Java动态加载类的原理

实现一个Java应用，使用动态类加载，从外部jar中加载应用的核心代码。

制作一个ClassLoader，提供读取类的方法

package com.kavmors.classloadtest;

import java.net.URL;
import java.net.URLClassLoader;

import com.kavmors.classes.RemoteEntry;

public class RemoteClassLoader {
    /**
     * 读取一个类,并返回实例
     * @param jarPath jar包的地址
     * @param classPath 类所在的地址(包括package名)
     * @return 继承RemoteEntry接口的实体类实例,失败则返回null
     */
    public static RemoteEntry load(String jarPath, String classPath) {
        URLClassLoader loader;
        try {
            loader = new URLClassLoader(new URL[]{new URL(jarPath)});
            Class<?> c = loader.loadClass(classPath);
            RemoteEntry instance = (RemoteEntry)c.newInstance();
            loader.close();
            return instance;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

制作一个供核心代码继承的接口。这个接口很简单，只有一个execute方法。

package com.kavmors.classes;

import com.kavmors.classloadtest.Main;

public interface RemoteEntry {
    public void execute(Main main);
}

其中的Main类如下，是整个程序的主入口

package com.kavmors.classloadtest;

import com.kavmors.classes.RemoteEntry;

public class Main {
    //这里定义核心代码所在类的包名+类名
    private final static String classPath = "com.kavmors.classes.MainEntry";
    //这里定义jar包的地址
    private final static String jarPath = "file:D:/MainEntry.jar";
    
    //提供一个Main类的成员方法
    public void printTime() {
        System.out.println(System.currentTimeMillis());
    }
    
    //主入口在这里
    public static void main(String[] args) {
        Main main = new Main();
        RemoteEntry entry = RemoteClassLoader.load(jarPath, classPath);
        if (entry!=null) entry.execute(main);    //执行核心代码
    }
}

 从以上代码看，RemoteClassLoader.load从jarPath读取了MainEntry.jar，然后从jar包中读取了MainEntry类并返回了该类的实例，最后运行实例中execute方法。到此应用的框架就制作好了，可以把以上代码打包成Runnable jar，命令为RemoteLoader.jar，方便后面的测试。

接下来，需要生成MainEntry，继承RemoteEntry接口。MainEntry里的就是核心代码。

package com.kavmors.classes;

import com.kavmors.classloadtest.Main;

public class MainEntry implements RemoteEntry {
    @Override
    public void execute(Main main) {
        System.out.println("Execute MainEntry.execute");
        main.printTime();
    }
}

以上，实现了接口中execute方法，并调用了Main类中的成员方法。把这个Class打包成jar，命名为MainEntry.jar，路径为D:/MainEntry.jar。

现在测试一下，执行java -jar RemoteLoader.jar，结果在控制台中打印"Execute MainEntry.execute和时间戳。由于MainEntry继承了RemoteEntry，RemoteClassLoader.load返回的相当于MainEntry类的实例，所以执行了其中execute方法。注意RemoteLoader.jar中是没有MainEntry这个类的，这个类是在MainEntry.jar中定义的。

以上仅用URLClassLoader实现动态加载，原理详见参考资料^[1]。

 

2. Android动态类加载框架

以上例子中，程序的主入口与核心代码进行了分离。如果把RemoteClassLoader.jar看成安装在机子上的Native App，MainEntry.jar看成远程服务器上的文件，那么对于每次更新，只需把MainEntry.jar更新后部署在服务器上就可以了，Native App不需要任何修改。根据这种想法，可以实现不依赖于重新安装的更新方式。

在JVM上，使用URLClassLoader可以调用本地及网络上的jar，把jar中的class读取出来。而在安卓上，类生成的概念与JVM不完全一样^[2]。Dalvik将编译到的.class文件重新打包成dex类型的文件，因此也有自己的类加载器DexClassLoader，只需要把上面例子的URLClassLoader换成DexClassLoader就可以。

考虑到现实开发的场景，在首次启动应用或需要更新的时候从服务器下载jar，存到本地，不需要更新的时候就直接使用本地的jar。这样，首先需要一个操作jar的类，用来判断jar是否存在，以及处理创建、删除、下载的任务。

package com.kavmors.remoteloader;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URL;
import java.net.URLConnection;

import android.os.AsyncTask;

public class JarUtil {
    private OnDownloadCompleteListener mListener;
    private String jarPath;
    
    public JarUtil(String jarPath) {
        this.jarPath = jarPath;
    }
    
    //下载任务完成后,回调接口内的方法
    public interface OnDownloadCompleteListener {
        public void onSuccess(String jarPath);
        public void onFail();
    }
    
    //jar不存在则返回false
    //若文件大小为0表示jar无效,删除该文件再返回false
    public boolean isJarExists() {
        File jar = new File(jarPath);
        if (!jar.exists()) {
            return false;
        }
        if (jar.length()==0) {
            jar.delete();
            return false;
        }
        return true;
    }
    
    public boolean create() {
        try {
            File file = new File(jarPath);
            file.getParentFile().mkdirs();
            file.createNewFile();
            return true;
        } catch (IOException e) {
            return false;
        }
    }
    
    public boolean delete() {
        File file = new File(jarPath);
        return file.delete();
    }
    
    public void download(String remotePath, OnDownloadCompleteListener listener) {
        mListener = listener;
        //启动异步类发送下载请求
        AsyncTask<String,String,String> task = new AsyncTask<String,String,String>() {
            @Override
            protected String doInBackground(String... path) {
                if (execDownload(path[0], path[1])) {
                    return path[1];    //成功返回jarPath
                } else {
                    return null;    //不成功时返回null
                }
            }
            
            @Override
            protected void onPostExecute(String jarPath) {
                if (mListener==null) return;
                //根据下载任务执行结果回调
                if (jarPath==null) {
                    mListener.onFail();
                } else {
                    mListener.onSuccess(jarPath);
                }
            }
        };
        task.execute(remotePath, jarPath);
    }
    
    private boolean execDownload(String remotePath, String jarPath) {
        try {
            URLConnection connection = new URL(remotePath).openConnection();
            InputStream in = connection.getInputStream();
            byte[] bs = new byte[1024];
            int len = 0;
            OutputStream out = new FileOutputStream(jarPath);
            while ((len=in.read(bs))!=-1) {
                out.write(bs, 0, len);
            }
            out.close();
            in.close();
            return true;
        } catch (IOException e) {
            return false;
        }
    }
}

以下组装ClassLoader辅助类

package com.kavmors.remoteloader;

import com.kavmors.core.RemoteEntry;

import android.app.Activity;
import dalvik.system.DexClassLoader;

public class ClassLoaderUtil {
    private Activity mActivity;
    
    public ClassLoaderUtil(Activity activity) {
        mActivity = activity;
    }
    
    /**
     * 读取一个类,并返回实例
     * @param jarPath jar包的本地路径
     * @param classPath 类所在的地址(包括package名)
     * @return 继承RemoteEntry接口的实体类实例,失败则返回null
     */
    public RemoteEntry load(String jarPath, String classPath) {
        DexClassLoader loader;
        try {
            String optimizedDir = mActivity.getDir(mActivity.getString(R.string.app_name), Activity.MODE_PRIVATE).getAbsolutePath();
            loader = new DexClassLoader(jarPath, optimizedDir, null, mActivity.getClassLoader());
            Class<?> c = loader.loadClass(classPath);
            RemoteEntry instance = (RemoteEntry)c.newInstance();
            return instance;
        } catch (Exception e) {
            return null;
        }
    }
}

简单解释DexClassLoader构造方法^[3]。第一个参数dexPath表示jar文件的路径，用File.pathSeparator隔开；第二个参数是优化后dex文件的存储路径，可以理解为解压jar得到的文件的路径；第三个参数是目标类使用的本地C/C++库，这里为null；第四个参数是要加载的类的父加载器，一般是当前的加载器。需要说明，第二个参数需要宿主程序目录，只允许当前程序访问，因此不能为SD卡路径，官网上建议使用context.getCodeCacheDir().getAbsolutePath()的方法获取，在低于API 21的应用可以用上面例子的方法。为了避免漏洞，建议jar路径（第一个参数）也设为宿主目录，但由于测试中方便删除，这里将直接使用SD卡路径。

返回的RemoteEntry类很简单，传入参数为Activity

package com.kavmors.core;

import android.app.Activity;

public interface RemoteEntry {
    public void execute(Activity activity);
}

下面开始主程序。首先生成一个布局文件activity_main.xml，内容很简单，一个TextView一个Button，分别加@+id/txt和@+id/btn。Activity的执行逻辑是，先判断jar文件是否存在，存在则直接执行类加载任务。若不存在，则下载jar到SD卡路径中，再加载。加载完成后，执行RemoteEntry.execute(Activity)。细节方面，在下载jar时生成一个ProgressDialog提示。

package com.kavmors.remoteloader;

import java.io.File;

import com.kavmors.core.RemoteEntry;

import android.app.Activity;
import android.app.ProgressDialog;
import android.os.Bundle;
import android.os.Environment;
import android.widget.Toast;

public class MainActivity extends Activity implements JarUtil.OnDownloadCompleteListener {
    private final String REMOTE_PATH = "http://127.0.0.1/kavmors/MainEntry.jar";    //服务器上MainEntry.jar的URL
    private ProgressDialog dialog;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        JarUtil util = new JarUtil(getJarPath());
        if (util.isJarExists()) {
            onSuccess(getJarPath());    //存在则直接执行类加载
        } else {        
            //创建新的jar文件
            util.create();
            //显示ProgressDialog
            dialog = new ProgressDialog(this);
            dialog.setTitle("提示");
            dialog.setMessage("加载中...");
            dialog.show();
            //执行下载
            util.download(REMOTE_PATH, this);
        }
    }
    
    @Override
    public void onSuccess(String jarPath) {
        if (dialog!=null) dialog.dismiss();
        //使用加载器加载,获取一个RemoteEntry实例
        RemoteEntry entry = new ClassLoaderUtil(this).load(jarPath, getClassPath());
        if (entry==null) onFail();
        else entry.execute(this);
    }
    
    @Override
    public void onFail() {
        if (dialog!=null) dialog.dismiss();
        Toast.makeText(this, "Fail to load class", Toast.LENGTH_SHORT).show();
    }
    
    //返回jar路径
    private String getJarPath() {
        String exterPath = Environment.getExternalStorageDirectory().getAbsolutePath();
        return exterPath + File.separator + this.getResources().getString(R.string.app_name) + File.separator + "MainEntry.jar";
    }
    
    //返回包+类路径
    private String getClassPath() {
        return "com.kavmors.core.MainEntry";
    }
}

编译一下，这个应用框架已经完成了，先安装到机子上，但由于没有MainEntry.jar，这时运行会提示“Fail to load class.”。

 

3. 动态类的编译和打包

还差一个MainEntry.jar。现在创建一个MainEntry类继承RemoteEntry接口，做一些简单的控件操作。

package com.kavmors.core;

import com.kavmors.remoteloader.R;

import android.app.Activity;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

public class MainEntry implements RemoteEntry {
    @Override
    public void execute(Activity activity) {
        //控件操作
        final TextView txt = (TextView) activity.findViewById(R.id.txt);
        Button btn = (Button) activity.findViewById(R.id.btn);
        btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                txt.setText("Button on click");
            }
        });
    }
}

和Java应用的例子一样，把MainEntry单独打包成MainEntry.jar。这里还有一步，由于Dalvik执行dex文件，还需要把jar使用SDK包中的工具制成dex文件^[4]。这个工具在SDK包中，路径为SDK/build-tools/22.0.1/dx.bat，中间的22.0.1表示API版本。可以把这个路径加入环境变量，调用命令为
【dx --dex --output=MainEntry.jar MainEntry.jar】
--output的参数表示压缩为dex后生成的文件，与原始jar同名即覆盖。压缩后，把MainEntry.jar放上服务器，服务器路径在MainActivity中定义了。

 

4. 总结

原理很简单，与Java加载的例子一样道理，只是ClassLoader换成了DexClassLoader，以及生成jar后要再次压缩成dex。本例只是提供一种思路，以及简述实现该思路的方法，如果要用在实际应用中，需要考虑的情况很多，如根据版本号更新jar，下载jar失败时的策略，等。应用庞大的时候需要考虑到下载更新一次jar需要很长时间，这时可以拆分为多个jar，按需更新。同时，这种方式加载可能增加被破解的风险，也带来应用签名的问题。实际情况实际考虑，有兴趣深入研究，推荐查阅【安卓插件化】的相关资料和开源框架^[5]。

 

参考资料及引用

[1] ClassLoader原理：开源中国. Java Classloader机制解析. 
http://my.oschina.net/aminqiao/blog/262601#OSC_h1_1

[2] 安卓类加载器：CSDN博客. Android中的类装载器DexClassLoader.
http://blog.csdn.net/com360/article/details/14125683

[3] DexClassLoader构造方法：Android Developers. DexClassLoader. 
http://developer.android.com/reference/dalvik/system/DexClassLoader.html

[4] dex文件：CSDN博客. class文件和dex文件的区别（DVM和JVM的区别）及Android DVM介绍. 
http://m.blog.csdn.net/blog/fangchao3652/42246049

[5] 插件化框架：Github. dynamic-load-apk. 
https://github.com/singwhatiwanna/dynamic-load-apk