[工具库]JFileDownloader工具类——多线程下载网络文件，并保存在本地

本人大四即将毕业的准程序员（JavaSE、JavaEE、android等）一枚，小项目也做过一点，于是乎一时兴起就写了一些工具。

我会在本博客中陆续发布一些平时可能会用到的工具。

代码质量可能不是很好，大家多担待！

代码或者思路有不妥之处，还希望大牛们能不吝赐教哈！

以下代码为本人原创，转载请注明：

本文转载，来自：http://www.cnblogs.com/tiantianbyconan/archive/2013/02/20/2919132.html

JFileDownloader：用于多线程下载网络文件，并保存在本地。

源码如下：

1.JFileDownloader类：主要负责下载的初始化可启动工作。

package com.wangjie.extrautil.jfiledownloader;

import java.io.File;
import java.net.HttpURLConnection;
import java.net.URL;

/**
 * 
 * @author wangjie
 * @version 创建时间：2013-2-7 下午1:40:52
 */
public class JFileDownloader{
    private String urlPath;
    private String destFilePath;
    private int threadCount;
    private JFileDownloadThread[] threads;
    
    private JFileDownloadListener fileDownloadListener; // 进度监听器
    private JFileDownloaderNotificationThread notificationThread; // 通知进度线程
    
    private File destFile;
    /**
     * 下载过程中文件的后缀名。
     */
    public final static String DOWNLOADING_SUFFIX = ".jd"; 
    /**
     * 默认使用的线程数量。<br>
     * 如果不设置线程数量参数（threadCount），则默认线程启动数量为1，即单线程下载。
     */
    public static final int DEFAULT_THREADCOUNT = 1;
    /**
     * 生成JFileDownloader对象。
     * @param urlPath 要下载的目标文件URL路径
     * @param destFilePath 要保存的文件目标（路径+文件名）
     * @param threadCount 下载该文件所需要的线程数量
     */
    public JFileDownloader(String urlPath, String destFilePath, int threadCount) {
        this.urlPath = urlPath;
        this.destFilePath = destFilePath;
        this.threadCount = threadCount;
    }
    /**
     * 生成JFileDownloader对象，其中下载线程数量默认是1，也就是选择单线程下载。
     * @param urlPath urlPath 要下载的目标文件URL路径
     * @param destFilePath destFilePath 要保存的文件目标（路径+文件名）
     */
    public JFileDownloader(String urlPath, String destFilePath) {
        this(urlPath, destFilePath, DEFAULT_THREADCOUNT);
    }
    /**
     * 默认的构造方法，使用构造方法后必须要调用set方法来设置url等下载所需配置。
     */
    public JFileDownloader() {
        
    }
    /**
     * 开始下载方法（流程分为3步）。
     * <br><ul>
     * <li>检验URL的合法性<br>
     * <li>计算下载所需的线程数量和每个线程需下载多少大小的文件<br>
     * <li>启动各线程。
     * </ul>
     * @author wangjie
     * @throws Exception 如果设置的URL，includes等参数不合法，则抛出该异常
     */
    public void startDownload() throws Exception{
        checkSettingfValidity(); // 检验参数合法性
        
        URL url = new URL(urlPath);
        HttpURLConnection conn = (HttpURLConnection)url.openConnection();
        conn.setConnectTimeout(20 * 1000);
        // 获取文件长度
        long size = conn.getContentLength();
//        int size = conn.getInputStream().available();
        if(size < 0 || null == conn.getInputStream()){
            throw new Exception("网络连接错误，请检查URL地址是否正确");
        }
        conn.disconnect();
        
        
        // 计算每个线程需要下载多少byte的文件
        long perSize = size % threadCount == 0 ? size / threadCount : (size / threadCount + 1);
        // 建立目标文件（文件以.jd结尾）
        destFile = new File(destFilePath + DOWNLOADING_SUFFIX);
        destFile.createNewFile();
        
        threads = new JFileDownloadThread[threadCount];
        
        // 启动进度通知线程
        notificationThread = new JFileDownloaderNotificationThread(threads, fileDownloadListener, destFile, size);
        notificationThread.start();
        
        // 初始化若干个下载线程
        for(int i = 0; i < threadCount; i++){
            if(i != (threadCount - 1)){
                threads[i] = new JFileDownloadThread(urlPath, destFile, 
                        i * perSize, perSize, notificationThread);
            }else{
                threads[i] = new JFileDownloadThread(urlPath, destFile, 
                        i * perSize, size - (threadCount - 1) * perSize, notificationThread);
            }
            threads[i].setPriority(8);
//            threads[i].start();
        }
        // 启动若干个下载线程（因为下载线程JFileDownloaderNotificationThread中使用了threads属性，所以必须等下载线程全部初始化以后才能启动线程）
        for(JFileDownloadThread thread : threads){
            thread.start();
        }
        
    }
    /**
     * 取消所有下载线程。
     * @author wangjie
     */
    public void cancelDownload(){
        if(null != threads && 0 != threads.length && null != notificationThread){
            for(JFileDownloadThread thread : threads){ // 终止所有下载线程
                thread.cancelThread();
            }
            notificationThread.cancelThread(); // 终止通知线程
            System.out.println("下载已被终止。");
            return;
        }
        System.out.println("下载线程还未启动，无法终止。");
    }
    
