java多线程分块上传并支持断点续传最新修正完整版本[转]

1. package com.test;
2. import java.io.DataInputStream;
3. import java.io.DataOutputStream;
4. import java.io.File;
5. import java.io.FileInputStream;
6. import java.io.FileOutputStream;
7. import java.io.IOException;
8. import java.io.RandomAccessFile;
9. import java.net.HttpURLConnection;
10. import java.net.URL;
11. /**
12. * 文件断点续传加分段上传线程
13. * @author wzztestin
14. *
15. */
16. /**
17. * 文件断点续传加分段上传线程
18. * @author wzztestin
19. *
20. */
21. public class DownFileFetch extends Thread {
22. DownFileInfoBean siteInfoBean = null; // 文件信息 Bean
23. long[] nStartPos; // 开始位置
24. long[] nEndPos; // 结束位置
25. DownFileSplitterFetch[] fileSplitterFetch; // 子线程对象
26. long nFileLength; // 文件长度
27. boolean bFirst = true; // 是否第一次取文件
28. boolean bStop = false; // 停止标志
29. File tmpFile; // 文件下载的临时信息
30. DataOutputStream output; // 输出到文件的输出流
31. boolean fileflag; //是本地上传还是远程下载的标志
32. File downfile; //本地文件下载
33. int splitter = 0;
34. /**
35. * 下载上传文件抓取初始化
36. * @param bean
37. * @throws IOException
38. */
39. public DownFileFetch(DownFileInfoBean bean) throws IOException {
40. siteInfoBean = bean;
41. /**
42. * File.separator windows是\,unix是/
43. */
44. tmpFile = new File(bean.getSFilePath() + File.separator
45. + bean.getSFileName() + ".info");
46. if (tmpFile.exists()) {
47. bFirst = false;
48. //读取已下载的文件信息
49. read_nPos();
50. } else {
51. nStartPos = new long[bean.getNSplitter()];
52. nEndPos = new long[bean.getNSplitter()];
53. }
54. fileflag = bean.getFileflag();
55. downfile = bean.getDownfile();
56. this.splitter = bean.getNSplitter();
57. }
58. public void run() {
59. // 获得文件长度
60. // 分割文件
61. // 实例 FileSplitterFetch
62. // 启动 FileSplitterFetch 线程
63. // 等待子线程返回
64. try {
65. if (bFirst) {
66. nFileLength = getFileSize();
67. if (nFileLength == -1) {
68. DownFileUtility.log("File Length is not known!");
69. } else if (nFileLength == -2) {
70. DownFileUtility.log("File is not access!");
71. } else {
72. for (int i = 0; i < nStartPos.length; i++) {
73. nStartPos[i] = (long) (i * (nFileLength / nStartPos.length));
74. }
75. for (int i = 0; i < nEndPos.length - 1; i++) {
76. nEndPos[i] = nStartPos[i + 1];
77. }
78. nEndPos[nEndPos.length - 1] = nFileLength;
79. }
80. }
81. // 启动子线程
82. fileSplitterFetch = new DownFileSplitterFetch[nStartPos.length];
83. for (int i = 0; i < nStartPos.length; i++) {
84. fileSplitterFetch[i] = new DownFileSplitterFetch(
85. siteInfoBean.getSSiteURL(), siteInfoBean.getSFilePath()
86. + File.separator + siteInfoBean.getSFileName()+"_"+i,
87. nStartPos[i], nEndPos[i], i,fileflag,downfile,bFirst);
88. DownFileUtility.log("Thread " + i + " , nStartPos = " + nStartPos[i]
89. + ", nEndPos = " + nEndPos[i]);
90. fileSplitterFetch[i].start();
91. }
92. //下载子线程是否完成标志
93. boolean breakWhile = false;
94. while (!bStop) {
95. write_nPos();
96. DownFileUtility.sleep(500);
97. breakWhile = true;
98. for (int i = 0; i < nStartPos.length; i++) {
99. if (!fileSplitterFetch[i].bDownOver) {
100. breakWhile = false;
101. break;
102. }else{
103. write_nPos();
104. }
105. }
106. if (breakWhile){
107. break;
108. }
109. }
110. hebinfile(siteInfoBean.getSFilePath()+ File.separator + siteInfoBean.getSFileName(),splitter);
111. DownFileUtility.log("文件下载结束！");
112. } catch (Exception e) {
113. e.printStackTrace();
114. }
115. }
116. /**
117. * 获得文件长度
118. * @return
119. */
120. public long getFileSize() {
121. int nFileLength = -1;
122. if(fileflag){
123. try {
124. URL url = new URL(siteInfoBean.getSSiteURL());
125. HttpURLConnection httpConnection = (HttpURLConnection) url
126. .openConnection();
127. httpConnection.setRequestProperty("User-Agent", "NetFox");
128. int responseCode = httpConnection.getResponseCode();
129. if (responseCode >= 400) {
130. processErrorCode(responseCode);
131. //represent access is error
132. return -2;
133. }
134. String sHeader;
135. for (int i = 1;; i++) {
136. sHeader = httpConnection.getHeaderFieldKey(i);
137. if (sHeader != null) {
138. if (sHeader.equals("Content-Length")) {
139. nFileLength = Integer.parseInt(httpConnection
140. .getHeaderField(sHeader));
141. break;
142. }
143. } else {
144. break;
145. }
146. }
147. } catch (IOException e) {
148. e.printStackTrace();
149. } catch (Exception e) {
150. e.printStackTrace();
151. }
152. DownFileUtility.log(nFileLength);
153. }else{
154. try{
155. File myflie = downfile;
156. nFileLength = (int)myflie.length();
157. }catch(Exception e){
158. e.printStackTrace();
159. }
160. DownFileUtility.log(nFileLength);
161. }
162. return nFileLength;
163. }
164. /**
165. * 保存下载信息（文件指针位置）
166. */
167. private void write_nPos() {
168. try {
169. output = new DataOutputStream(new FileOutputStream(tmpFile));
170. output.writeInt(nStartPos.length);
171. for (int i = 0; i < nStartPos.length; i++) {
172. output.writeLong(fileSplitterFetch[i].nStartPos);
173. output.writeLong(fileSplitterFetch[i].nEndPos);
174. }
175. output.close();
176. } catch (IOException e) {
177. e.printStackTrace();
178. } catch (Exception e) {
179. e.printStackTrace();
180. }
181. }
182. /**
183. * 读取保存的下载信息（文件指针位置）
184. */
185. private void read_nPos() {
186. try {
187. DataInputStream input = new DataInputStream(new FileInputStream(
188. tmpFile));
189. int nCount = input.readInt();
190. nStartPos = new long[nCount];
191. nEndPos = new long[nCount];
192. for (int i = 0; i < nStartPos.length; i++) {
193. nStartPos[i] = input.readLong();
194. nEndPos[i] = input.readLong();
195. }
196. input.close();
197. } catch (IOException e) {
198. e.printStackTrace();
199. } catch (Exception e) {
200. e.printStackTrace();
201. }
202. }
203. /**
204. * 输出错误信息
205. * @param nErrorCode
206. */
207. private void processErrorCode(int nErrorCode) {
208. DownFileUtility.log("Error Code : " + nErrorCode);
209. }
210. /**
211. * 停止文件下载
212. */
213. public void siteStop() {
214. bStop = true;
215. for (int i = 0; i < nStartPos.length; i++)
216. fileSplitterFetch[i].splitterStop();
217. }
218. /**
219. * 合并文件
220. * @param sName
221. * @param splitternum
222. */
223. private void hebinfile(String sName,int splitternum){
224. try{
225. File file = new File(sName);
226. if(file.exists()){
227. file.delete();
228. }
229. RandomAccessFile saveinput = new RandomAccessFile(sName,"rw");
230. for(int i = 0;i<splitternum;i++){
231. try {
232. RandomAccessFile input = new RandomAccessFile (new File(sName+"_"+i),"r");
233. byte[] b = new byte[1024];
234. int nRead;
235. while ((nRead = input.read(b, 0, 1024)) > 0) {
236. write(saveinput,b, 0, nRead);
237. }
238. input.close();
239. } catch (Exception e) {
240. e.printStackTrace();
241. }
242. }
243. DownFileUtility.log("file size is "+saveinput.length());
244. }catch(Exception e){
245. e.printStackTrace();
246. }
247. }
248. /**
249. * 写文件
250. * @param b
251. * @param nStart
252. * @param nLen
253. * @return
254. */
255. private int write(RandomAccessFile oSavedFile,byte[] b, int nStart, int nLen) {
256. int n = -1;
257. try {
258. oSavedFile.seek(oSavedFile.length());
259. oSavedFile.write(b, nStart, nLen);
260. n = nLen;
261. } catch (IOException e) {
262. e.printStackTrace();
263. }
264. return n;
265. }
266. }

