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

  1 package com.wangjie.extrautil.jfiledownloader;
  2
  3 import java.io.File;
  4 import java.net.HttpURLConnection;
  5 import java.net.URL;
  6
  7 /
  8  
  9   @author wangjie
 10   @version 创建时间：2013-2-7 下午1:40:52
 11  /
 12 public class JFileDownloader{
 13     private String urlPath;
 14     private String destFilePath;
 15     private int threadCount;
 16     private JFileDownloadThread[] threads;
 17
 18     private JFileDownloadListener fileDownloadListener; // 进度监听器
 19     private JFileDownloaderNotificationThread notificationThread; // 通知进度线程
 20
 21     private File destFile;
 22     /
 23       下载过程中文件的后缀名。
 24      /
 25     public final static String DOWNLOADING_SUFFIX = “.jd”;
 26     /
 27       默认使用的线程数量。<br>
 28       如果不设置线程数量参数（threadCount），则默认线程启动数量为1，即单线程下载。
 29      */
 30     public static final int DEFAULT_THREADCOUNT = 1;
 31     /
 32       生成JFileDownloader对象。
 33       @param urlPath 要下载的目标文件URL路径
 34       @param destFilePath 要保存的文件目标（路径+文件名）
 35       @param threadCount 下载该文件所需要的线程数量
 36      /
 37     public JFileDownloader(String urlPath, String destFilePath, int threadCount) {
 38         this.urlPath = urlPath;
 39         this.destFilePath = destFilePath;
 40         this.threadCount = threadCount;
 41     }
 42     /**
 43       生成JFileDownloader对象，其中下载线程数量默认是1，也就是选择单线程下载。
 44       @param urlPath urlPath 要下载的目标文件URL路径
 45       @param destFilePath destFilePath 要保存的文件目标（路径+文件名）
 46      /
 47     public JFileDownloader(String urlPath, String destFilePath) {
 48         this(urlPath, destFilePath, DEFAULT_THREADCOUNT);
 49     }
 50     /**
 51       默认的构造方法，使用构造方法后必须要调用set方法来设置url等下载所需配置。
 52      /
 53     public JFileDownloader() {
 54
 55     }
 56     /**
 57       开始下载方法（流程分为3步）。
 58       <br><ul>
 59       <li>检验URL的合法性<br>
 60       <li>计算下载所需的线程数量和每个线程需下载多少大小的文件<br>
 61       <li>启动各线程。
 62       </ul>
 63       @author wangjie
 64       @throws Exception 如果设置的URL，includes等参数不合法，则抛出该异常
 65      /
 66     public void startDownload() throws Exception{
 67         checkSettingfValidity(); // 检验参数合法性
 68
 69         URL url = new URL(urlPath);
 70         HttpURLConnection conn = (HttpURLConnection)url.openConnection();
 71         conn.setConnectTimeout(20  1000);
 72         // 获取文件长度
 73         long size = conn.getContentLength();
 74 //        int size = conn.getInputStream().available();
 75         if(size < 0 || null == conn.getInputStream()){
 76             throw new Exception(“网络连接错误，请检查URL地址是否正确”);
 77         }
 78         conn.disconnect();
 79
 80
 81         // 计算每个线程需要下载多少byte的文件
 82         long perSize = size % threadCount == 0 ? size / threadCount : (size / threadCount + 1);
 83         // 建立目标文件（文件以.jd结尾）
 84         destFile = new File(destFilePath + DOWNLOADING_SUFFIX);
 85         destFile.createNewFile();
 86
 87         threads = new JFileDownloadThread[threadCount];
 88
 89         // 启动进度通知线程
 90         notificationThread = new JFileDownloaderNotificationThread(threads, fileDownloadListener, destFile, size);
 91         notificationThread.start();
 92
 93         // 初始化若干个下载线程
 94         for(int i = 0; i < threadCount; i++){
 95             if(i != (threadCount - 1)){
 96                 threads[i] = new JFileDownloadThread(urlPath, destFile,
 97                         i  perSize, perSize, notificationThread);
 98             }else{
 99                 threads[i] = new JFileDownloadThread(urlPath, destFile,
100                         i  perSize, size - (threadCount - 1)  perSize, notificationThread);
101             }
102             threads[i].setPriority(8);
103 //            threads[i].start();
104         }
105         // 启动若干个下载线程（因为下载线程JFileDownloaderNotificationThread中使用了threads属性，所以必须等下载线程全部初始化以后才能启动线程）
106         for(JFileDownloadThread thread : threads){
107             thread.start();
108         }
109
110     }
111     /
112       取消所有下载线程。
113       @author wangjie
114      */
115     public void cancelDownload(){
116         if(null != threads && 0 != threads.length && null != notificationThread){
117             for(JFileDownloadThread thread : threads){ // 终止所有下载线程
118                 thread.cancelThread();
119             }
120             notificationThread.cancelThread(); // 终止通知线程
121             System.out.println(“下载已被终止。”);
122             return;
123         }
124         System.out.println(“下载线程还未启动，无法终止。”);
125     }
126
127     /
128       设置要下载的目标文件URL路径。
129       @author wangjie
130       @param urlPath 要下载的目标文件URL路径
131       @return 返回当前JFileDownloader对象
132      /
133     public JFileDownloader setUrlPath(String urlPath) {
134         this.urlPath = urlPath;
135         return this;
136     }
137     /**
138       设置要保存的目标文件（路径+文件名）。
139       @author wangjie
140       @param destFilePath 要保存的文件目标（路径+文件名）
141       @return 返回当前JFileDownloader对象
142      /
143     public JFileDownloader setDestFilePath(String destFilePath) {
144         this.destFilePath = destFilePath;
145         return this;
146     }
147     /
148       设置下载该文件所需要的线程数量。
149       @author wangjie
150       @param threadCount 下载该文件所需要的线程数量
151       @return 返回当前JFileDownloader对象
152      */
153     public JFileDownloader setThreadCount(int threadCount) {
154         this.threadCount = threadCount;
155         return this;
156     }
157
158     //观察者模式来获取下载进度
159     /
160       设置监听器，以获取下载进度。
161      /
162     public JFileDownloader setFileDownloadListener(
163             JFileDownloadListener fileDownloadListener) {
164         this.fileDownloadListener = fileDownloadListener;
165         return this;
166     }
167     /
168       通过该方法移出相应的监听器对象。
169       @author wangjie
170       @param fileDownloadListener 要移除的监听器对象
171      /
172     public void removeFileDownloadListener(
173             JFileDownloadListener fileDownloadListener) {
174         fileDownloadListener = null;
175     }
176
177
178     /
179       检验设置的参数是否合法。
180       @author wangjie
181       @throws Exception 目标文件URL路径不合法，或者线程数小于1，则抛出该异常
182      /
183     private void checkSettingfValidity() throws Exception{
184         if(null == urlPath || “”.equals(urlPath)){
185             throw new Exception(“目标文件URL路径不能为空”);
186         }
187         if(threadCount < 1){
188             throw new Exception(“线程数不能小于1”);
189         }
190     }
191
192 }

 1 package com.wangjie.extrautil.jfiledownloader;
 2
 3 import java.io.File;
 4
 5 /
 6  
 7   该接口用于监听JFileDownloader下载的进度。
 8  
 9   @author wangjie
