Android多線程下載單個文件和斷點續傳

實現要點：

（1）建立一個線程數組用於多個線程同時開工下載

（2）經過http鏈接獲取文件的大小信息，而後按照線程個數來分配各個線程下載的文件片斷

（3）經過http的Range頭來請求文件的片斷

（4）用一個map表來記錄每一個線程下載的信息，保存到sqlite數據庫裏面，用於斷點續傳的實現，當下載中斷，能夠從map表的位置開始下載

DBOpenHelper類：數據庫操做

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;

public class DBOpenHelper extends SQLiteOpenHelper {
    private static final String DBNAME = "eric.db";
    private static final int VERSION = 1;

    public DBOpenHelper(Context context) {
        super(context, DBNAME, null, VERSION);
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
        // 建立filedownlog表
        db.execSQL("CREATE TABLE IF NOT EXISTS filedownlog (id integer primary key autoincrement, downpath varchar(100), threadid INTEGER, downlength INTEGER)");
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        db.execSQL("DROP TABLE IF EXISTS filedownlog");
        onCreate(db);
    }
}

FileService類：從數據庫讀寫數據，封裝成爲map表操做

import java.util.HashMap;
import java.util.Map;

import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;

import com.scofield.oneeng.db.DBOpenHelper;


/**
 * 業務bean
 *
 */
public class FileService {
    private DBOpenHelper openHelper;

    public FileService(Context context) {
        openHelper = new DBOpenHelper(context);
    }

    /**
     * 獲取每條線程已經下載的文件長度
     *
     * @param path
     * @return
     */
    public Map<Integer, Integer> getData(String path) {
        SQLiteDatabase db = openHelper.getReadableDatabase();
        Cursor cursor = db
                .rawQuery(
                        "select threadid, downlength from filedownlog where downpath=?",
                        new String[] { path });
        Map<Integer, Integer> data = new HashMap<Integer, Integer>();
        while (cursor.moveToNext()) {
            data.put(cursor.getInt(0), cursor.getInt(1));
        }
        cursor.close();
        db.close();
        return data;
    }

    /**
     * 保存每條線程已經下載的文件長度
     *
     * @param path
     * @param map
     */
    public void save(String path, Map<Integer, Integer> map) {// int threadid,
        // int position
        SQLiteDatabase db = openHelper.getWritableDatabase();
        db.beginTransaction();
        try {
            for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
                db.execSQL(
                        "insert into filedownlog(downpath, threadid, downlength) values(?,?,?)",
                        new Object[] { path, entry.getKey(), entry.getValue() });
            }
            db.setTransactionSuccessful();
        } finally {
            db.endTransaction();
        }
        db.close();
    }

    /**
     * 實時更新每條線程已經下載的文件長度
     *
     * @param path
     * @param map
     */
    public void update(String path, int threadId, int pos) {
        SQLiteDatabase db = openHelper.getWritableDatabase();
        db.execSQL(
                "update filedownlog set downlength=? where downpath=? and threadid=?",
                new Object[] { pos, path, threadId });
        db.close();
    }

    /**
     * 當文件下載完成後，刪除對應的下載記錄
     *
     * @param path
     */
    public void delete(String path) {
        SQLiteDatabase db = openHelper.getWritableDatabase();
        db.execSQL("delete from filedownlog where downpath=?",
                new Object[] { path });
        db.close();
    }
}

 

DownloadThread類：下載線程類，根據下載的位置來下載文件，而且保存到臨時文件裏面

import java.io.File;
import java.io.InputStream;
import java.io.RandomAccessFile;
import java.net.HttpURLConnection;
import java.net.URL;

import android.util.Log;

public class DownloadThread extends Thread {
    private static final String TAG = "DownloadThread";
    private File saveFile;
    private URL downUrl;
    private int block;
    /* 下載開始位置 */
    private int threadId = -1;
    private int downLength;
    private boolean finish = false;
    private FileDownloader downloader;

    public DownloadThread(FileDownloader downloader, URL downUrl,
                          File saveFile, int block, int downLength, int threadId) {
        this.downUrl = downUrl;
        this.saveFile = saveFile;
        this.block = block;
        this.downloader = downloader;
        this.threadId = threadId;
        this.downLength = downLength;
    }