1. package com.test;
2. import java.io.File;
3. import java.io.IOException;
4. import java.io.InputStream;
5. import java.io.RandomAccessFile;
6. import java.net.HttpURLConnection;
7. import java.net.URL;
8. /**
9. * 下载上传子线程
10. * @author wzztestin
11. *
12. */
13. public class DownFileSplitterFetch extends Thread {
14. String sURL; // 下载文件的地址
15. long nStartPos; // 文件分段的开始位置
16. long nEndPos; // 文件分段的结束位置
17. int nThreadID; // 线程的 ID
18. boolean bDownOver = false; // 是否下载完成
19. boolean bStop = false; // 停止下载
20. DownFileAccess fileAccessI = null; // 文件对象
21. boolean fileflag; //是URL下载还是本地下载
22. File file = null;//本地下载文件
23. boolean bFirst = true;
24. /**
25. * 下载，上传子线程初始化
26. * @param sURL
27. * @param sName
28. * @param nStart
29. * @param nEnd
30. * @param id
31. * @param fileflag
32. * @param downfile
33. * @throws IOException
34. */
35. public DownFileSplitterFetch(String sURL, String sName, long nStart, long nEnd,
36. int id,boolean fileflag,File downfile,boolean bFirst) throws IOException {
37. this.sURL = sURL;
38. this.nStartPos = nStart;
39. this.nEndPos = nEnd;
40. nThreadID = id;
41. fileAccessI = new DownFileAccess(sName, nStartPos,bFirst);
42. this.fileflag = fileflag;
43. this.file = downfile;
44. this.bFirst = bFirst;
45. }
46. /**
47. * 线程执行
48. */
49. public void run() {
50. if(fileflag){
51. this.urldownload();
52. }else{
53. this.filedownload();
54. }
55. }
56. /**
57. * 打印回应的头信息
58. * @param con
59. */
60. public void logResponseHead(HttpURLConnection con) {
61. for (int i = 1;; i++) {
62. String header = con.getHeaderFieldKey(i);
63. if (header != null){
64. DownFileUtility.log(header + " : " + con.getHeaderField(header));
65. }else{
66. break;
67. }
68. }
69. }
70. /**
71. * 地址下载
72. */
73. private void urldownload(){
74. DownFileUtility.log("Thread " + nThreadID + " url down filesize is "+(nEndPos-nStartPos));
75. DownFileUtility.log("Thread " + nThreadID + " url start >> "+nStartPos +"------end >> "+nEndPos);
76. while (nStartPos < nEndPos && !bStop) {
77. try {
78. URL url = new URL(sURL);
79. HttpURLConnection httpConnection = (HttpURLConnection) url
80. .openConnection();
81. httpConnection.setRequestProperty("User-Agent", "NetFox");
82. String sProperty = "bytes=" + nStartPos + "-";
83. httpConnection.setRequestProperty("RANGE", sProperty);
84. DownFileUtility.log(sProperty);
85. InputStream input = httpConnection.getInputStream();
86. byte[] b = new byte[1024];
87. int nRead;
88. while ((nRead = input.read(b, 0, 1024)) > 0
89. && nStartPos < nEndPos && !bStop) {
90. if((nStartPos+nRead)>nEndPos)
91. {
92. nRead = (int)(nEndPos - nStartPos);
93. }
94. nStartPos += fileAccessI.write(b, 0, nRead);
95. }
96. DownFileUtility.log("Thread " + nThreadID + " nStartPos : "+nStartPos);
97. fileAccessI.oSavedFile.close();
98. DownFileUtility.log("Thread " + nThreadID + " is over!");
99. input.close();
100. bDownOver = true;
101. } catch (Exception e) {
102. e.printStackTrace();
103. }
104. }
105. if(!bDownOver){
106. if(nStartPos >= nEndPos){
107. bDownOver = true;
108. }
109. }
110. }
111. /**
112. * 文件下载
113. */
114. private void filedownload(){
115. DownFileUtility.log("Thread " + nThreadID + " down filesize is "+(nEndPos-nStartPos));
116. DownFileUtility.log("Thread " + nThreadID + " start >> "+nStartPos +"------end >> "+nEndPos);
117. while (nStartPos < nEndPos && !bStop) {
118. try {
119. RandomAccessFile input = new RandomAccessFile(file,"r");
120. input.seek(nStartPos);
121. byte[] b = new byte[1024];
122. int nRead;
123. while ((nRead = input.read(b, 0, 1024)) > 0
124. && nStartPos < nEndPos && !bStop) {
125. if((nStartPos+nRead)>nEndPos)
126. {
127. nRead = (int)(nEndPos - nStartPos);
128. }
129. nStartPos += fileAccessI.write(b, 0, nRead);
130. }
131. fileAccessI.oSavedFile.close();
132. DownFileUtility.log("Thread " + nThreadID + " is over!");
133. input.close();
134. bDownOver = true;
135. input.close();
136. } catch (Exception e) {
137. e.printStackTrace();
138. }
139. }
140. if(!bDownOver){
141. if(nStartPos >= nEndPos){
142. bDownOver = true;
143. }
144. }
145. DownFileUtility.log("Thread " + nThreadID + "last start >> "+nStartPos );
146. }
147. /**
148. * 停止
149. */
150. public void splitterStop() {
151. bStop = true;
152. }
153. }

