Android 多线程断点下载文件

最新推荐文章于 2024-07-31 17:21:46 发布
最新推荐文章于 2024-07-31 17:21:46 发布
阅读量2.2k 收藏 4
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/louyulin/article/details/88221116
版权

效果图

首先先上一下效果图 如果有需要的朋友可以往下看我的具体实现:
在这里插入图片描述
整个下载的过程都在后台服务中进行,因此实现了一个activity将任务加入下载 在另一个activity中显示进度并能控制暂停,同时结合了sqlite进行缓存,将任务列表缓存到本地,下次打开app任务依然存在并能继续

实现的思路

1.创建一个sqlite的表 将任务列表中的 例如文件名 url 等信息进行缓存
2. 封装下载工具类
3. 创建后台服务 将下载的开始暂停等方法写到服务中

代码具体实现

一 创建DBHelper 并封装一些方法
public class DBHelper extends SQLiteOpenHelper {
    private static final String DB_NAME = "download.db";
    private static final int VERSION = 1;
    //state 1 是正在下载 2 是暂停  3是已经完成
    //thread_id(与文件id相同) 下载url 文件总长度 下载状态 title文件标题
    private static final String SQL_CREATE = "create table if not exists thread_info(" +
            "thread_id integer,url text,filelength integer,state integer,title text)";

    private static final String SQL_DROP = "drop table if exists thread_info";



    public DBHelper(Context context) {
        super(context, DB_NAME, null, VERSION);
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
        db.execSQL(SQL_CREATE);
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        db.execSQL(SQL_DROP);
        db.execSQL(SQL_CREATE);
    }
}

封装增删改查的方法

public interface ThreadDao {
    //插入线程信息
    void insertThread(ThreadInfo threadInfo);

    //删除线程
    void deleteThread(String url, int thread_id);

    //更新线程信息
    void updateThread(String url, int thread_id,int state);


    //根据url查询文件的线程信息
    ThreadInfo getThreadsByUrl(String url);

    List<ThreadInfo> getAllThreads();

    //系统被杀死的时候没有完成的任务
    List<ThreadInfo> getAllContinueThreads();

    //线程信息是否存在
    boolean isExists(String url, int thread_id);
}

具体的sql 语句实现

public class ThreadDaoImpl implements ThreadDao {
    private DBHelper mHelper = null;

    public ThreadDaoImpl(Context context) {
        mHelper = new DBHelper(context);
    }

    @Override
    public synchronized void insertThread(ThreadInfo threadInfo) {
        SQLiteDatabase db = mHelper.getWritableDatabase();
        db.execSQL("insert into thread_info(thread_id,url,filelength,state,title) values (?,?,?,?,?)",
                new Object[]{threadInfo.getId(), threadInfo.getUrl(), threadInfo.getFilelength(), threadInfo.getState(), threadInfo.getTitle()});
        db.close();
    }

    @Override
    public synchronized void deleteThread(String url, int thread_id) {
        SQLiteDatabase db = mHelper.getWritableDatabase();
        db.execSQL("delete from thread_info where thread_id = ? and url = ?",
                new Object[]{thread_id, url});
        db.close();
    }

    @Override
    public synchronized void updateThread(String url, int thread_id, int state) {
        SQLiteDatabase db = mHelper.getWritableDatabase();
        db.execSQL("update thread_info set  state = ? where thread_id = ? and url = ?",
                new Object[]{state,thread_id, url});
        db.close();
    }

    @Override
    public synchronized ThreadInfo getThreadsByUrl(String url) {
        SQLiteDatabase db = mHelper.getWritableDatabase();
        Cursor cursor = db.rawQuery("select * from thread_info where url = ?", new String[]{url});
        ThreadInfo threadInfo = null;
        while (cursor.moveToNext()) {
            threadInfo = new ThreadInfo();
            threadInfo.setId(cursor.getInt(cursor.getColumnIndex("thread_id")));
            threadInfo.setUrl(cursor.getString(cursor.getColumnIndex("url")));
            threadInfo.setFilelength(cursor.getInt(cursor.getColumnIndex("filelength")));
            threadInfo.setState(cursor.getInt(cursor.getColumnIndex("state")));
            threadInfo.setTitle(cursor.getString(cursor.getColumnIndex("title")));
        }
        cursor.close();
        db.close();
        return threadInfo;
    }

