Android教程網
  1. 首頁
  2. Android 技術
  3. Android 手機
  4. Android 系統教程
  5. Android 游戲
 Android教程網 >> Android技術 >> Android開發實例 >> 斷點續傳的原理剖析與實例講解

斷點續傳的原理剖析與實例講解

編輯:Android開發實例

       本文所要講的是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代碼
  1. url url = new url("http://www.jizhuomi.com/android/down.zip");   
  2. httpurlconnection httpconnection = (httpurlconnection)url.openconnection();   
  3. //設置user-agent   
  4. httpconnection.setrequestproperty("user-agent","netfox");   
  5. //設置斷點續傳的開始位置   
  6. httpconnection.setrequestproperty("range","bytes=2000070");   
  7. //獲得輸入流   
  8. inputstream input = httpconnection.getinputstream();  

       從輸入流中取出的字節流就是down.zip文件從2000070開始的字節流。

       大家看,其實斷點續傳用java實現起來還是很簡單的吧。

       接下來要做的事就是怎麼保存獲得的流到文件中去了。

       保存文件采用的方法:我采用的是io包中的randaccessfile類

       操作相當簡單,假設從2000070處開始保存文件,代碼如下:

Java代碼
  1. randomaccess osavedfile = new randomaccessfile("down.zip","rw");   
  2. long npos = 2000070;   
  3. //定位文件指針到npos位置   
  4. osavedfile.seek(npos);   
  5. byte[] b = new byte[1024];   
  6. int nread;   
  7. //從輸入流中讀入字節流,然後寫到文件中   
  8. while((nread=input.read(b,0,1024)) > 0)   
  9. {   
  10.     osavedfile.write(b,0,nread);   
  11. }  

       怎麼樣,也很簡單吧。

       接下來要做的就是整合成一個完整的程序了。包括一系列的線程控制等等。

       三、斷點續傳內核的實現

       主要用了6個類,包括一個測試類。

       sitefilefetch.java負責整個文件的抓取,控制內部線程(filesplitterfetch類)。

       filesplitterfetch.java負責部分文件的抓取。

       fileaccess.java負責文件的存儲。

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

       utility.java工具類,放一些簡單的方法。

       testmethod.java測試類。

       四、實例源碼

       下面是源程序:

