单线程下载，并实现断点续传

作者： 夏至 转载请保留以下申明，谢谢

http://blog.csdn.net/u011418943/article/details/56674086

现在网络框架越来越多，对于下载一个文件来说，用一个别人封装好的库，基本很容易就可以搞定，比如用okhttp3这个比较优秀的框架，里面它封装好的网络框架就非常优秀。

当然，有时候我们需要自定义我们自己的下载器，比如显示一些其他要实现其他属性，这个时候，就不得不自己去封装了。其实也不是太难，就是可能在考虑上欠缺了吧。

这篇博客是看完慕课网的异步下载笔记，不了解的可以先去看。连接如下：http://www.imooc.com/learn/363

废话不多说，先上效果图：



工程下载地址如下：

https://git.oschina.net/zhengshaorui/filedownloaduesdb.git

扩展之后，我们可以实现apk的在线更新功能，效果图如下所示：



工程下载地址如下：

https://git.oschina.net/zhengshaorui/ApkAutoUpdateDemo.git

首先，通过 Serioliable 传递参数，定义一个实体类：

/**
* 用serializable就可以接受intent的参数了
* @author zhengshaorui
*
*/
public class FileInfo implements Serializable{

private int id;
private String apkurl;
private String fileDir;
private String fileName;
private int length;
private File Dir;
private int finished;
private int threadCount;

public FileInfo() {
super();
}

public FileInfo(int id, String apkurl, String fileDir, String fileName,
int length, File dir, int finished, int threadCount) {
this.id = id;
this.apkurl = apkurl;
this.fileDir = fileDir;
this.fileName = fileName;
this.length = length;
Dir = dir;
this.finished = finished;
this.threadCount = threadCount;
}

public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getApkurl() {
return apkurl;
}
public void setApkurl(String apkurl) {
this.apkurl = apkurl;
}
public String getFileName() {
return fileName;
}

@Override
public String toString() {
return "FileInfo{" +
"id=" + id +
", apkurl='" + apkurl + '\'' +
", fileDir='" + fileDir + '\'' +
", fileName='" + fileName + '\'' +
", length=" + length +
", Dir=" + Dir +
", finished=" + finished +
", threadCount=" + threadCount +
'}';
}

public void setFileName(String fileName) {
this.fileName = fileName;
}
public int getLength() {
return length;
}
public void setLength(int length) {
this.length = length;
}
public int getFinished() {
return finished;
}
public void setFinished(int finished) {
this.finished = finished;
}

public String getFileDir() {
return fileDir;
}

public void setFileDir(String fileDir) {
this.fileDir = fileDir;
}

public File getDir() {
return Dir;
}

public void setDir(File dir) {
Dir = dir;
}

public int getThreadCount() {
return threadCount;
}

public void setThreadCount(int threadCount) {
this.threadCount = threadCount;
}
}

这里你可能有疑问，threadcount是什么gui，还有其他乱七八糟的属性，别急，这个是为了接下来的多线程的封装的。

然后，main函数中，把参数传递给service

protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
fileDir = getFilesDir()+"/mydownload/";
mFileInfo = new FileInfo(0,"http://images.infzm.com/mobile/infzmreader.apk",
fileDir,"north.apk",0,null,0);
}
public void start(View view){
Intent start = new Intent(this,DowaloadService.class);
start.putExtra("fileinfo",mFileInfo);
start.putExtra("service",1);
startService(start);
}
public void stop(View view){
Intent start = new Intent(this,DowaloadService.class);
start.putExtra("fileinfo",mFileInfo);
start.putExtra("service",0);
startService(start);
}

service 中，先启动线程检测文件的大小；把它保存到Fileinfo里面，再启动下城下载：