1. package com.test;
2. import java.io.*;
3. /**
4. * 文件对象
5. * @author wzztestin
6. *
7. */
8. public class DownFileAccess implements Serializable {
9. /**
10. *
11. */
12. private static final long serialVersionUID = -2518013155676212866L;
13. //写入文件的流
14. RandomAccessFile oSavedFile;
15. //开始位置
16. long nPos;
17. boolean bFirst;
18. public DownFileAccess() throws IOException {
19. this("", 0,true);
20. }
21. /**
22. * 写入文件初始化
23. * @param sName
24. * @param nPos
25. * @throws IOException
26. */
27. public DownFileAccess(String sName, long nPos,boolean bFirst) throws IOException {
28. File wfile = new File(sName);
29. oSavedFile = new RandomAccessFile(wfile,"rw");
30. if(!bFirst){
31. oSavedFile.seek(wfile.length());
32. }
33. this.nPos = nPos;
34. this.bFirst = bFirst;
35. }
36. /**
37. * 写文件
38. * @param b
39. * @param nStart
40. * @param nLen
41. * @return
42. */
43. public synchronized int write(byte[] b, int nStart, int nLen) {
44. int n = -1;
45. try {
46. oSavedFile.write(b, nStart, nLen);
47. n = nLen;
48. } catch (IOException e) {
49. e.printStackTrace();
50. }
51. return n;
52. }
53. }

