断点下载续传—支持断点续传 ,后台有服务来下载文件。

最新推荐文章于 2024-06-18 10:33:06 发布
最新推荐文章于 2024-06-18 10:33:06 发布
阅读量1.9k 收藏 3
点赞数
分类专栏： Android-联网工具 文章标签： download 断点下载
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37293612/article/details/54562451
版权

这里写图片描述

分析思路：

开发下载文件的要求有两点:1.支持断点续传 2.后台有服务来下载文件。

1、复制xutils.jar到项目中 libs 点击下载
2、复制 核心类 到你的app文件下
DownloadInfo支持记录保存 。核心类下载
DownloadService有服务支持好处是所有activity关闭，下载不被中断。
DownloadManager作用。用来支持常见的下载操作。
配置服务。调用DownloadManager编写业务逻辑 下载 暂停 续传

核心类展示

DownloadInfo

public class DownloadInfo {

    public DownloadInfo() {
    }

    private long id;
    //一个应用只有一个appId 可以根据appId进行存储断点.方便下次查找断点

    private String appId;

    public String getAppId() {
        return appId;
    }

    public void setAppId(String appId) {
        this.appId = appId;
    }

    @Transient
    private HttpHandler<File> handler;

    private HttpHandler.State state;

    private String downloadUrl;

    private String fileName;

    private String fileSavePath;

    private long progress;

    private long fileLength;

    private boolean autoResume;

    private boolean autoRename;


    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public HttpHandler<File> getHandler() {
        return handler;
    }

    public void setHandler(HttpHandler<File> handler) {
        this.handler = handler;
    }

    public HttpHandler.State getState() {
        return state;
    }

    public void setState(HttpHandler.State state) {
        this.state = state;
    }

    public String getDownloadUrl() {
        return downloadUrl;
    }

    public void setDownloadUrl(String downloadUrl) {
        this.downloadUrl = downloadUrl;
    }

    public String getFileName() {
        return fileName;
    }

    public void setFileName(String fileName) {
        this.fileName = fileName;
    }

    public String getFileSavePath() {
        return fileSavePath;
    }

    public void setFileSavePath(String fileSavePath) {
        this.fileSavePath = fileSavePath;
    }

    public long getProgress() {
        return progress;
    }

    public void setProgress(long progress) {
        this.progress = progress;
    }

    public long getFileLength() {
        return fileLength;
    }

    public void setFileLength(long fileLength) {
        this.fileLength = fileLength;
    }

    public boolean isAutoResume() {
        return autoResume;
    }

    public void setAutoResume(boolean autoResume) {
        this.autoResume = autoResume;
    }

    public boolean isAutoRename() {
        return autoRename;
    }

    public void setAutoRename(boolean autoRename) {
        this.autoRename = autoRename;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof DownloadInfo)) return false;

        DownloadInfo that = (DownloadInfo) o;

        if (id != that.id) return false;

        return true;
    }

    @Override
    public int hashCode() {
        return (int) (id ^ (id >>> 32));
    }
}

DownloadService

public class DownloadService extends Service {

    private static DownloadManager DOWNLOAD_MANAGER;

    public static DownloadManager getDownloadManager(Context appContext) {
        if (!DownloadService.isServiceRunning(appContext)) {
            Intent downloadSvr = new Intent(appContext,DownloadService.class);
            appContext.startService(downloadSvr);
        }
        if (DownloadService.DOWNLOAD_MANAGER == null) {
            DownloadService.DOWNLOAD_MANAGER = new DownloadManager(appContext);
        }
        return DOWNLOAD_MANAGER;
    }

    public DownloadService() {
        super();
    }

    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    @Override
    public void onCreate() {
        super.onCreate();
    }

    @Override
    public void onStart(Intent intent, int startId) {
        super.onStart(intent, startId);
    }

    @Override
    public void onDestroy() {
        if (DOWNLOAD_MANAGER != null) {
            try {
                DOWNLOAD_MANAGER.stopAllDownload();
                DOWNLOAD_MANAGER.backupDownloadInfoList();
            } catch (DbException e) {
                LogUtils.e(e.getMessage(), e);
            }
        }
        super.onDestroy();
    }