    @Override
    public void run() {
        if (downLength < block) {// 未下載完成
            try {
                HttpURLConnection http = (HttpURLConnection) downUrl.openConnection();
                http.setConnectTimeout(5 * 1000); // 設置鏈接超時
                http.setRequestMethod("GET"); // 設置請求方法，這裏是「GET」
                // 瀏覽器可接受的MIME類型
                http.setRequestProperty(
                        "Accept",
                        "image/gif, image/jpeg, image/pjpeg, image/pjpeg, application/x-shockwave-flash, application/xaml+xml, application/vnd.ms-xpsdocument, application/x-ms-xbap, application/x-ms-application, application/vnd.ms-excel, application/vnd.ms-powerpoint, application/msword, */*");
                http.setRequestProperty("Accept-Language", "zh-CN"); // 瀏覽器所但願的語言種類，當服務器可以提供一種以上的語言版本時要用到
                http.setRequestProperty("Referer", downUrl.toString());// 包含一個URL，用戶從該URL表明的頁面出發訪問當前請求的頁面。
                http.setRequestProperty("Charset", "UTF-8"); // 字符集
                int startPos = block * (threadId - 1) + downLength;// 開始位置
                int endPos = block * threadId - 1;// 結束位置
                http.setRequestProperty("Range", "bytes=" + startPos + "-"
                        + endPos);// 設置獲取實體數據的範圍
                // 瀏覽器類型，若是Servlet返回的內容與瀏覽器類型有關則該值很是有用。
                http.setRequestProperty(
                        "User-Agent",
                        "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.2; Trident/4.0; .NET CLR 1.1.4322; .NET CLR 2.0.50727; .NET CLR 3.0.04506.30; .NET CLR 3.0.4506.2152; .NET CLR 3.5.30729)");
                http.setRequestProperty("Connection", "Keep-Alive"); // 設置爲持久鏈接

                // 獲得輸入流
                InputStream inStream = http.getInputStream();
                byte[] buffer = new byte[1024];
                int offset = 0;
                print("Thread " + this.threadId
                        + " start download from position " + startPos);
                // 隨機訪問文件
                RandomAccessFile threadfile = new RandomAccessFile(
                        this.saveFile, "rwd");
                // 定位到pos位置
                threadfile.seek(startPos);
                while (!downloader.getExit()
                        && (offset = inStream.read(buffer, 0, 1024)) != -1) {
                    // 寫入文件
                    threadfile.write(buffer, 0, offset);
                    downLength += offset; // 累加下載的大小
                    downloader.update(this.threadId, downLength); // 更新指定線程下載最後的位置
                    downloader.append(offset); // 累加已下載大小
                }
                threadfile.close();
                inStream.close();
                print("Thread " + this.threadId + " download finish");
                this.finish = true;
            } catch (Exception e) {
                this.downLength = -1;
                print("Thread " + this.threadId + ":" + e);
            }
        }
    }

    private static void print(String msg) {
        Log.i(TAG, msg);
    }

    /**
     * 下載是否完成
     *
     * @return
     */
    public boolean isFinish() {
        return finish;
    }

    /**
     * 已經下載的內容大小
     *
     * @return 若是返回值爲-1,表明下載失敗
     */
    public long getDownLength() {
        return downLength;
    }
}

 

FileDownloader類：文件下載管理器，獲取文件大小，分配和啓動下載線程，監聽下載的結果

import java.io.File;
import java.io.RandomAccessFile;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import android.content.Context;
import android.util.Log;

/**
 * 文件下載器
 *
 */
public class FileDownloader {
    private static final String TAG = "FileDownloader";
    private Context context;
    private FileService fileService;
    /* 中止下載 */
    private boolean exit;
    /* 已下載文件長度 */
    private int downloadSize = 0;
    /* 原始文件長度 */
    private int fileSize = 0;
    /* 線程數 */
    private DownloadThread[] threads;
    /* 本地保存文件 */
    private File saveFile;
    /* 緩存各線程下載的長度 */
    private Map<Integer, Integer> data = new ConcurrentHashMap<Integer, Integer>();
    /* 每條線程下載的長度 */
    private int block;
    /* 下載路徑 */
    private String downloadUrl;

