Java實現(xiàn)http中的文件下載斷點續(xù)傳

實現(xiàn)思路：

1尉咕、創(chuàng)建一個下載任務類SiteInfoBean（用于記錄文件保存的目錄重罪，文件下載URL风宁，文件名)

2腐碱、創(chuàng)建一個FileAccessI 用于隨機訪問文件誊垢，向文件寫入內(nèi)容。

3喻杈、創(chuàng)建一個下載任務執(zhí)行線程SiteFileFetch彤枢，此線程主要做如下工作

接受指定下載子線程個數(shù)

首先判斷下載的文件是否存在，

如果下載的文件已經(jīng)存在筒饰，則繼續(xù)判斷它對應的xxx.info文件是否存在缴啡，

如果info文件存在則認為是上次下載沒有完成。此時讀取info文件中的下載信息瓷们，分配下載區(qū)段业栅。

如果info文件不存在，則認為已經(jīng)下載完了谬晕，重新命名一個文件xxx(1)碘裕，如果重新命名的文件也存在則繼續(xù)累加命名xxx(2)…

判斷臨時文件xxx.info文件（用于保存文件下載信息：下載子線程個數(shù)，子線程1開始位置,子線程1結束位置,子線程2開始位置,子線程2結束位置,…)

是否存在攒钳，存在則說明是上次沒有下載完成帮孔，不存在則創(chuàng)建此臨時info文件記錄下載信息。

獲取文件總長度不撑，根據(jù)子線程個數(shù)將長度劃分若干等分

創(chuàng)建若干子線程文兢，為每個子線程分配下載區(qū)段(文件開始位置,文件結束位置)，啟動子線程

每隔500ms從各個子線程獲取當前下載的進度位置焕檬，然后覆蓋保存在xxx.info文件中姆坚。

每隔500ms同時判斷是否存在沒有下載完分配區(qū)段內(nèi)容的子線程，如果存在則認為整個下載任務是沒有完成的实愚，如果不存在則認為總的已經(jīng)下載完成兼呵。

每隔500ms同時統(tǒng)計出總的下載進度兔辅，當進度達到100%的時候，刪除臨時文件xx.info文件

4击喂、下載子線程FileSplitterFetch 此線程主要做的就是根據(jù)任務線程SiteFileFetch劃分的下載區(qū)段進行下載

此子線程主要通過FileAccessI 向同一個文件寫入內(nèi)容（多個線程向同一個文件寫入內(nèi)容维苔，寫入的內(nèi)容都是事先指定的區(qū)段）

斷點續(xù)傳的原理很簡單，就是在Http的請求上和一般的下載有所不同而已懂昂。

打個比方蕉鸳，瀏覽器請求服務器上的一個文時，所發(fā)出的請求如下：

假設服務器域名為www.sjtu.edu.cn文件名為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

所謂斷點續(xù)傳，也就是要從文件已經(jīng)下載的地方開始繼續(xù)下載原探。所以在客戶端瀏覽器傳給 Web服務器的時候要多加一條信息–從哪里開始乱凿。

下面是用自己編的一個"瀏覽器"來傳遞請求信息給Web服務器，要求從2000070字節(jié)開始咽弦。

GET /down.zip HTTP/1.0 User-Agent: NetFox RANGE: bytes=2000070- Accept: text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2

仔細看一下就會發(fā)現(xiàn)多了一行RANGE: bytes=2000070-

這一行的意思就是告訴服務器down.zip這個文件從2000070字節(jié)開始傳徒蟆，前面的字節(jié)不用傳了。

服務器收到這個請求以后型型，返回的信息如下：

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

和前面服務器返回的信息比較一下段审，就會發(fā)現(xiàn)增加了一行：
Content-Range=bytes 2000070-106786027/106786028
返回的代碼也改為206了，而不再是200了闹蒜。

知道了以上原理寺枉，就可以進行斷點續(xù)傳的編程了。

Java實現(xiàn)斷點續(xù)傳的關鍵幾點

1绷落、用什么方法實現(xiàn)提交RANGE: bytes=2000070-姥闪。

當然用最原始的Socket是肯定能完成的，不過那樣太費事了砌烁，其實Java的net包中提供了這種功能筐喳。代碼如下：