    /**
     * 设置要下载的目标文件URL路径。
     * @author wangjie
     * @param urlPath 要下载的目标文件URL路径
     * @return 返回当前JFileDownloader对象
     */
    public JFileDownloader setUrlPath(String urlPath) {
        this.urlPath = urlPath;
        return this;
    }
    /**
     * 设置要保存的目标文件（路径+文件名）。
     * @author wangjie
     * @param destFilePath 要保存的文件目标（路径+文件名）
     * @return 返回当前JFileDownloader对象
     */
    public JFileDownloader setDestFilePath(String destFilePath) {
        this.destFilePath = destFilePath;
        return this;
    }
    /**
     * 设置下载该文件所需要的线程数量。
     * @author wangjie
     * @param threadCount 下载该文件所需要的线程数量
     * @return 返回当前JFileDownloader对象
     */
    public JFileDownloader setThreadCount(int threadCount) {
        this.threadCount = threadCount;
        return this;
    }
    
    //观察者模式来获取下载进度
    /**
     * 设置监听器，以获取下载进度。
     */
    public JFileDownloader setFileDownloadListener(
            JFileDownloadListener fileDownloadListener) {
        this.fileDownloadListener = fileDownloadListener;
        return this;
    }
    /**
     * 通过该方法移出相应的监听器对象。
     * @author wangjie
     * @param fileDownloadListener 要移除的监听器对象
     */
    public void removeFileDownloadListener(
            JFileDownloadListener fileDownloadListener) {
        fileDownloadListener = null;
    }


    /**
     * 检验设置的参数是否合法。
     * @author wangjie
     * @throws Exception 目标文件URL路径不合法，或者线程数小于1，则抛出该异常
     */
    private void checkSettingfValidity() throws Exception{
        if(null == urlPath || "".equals(urlPath)){
            throw new Exception("目标文件URL路径不能为空");
        }
        if(threadCount < 1){
            throw new Exception("线程数不能小于1");
        }
    }
    
}

2.JFileDownloadListener接口：该接口用于监听JFileDownloader下载的进度。

package com.wangjie.extrautil.jfiledownloader;

import java.io.File;

/**
 * 
 * 该接口用于监听JFileDownloader下载的进度。
 * 
 * @author wangjie
 * @version 创建时间：2013-2-7 下午2:12:45
 */
public interface JFileDownloadListener {
    /**
     * 该方法可获得文件的下载进度信息。
     * @author wangjie
     * @param progress 文件下载的进度值，范围（0-100）。0表示文件还未开始下载；100则表示文件下载完成。
     * @param speed 此时下载瞬时速度（单位：kb/每秒）。
     * @param remainTime 此时剩余下载所需时间（单位为毫秒）。
     */
    public void downloadProgress(int progress, double speed, long remainTime);
    /**
     * 文件下载完成会调用该方法。
     * @author wangjie
     * @param file 返回下载完成的File对象。
     * @param downloadTime 下载所用的总时间（单位为毫秒）。
     */
    public void downloadCompleted(File file, long downloadTime);
}

3.JFileDownloaderNotificationThread类：该线程为通知下载进度的线程。

package com.wangjie.extrautil.jfiledownloader;

import java.io.File;
import java.math.BigDecimal;