public int onStartCommand(Intent intent, int flags, int startId) {
FileInfo mFileInfo = (FileInfo) intent.getSerializableExtra("fileinfo");
int status = intent.getIntExtra("service",0);
if (status == 1){
Log.d(TAG, "start: "+mFileInfo);
}else{
Log.d(TAG, "stop: ");
}
new download(mFileInfo).start();
return super.onStartCommand(intent, flags, startId);
}
class download extends  Thread{
FileInfo mFileInfo;
public download(FileInfo fileinfo){
this.mFileInfo = fileinfo;
}
@Override
public void run() {
super.run();
HttpURLConnection conn = null;
try {
URL url = new URL(mFileInfo.getApkurl());
conn = (HttpURLConnection) url.openConnection();
//加上这句是为了防止connection.getContentLength()获取不到
conn.setRequestProperty("Accept-Encoding", "identity");
conn.setRequestMethod("GET");
conn.setReadTimeout(5000);
conn.setConnectTimeout(5000);
if (conn.getResponseCode() == 200){
int length = conn.getContentLength();
if (length < 0) return;
else mFileInfo.setLength(length);
}
File dir = new File(mFileInfo.getFileDir());
if (!dir.exists()){
dir.mkdir();
}
mFileInfo.setDir(dir);
Log.d(TAG, "run: "+mFileInfo);
new DownloadTask(mContext).download(mFileInfo);
} catch (Exception e) {
e.printStackTrace();
Log.d(TAG, "error: "+e.toString());
}finally {
conn.disconnect();
}
}
}

其中下载方法 DownloadTask 如下所示：

public class DownloadTask {
private static final String TAG = "zsr";
private Context mContext;
private int downloadlength = 0;
public DownloadTask(Context mContext) {
this.mContext = mContext;
}
public void download(FileInfo fileInfo){
new DownloadThread(fileInfo).start();
}
class DownloadThread extends Thread{
FileInfo mFileInfo;
public DownloadThread(FileInfo mFileInfo) {
this.mFileInfo = mFileInfo;
}
@Override
public void run() {
super.run();
HttpURLConnection conn = null;
RandomAccessFile raf = null;
BufferedInputStream bis = null;
try {
URL url = new URL(mFileInfo.getApkurl());
conn = (HttpURLConnection) url.openConnection();
//加上这句是为了防止connection.getContentLength()获取不到
conn.setRequestProperty("Accept-Encoding", "identity");
conn.setRequestMethod("GET");
conn.setReadTimeout(5000);
conn.setConnectTimeout(5000);
int start = 0;
int end = mFileInfo.getLength();
//设置下载位置
conn.setRequestProperty("Range", "bytes="+start+"-"+end);
//文件写入位置
File file = new File(mFileInfo.getDir(),mFileInfo.getFileName());
raf = new RandomAccessFile(file,"rwd");
raf.seek(start);
int len = -1;
byte[] bytes = new byte[1024*2];
bis = new BufferedInputStream(conn.getInputStream());
while( (len = bis.read(bytes)) != -1 ){
raf.write(bytes,0,len);
downloadlength += len;
Log.d(TAG, "run: "+downloadlength);
}
} catch (Exception e) {
e.printStackTrace();
Log.d(TAG, "downloaderror: "+e.toString());
}finally {
if (bis != null) try {
bis.close();
if (raf != null) raf.close();
} catch (IOException e) {
e.printStackTrace();
}
if (conn != null) conn.disconnect();
}
}
}
}

log 和文件如下：





那么如何把文件保存到数据库中，实现断点续传呢 ，其实说白了，就是把上次的断点保存在文件、map或者数据库中。这里保存在数据库中

首先定义一个实体类，ThreadInfo：