URL url = new URL("http://www.sjtu.edu.cn/down.zip"); HttpURLConnection httpConnection = (HttpURLConnection)url.openConnection();
//設置User-Agent
httpConnection.setRequestProperty("User-Agent","NetFox");
//設置斷點續(xù)傳的開始位置
httpConnection.setRequestProperty("RANGE","bytes=2000070");
//獲得輸入流
InputStream input = httpConnection.getInputStream();

從輸入流中取出的字節(jié)流就是down.zip文件從2000070開始的字節(jié)流。大家看函喉，其實斷點續(xù)傳用Java實現(xiàn)起來還是很簡單的吧避归。接下來要做的事就是怎么保存獲得的流到文件中去了。

2函似、保存文件采用的方法槐脏。

我采用的是IO包中的RandAccessFile類喉童。

操作相當簡單撇寞，假設從2000070處開始保存文件顿天，代碼如下：

RandomAccess oSavedFile = new RandomAccessFile("down.zip","rw"); long nPos = 2000070; //定位文件指針到nPos位置 oSavedFile.seek(nPos); byte[] b = new byte[1024]; int nRead; //從輸入流中讀入字節(jié)流，然后寫到文件中 while((nRead=input.read(b,0,1024)) > 0) { oSavedFile.write(b,0,nRead); }

怎么樣蔑担，也很簡單吧牌废。接下來要做的就是整合成一個完整的程序了。包括一系列的線程控制等等啤握。

具體源碼如下：

SiteInfoBean.java

package com.scoket.io.BreakpointUpLoad;
/**
 * @author riemann
 * @date 2019/04/24 23:21
 */
public class SiteInfoBean {

    /**
     * 文件URL資源
     */
    private String sSiteURL; // Site's URL

    /**
     * 文件保存的路徑(不包含文件名)
     */
    private String sFilePath; // Saved File's Path

    /**
     * 文件名
     */
    private String sFileName; // Saved File's Name

    /** 下載線程個數(shù) */
    private int nSplitter;

    public SiteInfoBean()
    {
        // default value of nSplitter is 5
        this("", "", "", 5);
    }

    /**
     *
     * @param sURL 文件資源URL
     * @param sPath 文件保存的路徑(不包含文件名)
     * @param sName 文件名
     * @param nSpiltter 下載線程個數(shù)
     */
    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;
    }

    /**
     * 獲取文件保存的路徑
     * @return
     */
    public String getSFilePath()
    {
        return sFilePath;
    }

    public void setSFilePath(String value)
    {
        sFilePath = value;
    }

    /**
     * 獲取文件名
     * @return
     */
    public String getSFileName()
    {
        return sFileName;
    }

    public void setSFileName(String value)
    {
        sFileName = value;
    }

    /**
     * 分割成的子文件個數(shù)
     * @return
     */
    public int getNSplitter()
    {
        return nSplitter;
    }

    public void setNSplitter(int nCount)
    {
        nSplitter = nCount;
    }
}

FileAccessI.java

package com.scoket.io.BreakpointUpLoad;

import java.io.IOException;
import java.io.RandomAccessFile;
import java.io.Serializable;

/**
 * @author riemann
 * @date 2019/04/24 23:22
 */
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;
    }
}

SiteFileFetch.java

package com.scoket.io.BreakpointUpLoad;

import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;

/**
 * @author riemann
 * @date 2019/04/24 23:23
 */
public class SiteFileFetch extends Thread{

    /** 文件信息 Bean */
    SiteInfoBean siteInfoBean = null;

    /** 文件指針開始位置數(shù)組 */
    long[] nStartPos;

    /** 文件指針結束位置數(shù)組 */
    long[] nEndPos;

    /** 子下載線程數(shù)組 */
    FileSplitterFetch[] fileSplitterFetch;

    /** 文件長度 (字節(jié)byte) */
    long nFileLength;

    /** 是否第一次取文件 */
    boolean bFirst = true;

    /** 停止標志 */
    boolean bStop = false;

    /**
     * 臨時文件用于記錄文件下載信息(下載線程個數(shù),每個下載線程的當前文件開始指針,文件結束指針)
     */
    private File tmpFile;

    // 輸出到文件的輸出流
    DataOutputStream output;

    private boolean isLoading;

