一种下载管理方案的设计与实现开发者社区

link之家

链接快照平台

输入网页链接，自动生成快照
标签化管理网页链接

一种下载管理方案的设计与实现

    /**
     * 开始一个下载任务
     * @param url      文件下载地址
     * @param dir      文件下载后保存的目录地址，该值为空时会默认使用应用的文件缓存目录作为保存目录地址
     * @param name     文件名，文件名需要包括文件扩展名。该值可为空，为空时将由程序决定文件名。  
     * @param headers  请求头参数
     * @param priority 任务优先级
     * @param listener 下载监听器
    public synchronized void dlStart(String url, String dir, String name, List headers, int priority,
                                     IDListener listener) {
        // 验证优先级合法
        if (priority != PRIORITY_LOW && priority != PRIORITY_NORMAL && priority != PRIORITY_HIGH && priority !=
                PRIORITY_UNSPECIFIED) {
            throw new IllegalArgumentException("Priority illegal. Please set a correct priority between PRIORITY_LOW," +
                    " " +
                    "PRIORITY_NORMAL, PRIORITY_HIGH and PRIORITY_UNSPECIFIED.");
        boolean hasListener = listener != null;
        if (TextUtils.isEmpty(url)) {
            if (hasListener) {
                listener.onError(ERROR_INVALID_URL, "Url can not be null.", url);
            return;
        if (!NetworkUtil.isNetworkAvailable(mContext)) {
            if (hasListener) {
                listener.onError(ERROR_NOT_NETWORK, "Network is not available.", url);
            return;
        // 是正在下载或排队的任务
        if (TASK_DLING.containsKey(url) || isQueueing(url)) {
            if (hasListener) {
                listener.onError(ERROR_REPEAT_URL, "Url is downloading.", url);
            return;
        // 不是正在下载或排队的任务
        LogUtil.logD(TAG, "不是正在下载的任务");
        DLTaskInfo info;
        // 是否是就绪任务或上次未执行过的排队任务
        boolean isReadyTask = false;
        // 是运行/排队过的已暂停的任务
        if (TASK_STOPPED.containsKey(url)) {
            LogUtil.logD(TAG, "是运行/排队过的已暂停的任务，恢复下载.");
            info = TASK_STOPPED.remove(url);
        // 内存任务列表中不存在该任务，从数据库中读取任务信息（本次运行未启动过该任务的下载）
        else {
            LogUtil.logD(TAG, "不是运行过的已暂停任务，从数据库中恢复");
            info = DLDBManager.getInstance().queryTaskInfo(url);
            if (null != info) {
                LogUtil.logD(TAG, "数据库中查到信息");
                // directly add task case
                List threadInfo = DLDBManager.getInstance().queryAllThreadInfo(url);
                if (threadInfo == null) {
                    LogUtil.logD(TAG, "是就绪任务或上次未执行过的排队任务");
                    isReadyTask = true;
                } else {
                    LogUtil.logD(TAG, "是已暂停的任务");
                    info.threads.clear();
                    info.threads.addAll(threadInfo);
        // 新建任务
        if (!isReadyTask && null == info) {
            LogUtil.logD(TAG, "新建任务");
            info = new DLTaskInfo();
            info.baseUrl = url;
            info.realUrl = url;
            dir = TextUtils.isEmpty(dir) ? mContext.getCacheDir().getAbsolutePath() : dir;
            info.dirPath = dir;
            info.fileName = name;
        // 断点续传任务（不是单线程任务）
        else if (!info.isSingleThread) {
            LogUtil.logD(TAG, "断点续传任务（不是单线程任务）");
            info.isResume = !isReadyTask;
            for (DLThreadInfo threadInfo : info.threads) {
                threadInfo.isStop = false;
        info.redirect = 0;
        info.requestHeaders = DLUtil.initRequestHeaders(headers, info);
        info.listener = listener;
        info.hasListener = hasListener;
        // 未指定优先级
        if (priority == PRIORITY_UNSPECIFIED) {
            if (info.priority == PRIORITY_UNSPECIFIED) {
                // 任务未指定优先级，使用中优先级
                info.priority = PRIORITY_NORMAL;
        // 使用外部指定的优先级
        else {
            info.priority = priority;
        // 任务插入数据库
        if (DLDBManager.getInstance().queryTaskInfo(url) == null) {
            DLDBManager.getInstance().insertTaskInfo(info);
        if (hasListener) {
            listener.onCreate(info);
        resetQueue(info); // 强制isQueue复位
        // 检查当前下载任务数和优先级
        if (TASK_DLING.size() >= mMaxTask) {
            DLTaskInfo lowestPriorityDLTask = TASK_DLING_PRIO.get(TASK_DLING_PRIO.size() - 1);
            LogUtil.logD(TAG, "TASK_DLING_PRIO中最低优先级为" + lowestPriorityDLTask.priority);
            LogUtil.logD(TAG, "调用dlStart的任务优先级为" + info.priority);
            // 若当前下载队列中存在更低优先级的任务
            if (lowestPriorityDLTask.priority > info.priority) {
                LogUtil.logD(TAG, "当前下载队列中存在更低优先级的任务，正在下载队列中最低优先级任务进入排队");
                dlQueue(lowestPriorityDLTask.baseUrl);
            // 若当前下载队列中不存在更低优先级的任务
            else {
                LogUtil.logD(TAG, "当前下载队列中不存在更低优先级的任务");
                addQueueTask(info);
                return;
        addDLTaskPriority(info);
        TASK_DLING.put(url, info);
        info.status = STATUS_DOWNLOADING;
        if (hasListener) {
            listener.onPrepare(info.baseUrl);
        LogUtil.logD(TAG, "准备运行任务URL：" + url);
        POOL_TASK.execute(new DLTask(info));
    }

    /**
     * 调度排队任务
     * @return
    synchronized DLManager scheduleDLTask() {
        if (!TASK_QUEUE.isEmpty()) {
            if (TASK_DLING.size() >= mMaxTask) {
                LogUtil.logD(TAG, "TASK_DLING_PRIO中最低优先级为" + TASK_DLING_PRIO.get(TASK_DLING_PRIO.size() - 1).priority);
                LogUtil.logD(TAG, "TASK_PREPARE中最高优先级为" + TASK_QUEUE.get(0).priority);
                if (TASK_DLING_PRIO.get(TASK_DLING_PRIO.size() - 1).priority < TASK_QUEUE.get(0).priority) {
                    LogUtil.logD(TAG, "排序队列中没有可替换调度的任务");
            } else {
                DLTaskInfo info = popPrepareTask();
                addDLTaskPriority(info);
                TASK_DLING.put(info.baseUrl, info);
                info.status = STATUS_DOWNLOADING;
                if (info.hasListener) {
                    info.listener.onPrepare(info.baseUrl);
                POOL_TASK.execute(new DLTask(info));
        return sManager;
    }

    private final ExecutorService POOL_TASK = new ThreadPoolExecutor(POOL_SIZE,
            POOL_SIZE_MAX, 3, TimeUnit.SECONDS, POOL_QUEUE_TASK, TASK_FACTORY);
    private final ExecutorService POOL_Thread = new ThreadPoolExecutor(POOL_SIZE * 5,
            POOL_SIZE_MAX * 5, 1, TimeUnit.SECONDS, POOL_QUEUE_THREAD, THREAD_FACTORY);

    /**
     * 设置线程信息
    private void dlDispatch() {
        int threadSize;
        int threadLength;
        // 线程数下限: 小于LENGTH_PER_THREAD开单线程
        if (info.totalBytes <= LENGTH_PER_THREAD) {
            threadSize = 1;
        // 线程数上限: 大于LENGTH_PER_THREAD * 2开2个线程
        else if (info.totalBytes > LENGTH_PER_THREAD * 2) {
            threadSize = 2;
        // 根据文件大小分配线程
        else {
            threadSize = info.totalBytes / LENGTH_PER_THREAD;
        threadLength = info.totalBytes / threadSize;
        int remainder = info.totalBytes % threadLength;
        LogUtil.logD(TAG, "thread calc finished:" + info.baseUrl + ", threadSize=" + threadSize);
        for (int i = 0; i < threadSize; i++) {
            int start = i * threadLength;
            int end = start + threadLength - 1;
            if (i == threadSize - 1) {
                end = start + threadLength + remainder;
            DLThreadInfo threadInfo =
                    new DLThreadInfo(UUID.randomUUID().toString(), info.baseUrl, start, end);
            info.addDLThread(threadInfo);
            DLDBManager.getInstance().insertThreadInfo(threadInfo);
            DLManager.getInstance().addDLThread(new DLThread(threadInfo, info, this));
            LogUtil.logD(TAG, "not resume task thread added:" + info.baseUrl);
    }

    /**
     * 添加请求头参数
     * @param conn
    private void addRequestHeaders(HttpURLConnection conn) {
        for (DLHeader header : dlInfo.requestHeaders) {
            conn.addRequestProperty(header.key, header.value);
        conn.setRequestProperty("Range", "bytes=" + dlThreadInfo.start + "-" + dlThreadInfo.end);
    }

            raf = new RandomAccessFile(dlInfo.file, "rw");
            fd = raf.getFD();
            // 定位到开始写文件位置
            raf.seek(dlThreadInfo.start);
            byte[] b = new byte[RAF_BUFFER_SIZE];
            int len;
            while (!dlThreadInfo.isStop && !dlThreadInfo.isCancel && !dlThreadInfo.isQueue && !dlInfo.isQueue && (len
                    = bis.read(b)) != -1) {
                dlThreadInfo.start += len;
                raf.write(b, 0, len);
                listener.onProgress(len, fd, dlThreadInfo);
            }

   @Override
    public synchronized void onProgress(int progress, FileDescriptor fd, DLThreadInfo threadInfo) {
        info.currentBytes += progress;
        LogUtil.logD(TAG, info.currentBytes + "");
        long timeNow = SystemClock.elapsedRealtime();
        long timeDelta = timeNow - lastTime;
        int bytesDelta = info.currentBytes - lastTotalBytes;
        if (timeDelta > MIN_PROGRESS_INTERVAL && bytesDelta > MIN_PROGRESS_STEP) {
            // 同步文件
            if (fd != null) {
                try {
                    fd.sync();
                } catch (SyncFailedException e) {
                    e.printStackTrace();
            // 更新数据库
            if (threadInfo != null) {
                DLDBManager.getInstance().updateThreadInfo(threadInfo);
                DLDBManager.getInstance().updateTaskInfo(info);
            // 保存本次进度
            lastTime = timeNow;
            lastTotalBytes = info.currentBytes;
            // 通知UI
            if (info.hasListener) {
                info.listener.onProgress(info.currentBytes, info.totalBytes, info.baseUrl);
    }

/**
 * 使用EventBus的Download Listener
public class EventBusDLListener implements IDListener {
    @Override
    public void onCreate(DLTaskInfo info) {
        EventBus.getDefault().post(new DLCreateEvent(info));
    @Override
    public void onPrepare(String baseUrl) {
        EventBus.getDefault().post(new DLPrepareEvent(baseUrl));
    @Override
    public void onStart(String fileName, String baseUrl, int fileLength) {
        EventBus.getDefault().post(new DLStartEvent(fileName, baseUrl, fileLength));
    @Override
    public void onProgress(int progress, int total, String baseUrl) {
        EventBus.getDefault().post(new DLProgressEvent(progress, total, baseUrl));
    @Override
    public void onStop(int progress, String baseUrl) {
        EventBus.getDefault().post(new DLStopEvent(progress, baseUrl));
    @Override
    public void onFinish(File file, String baseUrl) {
        EventBus.getDefault().post(new DLFinishEvent(file, baseUrl));
    @Override
    public void onError(int status, String error, String baseUrl) {
        EventBus.getDefault().post(new DLErrorEvent(status, error, baseUrl));
    @Override
    public void onCancel(String baseUrl) {
        EventBus.getDefault().post(new DLCancelEvent(baseUrl));
    @Override
    public void onQueue(String baseUrl) {

一种下载管理方案的设计与实现

一种下载管理方案的设计与实现

一、技术调研

1.1 DownloadManager

1.2 第三方开源下载组件

二、需求分析

三、详细设计

3.1 下载任务状态

3.2 下载任务控制

3.3 关键技术的实现

3.3.1 任务队列

3.3.2 任务调度

3.3.3 任务/线程模型（DLTask/DLThread）

3.3.4 数据表设计

3.3.5 消息通知