    @Override
    public List<ThreadInfo> getAllThreads() {
        SQLiteDatabase db = mHelper.getWritableDatabase();
        Cursor cursor = db.rawQuery("select * from thread_info", new String[]{});
        ThreadInfo threadInfo = null;
        List<ThreadInfo> list = new ArrayList<>();
        while (cursor.moveToNext()) {
            threadInfo = new ThreadInfo();
            threadInfo.setId(cursor.getInt(cursor.getColumnIndex("thread_id")));
            threadInfo.setUrl(cursor.getString(cursor.getColumnIndex("url")));
            threadInfo.setFilelength(cursor.getInt(cursor.getColumnIndex("filelength")));
            threadInfo.setState(cursor.getInt(cursor.getColumnIndex("state")));
            threadInfo.setTitle(cursor.getString(cursor.getColumnIndex("title")));
            list.add(threadInfo);
        }
        cursor.close();
        db.close();
        return list;
    }

    @Override
    public List<ThreadInfo> getAllContinueThreads() {
        SQLiteDatabase db = mHelper.getWritableDatabase();
        Cursor cursor = db.rawQuery("select * from thread_info where state = ?", new String[]{"1"});
        ThreadInfo threadInfo = null;
        List<ThreadInfo> list = new ArrayList<>();
        while (cursor.moveToNext()) {
            threadInfo = new ThreadInfo();
            threadInfo.setId(cursor.getInt(cursor.getColumnIndex("thread_id")));
            threadInfo.setUrl(cursor.getString(cursor.getColumnIndex("url")));
            threadInfo.setFilelength(cursor.getInt(cursor.getColumnIndex("filelength")));
            threadInfo.setState(cursor.getInt(cursor.getColumnIndex("state")));
            threadInfo.setTitle(cursor.getString(cursor.getColumnIndex("title")));
            list.add(threadInfo);
        }
        cursor.close();
        db.close();
        return list;
    }

    @Override
    public synchronized boolean isExists(String url, int thread_id) {
        SQLiteDatabase db = mHelper.getWritableDatabase();
        Cursor cursor = db.rawQuery("select * from thread_info where url = ? and thread_id = ?",
                new String[]{url, thread_id + ""});
        while (cursor.moveToNext()) {
            cursor.close();
            db.close();
            return true;
        }
        return false;
    }
}
二 创建实体类

我们需要两个实体类 第一个实体类是做文件列表假数据用的 不需要state(是暂停还是正在下载) 第二个实体类是线程下载用的

文件的实体类

public class FileInfo implements Serializable {
    private int id;
    private String url;
    private String fileName;
    private int length;
    
    public FileInfo() {
    
    }

    public FileInfo(int id, String url, String fileName, int length) {
        this.id = id;
        this.url = url;
        this.fileName = fileName;
        this.length = length;
    }

    public int getId() {
        return id;
    }

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

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getFileName() {
        return fileName;
    }

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

    public int getLength() {
        return length;
    }

    public void setLength(int length) {
        this.length = length;
    }
    
}

线程的实体类

public class ThreadInfo {
    private int id;
    private String url;
    private long filelength;
    private int state;
    private String title;

    public ThreadInfo() {

    }

    public ThreadInfo(int id, String url, long filelength, int state, String title) {
        this.id = id;
        this.url = url;
        this.filelength = filelength;
        this.state = state;
        this.title = title;
    }

    public int getId() {
        return id;
    }

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

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public long getFilelength() {
        return filelength;
    }

    public void setFilelength(long filelength) {
        this.filelength = filelength;
    }

