首页 › 程序设计 › java

okhttp下载文件断点续传(转)实测有用

寻找躲雨人 / 文 发表于2017-09-07 18:38 次阅读

时下,得力于谷歌官方强烈推荐,加上自身优秀特性,OkHttp成了当前最火的HTTP框架之一。现在公司的项目我也全都换成了基于OkHttp+Gson底层网络访问和解析平台。

        最近项目需要使用到断点下载功能,笔者比较喜欢折腾,想方设法抛弃SharedPreferences,尤其是sqlite作记录辅助,改用临时记录文件的形式记录下载进度,本文以断点下载为例。先看看demo运行效果图:

     


        断点续传:记录上次上传(下载)节点位置,下次接着该位置继续上传(下载)。多线程断点续传下载则是根据目标下载文件长度,尽可能地等分给多个线程同时下载文件块,当各个线程全部完成下载后,将文件块合并成一个文件,即目标文件。多线程断点续传不仅为用户避免了断网等突发事故需要重新下载浪费流量的尴尬局面,也大大提高了下载速率,当然,不是线程越多越好,网络带宽才是硬道理!以下为原理图:


    


          java,android中可以使用RandomAccessFile类生成一个同目标文件大小的占位文件,以便于各个线程可以同时操作该文件,并写入各线程实时下载的数据。

          下面贴出OkHttp实现的单个多线程下载任务类的DownloadTask.java文件:

[java] view plain copy

  1. package cn.icheny.download;  

  2.   

  3. import android.os.Handler;  

  4. import android.os.Message;  

  5. import java.io.Closeable;  

  6. import java.io.File;  

  7. import java.io.IOException;  

  8. import java.io.InputStream;  

  9. import java.io.RandomAccessFile;  

  10. import okhttp3.Call;  

  11. import okhttp3.Response;  

  12.   

  13. /** 

  14.  * 多线程下载任务 

  15.  * Created by Cheny on 2017/05/03. 

  16.  */  

  17.   

  18. public class DownloadTask extends Handler {  

  19.   

  20.     private final int THREAD_COUNT = 4;//下载线程数量  

  21.     private FilePoint mPoint;  

  22.     private long mFileLength;//文件大小  

  23.   

  24.     private boolean isDownloading = false;//是否正在下载  

  25.     private int childCanleCount;//子线程取消数量  

  26.     private int childPauseCount;//子线程暂停数量  

  27.     private int childFinishCount;//子线程完成下载数量  

  28.     private HttpUtil mHttpUtil;//http网络通信工具  

  29.     private long[] mProgress;//各个子线程下载进度集合  

  30.     private File[] mCacheFiles;//各个子线程下载缓存数据文件  

  31.     private File mTmpFile;//临时占位文件  

  32.     private boolean pause;//是否暂停  

  33.     private boolean cancel;//是否取消下载  

  34.   

  35.     private final int MSG_PROGRESS = 1;//进度  

  36.     private final int MSG_FINISH = 2;//完成下载  

  37.     private final int MSG_PAUSE = 3;//暂停  

  38.     private final int MSG_CANCEL = 4;//暂停  

  39.     private DownloadListner mListner;//下载回调监听  

  40.   

  41.     DownloadTask(FilePoint point, DownloadListner l) {  

  42.         this.mPoint = point;  

  43.         this.mListner = l;  

  44.         this.mProgress = new long[THREAD_COUNT];  

  45.         this.mCacheFiles = new File[THREAD_COUNT];  

  46.         this.mHttpUtil = HttpUtil.getInstance();  

  47.     }  

  48.   

  49.     /** 

  50.      * 开始下载 

  51.      */  

  52.     public synchronized void start() {  

  53.         try {  

  54.             if (isDownloading) return;  

  55.             isDownloading = true;  

  56.             mHttpUtil.getContentLength(mPoint.getUrl(), new okhttp3.Callback() {  

  57.                 @Override  

  58.                 public void onResponse(Call call, Response response) throws IOException {  

  59.                     if (response.code() != 200) {  

  60.                         close(response.body());  

  61.                         resetStutus();  

  62.                         return;  

  63.                     }  

  64.                     // 获取资源大小  

  65.                     mFileLength = response.body().contentLength();  

  66.                     close(response.body());  

  67.                     // 在本地创建一个与资源同样大小的文件来占位  

  68.                     mTmpFile = new File(mPoint.getFilePath(), mPoint.getFileName() + ".tmp");  

  69.                     if (!mTmpFile.getParentFile().exists()) mTmpFile.getParentFile().mkdirs();  

  70.                     RandomAccessFile tmpAccessFile = new RandomAccessFile(mTmpFile, "rw");  

  71.                     tmpAccessFile.setLength(mFileLength);  

  72.                     /*将下载任务分配给每个线程*/  

  73.                     long blockSize = mFileLength / THREAD_COUNT;// 计算每个线程理论上下载的数量.  

  74.   

  75.                     /*为每个线程配置并分配任务*/  

  76.                     for (int threadId = 0; threadId < THREAD_COUNT; threadId++) {  

  77.                         long startIndex = threadId * blockSize; // 线程开始下载的位置  

  78.                         long endIndex = (threadId + 1) * blockSize - 1// 线程结束下载的位置  

  79.                         if (threadId == (THREAD_COUNT - 1)) { // 如果是最后一个线程,将剩下的文件全部交给这个线程完成  

  80.                             endIndex = mFileLength - 1;  

  81.                         }  

  82.                         download(startIndex, endIndex, threadId);// 开启线程下载  

  83.                     }  

  84.                 }  

  85.   

  86.                 @Override  

  87.                 public void onFailure(Call call, IOException e) {  

  88.                     resetStutus();  

  89.                 }  

  90.             });  

  91.         } catch (IOException e) {  

  92.             e.printStackTrace();  

  93.             resetStutus();  

  94.         }  

  95.     }  

  96.   

  97.     /** 

  98.      * 下载 

  99.      * @param startIndex 下载起始位置 

  100.      * @param endIndex  下载结束位置 

  101.      * @param threadId 线程id 

  102.      * @throws IOException 

  103.      */  

  104.     public void download(final long startIndex, final long endIndex, final int threadId) throws IOException {  

  105.         long newStartIndex = startIndex;  

  106.         // 分段请求网络连接,分段将文件保存到本地.  

  107.         // 加载下载位置缓存数据文件  

  108.         final File cacheFile = new File(mPoint.getFilePath(), "thread" + threadId + "_" + mPoint.getFileName() + ".cache");  

  109.         mCacheFiles[threadId] = cacheFile;  

  110.         final RandomAccessFile cacheAccessFile = new RandomAccessFile(cacheFile, "rwd");  

  111.         if (cacheFile.exists()) {// 如果文件存在  

  112.             String startIndexStr = cacheAccessFile.readLine();  

  113.             try {  

  114.                 newStartIndex = Integer.parseInt(startIndexStr);//重新设置下载起点  

  115.             } catch (NumberFormatException e) {  

  116.                 e.printStackTrace();  

  117.             }  

  118.         }  

  119.         final long finalStartIndex = newStartIndex;  

  120.         mHttpUtil.downloadFileByRange(mPoint.getUrl(), finalStartIndex, endIndex, new okhttp3.Callback() {  

  121.             @Override  

  122.             public void onResponse(Call call, Response response) throws IOException {  

  123.                 if (response.code() != 206) {// 206:请求部分资源成功码,表示服务器支持断点续传  

  124.                     resetStutus();  

  125.                     return;  

  126.                 }  

  127.                 InputStream is = response.body().byteStream();// 获取流  

  128.                 RandomAccessFile tmpAccessFile = new RandomAccessFile(mTmpFile, "rw");// 获取前面已创建的文件.  

  129.                 tmpAccessFile.seek(finalStartIndex);// 文件写入的开始位置.  

  130.                   /*  将网络流中的文件写入本地*/  

  131.                 byte[] buffer = new byte[1024 << 2];  

  132.                 int length = -1;  

  133.                 int total = 0;// 记录本次下载文件的大小  

  134.                 long progress = 0;  

  135.                 while ((length = is.read(buffer)) > 0) {//读取流  

  136.                     if (cancel) {  

  137.                         close(cacheAccessFile, is, response.body());//关闭资源  

  138.                         cleanFile(cacheFile);//删除对应缓存文件  

  139.                         sendMessage(MSG_CANCEL);  

  140.                         return;  

  141.                     }  

  142.                     if (pause) {  

  143.                         //关闭资源  

  144.                         close(cacheAccessFile, is, response.body());  

  145.                         //发送暂停消息  

  146.                         sendMessage(MSG_PAUSE);  

  147.                         return;  

  148.                     }  

  149.                     tmpAccessFile.write(buffer, 0, length);  

  150.                     total += length;  

  151.                     progress = finalStartIndex + total;  

  152.   

  153.                     //将该线程最新完成下载的位置记录并保存到缓存数据文件中  

  154.                     //建议转成Base64码,防止数据被修改,导致下载文件出错(若真有这样的情况,这样的朋友可真是无聊透顶啊)  

  155.                     cacheAccessFile.seek(0);  

  156.                     cacheAccessFile.write((progress + "").getBytes("UTF-8"));  

  157.                     //发送进度消息  

  158.                     mProgress[threadId] = progress - startIndex;  

  159.                     sendMessage(MSG_PROGRESS);  

  160.                 }  

  161.                 //关闭资源  

  162.                 close(cacheAccessFile, is, response.body());  

  163.                 // 删除临时文件  

  164.                 cleanFile(cacheFile);  

  165.                 //发送完成消息  

  166.                 sendMessage(MSG_FINISH);  

  167.             }  

  168.   

  169.             @Override  

  170.             public void onFailure(Call call, IOException e) {  

  171.                 isDownloading = false;  

  172.             }  

  173.         });  

  174.     }  

  175.     /** 

  176.      * 轮回消息回调 

  177.      * 

  178.      * @param msg 

  179.      */  

  180.     @Override  

  181.     public void handleMessage(Message msg) {  

  182.         super.handleMessage(msg);  

  183.         if (null == mListner) {  

  184.             return;  

  185.         }  

  186.         switch (msg.what) {  

  187.             case MSG_PROGRESS://进度  

  188.                 long progress = 0;  

  189.                 for (int i = 0, length = mProgress.length; i < length; i++) {  

  190.                     progress += mProgress[i];  

  191.                 }  

  192.                 mListner.onProgress(progress * 1.0f / mFileLength);  

  193.                 break;  

  194.             case MSG_PAUSE://暂停  

  195.                 childPauseCount++;  

  196.                 if (childPauseCount % THREAD_COUNT != 0return;//等待所有的线程完成暂停,真正意义的暂停,以下同理  

  197.                 resetStutus();  

  198.                 mListner.onPause();  

  199.                 break;  

  200.             case MSG_FINISH://完成  

  201.                 childFinishCount++;  

  202.                 if (childFinishCount % THREAD_COUNT != 0return;  

  203.                 mTmpFile.renameTo(new File(mPoint.getFilePath(), mPoint.getFileName()));//下载完毕后,重命名目标文件名  

  204.                 resetStutus();  

  205.                 mListner.onFinished();  

  206.                 break;  

  207.             case MSG_CANCEL://取消  

  208.                 childCanleCount++;  

  209.                 if (childCanleCount % THREAD_COUNT != 0return;  

  210.                 resetStutus();  

  211.                 mProgress = new long[THREAD_COUNT];  

  212.                 mListner.onCancel();  

  213.                 break;  

  214.         }  

  215.     }  

  216.   

  217.     /** 

  218.      * 发送消息到轮回器 

  219.      * 

  220.      * @param what 

  221.      */  

  222.     private void sendMessage(int what) {  

  223.         //发送暂停消息  

  224.         Message message = new Message();  

  225.         message.what = what;  

  226.         sendMessage(message);  

  227.     }  

  228.   

  229.   

  230.     /** 

  231.      * 关闭资源 

  232.      * 

  233.      * @param closeables 

  234.      */  

  235.     private void close(Closeable... closeables) {  

  236.         int length = closeables.length;  

  237.         try {  

  238.             for (int i = 0; i < length; i++) {  

  239.                 Closeable closeable = closeables[i];  

  240.                 if (null != closeable)  

  241.                     closeables[i].close();  

  242.             }  

  243.         } catch (IOException e) {  

  244.             e.printStackTrace();  

  245.         } finally {  

  246.             for (int i = 0; i < length; i++) {  

  247.                 closeables[i] = null;  

  248.             }  

  249.         }  

  250.     }  

  251.   

  252.     /** 

  253.      * 暂停 

  254.      */  

  255.     public void pause() {  

  256.         pause = true;  

  257.     }  

  258.   

  259.     /** 

  260.      * 取消 

  261.      */  

  262.     public void cancel() {  

  263.         cancel = true;  

  264.         cleanFile(mTmpFile);  

  265.         if (!isDownloading) {//针对非下载状态的取消,如暂停  

  266.             if (null != mListner) {  

  267.                 cleanFile(mCacheFiles);  

  268.                 resetStutus();  

  269.                 mListner.onCancel();  

  270.             }  

  271.         }  

  272.     }  

  273.   

  274.     /** 

  275.      * 重置下载状态 

  276.      */  

  277.     private void resetStutus() {  

  278.         pause = false;  

  279.         cancel = false;  

  280.         isDownloading = false;  

  281.     }  

  282.   

  283.     /** 

  284.      * 删除临时文件 

  285.      */  

  286.     private void cleanFile(File... files) {  

  287.         for (int i = 0, length = files.length; i < length; i++) {  

  288.             if (null != files[i])  

  289.                 files[i].delete();  

  290.         }  

  291.     }  

  292.   

  293.     /** 

  294.      * 获取下载状态 

  295.      * @return boolean 

  296.      */  

  297.     public boolean isDownloading() {  

  298.         return isDownloading;  

  299.     }  

  300. }  

           先网络请求获取文件的长度mFileLength,根据长度借助RandomAccessFile类在本地生成相同长度的占位文件mTmpFile,再根据线程数量THREAD_COUNT拆分下载任务,最后for循环出THREAD_COUNT数量的异步请求下载拆分内容(字节)并从mTmpFile的对应位置写入mTmpFile,每个线程(任务)每写入一定的数据后将任务的下载进度写入通过RandomAccessFile生成的对应任务的记录缓存文件中,以便于下次下载读取该线程已下载的进度。注释比较多,好像也没啥好解释的,有问题的朋友下方留言。

          在贴上由OkHttp简单封装的网络请求工具类HttpUtil的.java文件:

[java] view plain copy

  1. package cn.icheny.download;  

  2.   

  3. import java.io.IOException;  

  4. import java.util.concurrent.TimeUnit;  

  5. import okhttp3.Call;  

  6. import okhttp3.Callback;  

  7. import okhttp3.OkHttpClient;  

  8. import okhttp3.Request;  

  9. import okhttp3.Response;  

  10.   

  11. /** 

  12.  * Http网络工具,基于OkHttp 

  13.  * Created by Cheny on 2017/05/03. 

  14.  */  

  15.   

  16. public class HttpUtil {  

  17.     private OkHttpClient mOkHttpClient;  

  18.     private static HttpUtil mInstance;  

  19.     private final static long CONNECT_TIMEOUT = 60;//超时时间,秒  

  20.     private final static long READ_TIMEOUT = 60;//读取时间,秒  

  21.     private final static long WRITE_TIMEOUT = 60;//写入时间,秒  

  22.   

  23.     /** 

  24.      * @param url        下载链接 

  25.      * @param startIndex 下载起始位置 

  26.      * @param endIndex   结束为止 

  27.      * @param callback   回调 

  28.      * @throws IOException 

  29.      */  

  30.     public void downloadFileByRange(String url, long startIndex, long endIndex, Callback callback) throws IOException {  

  31.         // 创建一个Request  

  32.         // 设置分段下载的头信息。 Range:做分段数据请求,断点续传指示下载的区间。格式: Range bytes=0-1024或者bytes:0-1024  

  33.         Request request = new Request.Builder().header("RANGE""bytes=" + startIndex + "-" + endIndex)  

  34.                 .url(url)  

  35.                 .build();  

  36.         doAsync(request, callback);  

  37.     }  

  38.   

  39.     public void getContentLength(String url, Callback callback) throws IOException {  

  40.         // 创建一个Request  

  41.         Request request = new Request.Builder()  

  42.                 .url(url)  

  43.                 .build();  

  44.         doAsync(request, callback);  

  45.     }  

  46.   

  47.     /** 

  48.      * 同步GET请求 

  49.      */  

  50.     public void doGetSync(String url) throws IOException {  

  51.         //创建一个Request  

  52.         Request request = new Request.Builder()  

  53.                 .url(url)  

  54.                 .build();  

  55.         doSync(request);  

  56.     }  

  57.   

  58.     /** 

  59.      * 异步请求 

  60.      */  

  61.     private void doAsync(Request request, Callback callback) throws IOException {  

  62.         //创建请求会话  

  63.         Call call = mOkHttpClient.newCall(request);  

  64.         //同步执行会话请求  

  65.         call.enqueue(callback);  

  66.     }  

  67.   

  68.     /** 

  69.      * 同步请求 

  70.      */  

  71.     private Response doSync(Request request) throws IOException {  

  72.         //创建请求会话  

  73.         Call call = mOkHttpClient.newCall(request);  

  74.         //同步执行会话请求  

  75.         return call.execute();  

  76.     }  

  77.   

  78.   

  79.     /** 

  80.      * @return HttpUtil实例对象 

  81.      */  

  82.     public static HttpUtil getInstance() {  

  83.         if (null == mInstance) {  

  84.             synchronized (HttpUtil.class) {  

  85.                 if (null == mInstance) {  

  86.                     mInstance = new HttpUtil();  

  87.                 }  

  88.             }  

  89.         }  

  90.         return mInstance;  

  91.     }  

  92.   

  93.     /** 

  94.      * 构造方法,配置OkHttpClient 

  95.      */  

  96.     private HttpUtil() {  

  97.         //创建okHttpClient对象  

  98.         OkHttpClient.Builder builder = new OkHttpClient.Builder()  

  99.                 .connectTimeout(CONNECT_TIMEOUT, TimeUnit.SECONDS)  

  100.                 .writeTimeout(READ_TIMEOUT, TimeUnit.SECONDS)  

  101.                 .readTimeout(WRITE_TIMEOUT, TimeUnit.SECONDS);  

  102.         mOkHttpClient = builder.build();  

  103.     }  

  104. }  

           header("RANGE", "bytes=" + startIndex + "-" + endIndex),在OkHttp请求头中添加RANGE(范围)参数,告诉服务器需要下载文件内容的始末位置。鉴于OkHttp的火热程度,好像人人都会使用OkHttp,我就不赘言了。

         为了更清晰的教程思路,这里也贴出FilePoint.java:

[java] view plain copy

  1. package cn.icheny.download;  

  2.   

  3. /** 

  4.  * 目标文件 

  5.  * Created by Cheny on 2017/05/03. 

  6.  */  

  7.   

  8. public class FilePoint {  

  9.     private String fileName;//文件名  

  10.     private String url;//文件url  

  11.     private String filePath;//文件下载路径  

  12.   

  13.     public FilePoint(String url) {  

  14.         this.url = url;  

  15.     }  

  16.   

  17.     public FilePoint(String filePath, String url) {  

  18.         this.filePath = filePath;  

  19.         this.url = url;  

  20.     }  

  21.   

  22.     public FilePoint(String url, String filePath, String fileName) {  

  23.         this.url = url;  

  24.         this.filePath = filePath;  

  25.         this.fileName = fileName;  

  26.     }  

  27.   

  28.     public String getFileName() {  

  29.         return fileName;  

  30.     }  

  31.   

  32.     public void setFileName(String fileName) {  

  33.         this.fileName = fileName;  

  34.     }  

  35.   

  36.     public String getUrl() {  

  37.         return url;  

  38.     }  

  39.   

  40.     public void setUrl(String url) {  

  41.         this.url = url;  

  42.     }  

  43.   

  44.     public String getFilePath() {  

  45.         return filePath;  

  46.     }  

  47.   

  48.     public void setFilePath(String filePath) {  

  49.         this.filePath = filePath;  

  50.     }  

  51.   

  52. }  

      下面是下载管理器DownloadManager 代码,统一管理所有文件的下载任务:

[java] view plain copy

  1. package cn.icheny.download;  

  2.   

  3. import android.os.Environment;  

  4. import android.text.TextUtils;  

  5. import java.io.File;  

  6. import java.util.HashMap;  

  7. import java.util.Map;  

  8.   

  9. /** 

  10.  * 下载管理器,断点续传 

  11.  * 

  12.  * @author Cheny 

  13.  */  

  14. public class DownloadManager {  

  15.   

  16.     private String DEFAULT_FILE_DIR;//默认下载目录  

  17.     private Map<String, DownloadTask> mDownloadTasks;//文件下载任务索引,String为url,用来唯一区别并操作下载的文件  

  18.     private static DownloadManager mInstance;  

  19.   

  20.     /** 

  21.      * 下载文件 

  22.      */  

  23.     public void download(String... urls) {  

  24.         for (int i = 0, length = urls.length; i < length; i++) {  

  25.             String url = urls[i];  

  26.             if (mDownloadTasks.containsKey(url)) {  

  27.                 mDownloadTasks.get(url).start();  

  28.             }  

  29.         }  

  30.     }  

  31.   

  32.     /** 

  33.      * 通过url获取下载文件的名称 

  34.      */  

  35.     public String getFileName(String url) {  

  36.         return url.substring(url.lastIndexOf("/") + 1);  

  37.     }  

  38.   

  39.     /** 

  40.      * 暂停 

  41.      */  

  42.     public void pause(String... urls) {  

  43.         for (int i = 0, length = urls.length; i < length; i++) {  

  44.             String url = urls[i];  

  45.             if (mDownloadTasks.containsKey(url)) {  

  46.                 mDownloadTasks.get(url).pause();  

  47.             }  

  48.         }  

  49.     }  

  50.   

  51.     /** 

  52.      * 取消下载 

  53.      */  

  54.     public void cancel(String... urls) {  

  55.         for (int i = 0, length = urls.length; i < length; i++) {  

  56.             String url = urls[i];  

  57.             if (mDownloadTasks.containsKey(url)) {  

  58.                 mDownloadTasks.get(url).cancel();  

  59.             }  

  60.         }  

  61.     }  

  62.   

  63.     /** 

  64.      * 添加下载任务 

  65.      */  

  66.     public void add(String url, DownloadListner l) {  

  67.         add(url, nullnull, l);  

  68.     }  

  69.   

  70.     /** 

  71.      * 添加下载任务 

  72.      */  

  73.     public void add(String url, String filePath, DownloadListner l) {  

  74.         add(url, filePath, null, l);  

  75.     }  

  76.   

  77.     /** 

  78.      * 添加下载任务 

  79.      */  

  80.     public void add(String url, String filePath, String fileName, DownloadListner l) {  

  81.         if (TextUtils.isEmpty(filePath)) {//没有指定下载目录,使用默认目录  

  82.             filePath = getDefaultDirectory();  

  83.         }  

  84.         if (TextUtils.isEmpty(fileName)) {  

  85.             fileName = getFileName(url);  

  86.         }  

  87.         mDownloadTasks.put(url, new DownloadTask(new FilePoint(url, filePath, fileName), l));  

  88.     }  

  89.   

  90.     /** 

  91.      * 获取默认下载目录 

  92.      * 

  93.      * @return 

  94.      */  

  95.     private String getDefaultDirectory() {  

  96.         if (TextUtils.isEmpty(DEFAULT_FILE_DIR)) {  

  97.             DEFAULT_FILE_DIR = Environment.getExternalStorageDirectory().getAbsolutePath()  

  98.                     + File.separator + "icheny" + File.separator;  

  99.         }  

  100.         return DEFAULT_FILE_DIR;  

  101.     }  

  102.   

  103.     /** 

  104.      * 是否正在下载 

  105.      * @param urls 

  106.      * @return boolean 

  107.      */  

  108.     public boolean isDownloading(String... urls) {  

  109.         boolean result = false;  

  110.         for (int i = 0, length = urls.length; i < length; i++) {  

  111.             String url = urls[i];  

  112.             if (mDownloadTasks.containsKey(url)) {  

  113.                 result = mDownloadTasks.get(url).isDownloading();  

  114.             }  

  115.         }  

  116.         return result;  

  117.     }  

  118.   

  119.     public static DownloadManager getInstance() {  

  120.         if (mInstance == null) {  

  121.             synchronized (DownloadManager.class) {  

  122.                 if (mInstance == null) {  

  123.                     mInstance = new DownloadManager();  

  124.                 }  

  125.             }  

  126.         }  

  127.         return mInstance;  

  128.     }  

  129.     /** 

  130.      * 初始化下载管理器 

  131.      */  

  132.     private DownloadManager() {  

  133.         mDownloadTasks = new HashMap<>();  

  134.     }  

  135. }  

           下载管理器通过一个Map将下载链接(url,教程图方便使用url的方式。建议使用其他唯一标识,毕竟一般url长度都很长,会影响一定性能。另外,考虑一个项目中可能需要下载同一个文件到不同的目录,url做索引显得生硬)与对应的下载任务( DownloadTask )绑定在一起,以便于根据url判断或获取对应的下载任务,进行下载,取消和暂停等操作。


收藏 赞 (0) 踩 (0)