碼上歡樂
相關內容    簡體    繁體

HTTP斷點續傳

本文轉載自   查看原文   2011-12-29 10:33   24751 

http://rainbow702.iteye.com/category/156952

 

 

在網上看J2EE的職位時，不僅需要了解SSH框架及數據庫等基本知識，還有不少要求了解 FTP或者HTTP之類的協議。起初，我不知道到底是什么才叫了解FTP或者HTTP協議（現在也沒怎么理解這句話）。偶爾有一次，聽老大電話面試一個人，問到了對方了不了解HTTP協議，然后直接問了對方“斷點續傳”的原理是什么？我想，這就是對HTTP協議有了解的一個表現吧。今天突然想起來了“斷點續傳”，於是就找了一篇貼子來理解一下。

--------------------------------------------------------------------------------------------------------------------------------------

 

斷點續傳的原理

其實斷點續傳的原理很簡單，就是在 Http 的請求上和一般的下載有所不同而已。
打個比方，瀏覽器請求服務器上的一個文時，所發出的請求如下：
假設服務器域名為 wwww.sjtu.edu.cn，文件名為 down.zip。

Http代碼 復制代碼  收藏代碼
  1. GET /down.zip HTTP/1.1  
  2. Accept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, application/vnd.ms-   
  3. excel, application/msword, application/vnd.ms-powerpoint, */*   
  4. Accept-Language: zh-cn   
  5. Accept-Encoding: gzip, deflate   
  6. User-Agent: Mozilla/4.0 (compatible; MSIE 5.01; Windows NT 5.0)   
  7. Connection: Keep-Alive   

 服務器收到請求后，按要求尋找請求的文件，提取文件的信息，然后返回給瀏覽器，返回信息如下：

Http代碼 復制代碼  收藏代碼
  1. 200  
  2. Content-Length=106786028  
  3. Accept-Ranges=bytes   
  4. Date=Mon, 30 Apr 2001 12:56:11 GMT   
  5. ETag=W/"02ca57e173c11:95b"  
  6. Content-Type=application/octet-stream   
  7. Server=Microsoft-IIS/5.0  
  8. Last-Modified=Mon, 30 Apr 2001 12:56:11 GMT   

 所謂斷點續傳，也就是要從文件已經下載的地方開始繼續下載。所以在客戶端瀏覽器傳給 Web 服務器的時候要多加一條信息 -- 從哪里開始。
下面是用自己編的一個"瀏覽器"來傳遞請求信息給 Web 服務器，要求從 2000070 字節開始。

Http代碼 復制代碼  收藏代碼
  1. GET /down.zip HTTP/1.0  
  2. User-Agent: NetFox   
  3. RANGE: bytes=2000070-   
  4. Accept: text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2   

 仔細看一下就會發現多了一行 RANGE: bytes=2000070-
這一行的意思就是告訴服務器 down.zip 這個文件從 2000070 字節開始傳，前面的字節不用傳了。
服務器收到這個請求以后，返回的信息如下：

Http代碼 復制代碼  收藏代碼
  1. 206  
  2. Content-Length=106786028  
  3. Content-Range=bytes 2000070-106786027/106786028  
  4. Date=Mon, 30 Apr 2001 12:55:20 GMT   
  5. ETag=W/"02ca57e173c11:95b"  
  6. Content-Type=application/octet-stream   
  7. Server=Microsoft-IIS/5.0  
  8. Last-Modified=Mon, 30 Apr 2001 12:55:20 GMT   

 和前面服務器返回的信息比較一下，就會發現增加了一行：

Http代碼 復制代碼  收藏代碼
  1. Content-Range=bytes 2000070-106786027/106786028   

 返回的代碼也改為 206 了，而不再是 200 了。

知道了以上原理，就可以進行斷點續傳的編程了。

 

Java 實現斷點續傳的關鍵幾點

(1) 用什么方法實現提交 RANGE: bytes=2000070-。
當然用最原始的 Socket 是肯定能完成的，不過那樣太費事了，其實 Java 的 net 包中提供了這種功能。代碼如下：

Java代碼 復制代碼  收藏代碼
  1. URL url = new URL("http://www.sjtu.edu.cn/down.zip");   
  2. HttpURLConnection httpConnection = (HttpURLConnection)url.openConnection();   
  3.   
  4. // 設置 User-Agent   
  5. httpConnection.setRequestProperty("User-Agent","NetFox");   
  6. // 設置斷點續傳的開始位置   
  7. httpConnection.setRequestProperty("RANGE","bytes=2000070");   
  8. // 獲得輸入流   
  9. InputStream input = httpConnection.getInputStream();  

從輸入流中取出的字節流就是 down.zip 文件從 2000070 開始的字節流。大家看，其實斷點續傳用 Java 實現起來還是很簡單的吧。接下來要做的事就是怎么保存獲得的流到文件中去了。
(2) 保存文件采用的方法。
我采用的是 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.  public class SiteFileFetch extends Thread {    
  8.      SiteInfoBean siteInfoBean = null; // 文件信息 Bean    
  9.      long[] nStartPos; // 開始位置   
  10.      long[] nEndPos; // 結束位置   
  11.      FileSplitterFetch[] fileSplitterFetch; // 子線程對象   
  12.      long nFileLength; // 文件長度   
  13.      boolean bFirst = true; // 是否第一次取文件   
  14.      boolean bStop = false; // 停止標志   
  15.      File tmpFile; // 文件下載的臨時信息   
  16.      DataOutputStream output; // 輸出到文件的輸出流   
  17.      public SiteFileFetch(SiteInfoBean bean) throws IOException    
  18.      {    
  19.          siteInfoBean = bean;    
  20.          //tmpFile = File.createTempFile ("zhong","1111",new File(bean.getSFilePath()));    
  21.          tmpFile = new File(bean.getSFilePath()+File.separator + bean.getSFileName()+".info");   
  22.          if(tmpFile.exists ())    
  23.          {    
  24.              bFirst = false;    
  25.              read_nPos();    
  26.          }    
  27.          else    
  28.          {    
  29.              nStartPos = new long[bean.getNSplitter()];    
  30.              nEndPos = new long[bean.getNSplitter()];    
  31.          }    
  32.      }    
  33.      public void run()    
  34.      {    
  35.          // 獲得文件長度   
  36.          // 分割文件   
  37.          // 實例 FileSplitterFetch    
  38.          // 啟動 FileSplitterFetch 線程   
  39.          // 等待子線程返回   
  40.          try{    
  41.              if(bFirst)    
  42.              {    
  43.                  nFileLength = getFileSize();    
  44.                  if(nFileLength == -1)    
  45.                  {    
  46.                      System.err.println("File Length is not known!");    
  47.                  }    
  48.                  else if(nFileLength == -2)    
  49.                  {    
  50.                      System.err.println("File is not access!");    
  51.                  }    
  52.                  else    
  53.                  {    
  54.                  for(int i=0;i<nStartPos.length;i++)    
  55.                  {    
  56.                       nStartPos[i] = (long)(i*(nFileLength/nStartPos.length));    
  57.                  }    
  58.                 for(int i=0;i<nEndPos.length-1;i++)    
  59.                 {    
  60.                     nEndPos[i] = nStartPos[i+1];    
  61.                 }    
  62.                 nEndPos[nEndPos.length-1] = nFileLength;    
  63.             }    
  64.      }    
  65.  // 啟動子線程   
  66.  fileSplitterFetch = new FileSplitterFetch[nStartPos.length];    
  67.  for(int i=0;i<nStartPos.length;i++)    
  68.  {    
  69.  fileSplitterFetch[i] = new FileSplitterFetch(siteInfoBean.getSSiteURL(),    
  70.  siteInfoBean.getSFilePath() + File.separator + siteInfoBean.getSFileName(),    
  71.  nStartPos[i],nEndPos[i],i);    
  72.  Utility.log("Thread " + i + " , nStartPos = " + nStartPos[i] + ", nEndPos = "    
  73.  + nEndPos[i]);    
  74.  fileSplitterFetch[i].start();    
  75.  }    
  76.  // fileSplitterFetch[nPos.length-1] = new FileSplitterFetch(siteInfoBean.getSSiteURL(),   
  77.  siteInfoBean.getSFilePath() + File.separator    
  78.  + siteInfoBean.getSFileName(),nPos[nPos.length-1],nFileLength,nPos.length-1);    
  79.  // Utility.log("Thread " +(nPos.length-1) + ",nStartPos = "+nPos[nPos.length-1]+",   
  80.  nEndPos = " + nFileLength);    
  81.  // fileSplitterFetch[nPos.length-1].start();    
  82.  // 等待子線程結束   
  83.  //int count = 0;    
  84.  // 是否結束 while 循環   
  85.  boolean breakWhile = false;    
  86.  while(!bStop)    
  87.  {    
  88.  write_nPos();    
  89.  Utility.sleep(500);    
  90.  breakWhile = true;    
  91.  for(int i=0;i<nStartPos.length;i++)    
  92.  {    
  93.  if(!fileSplitterFetch[i].bDownOver)    
  94.  {    
  95.  breakWhile = false;    
  96.  break;    
  97.  }    
  98.  }    
  99.  if(breakWhile)    
  100.  break;    
  101.  //count++;    
  102.  //if(count>4)    
  103.  // siteStop();    
  104.  }    
  105.  System.err.println("文件下載結束！");    
  106.  }    
  107.  catch(Exception e){e.printStackTrace ();}    
  108.  }    
  109.  // 獲得文件長度   
  110.  public long getFileSize()    
  111.  {    
  112.  int nFileLength = -1;    
  113.  try{    
  114.  URL url = new URL(siteInfoBean.getSSiteURL());    
  115.  HttpURLConnection httpConnection = (HttpURLConnection)url.openConnection ();   
  116.  httpConnection.setRequestProperty("User-Agent","NetFox");    
  117.  int responseCode=httpConnection.getResponseCode();    
  118.  if(responseCode>=400)    
  119.  {    
  120.  processErrorCode(responseCode);    
  121.  return -2; //-2 represent access is error    
  122.  }    
  123.  String sHeader;    
  124.  for(int i=1;;i++)    
  125.  {    
  126.  //DataInputStream in = new DataInputStream(httpConnection.getInputStream ());    
  127.  //Utility.log(in.readLine());    
  128.  sHeader=httpConnection.getHeaderFieldKey(i);    
  129.  if(sHeader!=null)    
  130.  {    
  131.  if(sHeader.equals("Content-Length"))    
  132.  {    
  133.  nFileLength = Integer.parseInt(httpConnection.getHeaderField(sHeader));    
  134.  break;    
  135.  }    
  136.  }    
  137.  else    
  138.  break;    
  139.  }    
  140.  }    
  141.  catch(IOException e){e.printStackTrace ();}    
  142.  catch(Exception e){e.printStackTrace ();}    
  143.  Utility.log(nFileLength);    
  144.  return nFileLength;    
  145.  }    
  146.  // 保存下載信息（文件指針位置）   
  147.  private void write_nPos()    
  148.  {    
  149.  try{    
  150.  output = new DataOutputStream(new FileOutputStream(tmpFile));    
  151.  output.writeInt(nStartPos.length);    
  152.  for(int i=0;i<nStartPos.length;i++)    
  153.  {    
  154.  // output.writeLong(nPos[i]);    
  155.  output.writeLong(fileSplitterFetch[i].nStartPos);    
  156.  output.writeLong(fileSplitterFetch[i].nEndPos);    
  157.  }    
  158.  output.close();    
  159.  }    
  160.  catch(IOException e){e.printStackTrace ();}    
  161.  catch(Exception e){e.printStackTrace ();}    
  162.  }    
  163.  // 讀取保存的下載信息（文件指針位置）   
  164.  private void read_nPos()    
  165.  {    
  166.  try{    
  167.  DataInputStream input = new DataInputStream(new FileInputStream(tmpFile));    
  168.  int nCount = input.readInt();    
  169.  nStartPos = new long[nCount];    
  170.  nEndPos = new long[nCount];    
  171.  for(int i=0;i<nStartPos.length;i++)    
  172.  {    
  173.  nStartPos[i] = input.readLong();    
  174.  nEndPos[i] = input.readLong();    
  175.  }    
  176.  input.close();    
  177.  }    
  178.  catch(IOException e){e.printStackTrace ();}    
  179.  catch(Exception e){e.printStackTrace ();}    
  180.  }    
  181.  private void processErrorCode(int nErrorCode)    
  182.  {    
  183.  System.err.println("Error Code : " + nErrorCode);    
  184.  }    
  185.  // 停止文件下載   
  186.  public void siteStop()    
  187.  {    
  188.  bStop = true;    
  189.  for(int i=0;i<nStartPos.length;i++)    
  190.  fileSplitterFetch[i].splitterStop();    
  191.  }    
  192.  }   
 
Java代碼 復制代碼  收藏代碼
  1. /*   
  2.  **FileSplitterFetch.java   
  3.  */    
  4.  package NetFox;    
  5.  import java.io.*;    
  6.  import java.net.*;    
  7.  public class FileSplitterFetch extends Thread {    
  8.  String sURL; //File URL    
  9.  long nStartPos; //File Snippet Start Position    
  10.  long nEndPos; //File Snippet End Position    
  11.  int nThreadID; //Thread's ID    
  12.  boolean bDownOver = false; //Downing is over    
  13.  boolean bStop = false; //Stop identical    
  14.  FileAccessI fileAccessI = null; //File Access interface    
  15.  public FileSplitterFetch(String sURL,String sName,long nStart,long nEnd,int id)   
  16.  throws IOException    
  17.  {    
  18.  this.sURL = sURL;    
  19.  this.nStartPos = nStart;    
  20.  this.nEndPos = nEnd;    
  21.  nThreadID = id;    
  22.  fileAccessI = new FileAccessI(sName,nStartPos);    
  23.  }    
  24.  public void run()    
  25.  {    
  26.  while(nStartPos < nEndPos && !bStop)    
  27.  {    
  28.  try{    
  29.  URL url = new URL(sURL);    
  30.  HttpURLConnection httpConnection = (HttpURLConnection)url.openConnection ();    
  31.  httpConnection.setRequestProperty("User-Agent","NetFox");    
  32.  String sProperty = "bytes="+nStartPos+"-";    
  33.  httpConnection.setRequestProperty("RANGE",sProperty);    
  34.  Utility.log(sProperty);    
  35.  InputStream input = httpConnection.getInputStream();    
  36.  //logResponseHead(httpConnection);    
  37.  byte[] b = new byte[1024];    
  38.  int nRead;    
  39.  while((nRead=input.read(b,0,1024)) > 0 && nStartPos < nEndPos    
  40.  && !bStop)    
  41.  {    
  42.  nStartPos += fileAccessI.write(b,0,nRead);    
  43.  //if(nThreadID == 1)    
  44.  // Utility.log("nStartPos = " + nStartPos + ", nEndPos = " + nEndPos);    
  45.  }    
  46.  Utility.log("Thread " + nThreadID + " is over!");    
  47.  bDownOver = true;    
  48.  //nPos = fileAccessI.write (b,0,nRead);    
  49.  }    
  50.  catch(Exception e){e.printStackTrace ();}    
  51.  }    
  52.  }    
  53.  // 打印回應的頭信息   
  54.  public void logResponseHead(HttpURLConnection con)    
  55.  {    
  56.  for(int i=1;;i++)    
  57.  {    
  58.  String header=con.getHeaderFieldKey(i);    
  59.  if(header!=null)    
  60.  //responseHeaders.put(header,httpConnection.getHeaderField(header));    
  61.  Utility.log(header+" : "+con.getHeaderField(header));    
  62.  else    
  63.  break;    
  64.  }    
  65.  }    
  66.  public void splitterStop()    
  67.  {    
  68.  bStop = true;    
  69.  }    
  70.  }    
  71.     
  72.  /*   
  73.  **FileAccess.java   
  74.  */    
  75.  package NetFox;    
  76.  import java.io.*;    
  77.  public class FileAccessI implements Serializable{    
  78.  RandomAccessFile oSavedFile;    
  79.  long nPos;    
  80.  public FileAccessI() throws IOException    
  81.  {    
  82.  this("",0);    
  83.  }    
  84.  public FileAccessI(String sName,long nPos) throws IOException    
  85.  {    
  86.  oSavedFile = new RandomAccessFile(sName,"rw");    
  87.  this.nPos = nPos;    
  88.  oSavedFile.seek(nPos);    
  89.  }    
  90.  public synchronized int write(byte[] b,int nStart,int nLen)    
  91.  {    
  92.  int n = -1;    
  93.  try{    
  94.  oSavedFile.write(b,nStart,nLen);    
  95.  n = nLen;    
  96.  }    
  97.  catch(IOException e)    
  98.  {    
  99.  e.printStackTrace ();    
  100.  }    
  101.  return n;    
  102.  }    
  103.  }    
  104.     
  105.  /*   
  106.  **SiteInfoBean.java   
  107.  */    
  108.  package NetFox;    
  109.  public class SiteInfoBean {    
  110.  private String sSiteURL; //Site's URL    
  111.  private String sFilePath; //Saved File's Path    
  112.  private String sFileName; //Saved File's Name    
  113.  private int nSplitter; //Count of Splited Downloading File    
  114.  public SiteInfoBean()    
  115.  {    
  116.  //default value of nSplitter is 5    
  117.  this("","","",5);    
  118.  }    
  119.  public SiteInfoBean(String sURL,String sPath,String sName,int nSpiltter)   
  120.  {    
  121.  sSiteURL= sURL;    
  122.  sFilePath = sPath;    
  123.  sFileName = sName;    
  124.  this.nSplitter = nSpiltter;    
  125.  }    
  126.  public String getSSiteURL()    
  127.  {    
  128.  return sSiteURL;    
  129.  }    
  130.  public void setSSiteURL(String value)    
  131.  {    
  132.  sSiteURL = value;    
  133.  }    
  134.  public String getSFilePath()    
  135.  {    
  136.  return sFilePath;    
  137.  }    
  138.  public void setSFilePath(String value)    
  139.  {    
  140.  sFilePath = value;    
  141.  }    
  142.  public String getSFileName()    
  143.  {    
  144.  return sFileName;    
  145.  }    
  146.  public void setSFileName(String value)    
  147.  {    
  148.  sFileName = value;    
  149.  }    
  150.  public int getNSplitter()    
  151.  {    
  152.  return nSplitter;    
  153.  }    
  154.  public void setNSplitter(int nCount)    
  155.  {    
  156.  nSplitter = nCount;    
  157.  }    
  158.  }    
  159.     
  160.  /*   
  161.  **Utility.java   
  162.  */    
  163.  package NetFox;    
  164.  public class Utility {    
  165.  public Utility()    
  166.  {    
  167.  }    
  168.  public static void sleep(int nSecond)    
  169.  {    
  170.  try{    
  171.  Thread.sleep(nSecond);    
  172.  }    
  173.  catch(Exception e)    
  174.  {    
  175.  e.printStackTrace ();    
  176.  }    
  177.  }    
  178.  public static void log(String sMsg)    
  179.  {    
  180.  System.err.println(sMsg);    
  181.  }    
  182.  public static void log(int sMsg)    
  183.  {    
  184.  System.err.println(sMsg);    
  185.  }    
  186.  }    
  187.     
  188.  /*   
  189.  **TestMethod.java   
  190.  */    
  191.  package NetFox;    
  192.  public class TestMethod {    
  193.  public TestMethod()    
  194.  { ///xx/weblogic60b2_win.exe    
  195.  try{    
  196.  SiteInfoBean bean = new SiteInfoBean("http://localhost/xx/weblogic60b2_win.exe",   
  197.      "L:\\temp","weblogic60b2_win.exe",5);    
  198.  //SiteInfoBean bean = new SiteInfoBean("http://localhost:8080/down.zip","L:\\temp",   
  199.      "weblogic60b2_win.exe",5);    
  200.  SiteFileFetch fileFetch = new SiteFileFetch(bean);    
  201.  fileFetch.start();    
  202.  }    
  203.  catch(Exception e){e.printStackTrace ();}    
  204.  }    
  205.  public static void main(String[] args)    
  206.  {    
  207.  new TestMethod();    
  208.  }    
  209.  }  

 

原文地址： http://www.ibm.com/developerworks/cn/java/joy-down/

我打算現在就弄一下，從下載SolarWind的UDT開始


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 HTTP斷點續傳 HTTP斷點續傳原理 http+斷點續傳 Android Http 與斷點續傳 用js 實現斷點續傳 (HTTP) 用JavaScript 實現斷點續傳 (HTTP) 用vue 實現斷點續傳 (HTTP) 用Java 實現斷點續傳 (HTTP) 用SpringBoot 實現斷點續傳 (HTTP) 用php 實現斷點續傳 (HTTP)
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM