断点续传的原理剖析与讲解

本文所要讲的是Android断点续传的内容，以实例的形式进行了详细介绍。

一、断点续传的原理

其实断点续传的原理很简单，就是在http的请求上和一般的下载有所不同而已。

打个比方，浏览器请求服务器上的一个文时，所发出的请求如下：

假设服务器域名为www.jizhuomi.com/android，文件名为down.zip。

get /down.zip http/1.1

accept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, application/vnd.ms-

excel, application/msword, application/vnd.ms-powerpoint, */*

accept-language: zh-cn

accept-encoding: gzip, deflate

user-agent: mozilla/4.0 (compatible; msie 5.01; windows nt 5.0)

connection: keep-alive

服务器收到请求后，按要求寻找请求的文件，提取文件的信息，然后返回给浏览器，返回信息如下：

200

content-length=106786028

accept-ranges=bytes

date=mon, 30 apr 2001 12:56:11 gmt

etag=w/"02ca57e173c11:95b"

content-type=application/octet-stream

server=microsoft-iis/5.0

last-modified=mon, 30 apr 2001 12:56:11 gmt

所谓断点续传，也就是要从文件已经下载的地方开始继续下载。所以在客户端浏览器传给web服务器的时候要多加一条信息--从哪里开始。

下面是用自己编的一个“浏览器”来传递请求信息给web服务器，要求从2000070字节开始。

get /down.zip http/1.0

user-agent: netfox

range: bytes=2000070-

accept: text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2

仔细看一下就会发现多了一行 range: bytes=2000070-

这一行的意思就是告诉服务器down.zip这个文件从2000070字节开始传，前面的字节不用传了。

服务器收到这个请求以后，返回的信息如下：

206

content-length=106786028

content-range=bytes 2000070-106786027/106786028

date=mon, 30 apr 2001 12:55:20 gmt

etag=w/"02ca57e173c11:95b"

content-type=application/octet-stream

server=microsoft-iis/5.0

last-modified=mon, 30 apr 2001 12:55:20 gmt

和前面服务器返回的信息比较一下，就会发现增加了一行：

content-range=bytes 2000070-106786027/106786028

返回的代码也改为206了，而不再是200了。

知道了以上原理，就可以进行断点续传的编程了。

二、java实现断点续传的关键几点

用什么方法实现提交range: bytes=2000070-？

当然用最原始的socket是肯定能完成的，不过那样太费事了，其实java的net包中提供了这种功能。代码如下：

Java代码

url url = new url("http://www.jizhuomi.com/android/down.zip");

httpurlconnection httpconnection = (httpurlconnection)url.openconnection();

//设置user-agent
httpconnection.setrequestproperty("user-agent","netfox");

//设置断点续传的开始位置
httpconnection.setrequestproperty("range","bytes=2000070");

//获得输入流
inputstream input = httpconnection.getinputstream();

从输入流中取出的字节流就是down.zip文件从2000070开始的字节流。

大家看，其实断点续传用java实现起来还是很简单的吧。

接下来要做的事就是怎么保存获得的流到文件中去了。

保存文件采用的方法：我采用的是io包中的randaccessfile类。

操作相当简单，假设从2000070处开始保存文件，代码如下：

Java代码

randomaccess osavedfile = new randomaccessfile("down.zip","rw");

long npos = 2000070;

//定位文件指针到npos位置
osavedfile.seek(npos);

byte[] b = new byte[1024];

int nread;

//从输入流中读入字节流，然后写到文件中
while((nread=input.read(b,0,1024)) > 0)

{
osavedfile.write(b,0,nread);

}

怎么样，也很简单吧。

接下来要做的就是整合成一个完整的程序了。包括一系列的线程控制等等。

三、断点续传内核的实现

主要用了6个类，包括一个测试类。

sitefilefetch.java负责整个文件的抓取，控制内部线程（filesplitterfetch类）。

filesplitterfetch.java负责部分文件的抓取。

fileaccess.java负责文件的存储。

siteinfobean.java要抓取的文件的信息，如文件保存的目录，名字，抓取文件的url等。

utility.java工具类，放一些简单的方法。

testmethod.java测试类。

四、实例源码

下面是源程序：

Java代码

/*
**sitefilefetch.java

*/
package netfox;

import java.io.*;
import java.net.*;