    public static boolean isServiceRunning(Context context) {
        boolean isRunning = false;

        ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
        List<ActivityManager.RunningServiceInfo> serviceList = activityManager.getRunningServices(Integer.MAX_VALUE);

        if (serviceList == null || serviceList.size() == 0) {
            return false;
        }

        for (int i = 0; i < serviceList.size(); i++) {
            if (serviceList.get(i).service.getClassName().equals(DownloadService.class.getName())) {
                isRunning = true;
                break;
            }
        }
        return isRunning;
    }
}

DownloadManager

public class DownloadManager {

    private List<DownloadInfo> downloadInfoList;

    private int maxDownloadThread = 3;

    private Context mContext;
    private DbUtils db;

    /* package */ DownloadManager(Context appContext) {
        ColumnConverterFactory.registerColumnConverter(HttpHandler.State.class, new HttpHandlerStateConverter());
        mContext = appContext;
        db = DbUtils.create(mContext);// xUtils.db
        try {
            downloadInfoList = db.findAll(Selector.from(DownloadInfo.class));
        } catch (DbException e) {
            LogUtils.e(e.getMessage(), e);
        }
        if (downloadInfoList == null) {
            downloadInfoList = new ArrayList<DownloadInfo>();
        }
    }

    public int getDownloadInfoListCount() {
        return downloadInfoList.size();
    }

    public DownloadInfo getDownloadInfo(int index) {
        return downloadInfoList.get(index);
    }

    /***
     * 方法 按照应用appId查找断点记录
     * 
     * @param appId
     * @return
     */
    public DownloadInfo getDownloadInfoByAppId(String appId) {
        for (DownloadInfo item : downloadInfoList) {
            if (TextUtils.equals(item.getAppId(), appId)) {
                return item;// 返回指定appId的断点记录
            }
        }
        return null;
    }

    public void addNewDownload(String appId, String url, String fileName, String target, boolean autoResume, boolean autoRename, final RequestCallBack<File> callback) throws DbException {
        final DownloadInfo downloadInfo = new DownloadInfo();
        downloadInfo.setAppId(appId);
        downloadInfo.setDownloadUrl(url);
        downloadInfo.setAutoRename(autoRename);
        downloadInfo.setAutoResume(autoResume);
        downloadInfo.setFileName(fileName);
        downloadInfo.setFileSavePath(target);
        HttpUtils http = new HttpUtils();
        http.configRequestThreadPoolSize(maxDownloadThread);
        HttpHandler<File> handler = http.download(url, target, autoResume, autoRename, new ManagerCallBack(downloadInfo, callback));
        downloadInfo.setHandler(handler);
        downloadInfo.setState(handler.getState());
        downloadInfoList.add(downloadInfo);
        db.saveBindingId(downloadInfo);
    }

    public void resumeDownload(int index, final RequestCallBack<File> callback) throws DbException {
        final DownloadInfo downloadInfo = downloadInfoList.get(index);
        resumeDownload(downloadInfo, callback);
    }

    public void resumeDownload(DownloadInfo downloadInfo, final RequestCallBack<File> callback) throws DbException {
        HttpUtils http = new HttpUtils();
        http.configRequestThreadPoolSize(maxDownloadThread);
        HttpHandler<File> handler = http.download(downloadInfo.getDownloadUrl(), downloadInfo.getFileSavePath(), downloadInfo.isAutoResume(), downloadInfo.isAutoRename(), new ManagerCallBack(downloadInfo, callback));
        downloadInfo.setHandler(handler);
        downloadInfo.setState(handler.getState());
        db.saveOrUpdate(downloadInfo);
    }

    public void removeDownload(int index) throws DbException {
        DownloadInfo downloadInfo = downloadInfoList.get(index);
        removeDownload(downloadInfo);
    }

    public void removeDownload(DownloadInfo downloadInfo) throws DbException {
        HttpHandler<File> handler = downloadInfo.getHandler();
        if (handler != null && !handler.isCancelled()) {
            handler.cancel();
        }
        // 从下载的断点记录集合中移除断点记录(内存)
        downloadInfoList.remove(downloadInfo);
        // 从数据库删除。
        db.delete(downloadInfo);
        // 下载一半的文件?100M 55M
        String fileSavePath = downloadInfo.getFileSavePath();
        // 如果存在下载一半的文件，由于下次找不到断点记录，没法续传,直接删除这个文件节省sd空间.
        File file = new File(fileSavePath);
        if (file.exists()) {
            file.delete();
        }
    }

