Android多线程断点续传下载

最近项目里用到了断点续传下载，所以在博客里做个记录，便于以后回顾。

背景知识

依赖于Http/206响应

首先你需要知道文件大小以及远程服务器是否支持HTTP 206请求.使用curl命令可以查看任意资源的HTTP头,使用下面的curl命令可以发送一个HEAD请求

$ curl -I http://avatar.csdn.net/D/0/9/1_wz249863091.jpg
这张图是我在CSDN博客的头像

这里只看2个属性

Accept-Ranges: bytes - 该响应头表明服务器支持Range请求,以及服务器所支持的单位是字节(这也是唯一可用的单位).我们还能知道:服务器支持断点续传,以及支持同时下载文件的多个部分,也就是说下载工具可以利用范围请求加速下载该文件.Accept-Ranges: none 响应头表示服务器不支持范围请求.

Content-Length: 30220 - Content-Length响应头表明了响应实体的大小,也就是真实的图片文件的大小是30220字节 (30K).

正常情况下，我们不指定range属性的时候，默认值都是0-length,也就是全量下载，返回的code就是200
如果我们指定了range，那么返回的code就是206

代码实现

根据上面的背景知识，可以写一个工具类，便于整个项目使用

package com.example.tony.myapplication;

import android.os.Environment;
import android.text.TextUtils;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.RandomAccessFile;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;

/**
 * 断点续传工具类
 *
 * @author Tony.W
 */
public class DownloadUtil {
    private static final String RANGE = "Range";
    private static final String BYTE = "bytes=";
    private static final String TO = "-";
    private static final String RWS = "rws";
    private static final String SLASH = "/";
    private static final String UTF_8 = "utf-8";

    //Http协议--部分下载的状态码
    private static final int HTTP_PARTIAL_CODE = 206;
    //Htpp协议--下载成功的状态码
    private static final int HTPP_SUCCESS_CODE = 200;
    //Http超时时间
    private static final int TIME_OUT = 3000;
    //默认下载线程数
    private static final int DEFALUT_THREAD_COUNT = 3;

    /**
     * 断点续传下载
     *
     * @param path 资源路径
     * @param threadCount 下载线程数
     * */
    public static void down(String path, int threadCount){
        URL url = null;
        HttpURLConnection conn = null;
        RandomAccessFile raf = null;
        try {
            url = new URL(path);
            conn = (HttpURLConnection) url.openConnection();
            if (conn.getResponseCode() == HTPP_SUCCESS_CODE){
                //文件长度
                int fileLen = conn.getContentLength();
                //缓存文件名字
                String cacheFileName = path.substring(path.lastIndexOf(SLASH) + 1);
                File file = new File(Environment.getExternalStorageDirectory(), cacheFileName);
                raf = new RandomAccessFile(file, RWS);
                raf.setLength(fileLen);
                int partialLen = fileLen / threadCount;
                for(int i = 0;i<threadCount;i++){
                    new DownloadThread(url, i, partialLen, file);
                }
            }

        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(raf != null){
                try {
                    raf.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 断点续传下载，默认开启3个线程下载
     *
     * @param path 资源路径
     * */
    public static void down(String path){
        down(path, DEFALUT_THREAD_COUNT);
    }


    private static final class DownloadThread extends  Thread{
        //下载资源的url
        private URL url;
        //下载的线程Id
        private int threadId;
        //每个线程需要下载的长度
        private int particalLen;
        //缓存文件地址
        private File file;
        //是否暂停下载
        private boolean isPause = false;

        /**
         * 下载线程
         * */
        public DownloadThread(URL url, int threadId, int particalLen, File file){
            this.file = file;
            this.url = url;
            this.particalLen = particalLen;
            this.threadId = threadId;
        }

        /**
         * 从文件读取数据
         * */
        public static String readFromFile(File file) throws IOException {
            if (!file.exists() || file.isDirectory()) {
                return null;
            }
            BufferedReader br = new BufferedReader(new FileReader(file));
            String temp = null;
            StringBuffer sb = new StringBuffer();
            temp = br.readLine();
            while (temp != null) {
                sb.append(temp);
                temp = br.readLine();
            }
            return sb.toString();
        }

        /**
         * 向文件写入数据
         * */
        public static void writeToFile(File file, String data) throws IOException {
            if (!file.exists()) {
                file.createNewFile();
            }
            //重新写入，不是追加写入模式
            FileOutputStream out = new FileOutputStream(file, false);
            out.write(data.getBytes(UTF_8));
            out.close();
        }

        @Override
        public void run() {
            downTask();
        }

        private void downTask(){
            //缓存文件名字
            String cacheFileName = Environment.getExternalStorageDirectory() + url.getPath().substring(url.getPath().lastIndexOf(SLASH) + 1 + threadId);
            File cacheFile = new File(cacheFileName);
            //读取缓存文件，判断是否之前已经有下载部分
            float hasDownLen = 0;
            //下载开始位置
            int start = 0 + threadId * particalLen;
            //下载结束为止
            int end = (0 + threadId + 1) * particalLen -1;

            String data = null;
            try {
                data = readFromFile(cacheFile);
            } catch (IOException e) {
                e.printStackTrace();
            }

            if (!TextUtils.isEmpty(data)) {
                hasDownLen = Float.valueOf(data);
                start += hasDownLen;
            }

            HttpURLConnection conn = null;
            try {
                conn = (HttpURLConnection) url.openConnection();
            } catch (IOException e) {
                e.printStackTrace();
            }
            if(conn == null){
                return;
            }

            conn.setReadTimeout(TIME_OUT);
            //指定下载部分，如果超过服务器部分，以服务器为准
            conn.setRequestProperty(RANGE, BYTE + start + TO + end);
            RandomAccessFile raf = null;
            InputStream in = null;
            try {
                if (conn.getResponseCode() == HTTP_PARTIAL_CODE) {
                    raf = new RandomAccessFile(file, RWS);
                    raf.seek(start);
                    in = conn.getInputStream();
                    //分段下载，每段大小为1024个字节
                    byte[] buf = new byte[1024];
                    int len = 0;
                    //如果读到最后，就跳出循环
                    while ((len = in.read(buf)) != -1) {
                        //将下载的数据存到文件
                        raf.write(buf);
                        //记录下载长度
                        hasDownLen += len;
                        writeToFile(cacheFile, String.valueOf(hasDownLen));
                    }
                    //如果完成该部分下载，删除缓存文件
                    cacheFile.delete();
                }
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    if (raf != null) {
                        raf.close();
                    }
                    if (in != null) {
                        in.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

这里只实现了多线程断点续传功能，如果要结合UI，可以加入一个Handler。
但是需要主要，由于都是static的静态方法，如果处理Handler的时候需要格外小心，不要造成内存泄漏

另外可以观察DDMS，在下载的时候，会产生N+1个文件，N就是你开启线程的数量，当下载全部完成后，只会留下一个数据文件，其余临时缓存文件都会被删除

附件已经上传，有需要的朋友可以下载
http://download.csdn.net/detail/wz249863091/9566461
如果有什么问题，请留言或者私信，第一时间会做出合理修改