    public int getState() {
        return state;
    }

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

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }
}
三 创建下载工具类

下面我们创建一个下载的工具类 DownloadTask 断点下载的核心就是RandomAccessFile 这个类 通过seek() 这个方法能跳过已经下载的部分 另一个重点就是在请求头中加上range 下面看一下具体的代码

//下载任务类
public class DownloadTask {
    private Context context = null;
    private FileInfo fileInfo = null;
    private ThreadDao dao = null;
    public boolean isPause = false;

    public DownloadTask(Context context, FileInfo fileInfo) {
        this.context = context;
        this.fileInfo = fileInfo;
        dao = new ThreadDaoImpl(context);
    }

    public void download() {
        //读取数据库的线程任务信息
        ThreadInfo threadInfo = dao.getThreadsByUrl(fileInfo.getUrl());
        if (threadInfo == null) {
            //如果是空的初始化线程任务对象
            threadInfo = new ThreadInfo(fileInfo.getId(), fileInfo.getUrl(),  fileInfo.getLength(), 1, fileInfo.getFileName());
        }
        //创建子线程开始下载
        new DownloadThread(threadInfo).start();
    }

    //下载线程
    class DownloadThread extends Thread {
        ThreadInfo threadInfo = null;
        private File file;

        public DownloadThread(ThreadInfo threadInfo) {
            this.threadInfo = threadInfo;
        }