    public SiteFileFetch(SiteInfoBean bean) throws IOException
    {
        siteInfoBean = bean;

        isLoading = true;

        adjustFileNameForDuplicate(bean);

        tmpFile = new File(bean.getSFilePath() + File.separator
                + bean.getSFileName() + ".info");

        if (tmpFile.exists())
        {
            // 臨時文件存在,則認為不是第一次下載,之前有下載過,但是沒下載完成(斷點續(xù)傳下載)
            bFirst = false;

            read_nPos();
        }
        else
        {
            // 文件指針開始位置數(shù)組個數(shù)取決于文件被分割成子文件的個數(shù)
            nStartPos = new long[bean.getNSplitter()];
            nEndPos = new long[bean.getNSplitter()];
        }
    }



    /**
     * 文件名重復則重新命名
     *
     * @param bean
     */
    private void adjustFileNameForDuplicate(SiteInfoBean bean)
    {
        if (bean != null && bean.getSFileName() != null
                && bean.getSFilePath() != null)
        {
            File file = new File(bean.getSFilePath() + File.separator
                    + bean.getSFileName());

            int lastDotIdx = bean.getSFileName().lastIndexOf(".");

            String prefix = bean.getSFileName().substring(0, lastDotIdx);

            String suffix = bean.getSFileName().substring(lastDotIdx + 1);

            int count = 1;

            while (file.exists())
            {

                File loadInfoFile = new File(bean.getSFilePath() + File.separator
                        + bean.getSFileName() + ".info");

                if (loadInfoFile.exists())
                {//如果臨時文件存在,則認為是上次沒有下載完成的,這是不用重新命名
                    break;
                }

                String newPrefix = prefix + "(" + count + ")";

                bean.setSFileName(newPrefix + "." + suffix);

                file = new File(bean.getSFilePath() + File.separator
                        + bean.getSFileName());
                count++;
            }
        }
    }

    /**
     * (1) 獲得文件長度 <br>
     * (2) 分割文件<br>
     * (3) 創(chuàng)建文件下載線程 FileSplitterFetch<br>
     * (4) 啟動文件下載線程 FileSplitterFetch 線程<br>
     * (5) 等待子線程返回
     */
    public void run()
    {
        try
        {
            nFileLength = getFileSize();

            if (nFileLength == -1)
            {
                isLoading = false;
                bStop = true;
                System.err.println("File Length is not known!");
                return;
            }
            else if (nFileLength == -2)
            {
                isLoading = false;
                bStop = true;
                System.err.println("File is not access!");

                return;
            }

            if (bFirst)
            {// 如果是第一次下載
                // 分配文件指針數(shù)組的起始結束位置
                for (int i = 0; i < nStartPos.length; i++)
                {
                    nStartPos[i] = (long) (i * (nFileLength / nStartPos.length));
                }

                for (int i = 0; i < nEndPos.length - 1; i++)
                {
                    nEndPos[i] = nStartPos[i + 1];
                }

                nEndPos[nEndPos.length - 1] = nFileLength;
            }

            // 創(chuàng)建 啟動子線程數(shù)組
            fileSplitterFetch = new FileSplitterFetch[nStartPos.length];

            for (int i = 0; i < nStartPos.length; i++)
            {
                fileSplitterFetch[i] = new FileSplitterFetch(
                        siteInfoBean.getSSiteURL(), siteInfoBean.getSFilePath()
                        + File.separator + siteInfoBean.getSFileName(),
                        nStartPos[i], nEndPos[i], i);

                Utility.log("Thread " + i + " , nStartPos = " + nStartPos[i]
                        + ", nEndPos = " + nEndPos[i]);

                //啟動子線程
                fileSplitterFetch[i].start();
            }

            boolean breakWhile = false;

            while (!bStop)
            {// 如果下載沒有停止,則每隔500ms去保存一次文件指針信息到臨時文件

                write_nPos();

                gatherLoadProgress();

                Utility.sleep(500);

                breakWhile = true;

                for (int i = 0; i < nStartPos.length; i++)
                {
                    if (!fileSplitterFetch[i].bDownOver)
                    {// 只要其中有一個沒下載完成,
                        breakWhile = false;
                        break;
                    }
                }

                if (breakWhile)
                {
                    break;
                }
            }

            gatherLoadProgress();

            System.err.println("文件下載結束鸟缕！");

            isLoading = false;
        }
        catch (Exception e)
        {
            isLoading = false;
            e.printStackTrace();
        }
    }