10   @version 创建时间：2013-2-7 下午2:12:45
11  /
12 public interface JFileDownloadListener {
13     /
14       该方法可获得文件的下载进度信息。
15       @author wangjie
16       @param progress 文件下载的进度值，范围（0-100）。0表示文件还未开始下载；100则表示文件下载完成。
17       @param speed 此时下载瞬时速度（单位：kb/每秒）。
18       @param remainTime 此时剩余下载所需时间（单位为毫秒）。
19      /
20     public void downloadProgress(int progress, double speed, long remainTime);
21     /*
22       文件下载完成会调用该方法。
23       @author wangjie
24       @param file 返回下载完成的File对象。
25       @param downloadTime 下载所用的总时间（单位为毫秒）。
26      /
27     public void downloadCompleted(File file, long downloadTime);
28 }

  1 package com.wangjie.extrautil.jfiledownloader;
  2
  3 import java.io.File;
  4 import java.math.BigDecimal;
  5
  6 /
  7   该线程为通知下载进度的线程。
  8   用于在下载未完成时通知用户下载的进度，范围（0-100）。0表示文件还未开始下载；100则表示文件下载完成。
  9   此时下载瞬时速度（单位：kb/每秒）。
 10   在完成时返回下载完成的File对象给用户。返回下载所用的总时间（单位为毫秒）给用户。
 11   @author wangjie
 12   @version 创建时间：2013-2-17 下午12:23:59
 13  */
 14 public class JFileDownloaderNotificationThread extends Thread{
 15     private JFileDownloadThread[] threads;
 16     private JFileDownloadListener fileDownloadListener;
 17     private File destFile;
 18     private long destFileSize;
 19     private boolean isRunning; // 线程运行停止标志
 20     private boolean notificationTag; // 通知标志
 21     /
 22       通过该方法构建一个进度通知线程。
 23       @param threads 下载某文件需要的所有线程。
 24       @param fileDownloadListener 要通知进度的监听器对象。
 25       @param destFile 下载的文件对象。
 26      /
 27     public JFileDownloaderNotificationThread(JFileDownloadThread[] threads,
 28             JFileDownloadListener fileDownloadListener, File destFile, long destFileSize) {
 29         this.threads = threads;
 30         this.fileDownloadListener = fileDownloadListener;
 31         this.destFile = destFile;
 32         this.destFileSize = destFileSize;
 33     }
 34
 35     /**
 36       不断地循环来就检查更新进度。
 37      /
 38     @Override
 39     public void run() {
 40         isRunning = true;
 41         long startTime = 0;
 42         if(null != fileDownloadListener){
 43             startTime = System.currentTimeMillis(); // 文件下载开始时间
 44         }
 45
 46         long oldTemp = 0; // 上次已下载数据长度
 47         long oldTime = 0; // 上次下载的当前时间
 48
 49         while(isRunning){
 50             if(notificationTag){ // 如果此时正等待检查更新进度。
 51                 // 计算此时的所有线程下载长度的总和
 52                 long temp = 0;
 53                 for(JFileDownloadThread thread : threads){
 54                     temp += thread.currentLength;
 55                 }
 56 //                System.out.println(“temp: “ + temp);
 57 //                System.out.println(“destFileSize: “ + destFileSize);
 58                 // 换算成进度
 59                 int progress = (int) ((double)temp  100 / (double)destFileSize);
 60
 61                 // 把进度通知给监听器
 62                 if(null != fileDownloadListener){
 63                     // 计算瞬时速度
 64                     long detaTemp = temp - oldTemp; // 两次更新进度的时间段内的已下载数据差
 65                     long detaTime = System.currentTimeMillis() - oldTime; // 两次更新进度的时间段内的时间差
 66                     // 两次更新进度的时间段内的速度作为瞬时速度
 67                     double speed = ((double)detaTemp / 1024) / ((double)(detaTime) / 1000);
 68
 69                     // 保留小数点后2位，最后一位四舍五入
 70                     speed = new BigDecimal(speed).setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
 71
 72                     // 计算剩余下载时间
 73                     double remainTime = (double)(destFileSize - temp) / speed;
 74                     if(Double.isInfinite(remainTime) || Double.isNaN(remainTime)){
 75                         remainTime = 0;
 76                     }else{
 77                         remainTime = new BigDecimal(remainTime).setScale(0, BigDecimal.ROUND_HALF_UP).longValue();
 78                     }
 79
 80                     // 通知监听者进度和速度以及下载剩余时间
 81                     fileDownloadListener.downloadProgress(progress, speed, (long)remainTime);
 82
 83                     // 重置上次已下载数据长度和上次下载的当前时间
 84                     oldTemp = temp;
 85                     oldTime = System.currentTimeMillis();
 86                 }
 87
 88                 // 如果下载进度达到100，则表示下载完毕
 89                 if(100 <= progress){
 90                     // 给下载好的文件进行重命名，即去掉DOWNLOADING_SUFFIX后缀
 91                     String oldPath = destFile.getPath();
 92                     File newFile = new File(oldPath.substring(0, oldPath.lastIndexOf(“.”)));
 93                     // 检查去掉后的文件是否存在。如果存在，则删除原来的文件并重命名下载的文件（即：覆盖原文件）
 94                     if(newFile.exists()){
 95                         newFile.delete();
 96                     }
 97                     System.out.println(destFile.renameTo(newFile));// 重命名
 98                     // 通知监听器，并传入新的文件对象
 99                     if(null != fileDownloadListener){
100                         fileDownloadListener.downloadCompleted(newFile, System.currentTimeMillis() - startTime);
101                     }
102                     isRunning = false; // 文件下载完就结束通知线程。
103                 }
104                 notificationTag = false;
105             }
106             // 设置为每100毫秒进行检查并更新通知
107             try {
108                 Thread.sleep(100);
109             } catch (InterruptedException e) {
110                 e.printStackTrace();
111             }
112
113         }
114
115     }
116     /
117       调用这个方法，则会使得线程处于待检查更新进度状态。
118       @author wangjie
119      */
120     public synchronized void notificationProgress(){
121         notificationTag = true;
122     }
123     /
124       取消该通知线程
125       @author wangjie
126      */
127     public void cancelThread(){
128         isRunning = false;
129     }
130
131
132 }

  1 package com.wangjie.extrautil.jfiledownloader;
  2
  3 import java.io.File;
  4 import java.io.IOException;
  5 import java.io.InputStream;
  6 import java.io.RandomAccessFile;
  7 import java.net.HttpURLConnection;
  8 import java.net.URL;
  9
 10 /
 11  
 12   真正的下载线程，该线程用于执行该线程所要负责下载的数据。
 13  
 14   @author wangjie
 15   @version 创建时间：2013-2-7 上午11:58:24
 16  /
 17 public class JFileDownloadThread extends Thread{
 18     private String urlPath;
 19     private File destFile;
 20     private long startPos;
 21     /
 22       此线程需要下载的数据长度。
 23      /
 24     public long length;
 25     /
 26       此线程现在已下载好了的数据长度。
 27      /
 28     public long currentLength;
 29
 30     private JFileDownloaderNotificationThread notificationThread;
 31     private boolean isRunning = true;
 32
 33     /
 34       构造方法，可生成配置完整的JFileDownloadThread对象
 35       @param urlPath 要下载的目标文件URL
 36       @param destFile 要保存的目标文件
 37       @param startPos 该线程需要下载目标文件第几个byte之后的数据
 38       @param length 该线程需要下载多少长度的数据
 39       @param notificationThread 通知进度线程
 40      /
 41     public JFileDownloadThread(String urlPath, File destFile, long startPos,
 42             long length, JFileDownloaderNotificationThread notificationThread) {
 43         this.urlPath = urlPath;
 44         this.destFile = destFile;
 45         this.startPos = startPos;
 46         this.length = length;
 47         this.notificationThread = notificationThread;
 48     }
 49     /**
 50       该方法将执行下载功能，并把数据存储在目标文件中的相应位置。
 51      /
 52     @Override
 53     public void run() {
 54         RandomAccessFile raf = null;
 55         HttpURLConnection conn = null;
 56         InputStream is = null;
 57         try {
 58 //            URL url = new URL(“http://localhost:8080/firstserver/files/hibernate.zip”);
 59             URL url = new URL(urlPath);
 60             conn = (HttpURLConnection)url.openConnection();
 61             conn.setConnectTimeout(20  1000);
 62             is = conn.getInputStream();
 63             raf = new RandomAccessFile(destFile, “rw”);
 64             raf.setLength(conn.getContentLength()); // 设置保存文件的大小
 65 //            raf.setLength(conn.getInputStream().available());
 66
 67             // 设置读入和写入的文件位置
 68             is.skip(startPos);
 69             raf.seek(startPos);
 70
 71             currentLength = 0; // 当前已下载好的文件长度
 72             byte[] buffer = new byte[1024  1024];
 73             int len = 0;
 74             while(currentLength < length && -1 != (len = is.read(buffer))){
 75                 if(!isRunning){
 76                     break;
 77                 }
 78                 if(currentLength + len > length){
 79                     raf.write(buffer, 0, (int)(length - currentLength));
 80                     currentLength = length;
 81                     notificationThread.notificationProgress(); // 通知进度线程来更新进度
 82                     return;
 83                 }else{
 84                     raf.write(buffer, 0, len);
 85                     currentLength += len;
 86                     notificationThread.notificationProgress(); // 通知进度线程来更新进度
 87                 }
 88             }
 89         } catch (Exception e) {
 90             e.printStackTrace();
 91         } finally{
 92             try {
 93                 is.close();
 94                 raf.close();
 95                 conn.disconnect();
 96             } catch (IOException e) {
 97                 e.printStackTrace();
 98             }
 99         }
100
101     }
102     /**
103       取消该线程下载
104       @author wangjie
105      /
106     public void cancelThread(){
107         isRunning = false;
108     }
109
110
111 }