        @Override
        public void run() {
            super.run();
            //向数据库插入线程任务信息
            if (!dao.isExists(threadInfo.getUrl(), threadInfo.getId())) {
                //之前不存在这个线程任务就插入到数据库
                dao.insertThread(threadInfo);
            }
            HttpURLConnection httpURLConnection = null;
            RandomAccessFile raf = null;
            InputStream inputStream = null;
            try {
                Intent intent = new Intent(DownloadService.ACTION_UPDATA);

                //设置文件写入位置 同时判断手机中是否已经有下载的相同文件
                file = new File(DownloadService.DOWNLOAD_PATH, fileInfo.getFileName());

                if (file.length() == fileInfo.getLength()){
                    //已经有这个文件了
                    //下载完成之后发送广播
                    intent.putExtra("finished", 100 + "");
                    intent.putExtra("fileId", fileInfo.getId());
                    context.sendBroadcast(intent);
                    //下载完成之后更新线程任务信息
                    dao.updateThread(threadInfo.getUrl(), threadInfo.getId(), 3);
                    return;
                }

                raf = new RandomAccessFile(file, "rwd");
                raf.seek(file.length());

                //开始下载
                URL url = new URL(threadInfo.getUrl());
                httpURLConnection = (HttpURLConnection) url.openConnection();
                httpURLConnection.setConnectTimeout(3000);
                httpURLConnection.setRequestMethod("GET");
                httpURLConnection.setRequestProperty("RANGE", "bytes=" + file.length() + "-" );
                inputStream = httpURLConnection.getInputStream();
                byte[] bytes = new byte[1024 * 10];
                int len;
                long time = System.currentTimeMillis();

                while ((len = inputStream.read(bytes)) != -1) {
                    //写入文件
                    raf.write(bytes, 0, len);
                    //下载进度发送广播给activity
                    if (System.currentTimeMillis() - time > 300) {
                        time = System.currentTimeMillis();
                        intent.putExtra("finished", file.length() * 100 / fileInfo.getLength() + "");
                        intent.putExtra("fileId", fileInfo.getId());
                        context.sendBroadcast(intent);
                    }
                    //下载暂停保存下载进度
                    if (isPause) {
                        dao.updateThread(threadInfo.getUrl(), threadInfo.getId() , 2);
                        return;
                    }
                }
                //下载完成之后发送广播
                intent.putExtra("finished", 100 + "");
                intent.putExtra("fileId", fileInfo.getId());
                context.sendBroadcast(intent);
                //下载完成之后更新线程任务信息
                dao.updateThread(threadInfo.getUrl(), threadInfo.getId(), 3);
            } catch (Exception e) {
                e.printStackTrace();
                isPause = true;
                dao.updateThread(threadInfo.getUrl(), threadInfo.getId(), 2);
                Intent intent = new Intent(DownloadService.ACTION_ERRO);
                intent.putExtra("fileId", fileInfo.getId());
                context.sendBroadcast(intent);
            } finally {
                if (httpURLConnection != null) {
                    httpURLConnection.disconnect();
                }
                if (raf != null) {
                    try {
                        raf.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }

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


    }
}

在这个类的构造方法中需要传FileInfo,因为我们在往sql表中插入数据的时候需要从FileInfo中拿到一些属性进行插入 或者查询 下面将会在服务中进行传入

四 创建后台服务

在后台服务中 我们控制DownloadTask的开始和暂停 将每一个任务存在一个map中,同事在这个服务中 我们同时加入了一个请求下载文件的长度

public class DownloadService extends Service {

    public static final String ACTION_START = "ACTION_START";
    public static final String ACTION_STOP = "ACTION_STOP";
    public static final String ACTION_UPDATA = "ACTION_UPDATA";
    public static final String ACTION_ERRO = "ACTION_ERRO";
    public static final String DOWNLOAD_PATH = Environment.getExternalStorageDirectory().getAbsolutePath() + "/ADEMO";
    public static final int MSG_INIT = 0;
    private DownloadTask downloadTask;
    //下载任务的集合
    public static Map<Integer,DownloadTask> mTasks = new LinkedHashMap<>();
    
    Handler handler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MSG_INIT:
                    FileInfo fileInfo = (FileInfo) msg.obj;
                    Log.d("DownloadService", "MSG_INIT:" + fileInfo);
                    //启动下载任务
                    downloadTask = new DownloadTask(DownloadService.this,fileInfo);
                    downloadTask.download();
                    mTasks.put(fileInfo.getId(),downloadTask);
                    break;
            }
        }
    };

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        //获得Activity的参数
        if (ACTION_START.equals(intent.getAction())) {
            FileInfo fileInfo = (FileInfo) intent.getSerializableExtra("fileInfo");
            new InitThread(fileInfo).start();
        } else if (ACTION_STOP.equals(intent.getAction())){
            FileInfo fileInfo = (FileInfo) intent.getSerializableExtra("fileInfo");
            //从集合中取出下载任务
            DownloadTask downloadTask = mTasks.get(fileInfo.getId());
            if (downloadTask != null){
                downloadTask.isPause = true;
            }
        }
        return super.onStartCommand(intent, flags, startId);
    }

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

    class InitThread extends Thread {
        private FileInfo mFileInfo = null;

        public InitThread(FileInfo mFileInfo) {
            this.mFileInfo = mFileInfo;
        }

        @Override
        public void run() {
            HttpURLConnection httpURLConnection = null;
            RandomAccessFile raf = null;
            try {
                URL url = new URL(mFileInfo.getUrl());
                httpURLConnection = (HttpURLConnection) url.openConnection();
                httpURLConnection.setConnectTimeout(3000);
                httpURLConnection.setRequestMethod("GET");
                int length = -1;
                if (httpURLConnection.getResponseCode() == 200) {
                    length = httpURLConnection.getContentLength();
                }
                if (length <= 0) {
                    return;
                }
                File dir = new File(DOWNLOAD_PATH);
                if (!dir.exists()) {
                    dir.mkdir();
                }
                mFileInfo.setLength(length);
                Message message = handler.obtainMessage(MSG_INIT, mFileInfo);
                message.sendToTarget();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (httpURLConnection != null) {
                    httpURLConnection.disconnect();
                }
            }
        }
    }

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

主要的核心代码就展示完了 具体的一些细节 我会在文末贴上源码的下载地址

五 一些补充