    public void stopDownload(int index) throws DbException {
        DownloadInfo downloadInfo = downloadInfoList.get(index);
        stopDownload(downloadInfo);
    }

    public void stopDownload(DownloadInfo downloadInfo) throws DbException {
        HttpHandler<File> handler = downloadInfo.getHandler();
        if (handler != null && !handler.isCancelled()) {
            handler.cancel();
        } else {
            downloadInfo.setState(HttpHandler.State.CANCELLED);
        }
        db.saveOrUpdate(downloadInfo);
    }

    public void stopAllDownload() throws DbException {
        for (DownloadInfo downloadInfo : downloadInfoList) {
            HttpHandler<File> handler = downloadInfo.getHandler();
            if (handler != null && !handler.isCancelled()) {
                handler.cancel();
            } else {
                downloadInfo.setState(HttpHandler.State.CANCELLED);
            }
        }
        db.saveOrUpdateAll(downloadInfoList);
    }

    public void backupDownloadInfoList() throws DbException {
        for (DownloadInfo downloadInfo : downloadInfoList) {
            HttpHandler<File> handler = downloadInfo.getHandler();
            if (handler != null) {
                downloadInfo.setState(handler.getState());
            }
        }
        db.saveOrUpdateAll(downloadInfoList);
    }

    public int getMaxDownloadThread() {
        return maxDownloadThread;
    }

    public void setMaxDownloadThread(int maxDownloadThread) {
        this.maxDownloadThread = maxDownloadThread;
    }

    public class ManagerCallBack extends RequestCallBack<File> {
        private DownloadInfo downloadInfo;
        private RequestCallBack<File> baseCallBack;

        public RequestCallBack<File> getBaseCallBack() {
            return baseCallBack;
        }

        public void setBaseCallBack(RequestCallBack<File> baseCallBack) {
            this.baseCallBack = baseCallBack;
        }

        private ManagerCallBack(DownloadInfo downloadInfo, RequestCallBack<File> baseCallBack) {
            this.baseCallBack = baseCallBack;
            this.downloadInfo = downloadInfo;
        }

        @Override
        public Object getUserTag() {
            if (baseCallBack == null)
                return null;
            return baseCallBack.getUserTag();
        }

        @Override
        public void setUserTag(Object userTag) {
            if (baseCallBack == null)
                return;
            baseCallBack.setUserTag(userTag);
        }

        @Override
        public void onStart() {
            HttpHandler<File> handler = downloadInfo.getHandler();
            if (handler != null) {
                downloadInfo.setState(handler.getState());
            }
            try {
                db.saveOrUpdate(downloadInfo);
            } catch (DbException e) {
                LogUtils.e(e.getMessage(), e);
            }
            if (baseCallBack != null) {
                baseCallBack.onStart();
            }
        }

        @Override
        public void onCancelled() {
            HttpHandler<File> handler = downloadInfo.getHandler();
            if (handler != null) {
                downloadInfo.setState(handler.getState());
            }
            try {
                db.saveOrUpdate(downloadInfo);
            } catch (DbException e) {
                LogUtils.e(e.getMessage(), e);
            }
            if (baseCallBack != null) {
                baseCallBack.onCancelled();
            }
        }

        @Override
        public void onLoading(long total, long current, boolean isUploading) {
            HttpHandler<File> handler = downloadInfo.getHandler();
            if (handler != null) {
                downloadInfo.setState(handler.getState());
            }
            downloadInfo.setFileLength(total);
            downloadInfo.setProgress(current);
            try {
                db.saveOrUpdate(downloadInfo);
            } catch (DbException e) {
                LogUtils.e(e.getMessage(), e);
            }
            if (baseCallBack != null) {
                baseCallBack.onLoading(total, current, isUploading);
            }
        }

        @Override
        public void onSuccess(ResponseInfo<File> responseInfo) {
            HttpHandler<File> handler = downloadInfo.getHandler();
            if (handler != null) {
                downloadInfo.setState(handler.getState());
            }
            try {
                db.saveOrUpdate(downloadInfo);
            } catch (DbException e) {
                LogUtils.e(e.getMessage(), e);
            }
            if (baseCallBack != null) {
                baseCallBack.onSuccess(responseInfo);
            }
        }