    /**
     * 獲取線程數
     */
    public int getThreadSize() {
        return threads.length;
    }

    /**
     * 退出下載
     */
    public void exit() {
        this.exit = true;
    }

    public boolean getExit() {
        return this.exit;
    }

    /**
     * 獲取文件大小
     *
     * @return
     */
    public int getFileSize() {
        return fileSize;
    }

    /**
     * 累計已下載大小
     *
     * @param size
     */
    protected synchronized void append(int size) {
        downloadSize += size;
    }

    /**
     * 更新指定線程最後下載的位置
     *
     * @param threadId
     *            線程id
     * @param pos
     *            最後下載的位置
     */
    protected synchronized void update(int threadId, int pos) {
        this.data.put(threadId, pos);
        this.fileService.update(this.downloadUrl, threadId, pos);
    }

    /**
     * 構建文件下載器
     *
     * @param downloadUrl
     *            下載路徑
     * @param fileSaveDir
     *            文件保存目錄
     * @param threadNum
     *            下載線程數
     */
    public FileDownloader(Context context, String downloadUrl,
                          File fileSaveDir, int threadNum) {
        try {
            this.context = context;
            this.downloadUrl = downloadUrl;
            fileService = new FileService(this.context);
            URL url = new URL(this.downloadUrl);
            if (!fileSaveDir.exists()) // 判斷目錄是否存在，若是不存在，建立目錄
                fileSaveDir.mkdirs();
            this.threads = new DownloadThread[threadNum];// 實例化線程數組
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setConnectTimeout(5 * 1000);
            conn.setRequestMethod("GET");
            conn.setRequestProperty(
                    "Accept",
                    "image/gif, image/jpeg, image/pjpeg, image/pjpeg, application/x-shockwave-flash, application/xaml+xml, application/vnd.ms-xpsdocument, application/x-ms-xbap, application/x-ms-application, application/vnd.ms-excel, application/vnd.ms-powerpoint, application/msword, */*");
            conn.setRequestProperty("Accept-Language", "zh-CN");
            conn.setRequestProperty("Referer", downloadUrl);
            conn.setRequestProperty("Charset", "UTF-8");
            conn.setRequestProperty(
                    "User-Agent",
                    "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.2; Trident/4.0; .NET CLR 1.1.4322; .NET CLR 2.0.50727; .NET CLR 3.0.04506.30; .NET CLR 3.0.4506.2152; .NET CLR 3.5.30729)");
            conn.setRequestProperty("Connection", "Keep-Alive");
            conn.connect(); // 鏈接
            printResponseHeader(conn);
            if (conn.getResponseCode() == 200) { // 響應成功
                              this.fileSize = conn.getContentLength();// 根據響應獲取文件大小
                if (this.fileSize <= 0)
                    throw new RuntimeException("Unkown file size ");

                String filename = getFileName(conn);// 獲取文件名稱
                this.saveFile = new File(fileSaveDir, filename);// 構建保存文件
                Map<Integer, Integer> logdata = fileService
                        .getData(downloadUrl);// 獲取下載記錄
                if (logdata.size() > 0) {// 若是存在下載記錄
                    for (Map.Entry<Integer, Integer> entry : logdata.entrySet())
                        data.put(entry.getKey(), entry.getValue());// 把各條線程已經下載的數據長度放入data中
                }
                if (this.data.size() == this.threads.length) {// 下面計算全部線程已經下載的數據總長度
                    for (int i = 0; i < this.threads.length; i++) {
                        this.downloadSize += this.data.get(i + 1);
                    }
                    print("已經下載的長度" + this.downloadSize);
                }
                // 計算每條線程下載的數據長度
                this.block = (this.fileSize % this.threads.length) == 0 ? this.fileSize
                        / this.threads.length
                        : this.fileSize / this.threads.length + 1;
            } else {
                throw new RuntimeException("server no response ");
            }
        } catch (Exception e) {
            print(e.toString());
            throw new RuntimeException("don't connection this url");
        }
    }