public class ThreadInfo {
private int id;
private String url;
private int start;
private int end;
private int finished;

public ThreadInfo() {
super();
}

public ThreadInfo(int id, String url, int start, int end, int finished) {
super();
this.id = id;
this.url = url;
this.start = start;
this.end = end;
this.finished = finished;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getStart() {
return start;
}
public void setStart(int start) {
this.start = start;
}
public int getEnd() {
return end;
}
public void setEnd(int end) {
this.end = end;
}
public int getFinished() {
return finished;
}
public void setFinished(int finished) {
this.finished = finished;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
@Override
public String toString() {
return "ThreadInfo [id=" + id + ", url=" + url + ", start=" + start
+ ", end=" + end + ", finished=" + finished + "]";
}

}

ThreadInfo 是来记录线程信息的 ，所以，而数据的保存，我们用数据库来保存；首先，先定义表单：

public class DBhelper extends SQLiteOpenHelper{
public static final String DB_NAME = "download.db";
public static final int VERSION = 1;
private static final String SQL_CREATE_TABLE = "create table if not exists thread_info(" +
"_id integer primary key autoincrement," +
"thread_id integer," +
"url text," +
"start integer," +
"end integer," +
"finished interger)";
private static final String SQL_DROP = "drop table if exists thread_info";

public DBhelper(Context context, String name, CursorFactory factory,
int version) {
super(context, name, factory, version);
}
@Override
public void onCreate(SQLiteDatabase db) {
// TODO Auto-generated method stub
db.execSQL(SQL_CREATE_TABLE);
}
@Override
public void onUpgrade(SQLiteDatabase db, int arg1, int arg2) {
// TODO Auto-generated method stub
db.execSQL(SQL_DROP);
db.execSQL(SQL_CREATE_TABLE);
}
}

上面的实现很简单，就是创建一个数据库，然后，我们需要给它添加 listener回调接口：

public interface DBTreadListener {
/**
* 插入线程信息
* @param threadInfo
*/
public void insertThread(ThreadInfo threadInfo);
/**
* 删除数据库，用两个标志位来判断
* @param url
* @param thread_id
*/
public void deleteThread(String url, int thread_id);
/**
* 更新线程下载进度 finished
* @param url
* @param thread_id
* @param finished
*/
public void updateThread(String url, int thread_id, int finished);
/**
* 查询文件的线程信息,以一个List的形式返回
* @param url
* @return
*/
public List<ThreadInfo> getThreads(String url);
/**
* 判断线程是否存在，如果存在则更新，如果不存在则创建
* @param url
* @return
*/
public boolean isThreadExsits(String url, int thread_id);
}

回调接口中，我们要实现的方法就是数据库的 增删查改，还有就是检查该数据库，是否有线程和判断线程是否存在。接下来就是数据库的实现方法了：

/**
* 数据库接口的实现
*
* @author zhengshaorui
*
*/
public class DBThreadListenerImp implements DBTreadListener {
private DBhelper mDBhelper = null;
public DBThreadListenerImp(Context context) {
// 在接口实现的时候，创建数据库表
mDBhelper = new DBhelper(context, DBhelper.DB_NAME, null,
DBhelper.VERSION);
}
public void insertThread(ThreadInfo threadInfo) {
// TODO Auto-generated method stub
SQLiteDatabase db = mDBhelper.getWritableDatabase();
db.execSQL(
"insert into thread_info(thread_id,url,start,end,finished) values(?,?,?,?,?)",
new Object[] {threadInfo.getId(), threadInfo.getUrl(),
threadInfo.getStart(), threadInfo.getEnd(),
threadInfo.getFinished() });
db.close();
}
@Override
public void deleteThread(String url, int thread_id) {
// TODO Auto-generated method stub
SQLiteDatabase db = mDBhelper.getWritableDatabase();
db.execSQL("delete from thread_info where url = ? and thread_id = ?",
new Object[] { url, thread_id });
db.close();
}
@Override
public void updateThread(String url, int thread_id, int finished) {
// TODO Auto-generated method stub
Log.d("zsr", "finish: "+finished);
SQLiteDatabase db = mDBhelper.getWritableDatabase();
db.execSQL(
"update thread_info set finished = ? where url = ? and thread_id = ?",
new Object[] { finished, url, thread_id });
db.close();
}
public List<ThreadInfo> getThreads(String url) {
List<ThreadInfo> mList = new ArrayList<ThreadInfo>();
SQLiteDatabase db = mDBhelper.getWritableDatabase();
Cursor cursor = db.rawQuery("select * from thread_info where url = ?",
new String[] { url });
if (cursor.moveToFirst()) {
do {
ThreadInfo mThreadInfo = new ThreadInfo();
mThreadInfo.setUrl(cursor.getString(cursor
.getColumnIndex("url")));
mThreadInfo.setId(cursor.getInt(cursor.getColumnIndex("thread_id")));
mThreadInfo.setStart(cursor.getInt(cursor
.getColumnIndex("start")));
mThreadInfo.setEnd(cursor.getInt(cursor.getColumnIndex("end")));
mThreadInfo.setFinished(cursor.getInt(cursor
.getColumnIndex("finished")));
mList.add(mThreadInfo);
} while (cursor.moveToNext());
}
db.close();
cursor.close();
return mList;
}
@Override
public boolean isThreadExsits(String url, int thread_id) {
boolean isExsits = false;
SQLiteDatabase db = mDBhelper.getWritableDatabase();
Cursor cursor = db.rawQuery(
"select * from thread_info where url = ? and thread_id = ?",
new String[] { url, thread_id + "" });
isExsits = cursor.moveToNext();
db.close();
cursor.close();
return isExsits;
}
}

ok，这样，我们的续传的数据库就写好了，接下来就是对把线程信息给保存起来了；我们要修改一下我们的 DownloadTask 这个类：

首先，先初始化数据库：

private DBThreadListener mDbThreadListener;
public DownloadTask(Context mContext) {
this.mContext = mContext;
mDbThreadListener = new DBThreadListenerImp(mContext);
}

然后修改其中的download：

public void download(FileInfo fileInfo){
mFileInfo = fileInfo;
List<ThreadInfo> threadInfos = mDbThreadListener.getThreads(fileInfo.getApkurl());
ThreadInfo mThreadInfo;
if (threadInfos.size() == 0){ //第一次启动
mThreadInfo = new ThreadInfo(0,fileInfo.getApkurl(),0,fileInfo.getLength(),0,fileInfo.getLength());
}else{
mThreadInfo = threadInfos.get(0);
}
new DownloadThread(mThreadInfo).start();
}

然后修改DownloadThread：

class DownloadThread extends Thread{
ThreadInfo mThreadInfo;
public DownloadThread(ThreadInfo threadinfo) {
this.mThreadInfo = threadinfo;
}
@Override
public void run() {
super.run();
HttpURLConnection conn = null;
RandomAccessFile raf = null;
BufferedInputStream bis = null;
//开始之前先检测是否数据库有线程信息
if (!mDbThreadListener.isThreadExsits(mThreadInfo.getUrl(),mThreadInfo.getId())){
mDbThreadListener.insertThread(mThreadInfo); //没有则把线程信息保存进去
}
try {
URL url = new URL(mThreadInfo.getUrl());
conn = (HttpURLConnection) url.openConnection();
//加上这句是为了防止connection.getContentLength()获取不到
conn.setRequestProperty("Accept-Encoding", "identity");
conn.setRequestMethod("GET");
conn.setReadTimeout(5000);
conn.setConnectTimeout(5000);
//设置下载位置
int start = mThreadInfo.getStart()+mThreadInfo.getFinished(); //起始位置
int end = mThreadInfo.getEnd(); //结束位置
conn.setRequestProperty("Range", "bytes="+start+"-"+end);
//文件写入位置
File file = new File(mFileInfo.getDir(),mFileInfo.getFileName());
raf = new RandomAccessFile(file,"rwd");
raf.seek(start);

int len = -1;
downloadlength += len; //主要是暂停之后，重新下载，获取以前的进度
byte[] bytes = new byte[1024*2];
bis = new BufferedInputStream(conn.getInputStream());
while( (len = bis.read(bytes)) != -1 ){
raf.write(bytes,0,len);
downloadlength += len;
if (isPause) {
//数据库保存当前信息
mDbThreadListener.updateThread(mThreadInfo.getUrl(), mThreadInfo.getId(),
downloadlength);
return;
}
//以百分比的形式传递
Log.d(TAG, "run: "+downloadlength*100/mFileInfo.getLength());
}
//如果完成，则把以前的线程信息干掉
mDbThreadListener.deleteThread(mThreadInfo.getUrl(),mThreadInfo.getId());
} catch (Exception e) {
e.printStackTrace();
Log.d(TAG, "downloaderror: "+e.toString());
}finally {
if (bis != null) try {
bis.close();
if (raf != null) raf.close();
} catch (IOException e) {
e.printStackTrace();
}
if (conn != null) conn.disconnect();
}
}
}

这样就完成了。