/**
 * 该线程为通知下载进度的线程。
 * 用于在下载未完成时通知用户下载的进度，范围（0-100）。0表示文件还未开始下载；100则表示文件下载完成。
 * 此时下载瞬时速度（单位：kb/每秒）。
 * 在完成时返回下载完成的File对象给用户。返回下载所用的总时间（单位为毫秒）给用户。
 * @author wangjie
 * @version 创建时间：2013-2-17 下午12:23:59
 */
public class JFileDownloaderNotificationThread extends Thread{
    private JFileDownloadThread[] threads;
    private JFileDownloadListener fileDownloadListener;
    private File destFile;
    private long destFileSize;
    private boolean isRunning; // 线程运行停止标志
    private boolean notificationTag; // 通知标志
    /**
     * 通过该方法构建一个进度通知线程。
     * @param threads 下载某文件需要的所有线程。
     * @param fileDownloadListener 要通知进度的监听器对象。
     * @param destFile 下载的文件对象。
     */
    public JFileDownloaderNotificationThread(JFileDownloadThread[] threads,
            JFileDownloadListener fileDownloadListener, File destFile, long destFileSize) {
        this.threads = threads;
        this.fileDownloadListener = fileDownloadListener;
        this.destFile = destFile;
        this.destFileSize = destFileSize;
    }

    /**
     * 不断地循环来就检查更新进度。
     */
    @Override
    public void run() {
        isRunning = true;
        long startTime = 0;
        if(null != fileDownloadListener){
            startTime = System.currentTimeMillis(); // 文件下载开始时间
        }
        
        long oldTemp = 0; // 上次已下载数据长度
        long oldTime = 0; // 上次下载的当前时间
        
        while(isRunning){
            if(notificationTag){ // 如果此时正等待检查更新进度。
                // 计算此时的所有线程下载长度的总和
                long temp = 0;
                for(JFileDownloadThread thread : threads){
                    temp += thread.currentLength;
                }
//                System.out.println("temp: " + temp);
//                System.out.println("destFileSize: " + destFileSize);
                // 换算成进度
                int progress = (int) ((double)temp * 100 / (double)destFileSize);
                
                // 把进度通知给监听器
                if(null != fileDownloadListener){
                    // 计算瞬时速度
                    long detaTemp = temp - oldTemp; // 两次更新进度的时间段内的已下载数据差
                    long detaTime = System.currentTimeMillis() - oldTime; // 两次更新进度的时间段内的时间差 
                    // 两次更新进度的时间段内的速度作为瞬时速度
                    double speed = ((double)detaTemp / 1024) / ((double)(detaTime) / 1000); 
                    
                    // 保留小数点后2位，最后一位四舍五入
                    speed = new BigDecimal(speed).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
                    
                    // 计算剩余下载时间
                    double remainTime = (double)(destFileSize - temp) / speed;
                    if(Double.isInfinite(remainTime) || Double.isNaN(remainTime)){
                        remainTime = 0;
                    }else{
                        remainTime = new BigDecimal(remainTime).setScale(0, BigDecimal.ROUND_HALF_UP).longValue();
                    }
                    
                    // 通知监听者进度和速度以及下载剩余时间
                    fileDownloadListener.downloadProgress(progress, speed, (long)remainTime);
                    
                    // 重置上次已下载数据长度和上次下载的当前时间
                    oldTemp = temp;
                    oldTime = System.currentTimeMillis();
                }
                
                // 如果下载进度达到100，则表示下载完毕
                if(100 <= progress){
                    // 给下载好的文件进行重命名，即去掉DOWNLOADING_SUFFIX后缀
                    String oldPath = destFile.getPath();
                    File newFile = new File(oldPath.substring(0, oldPath.lastIndexOf(".")));
                    // 检查去掉后的文件是否存在。如果存在，则删除原来的文件并重命名下载的文件（即：覆盖原文件）
                    if(newFile.exists()){
                        newFile.delete();
                    }
                    System.out.println(destFile.renameTo(newFile));// 重命名
                    // 通知监听器，并传入新的文件对象
                    if(null != fileDownloadListener){
                        fileDownloadListener.downloadCompleted(newFile, System.currentTimeMillis() - startTime);
                    }
                    isRunning = false; // 文件下载完就结束通知线程。
                }
                notificationTag = false;
            }
            // 设置为每100毫秒进行检查并更新通知
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            
        }
        
    }
    /**
     * 调用这个方法，则会使得线程处于待检查更新进度状态。
     * @author wangjie
     */
    public synchronized void notificationProgress(){
        notificationTag = true;
    }
    /**
     * 取消该通知线程
     * @author wangjie
     */
    public void cancelThread(){
        isRunning = false;
    }
    

}