1. package com.test;
2. import java.io.File;
3. public class DownFileInfoBean {
4. private String sSiteURL; // 文件的下载地址
5. private String sFilePath; // 保存文件的路径
6. private String sFileName; // 保存文件的名字
7. private int nSplitter; // 文件分成几段，默认是5段
8. private boolean fileflag; // 如果为FALSE则是本地下载,为TRUE则URL下载
9. private File downfile;
10. public File getDownfile() {
11. return downfile;
12. }
13. public void setDownfile(File downfile) {
14. this.downfile = downfile;
15. }
16. public boolean getFileflag() {
17. return fileflag;
18. }
19. public void setFileflag(boolean fileflag) {
20. this.fileflag = fileflag;
21. }
22. /**
23. * 默认初始化
24. */
25. public DownFileInfoBean() {
26. // default 5
27. this("", "", "", 5,false,null);
28. }
29. /**
30. * 下载文件信息初始化
31. * @param sURL 下载的链接地址
32. * @param sPath 上传的保存路径
33. * @param sName 上传保存的文件名
34. * @param nSpiltter 文件分段个数
35. * @param fileflag 是本地文件上传下载还是链接上传下载的标志
36. * @param downfile 本地下载文件(FILE)
37. */
38. public DownFileInfoBean(String sURL, String sPath, String sName, int nSpiltter,boolean fileflag,File downfile) {
39. sSiteURL = sURL;
40. sFilePath = sPath;
41. sFileName = sName;
42. this.nSplitter = nSpiltter;
43. this.fileflag = fileflag;
44. this.downfile = downfile;
45. }
46. public String getSSiteURL() {
47. return sSiteURL;
48. }
49. public void setSSiteURL(String value) {
50. sSiteURL = value;
51. }
52. public String getSFilePath() {
53. return sFilePath;
54. }
55. public void setSFilePath(String value) {
56. sFilePath = value;
57. }
58. public String getSFileName() {
59. return sFileName;
60. }
61. public void setSFileName(String value) {
62. sFileName = value;
63. }
64. public int getNSplitter() {
65. return nSplitter;
66. }
67. public void setNSplitter(int nCount) {
68. nSplitter = nCount;
69. }
70. }