Java代碼
  1. /*  
  2. **sitefilefetch.java  
  3. */  
  4. package netfox;   
  5. import java.io.*;   
  6. import java.net.*;   
  7.    
  8. public class sitefilefetch extends thread {   
  9.     
  10. siteinfobean siteinfobean = null; //文件信息bean   
  11. long[] nstartpos; //開始位置   
  12. long[] nendpos; //結束位置   
  13. filesplitterfetch[] filesplitterfetch; //子線程對象   
  14. long nfilelength; //文件長度   
  15. boolean bfirst = true; //是否第一次取文件   
  16. boolean bstop = false; //停止標志   
  17. file tmpfile; //文件下載的臨時信息   
  18. dataoutputstream output; //輸出到文件的輸出流    
  19.   
  20. public sitefilefetch(siteinfobean bean) throws ioexception   
  21. {   
  22. siteinfobean = bean;   
  23. //tmpfile = file.createtempfile ("zhong","1111",new file(bean.getsfilepath()));   
  24. tmpfile = new file(bean.getsfilepath()+file.separator + bean.getsfilename()+".info");   
  25. if(tmpfile.exists ())   
  26. {   
  27. bfirst = false;   
  28. read_npos();   
  29. }   
  30. else  
  31. {   
  32. nstartpos = new long[bean.getnsplitter()];   
  33. nendpos = new long[bean.getnsplitter()];   
  34. }      
  35. }   
  36.     
  37. public void run()   
  38. {   
  39. //獲得文件長度   
  40. //分割文件   
  41. //實例filesplitterfetch   
  42. //啟動filesplitterfetch線程   
  43. //等待子線程返回   
  44. try{   
  45. if(bfirst)   
  46. {   
  47. nfilelength = getfilesize();   
  48. if(nfilelength == -1)   
  49. {   
  50. system.err.println("file length is not known!");   
  51. }   
  52. else if(nfilelength == -2)   
  53. {   
  54. system.err.println("file is not access!");   
  55. }   
  56. else  
  57. {   
  58. for(int i=0;i<nstartpos.length;i++)   
  59. {   
  60. nstartpos = (long)(i*(nfilelength/nstartpos.length));   
  61. }   
  62. for(int i=0;i<nendpos.length-1;i++)   
  63. {   
  64. nendpos = nstartpos[i+1];   
  65. }   
  66. nendpos[nendpos.length-1] = nfilelength;   
  67. }   
  68. }   
  69. //啟動子線程   
  70. filesplitterfetch = new filesplitterfetch[nstartpos.length];   
  71. for(int i=0;i<nstartpos.length;i++)   
  72. {   
  73. filesplitterfetch = new filesplitterfetch(siteinfobean.getssiteurl(),   
  74. siteinfobean.getsfilepath() + file.separator + siteinfobean.getsfilename(),   
  75. nstartpos,nendpos,i);   
  76. utility.log("thread " + i + " , nstartpos = " + nstartpos + ", nendpos = " + nendpos);   
  77. filesplitterfetch.start();   
  78. }   
  79. // filesplitterfetch[npos.length-1] = new filesplitterfetch(siteinfobean.getssiteurl(),   
  80. siteinfobean.getsfilepath() + file.separator + siteinfobean.getsfilename(),npos[npos.length-1],nfilelength,npos.length-1);   
  81. // utility.log("thread " + (npos.length-1) + " , nstartpos = " + npos[npos.length-1] + ",   
  82. nendpos = " + nfilelength);   
  83. // filesplitterfetch[npos.length-1].start();   
  84.   
  85. //等待子線程結束   
  86. //int count = 0;   
  87. //是否結束while循環   
  88. boolean breakwhile = false;   
  89.     
  90. while(!bstop)   
  91. {   
  92. write_npos();   
  93. utility.sleep(500);   
  94. breakwhile = true;   
  95.     
  96. for(int i=0;i<nstartpos.length;i++)   
  97. {   
  98. if(!filesplitterfetch.bdownover)   
  99. {   
  100. breakwhile = false;   
  101. break;   
  102. }   
  103. }   
  104. if(breakwhile)   
  105. break;   
  106.    
  107. //count++;   
  108. //if(count>4)   
  109. // sitestop();   
  110. }   
  111.    
  112. system.err.println("文件下載結束!");   
  113. }   
  114. catch(exception e){e.printstacktrace ();}   
  115. }   
  116.    
  117. //獲得文件長度   
  118. public long getfilesize()   
  119. {   
  120. int nfilelength = -1;   
  121. try{   
  122. url url = new url(siteinfobean.getssiteurl());   
  123. httpurlconnection httpconnection = (httpurlconnection)url.openconnection ();   
  124. httpconnection.setrequestproperty("user-agent","netfox");    
  125.   
  126. int responsecode=httpconnection.getresponsecode();   
  127. if(responsecode>=400)   
  128. {   
  129. processerrorcode(responsecode);   
  130. return -2; //-2 represent access is error   
  131. }   
  132.    
  133. string sheader;   
  134.     
  135. for(int i=1;;i++)   
  136. {   
  137. //datainputstream in = new datainputstream(httpconnection.getinputstream ());   
  138. //utility.log(in.readline());   
  139. sheader=httpconnection.getheaderfieldkey(i);   
  140. if(sheader!=null)   
  141. {   
  142. if(sheader.equals("content-length"))   
  143. {   
  144. nfilelength = integer.parseint(httpconnection.getheaderfield(sheader));   
  145. break;   
  146. }   
  147. }   
  148. else  
  149. break;   
  150. }   
  151. }   
  152. catch(ioexception e){e.printstacktrace ();}   
  153. catch(exception e){e.printstacktrace ();}   
  154.    
  155. utility.log(nfilelength);   
  156.    
  157. return nfilelength;   
  158. }   
  159.     
  160. //保存下載信息(文件指針位置)   
  161. private void write_npos()   
  162. {   
  163. try{   
  164. output = new dataoutputstream(new fileoutputstream(tmpfile));   
  165. output.writeint(nstartpos.length);   
  166. for(int i=0;i<nstartpos.length;i++)   
  167. {   
  168. // output.writelong(npos);   
  169. output.writelong(filesplitterfetch.nstartpos);   
  170. output.writelong(filesplitterfetch.nendpos);   
  171. }   
  172. output.close();   
  173. }   
  174. catch(ioexception e){e.printstacktrace ();}   
  175. catch(exception e){e.printstacktrace ();}   
  176. }   
  177.     
  178. //讀取保存的下載信息(文件指針位置)   
  179. private void read_npos()   
  180. {   
  181. try{   
  182. datainputstream input = new datainputstream(new fileinputstream(tmpfile));   
  183. int ncount = input.readint();   
  184. nstartpos = new long[ncount];   
  185. nendpos = new long[ncount];   
  186. for(int i=0;i<nstartpos.length;i++)   
  187. {   
  188. nstartpos = input.readlong();   
  189. nendpos = input.readlong();   
  190. }   
  191. input.close();   
  192. }   
  193. catch(ioexception e){e.printstacktrace ();}   
  194. catch(exception e){e.printstacktrace ();}   
  195. }   
  196.    
  197. private void processerrorcode(int nerrorcode)   
  198. {   
  199. system.err.println("error code : " + nerrorcode);   
  200. }   
  201.     
  202. //停止文件下載   
  203. public void sitestop()   
  204. {   
  205. bstop = true;   
  206. for(int i=0;i<nstartpos.length;i++)   
  207. filesplitterfetch.splitterstop();    
  208. }   
  209. }   
  210. /*  
  211. **filesplitterfetch.java  
  212. */  
  213. package netfox;   
  214.     
  215. import java.io.*;   
  216. import java.net.*;   
  217.    
  218. public class filesplitterfetch extends thread {   
  219.     
  220. string surl; //file url   
  221. long nstartpos; //file snippet start position   
  222. long nendpos; //file snippet end position   
  223. int nthreadid; //threads id   
  224. boolean bdownover = false; //downing is over   
  225. boolean bstop = false; //stop identical   
  226. fileaccessi fileaccessi = null; //file access interface   
  227.     
  228. public filesplitterfetch(string surl,string sname,long nstart,long nend,int id) throws ioexception   
  229. {   
  230. this.surl = surl;   
  231. this.nstartpos = nstart;   
  232. this.nendpos = nend;   
  233. nthreadid = id;   
  234. fileaccessi = new fileaccessi(sname,nstartpos);   
  235. }   
  236.     
  237. public void run()   
  238. {   
  239. while(nstartpos < nendpos && !bstop)   
  240. {     
  241. try{   
  242. url url = new url(surl);   
  243. httpurlconnection httpconnection = (httpurlconnection)url.openconnection ();   
  244. httpconnection.setrequestproperty("user-agent","netfox");   
  245. string sproperty = "bytes="+nstartpos+"-";   
  246. httpconnection.setrequestproperty("range",sproperty);   
  247. utility.log(sproperty);   
  248.     
  249. inputstream input = httpconnection.getinputstream();   
  250. //logresponsehead(httpconnection);   
  251.    
  252. byte[] b = new byte[1024];   
  253. int nread;   
  254. while((nread=input.read(b,0,1024)) > 0 && nstartpos < nendpos && !bstop)   
  255. {   
  256. nstartpos += fileaccessi.write(b,0,nread);   
  257. //if(nthreadid == 1)   
  258. // utility.log("nstartpos = " + nstartpos + ", nendpos = " + nendpos);   
  259. }   
  260.     
  261. utility.log("thread " + nthreadid + " is over!");   
  262. bdownover = true;   
  263. //npos = fileaccessi.write (b,0,nread);   
  264. }   
  265. catch(exception e){e.printstacktrace ();}   
  266. }   
  267. }   
  268.    
  269. //打印回應的頭信息   
  270. public void logresponsehead(httpurlconnection con)   
  271. {   
  272. for(int i=1;;i++)   
  273. {   
  274. string header=con.getheaderfieldkey(i);   
  275. if(header!=null)   
  276. //responseheaders.put(header,httpconnection.getheaderfield(header));   
  277. utility.log(header+" : "+con.getheaderfield(header));   
  278. else  
  279. break;   
  280. }   
  281. }   
  282.     
  283. public void splitterstop()   
  284. {   
  285. bstop = true;   
  286. }      
  287. }   
  288.     
  289. /*  
  290. **fileaccess.java  
  291. */  
  292. package netfox;   
  293. import java.io.*;   
  294.     
  295. public class fileaccessi implements serializable{   
  296.     
  297. randomaccessfile osavedfile;   
  298. long npos;   
  299.    
  300. public fileaccessi() throws ioexception   
  301. {   
  302. this("",0);   
  303. }   
  304.     
  305. public fileaccessi(string sname,long npos) throws ioexception   
  306. {   
  307. osavedfile = new randomaccessfile(sname,"rw");   
  308. this.npos = npos;   
  309. osavedfile.seek(npos);   
  310. }   
  311.     
  312. public synchronized int write(byte[] b,int nstart,int nlen)   
  313. {   
  314. int n = -1;   
  315. try{   
  316. osavedfile.write(b,nstart,nlen);   
  317. n = nlen;   
  318. }   
  319. catch(ioexception e)   
  320. {   
  321. e.printstacktrace ();   
  322. }   
  323.     
  324. return n;   
  325. }     
  326. }   
  327.     
  328. /*  
  329. **siteinfobean.java  
  330. */  
  331. package netfox;   
  332.     
  333. public class siteinfobean {   
  334.     
  335. private string ssiteurl; //sites url   
  336. private string sfilepath; //saved files path   
  337. private string sfilename; //saved files name   
  338. private int nsplitter; //count of splited downloading file   
  339.     
  340. public siteinfobean()   
  341. {   
  342. //default value of nsplitter is 5   
  343. this("","","",5);   
  344. }   
  345.     
  346. public siteinfobean(string surl,string spath,string sname,int nspiltter)   
  347. {   
  348. ssiteurl= surl;   
  349. sfilepath = spath;   
  350. sfilename = sname;   
  351. this.nsplitter = nspiltter;     
  352. }   
  353.     
  354. public string getssiteurl()   
  355. {   
  356. return ssiteurl;   
  357. }   
  358.     
  359. public void setssiteurl(string value)   
  360. {   
  361. ssiteurl = value;   
  362. }   
  363.     
  364. public string getsfilepath()   
  365. {   
  366. return sfilepath;   
  367. }   
  368.     
  369. public void setsfilepath(string value)   
  370. {   
  371. sfilepath = value;   
  372. }   
  373.    
  374. public string getsfilename()   
  375. {   
  376. return sfilename;   
  377. }   
  378.    
  379. public void setsfilename(string value)   
  380. {   
  381. sfilename = value;   
  382. }   
  383.    
  384. public int getnsplitter()   
  385. {   
  386. return nsplitter;   
  387. }    
  388.   
  389. public void setnsplitter(int ncount)   
  390. {   
  391. nsplitter = ncount;   
  392. }   
  393. }     
  394.   
  395. /*  
  396. **utility.java  
  397. */  
  398. package netfox;   
  399.    
  400. public class utility {   
  401.    
  402. public utility()   
  403. {    
  404. }   
  405.     
  406. public static void sleep(int nsecond)   
  407. {   
  408. try{   
  409. thread.sleep(nsecond);   
  410. }   
  411. catch(exception e)   
  412. {   
  413. e.printstacktrace ();   
  414. }   
  415. }   
  416.    
  417. public static void log(string smsg)   
  418. {   
  419. system.err.println(smsg);   
  420. }   
  421.    
  422. public static void log(int smsg)   
  423. {   
  424. system.err.println(smsg);   
  425. }   
  426. }   
  427.    
  428. /*  
  429. **testmethod.java  
  430. */  
  431. package netfox;   
  432.     
  433. public class testmethod {   
  434.    
  435. public testmethod()   
  436. { ///xx/weblogic60b2_win.exe   
  437. try{   
  438. siteinfobean bean = new siteinfobean("http://localhost/xx/weblogic60b2_win.exe","l:\\temp","weblogic60b2_win.exe",5);   
  439. //siteinfobean bean = new siteinfobean("http://localhost:8080/down.zip","l:\\temp","weblogic60b2_win.exe",5);   
  440. sitefilefetch filefetch = new sitefilefetch(bean);   
  441. filefetch.start();   
  442. }   
  443. catch(exception e){e.printstacktrace ();}     
  444. }   
  445.    
  446. public static void main(string[] args)   
  447. {   
  448. new testmethod();   
  449. }   
  450. }   
  1. 上一頁:
  2. 下一頁:
熱門文章
閱讀排行版
Copyright © Android教程網 All Rights Reserved