4.JFileDownloadThread类：真正的下载线程，该线程用于执行该线程所要负责下载的数据。

package com.wangjie.extrautil.jfiledownloader;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.RandomAccessFile;
import java.net.HttpURLConnection;
import java.net.URL;

/**
 * 
 * 真正的下载线程，该线程用于执行该线程所要负责下载的数据。
 * 
 * @author wangjie
 * @version 创建时间：2013-2-7 上午11:58:24
 */
public class JFileDownloadThread extends Thread{
    private String urlPath;
    private File destFile;
    private long startPos;
    /**
     * 此线程需要下载的数据长度。
     */
    public long length;
    /**
     * 此线程现在已下载好了的数据长度。
     */
    public long currentLength;
    
    private JFileDownloaderNotificationThread notificationThread;
    private boolean isRunning = true;
    
    /**
     * 构造方法，可生成配置完整的JFileDownloadThread对象
     * @param urlPath 要下载的目标文件URL
     * @param destFile 要保存的目标文件
     * @param startPos 该线程需要下载目标文件第几个byte之后的数据
     * @param length 该线程需要下载多少长度的数据
     * @param notificationThread 通知进度线程
     */
    public JFileDownloadThread(String urlPath, File destFile, long startPos,
            long length, JFileDownloaderNotificationThread notificationThread) {
        this.urlPath = urlPath;
        this.destFile = destFile;
        this.startPos = startPos;
        this.length = length;
        this.notificationThread = notificationThread;
    }
    /**
     * 该方法将执行下载功能，并把数据存储在目标文件中的相应位置。
     */
    @Override
    public void run() {
        RandomAccessFile raf = null;
        HttpURLConnection conn = null;
        InputStream is = null;
        try {
//            URL url = new URL("http://localhost:8080/firstserver/files/hibernate.zip");
            URL url = new URL(urlPath);
            conn = (HttpURLConnection)url.openConnection();
            conn.setConnectTimeout(20 * 1000);
            is = conn.getInputStream();
            raf = new RandomAccessFile(destFile, "rw");
            raf.setLength(conn.getContentLength()); // 设置保存文件的大小
//            raf.setLength(conn.getInputStream().available());
            
            // 设置读入和写入的文件位置
            is.skip(startPos);
            raf.seek(startPos);
            
            currentLength = 0; // 当前已下载好的文件长度
            byte[] buffer = new byte[1024 * 1024];
            int len = 0;
            while(currentLength < length && -1 != (len = is.read(buffer))){
                if(!isRunning){
                    break;
                }
                if(currentLength + len > length){
                    raf.write(buffer, 0, (int)(length - currentLength));
                    currentLength = length;
                    notificationThread.notificationProgress(); // 通知进度线程来更新进度
                    return;
                }else{
                    raf.write(buffer, 0, len);
                    currentLength += len;
                    notificationThread.notificationProgress(); // 通知进度线程来更新进度
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally{
            try {
                is.close();
                raf.close();
                conn.disconnect();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        
    }
    /**
     * 取消该线程下载
     * @author wangjie
     */
    public void cancelThread(){
        isRunning = false;
    }
    
    
}

使用方法如下：

String urlPath = "http://localhost:8080/firstserver/files/test.zip";
String destFilePath = "C:\\Users\\admin\\Desktop\\杂\\临时仓库\\test.zip";
int threadCount = 3;

JFileDownloader downloader = new JFileDownloader(urlPath, destFilePath, threadCount);
//或者：
JFileDownloader downloader = new JFileDownloader()
            .setUrlPath(urlPath)
            .setDestFilePath(destFilePath)
            .setThreadCount(threadCount)
            .setFileDownloadListener(new JFileDownloadListener() { // 设置进度监听器
                    public void downloadProgress(int progress, double speed, long remainTime) {
                        System.out.println("文件已下载：" + progress + "%，下载速度为：" + speed + "kb/s，剩余所需时间：" + remainTime + "毫秒");
                    }
                    public void downloadCompleted(File file, long downloadTime) {
                        System.out.println("文件：" + file.getName() + "下载完成，用时：" + downloadTime + "毫秒");
                    }
            });
    try {
        downloader.startDownload(); // 开始下载
    } catch (Exception e) {
        e.printStackTrace();
    }