1. package com.test;
2. /**
3. * 简单的工具类
4. * @author wzztestin
5. *
6. */
7. public class DownFileUtility {
8. public DownFileUtility() {
9. }
10. /**
11. * 休眠时长
12. * @param nSecond
13. */
14. public static void sleep(int nSecond) {
15. try {
16. Thread.sleep(nSecond);
17. } catch (Exception e) {
18. e.printStackTrace();
19. }
20. }
21. /**
22. * 打印日志信息
23. * @param sMsg
24. */
25. public static void log(String sMsg) {
26. System.err.println(sMsg);
27. }
28. /**
29. * 打印日志信息
30. * @param sMsg
31. */
32. public static void log(int sMsg) {
33. System.err.println(sMsg);
34. }
35. }

1. package com.test;
2. public class TestMethod {
3. public TestMethod() {
4. try {
5. DownFileInfoBean bean = new DownFileInfoBean(
6. "http://cdn.market.hiapk.com/data/upload//2012/09_27/17/car.wu.wei.kyo.shandian_174928.apk", "D:\\temp",
7. "shandian_174928.apk", 5,true,null);
8. /*File file = new File("D:\\dan07.apk");
9. DownFileInfoBean bean = new DownFileInfoBean(null, "D:\\temp",
10. "dan07.apk", 3,false,file);*/
11. DownFileFetch fileFetch = new DownFileFetch(bean);
12. fileFetch.start();
13. } catch (Exception e) {
14. e.printStackTrace();
15. }
16. }
17. public static void main(String[] args) {
18. new TestMethod();
19. }
20. }