    /**
     * 獲得文件長度
     *
     * @return
     */
    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++)
            {
                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 gatherLoadProgress()
    {
        // 剩余的字節(jié)數(shù)
        long laveLength = 0;

        for (int i = 0; i < nStartPos.length; i++)
        {
            laveLength += (fileSplitterFetch[i].nEndPos - fileSplitterFetch[i].nStartPos);
        }

        int percent = (int) ((nFileLength - laveLength) * 100 / nFileLength);

        if(percent == 100)
        {
            if(tmpFile != null && tmpFile.exists())
            {
                //全部下載完成,則刪除臨時文件,
                tmpFile.delete();
            }

            isLoading = false;

            bStop = true;
        }

        System.out.println("當前下載進度 " + percent + "%");
    }

    /**
     * 保存下載信息（文件指針位置）
     */
    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(fileSplitterFetch[i].nStartPos);
                output.writeLong(fileSplitterFetch[i].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));

            // 個數(shù)(這里記錄了文件被劃分成幾個子文件(子任務))
            int nCount = input.readInt();

            nStartPos = new long[nCount];
            nEndPos = new long[nCount];

            for (int i = 0; i < nStartPos.length; i++)
            {
                nStartPos[i] = input.readLong();
                nEndPos[i] = 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 boolean isLoading()
    {
        return isLoading;
    }

    /**
     * 停止文件下載
     */
    public void siteStop()
    {
        bStop = true;

        isLoading = false;

        for (int i = 0; i < nStartPos.length; i++)
        {
            fileSplitterFetch[i].splitterStop();
        }
    }

    public interface LoadProgressListener
    {
        void onstartLoad();
        void onProgressUpdate(int percent);
        void onCompleteLoad();
        void onStopLoad();
    }
    
}

FileSplitterFetch.java

package com.scoket.io.BreakpointUpLoad;

import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;

/**
 * @author riemann
 * @date 2019/04/24 23:24
 */
public class FileSplitterFetch extends Thread {
    
    String sURL; // File URL
    long nStartPos; // File Snippet Start Position
    long nEndPos; // File Snippet End Position
    int nThreadID; // Thread's ID
    boolean bDownOver = false; // Downing is over
    boolean bStop = false; // Stop identical
    FileAccessI fileAccessI = null; // File Access interface

    /**
     *
     * @param sURL 文件資源URL
     * @param sName 要保存的文件名(完整路徑,絕對路徑)
     * @param nStart 文件指針開始位置
     * @param nEnd 文件指針結束位置
     * @param id 線程ID
     * @throws IOException
     */
    public FileSplitterFetch(String sURL, String sName, long nStart, long nEnd,
                             int id) throws IOException, 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();

                byte[] b = new byte[1024];

                int nRead;

                while ((nRead = input.read(b, 0, 1024)) > 0
                        && nStartPos < nEndPos && !bStop)
                {
                    //注意這里不用再判斷 nRead+nStartPos<nEndPos,只需要 nStartPos<nEndPos就可以,
                    //因為是前面幾個下載線程讀取的內(nèi)容超出了nEndPos,也會被它后面的子線程讀取內(nèi)容覆蓋掉,
                    //最后一個子下載子線程最后讀取到的字節(jié)個數(shù)小于1024的,所以總的結束位置不超過就可以
                    nStartPos += fileAccessI.write(b, 0, nRead);
                }

                Utility.log("Thread " + nThreadID + " is over!"+",nStartPos="+nStartPos+",nEndPos="+nEndPos);

                bDownOver = true;
            }
            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;
    }

}

Utility.java

package com.scoket.io.BreakpointUpLoad;

/**
 * @author riemann
 * @date 2019/04/24 23:26
 */
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 com.scoket.io.BreakpointUpLoad;

/**
 * @author riemann
 * @date 2019/04/24 23:26
 */
public class TestMethod {
    public TestMethod()
    {
        try
        {
            SiteInfoBean bean = new SiteInfoBean(
                    "http://banzou.cdn.aliyun.com/apk/changba_6093.apk",
                    "E:\\Test", "changba_6093.apk", 3);

            SiteFileFetch fileFetch = new SiteFileFetch(bean);
            fileFetch.start();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }

    public static void main(String[] args)
    {
        new TestMethod();
    }
}

原文鏈接：

https://blog.csdn.net/riemann_/article/details/89484471