public class sitefilefetch extends thread {

siteinfobean siteinfobean = null; //文件信息bean

long[] nstartpos; //开始位置
long[] nendpos; //结束位置

filesplitterfetch[] filesplitterfetch; //子线程对象
long nfilelength; //文件长度

boolean bfirst = true; //是否第一次取文件
boolean bstop = false; //停止标志

file tmpfile; //文件下载的临时信息
dataoutputstream output; //输出到文件的输出流

public sitefilefetch(siteinfobean bean) throws ioexception

{

siteinfobean = bean;
//tmpfile = file.createtempfile ("zhong","1111",new file(bean.getsfilepath()));

tmpfile = new file(bean.getsfilepath()+file.separator + bean.getsfilename()+".info");

if(tmpfile.exists ())

{
bfirst = false;

read_npos();
}

else
{

nstartpos = new long[bean.getnsplitter()];

nendpos = new long[bean.getnsplitter()];

}

}

public void run()

{
//获得文件长度

//分割文件
//实例filesplitterfetch

//启动filesplitterfetch线程
//等待子线程返回

try{
if(bfirst)

{
nfilelength = getfilesize();

if(nfilelength == -1)

{

system.err.println("file length is not known!");
}

else if(nfilelength == -2)

{

system.err.println("file is not access!");
}

else
{

for(int i=0;i<nstartpos.length;i++)

{

nstartpos = (long)(i*(nfilelength/nstartpos.length));

}

for(int i=0;i<nendpos.length-1;i++)

{

nendpos = nstartpos[i+1];
}

nendpos[nendpos.length-1] = nfilelength;
}

}
//启动子线程

filesplitterfetch = new filesplitterfetch[nstartpos.length];

for(int i=0;i<nstartpos.length;i++)

{
filesplitterfetch = new filesplitterfetch(siteinfobean.getssiteurl(),

siteinfobean.getsfilepath() + file.separator + siteinfobean.getsfilename(),
nstartpos,nendpos,i);

utility.log("thread " + i + " , nstartpos = " + nstartpos + ", nendpos = " + nendpos);

filesplitterfetch.start();

}
// filesplitterfetch[npos.length-1] = new filesplitterfetch(siteinfobean.getssiteurl(),

siteinfobean.getsfilepath() + file.separator + siteinfobean.getsfilename(),npos[npos.length-1],nfilelength,npos.length-1);

// utility.log("thread " + (npos.length-1) + " , nstartpos = " + npos[npos.length-1] + ",

nendpos = " + nfilelength);
// filesplitterfetch[npos.length-1].start();

//等待子线程结束
//int count = 0;

//是否结束while循环
boolean breakwhile = false;

while(!bstop)
{

write_npos();
utility.sleep(500);

breakwhile = true;

for(int i=0;i<nstartpos.length;i++)

{
if(!filesplitterfetch.bdownover)

{
breakwhile = false;

break;
}

}
if(breakwhile)

break;

//count++;

//if(count>4)
// sitestop();

}

system.err.println("文件下载结束！");

}
catch(exception e){e.printstacktrace ();}

}

//获得文件长度

public long getfilesize()

{

int nfilelength = -1;

try{

url url = new url(siteinfobean.getssiteurl());

httpurlconnection httpconnection = (httpurlconnection)url.openconnection ();

httpconnection.setrequestproperty("user-agent","netfox");

int responsecode=httpconnection.getresponsecode();

if(responsecode>=400)

{

processerrorcode(responsecode);
return -2; //-2 represent access is error

}

string sheader;

for(int i=1;;i++)

{

//datainputstream in = new datainputstream(httpconnection.getinputstream ());
//utility.log(in.readline());

sheader=httpconnection.getheaderfieldkey(i);
if(sheader!=null)

{
if(sheader.equals("content-length"))

{
nfilelength = integer.parseint(httpconnection.getheaderfield(sheader));

break;
}

}
else

break;
}

}
catch(ioexception e){e.printstacktrace ();}

catch(exception e){e.printstacktrace ();}

utility.log(nfilelength);

return nfilelength;
}

//保存下载信息（文件指针位置）
private void write_npos()

{
try{

output = new dataoutputstream(new fileoutputstream(tmpfile));

output.writeint(nstartpos.length);

for(int i=0;i<nstartpos.length;i++)

{

// output.writelong(npos);
output.writelong(filesplitterfetch.nstartpos);

output.writelong(filesplitterfetch.nendpos);
}

output.close();
}

catch(ioexception e){e.printstacktrace ();}
catch(exception e){e.printstacktrace ();}

}

//读取保存的下载信息（文件指针位置）

private void read_npos()

{

try{
datainputstream input = new datainputstream(new fileinputstream(tmpfile));

int ncount = input.readint();
nstartpos = new long[ncount];

nendpos = new long[ncount];

for(int i=0;i<nstartpos.length;i++)

{
nstartpos = input.readlong();

nendpos = input.readlong();
}

input.close();
}

catch(ioexception e){e.printstacktrace ();}
catch(exception e){e.printstacktrace ();}

}

private void processerrorcode(int nerrorcode)

{
system.err.println("error code : " + nerrorcode);

}

//停止文件下载

public void sitestop()

{

bstop = true;
for(int i=0;i<nstartpos.length;i++)

filesplitterfetch.splitterstop();
}

}
/*

**filesplitterfetch.java
*/

package netfox;

import java.io.*;

import java.net.*;

public class filesplitterfetch extends thread {

string surl; //file url
long nstartpos; //file snippet start position

long nendpos; //file snippet end position
int nthreadid; //threads id

boolean bdownover = false; //downing is over
boolean bstop = false; //stop identical

fileaccessi fileaccessi = null; //file access interface

public filesplitterfetch(string surl,string sname,long nstart,long nend,int id) throws ioexception

{
this.surl = surl;

this.nstartpos = nstart;
this.nendpos = nend;

nthreadid = id;
fileaccessi = new fileaccessi(sname,nstartpos);

}

public void run()

{
while(nstartpos < nendpos && !bstop)

{
try{

url url = new url(surl);
httpurlconnection httpconnection = (httpurlconnection)url.openconnection ();

httpconnection.setrequestproperty("user-agent","netfox");

string sproperty = "bytes="+nstartpos+"-";

httpconnection.setrequestproperty("range",sproperty);
utility.log(sproperty);

inputstream input = httpconnection.getinputstream();
//logresponsehead(httpconnection);

byte[] b = new byte[1024];

int nread;

while((nread=input.read(b,0,1024)) > 0 && nstartpos < nendpos && !bstop)

{

nstartpos += fileaccessi.write(b,0,nread);
//if(nthreadid == 1)

// utility.log("nstartpos = " + nstartpos + ", nendpos = " + nendpos);
}

utility.log("thread " + nthreadid + " is over!");

bdownover = true;

//npos = fileaccessi.write (b,0,nread);
}

catch(exception e){e.printstacktrace ();}
}

}

//打印回应的头信息

public void logresponsehead(httpurlconnection con)

{

for(int i=1;;i++)

{

string header=con.getheaderfieldkey(i);
if(header!=null)

//responseheaders.put(header,httpconnection.getheaderfield(header));
utility.log(header+" : "+con.getheaderfield(header));

else
break;

}
}

public void splitterstop()

{

bstop = true;
}

}

/*

**fileaccess.java
*/

package netfox;
import java.io.*;

public class fileaccessi implements serializable{

randomaccessfile osavedfile;

long npos;

public fileaccessi() throws ioexception

{
this("",0);

}

public fileaccessi(string sname,long npos) throws ioexception

{
osavedfile = new randomaccessfile(sname,"rw");

this.npos = npos;
osavedfile.seek(npos);

}

public synchronized int write(byte[] b,int nstart,int nlen)

{
int n = -1;

try{
osavedfile.write(b,nstart,nlen);

n = nlen;
}

catch(ioexception e)
{

e.printstacktrace ();
}

return n;
}

}

/*

**siteinfobean.java
*/

package netfox;

public class siteinfobean {

private string ssiteurl; //sites url
private string sfilepath; //saved files path

private string sfilename; //saved files name
private int nsplitter; //count of splited downloading file

public siteinfobean()
{

//default value of nsplitter is 5
this("","","",5);

}

public siteinfobean(string surl,string spath,string sname,int nspiltter)

{
ssiteurl= surl;

sfilepath = spath;
sfilename = sname;

this.nsplitter = nspiltter;
}

public string getssiteurl()
{

return ssiteurl;
}

public void setssiteurl(string value)

{

ssiteurl = value;
}

public string getsfilepath()
{

return sfilepath;
}

public void setsfilepath(string value)

{

sfilepath = value;
}

public string getsfilename()
{

return sfilename;
}

public void setsfilename(string value)

{

sfilename = value;
}

public int getnsplitter()

{

return nsplitter;
}

public void setnsplitter(int ncount)

{

nsplitter = ncount;
}

}

/*

**utility.java
*/

package netfox;

public class utility {

public utility()
{

}

public static void sleep(int nsecond)

{
try{

thread.sleep(nsecond);
}

catch(exception e)
{

e.printstacktrace ();
}

}

public static void log(string smsg)

{
system.err.println(smsg);

}

public static void log(int smsg)

{
system.err.println(smsg);

}
}

/*
**testmethod.java

*/
package netfox;

public class testmethod {

public testmethod()

{ ///xx/weblogic60b2_win.exe
try{

siteinfobean bean = new siteinfobean("http://localhost/xx/weblogic60b2_win.exe","l:\\temp","weblogic60b2_win.exe",5);

//siteinfobean bean = new siteinfobean("http://localhost:8080/down.zip","l:\\temp","weblogic60b2_win.exe",5);

sitefilefetch filefetch = new sitefilefetch(bean);

filefetch.start();

}
catch(exception e){e.printstacktrace ();}

}

public static void main(string[] args)

{
new testmethod();

}
}