因为我们是在后台服务中进行下载 如何处理用户手动强行杀死这个进程,当进程杀死的时候也许还有线程正在进行 线程并未执行完毕,因此 我们可以通过我们sql中的一个属性state进行判断 首先判断服务中的Map是否为空,如果为空的话再去sql中查询哪些是state为正在下载的任务,那么我们将这些任务继续下载

     //强行杀死进程重启之后筛选未完成的任务继续下载
        if (DownloadService.mTasks.size() == 0){
            List<ThreadInfo> allContinueThreads = dao.getAllContinueThreads();
            for (ThreadInfo allContinueThread : allContinueThreads) {
                Intent intent = new Intent(this, DownloadService.class);
                FileInfo fileInfo = new FileInfo();
                fileInfo.setFileName(allContinueThread.getTitle());
                fileInfo.setId(allContinueThread.getId());
                fileInfo.setUrl(allContinueThread.getUrl());
                intent.putExtra("fileInfo", fileInfo);
                intent.setAction(DownloadService.ACTION_START);
                startService(intent);
            }
        }

上面的具体效果为下面的效果图
在这里插入图片描述

源码地址:
https://github.com/louyulin/DownTask

娄裕霖
关注
android多线程断点下载
01-13
android多线程断点下载，完美封装，包括暂停功能。写好接口，android小白即能轻松上手。
android多线程断点下载，源码+实例
03-16
摘要:Java源码,Android源码,多线程,断点下载　android多线程断点下载，通过本Android下载实例，可了解到以下知识技巧：实时得到文件下载的长度，设置获取实体数据的范围、获取文件已下载文件长度、原始文件长度、...
Android开发中的多线程
weixin_30586257的博客
12-01 178
多线程案例——计时器 这个案例中，屏幕启动之后，进入如图所示的界面。 屏幕上有一个文本框用于显示逝去的时间，此外还有一个“停止计时”按钮。案例的用例图如图所示。 能够在屏幕上“实时地显示”时间的流逝，单线程程序是无法实现的，必须要多线程程序才可以实现，即便有些计算机语言可以通过封装好的类实现这一功能，但从本质上讲这些封装好的类就是封装了一个线程。 综上所述，完成本案例用到的知识及技术如...
Android的线程和线程池
最新发布
huaihong1986的博客
07-31 649
线程分别主线程和子线程。在Android中，主线程也就是UI线程。在Android中，除了Thread本身以外，在Android中扮演线程角色的还有很多：AsyncTask、IntentService以及HandlerThread。对AsyncTask来说，底层使用了线程池。对与IntentService和HandlerThread来说，它们的底层则直接使用了线程。HandlerThread是一种特殊的线程，具有消息循环的线程，在它内部可以直接使用Handler。
Android实现网络多线程文件下载
dawuafang
08-07 389
实现原理 (1)首先获得下载文件的长度，然后设置本地文件的长度。 (2)根据文件长度和线程数计算每条线程下载的数据长度和下载位置。 如：文件的长度为6M，线程数为3，那么，每条线程下载的数据长度为2M，每条线程开始下载的位置如下图所示： （网上找的图） 例如10M大小，使用3个线程来下载， 线程下载的数据长度 (10%3 == 0 ？ 10/3:10/3+1) ,第1，2个线程下...
Android中的多线程断点下载
weixin_30838921的博客
12-19 112
首先来看一下多线程下载的原理。多线程下载就是将同一个网络上的原始文件根据线程个数分成均等份，然后每个单独的线程下载对应的一部分，然后再将下载好的文件按照原始文件的顺序“拼接”起来就构成了完整的文件了。这样就大大提高了文件的下载效率。对于文件下载来说，多线程下载是必须要考虑的环节。 多线程下载大致可分为以下几个步骤： 一．获取服务器上的目标文件的大...
Android多线程断点续传下载示例详解
01-20
在上一篇博文《Android多线程下载示例》中，我们讲解了如何实现Android的多线程下载功能，通过将整个文件分成多个数据块，开启多个线程，让每个线程分别下载一个相应的数据块来实现多线程下载的功能。多线程下载中，...
Android多线程文件夹下载及断点续传
08-07
在Android开发中，进行大文件下载时，为了提高效率并充分利用设备资源，通常会采用多线程下载技术。此外，为了提升用户体验，断点续传功能也显得尤为重要，尤其是在网络不稳定或者用户中断下载后，可以从上次停止的...
Android多线程断点下载（优化）
03-22
在本文中，我们将深入探讨Android多线程断点下载的原理、实现方式以及优化策略。 首先，了解多线程的基本概念是必要的。在单线程下载中，数据流通常是顺序的，如果网络状况不佳，整个下载过程将受到影响。而多线程...
Android FTP 多线程断点续传下载\上传的实例
08-29
总之，Android FTP多线程断点续传下载和上传涉及文件系统的操作、网络通信、多线程同步等多个技术点，需要理解FTP协议的基本原理，熟练使用FTPClient类，并处理好异常和状态管理，才能实现稳定可靠的文件传输功能。
Android多线程断点下载框架
09-06
支持断点下线，支持多线程下载，支持列表下载管理、支持通知栏下载。
Android文件下载——多线程断点下载
梦否
10-09 1480
1. 前言     在前面的博客中简单实现了Android单线程断点下载以及Android文件多线程下载，这篇将实现多线程断点下载。对于断点下载，我们知道主要是为了实现不重复下载上次下载过的数据文件内容，而和前面实践的区别在于我们将从单线程环境拓展到多线程环境中。下面简单整理下思路。 2. 设计思路 确定多线程环境下的线程数量； 确定每个线程自己所需要下载的数据范围； 每个线程下载的数据，使用临时文件进行存储，最终进行文件合并。 （测试结果发现合并太耗时了，故而不考虑使用临时文件的方式。） 记录每个线程下
Android多线程断点下载
红旺永福
08-23 887
断点下载，多线程任务处理，自己封装，不对的地方，请大家指正！
即拿即用-Android多线程断点下载
weifeng的博客
04-21 836
线程下载只需要确定好下载一个文件需要多少个线程，一般来说最好为3条线程，因为线程过多会占用系统资源，而且线程间的相互竞争也会导致下载变慢。其次下载的时候将文件分割为三份（假设用3条线程下载）下载，在java中就要用到上次提到的RandomAccessFile这个API，它的开始结束为止用以下代码确定：conn.setRequestProperty(“Range”, “bytes=” + start
Android 文件下载--普通多线程下载
此博客已停用，博文会逐渐转移到新地址，http://blog.csdn.net/liupeifeng3514
04-06 1199
我们都知道使用多线程下载文件可以更快地完成文件的下载,但是为什么呢? 答：因为抢占的服务器资源多,假设服务器最多服务100个用户,服务器中的一个线程 对应一个用户100条线程在计算机中并发执行,由CPU划分时间片轮流执行,加入a有99条线程 下载文件,那么相当于占用了99个用户资源,自然就有用较快的下载速度 PS:当然不是线程越多就越好,开启过多线程的话,app需要维护和同步每条线程的开销, 这
Android基础篇-多线程断点下载（三）
王涛的博客
11-21 1181
效果图： Log: 网上关于讲解挺多的，我这里不讲解了，不懂的可以评论留言，从问题中解决问题 我可以说一下我解决问题的方式，将复杂问题划分成多个简单的问题多线程下载一：请点击这里多线程下载二：请点击这里权限： <uses-permission android:name="android.permission.INTERNET"></uses-permission> <uses-perm
Android多线程断点下载实现与优化
"本文主要探讨如何在...总结来说，Android实现多线程断点下载涉及到文件分块、多线程同步、进度保存和恢复等多个技术点。理解这些概念并合理运用，可以帮助开发者构建高效、可靠的下载管理系统，提升用户下载体验。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值