        @Override
        public void onFailure(HttpException error, String msg) {
            HttpHandler<File> handler = downloadInfo.getHandler();
            if (handler != null) {
                downloadInfo.setState(handler.getState());
            }
            try {
                db.saveOrUpdate(downloadInfo);
            } catch (DbException e) {
                LogUtils.e(e.getMessage(), e);
            }
            if (baseCallBack != null) {
                baseCallBack.onFailure(error, msg);
            }
        }
    }

    private class HttpHandlerStateConverter implements ColumnConverter<HttpHandler.State> {

        @Override
        public HttpHandler.State getFieldValue(Cursor cursor, int index) {
            return HttpHandler.State.valueOf(cursor.getInt(index));
        }

        @Override
        public HttpHandler.State getFieldValue(String fieldStringValue) {
            if (fieldStringValue == null)
                return null;
            return HttpHandler.State.valueOf(fieldStringValue);
        }

        @Override
        public Object fieldValue2ColumnValue(HttpHandler.State fieldValue) {
            return fieldValue.value();
        }

        @Override
        public ColumnDbType getColumnDbType() {
            return ColumnDbType.INTEGER;
        }
    }
}

代码使用实现：

 //获取DownloadManager对象
 DownloadManager  mg = DownloadService.getDownloadManager(MyApp.getContext());
        //按钮BtnDownload的点击事件
        BtnDownload.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
               try { 
              //查询指定应用下载记录（断点 progress）
             DownloadInfo downloadInfo = mg.getDownloadInfoByAppId(data.id + "");
                   //判断是否有下载记录，有就是续传 没有就是开始下载
                   if (downloadInfo == null) {
                       //参数1 appId应用编号
                       String appId = data.id + "";
                       //参数2 下载地址
                       String url = ApiUrls.DOWNLOAD + data.downloadUrl;
                       //参数3 文件名
                       String fileName = data.name;
                       //参数4 保存的绝对路径
 String target = Environment.getExternalStorageDirectory().getAbsolutePath() + "/market/" + data.packageName + ".apk";
                       //参数5 是否支持断点
                       boolean autoResume = true;
                       //参数6 是否重命名
                       boolean autoRename = false;
                       //参数回调对象，处理界面更新业务逻辑
   mg.addNewDownload(appId, url, fileName, target, autoResume, autoRename, callback);

                   } else {
                       //继续传输
                       //载按钮点击事件
                       //loading当前出入下载状态
                       if (downloadInfo.getState() == HttpHandler.State.LOADING) {
                           mg.stopDownload(downloadInfo);
                           part5BtnDownload.setText("继续");
                       } else {
                           mg.resumeDownload(downloadInfo, callback);
                       }
                   }
               }catch(Exception e){e.printStackTrace();}
            }
        });

由于整个下载过程没有界面更新，用户不知道下载进度，所以编写进度更新的业务逻辑。编写在CallBack空方法里面

 RequestCallBack<File> callback= new RequestCallBack<File>(){

       //下载过程中进度变化
        @Override
        public void onLoading(long total, long current, boolean isUploading) {
            super.onLoading(total, current, isUploading);
            //设置进度条的进度文本
            //设置进度条最大值、设置当前进度
            if(total==0){total=1;}
            int percent = (int) (current*100f/total+0.5f);
            BtnDownload.setText(percent+"%");

            PbarProgress.setMax(100);//PbarProgress进度条
            PbarProgress.setProgress(percent);
        }
        @Override
        public void onSuccess(ResponseInfo<File> responseInfo) {
            part5BtnDownload.setText("安装");
            part5PbarProgress.setMax(100);
            part5PbarProgress.setProgress(100);
            //调用隐式意图安装
            ApkUtil.install((Activity) context,responseInfo.result.getAbsolutePath());
        }

        @Override
        public void onFailure(HttpException e, String s) {
            part5BtnDownload.setText("继续");
        }
    };
/**
 *APK安装工具类
 */
public class ApkUtil {
    public static void install(Activity activity,String target){
        //Intent :开启服务或者打开页面
        Intent intent = new Intent();
        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        intent.setAction("android.intent.action.VIEW");
        intent.addCategory("android.intent.category.DEFAULT");
        String type = "application/vnd.android.package-archive";
        // http://www.itheima.com f  /mnt/sdcard
        Uri data = Uri.parse("file:///" + target);
        intent.setDataAndType(data, type);
        activity.startActivity(intent);
    }
}