    /**
     * 獲取文件名
     */
    private String getFileName(HttpURLConnection conn) {
        String filename = this.downloadUrl.substring(this.downloadUrl
                .lastIndexOf('/') + 1);
        if (filename == null || "".equals(filename.trim())) {// 若是獲取不到文件名稱
            for (int i = 0;; i++) {
                String mine = conn.getHeaderField(i);
                if (mine == null)
                    break;
                if ("content-disposition".equals(conn.getHeaderFieldKey(i)
                        .toLowerCase())) {
                    Matcher m = Pattern.compile(".*filename=(.*)").matcher(
                            mine.toLowerCase());
                    if (m.find())
                        return m.group(1);
                }
            }
            filename = UUID.randomUUID() + ".tmp";// 默認取一個文件名
        }
        return filename;
    }

    /**
     * 開始下載文件
     *
     * @param listener
     *            監聽下載數量的變化,若是不須要了解實時下載的數量,能夠設置爲null
     * @return 已下載文件大小
     * @throws Exception
     */
    public int download(DownloadProgressListener listener) throws Exception {
        try {
            RandomAccessFile randOut = new RandomAccessFile(this.saveFile, "rw");
            if (this.fileSize > 0)
                randOut.setLength(this.fileSize); // 預分配fileSize大小
            randOut.close();
            URL url = new URL(this.downloadUrl);
            if (this.data.size() != this.threads.length) {// 若是原先不曾下載或者原先的下載線程數與如今的線程數不一致
                this.data.clear();
                for (int i = 0; i < this.threads.length; i++) {
                    this.data.put(i + 1, 0);// 初始化每條線程已經下載的數據長度爲0
                }
                this.downloadSize = 0;
            }
            for (int i = 0; i < this.threads.length; i++) {// 開啓線程進行下載
                int downLength = this.data.get(i + 1);
                if (downLength < this.block
                        && this.downloadSize < this.fileSize) {// 判斷線程是否已經完成下載,不然繼續下載
                    this.threads[i] = new DownloadThread(this, url,
                            this.saveFile, this.block, this.data.get(i + 1),
                            i + 1);
                    this.threads[i].setPriority(7); // 設置線程優先級
                    this.threads[i].start();
                } else {
                    this.threads[i] = null;
                }
            }
            fileService.delete(this.downloadUrl);// 若是存在下載記錄，刪除它們，而後從新添加
            fileService.save(this.downloadUrl, this.data);
            boolean notFinish = true;// 下載未完成
            while (notFinish) {// 循環判斷全部線程是否完成下載
                Thread.sleep(900);
                notFinish = false;// 假定所有線程下載完成
                for (int i = 0; i < this.threads.length; i++) {
                    if (this.threads[i] != null && !this.threads[i].isFinish()) {// 若是發現線程未完成下載
                        notFinish = true;// 設置標誌爲下載沒有完成
                        if (this.threads[i].getDownLength() == -1) {// 若是下載失敗,再從新下載
                            this.threads[i] = new DownloadThread(this, url,
                                    this.saveFile, this.block,
                                    this.data.get(i + 1), i + 1);
                            this.threads[i].setPriority(7);
                            this.threads[i].start();
                        }
                    }
                }
                if (listener != null)
                    listener.onDownloadSize(this.downloadSize);// 通知目前已經下載完成的數據長度
            }
            if (downloadSize == this.fileSize)
                fileService.delete(this.downloadUrl);// 下載完成刪除記錄
        } catch (Exception e) {
            print(e.toString());
            throw new Exception("file download error");
        }
        return this.downloadSize;
    }

    /**
     * 獲取Http響應頭字段
     *
     * @param http
     * @return
     */
    public static Map<String, String> getHttpResponseHeader(
            HttpURLConnection http) {
        Map<String, String> header = new LinkedHashMap<String, String>();
        for (int i = 0;; i++) {
            String mine = http.getHeaderField(i);
            if (mine == null)
                break;
            header.put(http.getHeaderFieldKey(i), mine);
        }
        return header;
    }

    /**
     * 打印Http頭字段
     *
     * @param http
     */
    public static void printResponseHeader(HttpURLConnection http) {
        Map<String, String> header = getHttpResponseHeader(http);
        for (Map.Entry<String, String> entry : header.entrySet()) {
            String key = entry.getKey() != null ? entry.getKey() + ":" : "";
            print(key + entry.getValue());
        }
    }

    private static void print(String msg) {
        Log.i(TAG, msg);
    }
}