进入页面需要进行回显（把断点记录下来，设置给界面）

 private void resumeDownLoadInfo(String appId) {
        //5.1获取断点记录
        DownloadInfo downloadInfo = mg.getDownloadInfoByAppId(appId);
        if (downloadInfo == null) {
            part5BtnDownload.setText("下载");
            part5PbarProgress.setMax(100);
            part5PbarProgress.setProgress(0);
        } else {
            //5.2计算百分比
            long total = downloadInfo.getFileLength();
            if (total == 0) {
                total = 1;
            }
            int percent = (int) (downloadInfo.getProgress() * 100f / total + 0.5f);
            part5PbarProgress.setMax(100);
            part5PbarProgress.setProgress(percent);
            if (downloadInfo.getState() == HttpHandler.State.LOADING) {
                part5BtnDownload.setText(percent + "%");
            } else {
                part5BtnDownload.setText("继续");
            }
        }
    }
码农王提莫
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
断点续传下载文件
03-06
断点续传下载技术是网络数据传输中一种重要的优化手段，尤其在大文件下载场景下，它极大地提高了用户下载效率并降低了网络资源的浪费。这一技术的原理是允许下载过程在中断后从上次中断的位置继续，而不是从头开始。...
PHP实现文件下载断点续传详解
01-20
如果我们的网站提供文件下载的服务，那么通常我们都希望下载可以断点续传(Resumable Download)，也就是说用户可以暂停下载，并在未来的某个时间从暂停处继续下载，而不必重新下载整个文件。 通常情况下，Web服务器...
Spring Boot 实现文件断点下载，实战来了！
编码行者的博客
07-26 471
互联网的连接速度慢且不稳定，有可能由于网络故障导致断开连接。在客户端下载一个大对象时，因网络断开导致上传下载失败的概率就会变得不可忽视。客户端在GET对象请求时通过设置Range头部来告诉接口服务需要从什么位置开始输出对象的数据。判断是否支持断点下载，根据文档：14.35.1 Byte Ranges// 直接判断是否有 Accept-Ranges = bytes直接判断头部HEADHeadObject接口用于获取某个文件（Object）的元信息。使用此接口不会返回文件内容。需知，对应HTTP。
Java-断点下载(分片下载)
weixin_45203607的博客
05-27 5134
介绍 当下载一个很大的文件时，如果下载到一半暂停，如果继续下载呢？断点下载就是解决这个问题的。 具体原理: 利用indexedDb,将下载的数据存储到用户的本地中,这样用户就算是关电脑那么下次下载还是从上次的位置开始的 先去看看本地缓存中是否存在这个文件的分片数据,如果存在那么就接着上一个分片继续下载(起始位置) 下载前先去后端拿文件的大小,然后计算分多少次下载(n/(1024*1024*10)) (结束位置) 每次下载的数据放入一个Blob中,然后存储到本地indexedDB 当全部下载完毕后,将所有
我又学会了使用Range实现网络文件下载的断点续传
最新发布
陈宝子的博客
06-18 760
HTTP/1.1 Range请求头代表发送范围获取数据的请求，要求服务器仅向客户端回传HTTP消息的一部分，常用于实现断点续传
Http实现断点下载和进度显示
qq_39271974的博客
05-11 508
断点下载文件并显示进度
深入理解文件上传下载的原理及实现逻辑
Lion_Long的博客
11-15 4202
文件上传原理、文件上传类型（秒传、分片上传、大文件上传、断点续传、断点下载原理）、多线程下载逻辑。
Android使用OKHttp3实现下载(断点续传、显示进度)
wenql209的博客
01-18 3026
okhttp下载，断点续传
一个支持多线程断点续传功能的Android下载工具.zip
03-03
综上所述，DownloadHelper项目是一个旨在提供高效、可靠下载体验的工具，它计划实现多线程和断点续传功能，以应对Android平台上的大文件下载需求。开发者在实现这个功能时需要掌握Android的异步编程、文件处理、网络...
Springboot 断点续传大文件
07-01
曾经上传一部分：前端在上传每个模块之前，先请求后台，判断此模块是否已经上传过，如果已经上传过，则不需要再上传，否则上传。 注：启动以后直接访问http://localhost:9002/demo/largeUpload/open,如果本地运行...
iOS 断点续传，下载管理
09-28
断点续传（Resume Download）是一种网络数据传输技术，它允许在文件下载过程中，如果因为网络问题或设备原因中断，可以在稍后的时间从已经下载的部分继续，而不是重新开始整个下载过程。这主要通过保存已下载部分的...
前端实现断点下载
极简
10-23 4136
背景：当下载一个很大的文件时，如果下载到一半暂停，如果继续下载呢？断点下载就是解决这个问题的。 什么是断点下载？ 所谓断点下载就是可以一部分一部分的下载，不用一次性把文件数据全部拿到。 涉及到的主要HTTP消息头 通用首部 请求头 响应头 实体头 Status Code Range:请求数据范围 Accept-Ranges：标识自身支持范围请求 Content-Range：一个数据片段在整个文件中的位置。 ETag：资源特定版本标识符 .
用网页 实现断点续传 (HTTP)
weixin_45525177的博客
11-18 1237
文件上传是一个老生常谈的话题了，在文件相对比较小的情况下，可以直接把文件转化为字节流上传到服务器，但在文件比较大的情况下，用普通的方式进行上传，这可不是一个好的办法，毕竟很少有人会忍受，当文件上传到一半中断后，继续上传却只能重头开始上传，这种让人不爽的体验。断点续传是在下载或上传时，将下载或上传任务（一个文件或一个压缩包）人为的划分为几个部分，每一个部分采用一个线程进行上传或下载，如果碰到网络故障，可以从已经上传或下载的部分开始继续上传或者下载未完成的部分，而没有必要从头开始上传或者下载。
ubuntu资源下载利器：多线程、断点续传下载工具mwget的安装与使用
嵌入式技术与人工智能
05-21 3659
ubuntu资源下载利器：多线程、断点续传下载工具mwget的安装与使用:orange_book: 实际问题：资源下载很慢:orange_book: mwget的安装与使用:book: mwget的安装:book: mwget的使用 📙 实际问题：资源下载很慢 ✨ 我们在使用wget下载网络上的资源时，经常遇到几k的下载速度。然而，我们已经设置国内源了，但是仍然无济于事。如下图所示，8M多的资源下了将近二十分钟。 如下下图所示，甚至更过分的是，有的时候终于等了小半个小时，下载到99%，然后wget下载终
Web文件分片上传,断点续传
weixin_45525177的博客
12-06 273
一、概述所谓断点续传，其实只是指下载，也就是要从文件已经下载的地方开始继续下载。在以前版本的HTTP协议是不支持断点的，HTTP/1.1开始就支持了。一般断点下载时才用到Range和Content-Range实体头。HTTP协议本身不支持断点上传，需要自己实现。二、Range 用于请求头中，指定第一个字节的位置和最后一个字节的位置，一般格式： Range:用于客户端到服务端的请求，可以通过改字段指定下载文件的某一段大小及其单位，字节偏移从0开始。典型格式： Ranges: (unit=fi
断点下载的主要知识总结。
baidu_33331545的博客
12-27 1577
断点下载 HTTP相关知识点 1.Header中总要的key 与 value Request Header Range 表示请求某个实体的一部分，字节偏移以0开始。 Range: bytes=500-999 Response Header Content-Type 当前内容的MIME类型 Content-Type: text/html; charset=utf-8 Content-Length 以8进制表示的请求体的长度 Content-Length: 348 首先...
Android 条件断点,Android DownloadManager 的使用及断点续传-Go语言中文社区
weixin_33958381的博客
05-25 364
Class OverviewThe download manager is a system service that handles long-running HTTP downloads. Clients may request that a URI be downloaded to a particular destination file. The download manager wil...
HTTP断点续传（分块传输）
weixin_33832340的博客
11-21 4547
简述 断点续传：指的是在上传/下载时，将任务（一个文件或压缩包）人为的划分为几个部分，每一个部分采用一个线程进行上传/下载，如果碰到网络故障，可以从已经上传/下载的部分开始继续上传/下载未完成的部分，而没有必要从头开始上传/下载。可以节省时间，提高速度。 简述 断点续传的用途 Range Content-Range 增强...
Xutils3.3.26使用详解
Arman的博客
08-11 1848
编程尚未成功,同志任需努力
Java与Android断点续传文件下载指南
"java和android文件下载 断点续传概要.pdf" 在Java和Android开发中，文件下载是一项常见的任务，特别是在移动设备上，用户可能需要下载各种大小的文件，如应用程序更新、图片、音频或视频文件。为了提供更好的用户...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值