Android應用開發之使用Socket進行大文件斷點上傳續傳

在Android中上傳文件可以采用HTTP方式，也可以采用Socket方式，但是HTTP方式不能上傳大文件，這裡介紹一種通過Socket方式來進行斷點續傳的方式，服務端會記錄下文件的上傳進度，當某一次上傳過程意外終止後，下一次可以繼續上傳，這裡用到的其實還是J2SE裡的知識。

這個上傳程序的原理是：客戶端第一次上傳時向服務端發送“Content-Length=35;filename=WinRAR_3.90_SC.exe;sourceid=“這種格式的字符串，服務端收到後會查找該文件是否有上傳記錄，如果有就返回已經上傳的位置，否則返回新生成的sourceid以及position為0，類似”sourceid=2324838389;position=0“這樣的字符串，客戶端收到返回後的字符串後再從指定的位置開始上傳文件。

首先是服務端代碼：

SocketServer.java

1. package com.android.socket.server;
3. import java.io.File;
4. import java.io.FileInputStream;
5. import java.io.FileOutputStream;
6. import java.io.IOException;
7. import java.io.OutputStream;
8. import java.io.PushbackInputStream;
9. import java.io.RandomAccessFile;
10. import java.net.ServerSocket;
11. import java.net.Socket;
12. import java.text.SimpleDateFormat;
13. import java.util.Date;
14. import java.util.HashMap;
15. import java.util.Map;
16. import java.util.Properties;
17. import java.util.concurrent.ExecutorService;
18. import java.util.concurrent.Executors;
20. import com.android.socket.utils.StreamTool;
22. public class SocketServer {
23. private ExecutorService executorService;// 線程池
24. private ServerSocket ss = null;
25. private int port;// 監聽端口
26. private boolean quit;// 是否退出
27. private Map<Long, FileLog> datas = new HashMap<Long, FileLog>();// 存放斷點數據，最好改為數據庫存放
29. public SocketServer(int port) {
30. this.port = port;
31. // 初始化線程池
32. executorService = Executors.newFixedThreadPool(Runtime.getRuntime()
33. .availableProcessors() * 50);
34. }
36. // 啟動服務
37. public void start() throws Exception {
38. ss = new ServerSocket(port);
39. while (!quit) {
40. Socket socket = ss.accept();// www.linuxidc.com接受客戶端的請求
41. // 為支持多用戶並發訪問，采用線程池管理每一個用戶的連接請求
42. executorService.execute(new SocketTask(socket));// 啟動一個線程來處理請求
43. }
44. }
46. // 退出
47. public void quit() {
48. this.quit = true;
49. try {
50. ss.close();
51. } catch (IOException e) {
52. e.printStackTrace();
53. }
54. }
56. public static void main(String[] args) throws Exception {
57. SocketServer server = new SocketServer(8787);
58. server.start();
59. }
61. private class SocketTask implements Runnable {
62. private Socket socket;
64. public SocketTask(Socket socket) {
65. this.socket = socket;
66. }
68. @Override
69. public void run() {
70. try {
71. System.out.println("accepted connenction from "
72. + socket.getInetAddress() + " @ " + socket.getPort());
73. PushbackInputStream inStream = new PushbackInputStream(
74. socket.getInputStream());
75. // 得到客戶端發來的第一行協議數據：Content-Length=143253434;filename=xxx.3gp;sourceid=
76. // 如果用戶初次上傳文件，sourceid的值為空。
77. String head = StreamTool.readLine(inStream);
78. System.out.println(head);
79. if (head != null) {
80. // 下面從協議數據中讀取各種參數值
81. String[] items = head.split(";");
82. String filelength = items[0].substring(items[0].indexOf("=") + 1);
83. String filename = items[1].substring(items[1].indexOf("=") + 1);
84. String sourceid = items[2].substring(items[2].indexOf("=") + 1);
85. Long id = System.currentTimeMillis();
86. FileLog log = null;
87. if (null != sourceid && !"".equals(sourceid)) {
88. id = Long.valueOf(sourceid);
89. log = find(id);//查找上傳的文件是否存在上傳記錄
90. }
91. File file = null;
92. int position = 0;
93. if(log==null){//如果上傳的文件不存在上傳記錄,為文件添加跟蹤記錄
94. String path = new SimpleDateFormat("yyyy/MM/dd/HH/mm").format(new Date());
95. File dir = new File("file/"+ path);
96. if(!dir.exists()) dir.mkdirs();
97. file = new File(dir, filename);
98. if(file.exists()){//如果上傳的文件發生重名，然後進行改名
99. filename = filename.substring(0, filename.indexOf(".")-1)+ dir.listFiles().length+ filename.substring(filename.indexOf("."));
100. file = new File(dir, filename);
101. }
102. save(id, file);
103. }else{// 如果上傳的文件存在上傳記錄,讀取上次的斷點位置
104. file = new File(log.getPath());//從上傳記錄中得到文件的路徑
105. if(file.exists()){
106. File logFile = new File(file.getParentFile(), file.getName()+".log");
107. if(logFile.exists()){
108. Properties properties = new Properties();
109. properties.load(new FileInputStream(logFile));
110. position = Integer.valueOf(properties.getProperty("length"));//讀取斷點位置
111. }
112. }
113. }
115. OutputStream outStream = socket.getOutputStream();
116. String response = "sourceid="+ id+ ";position="+ position+ "\r\n";
117. //服務器收到客戶端的請求信息後，給客戶端返回響應信息：sourceid=1274773833264;position=0
118. //sourceid由服務生成，唯一標識上傳的文件，position指示客戶端從文件的什麼位置開始上傳
119. outStream.write(response.getBytes());
121. RandomAccessFile fileOutStream = new RandomAccessFile(file, "rwd");
122. if(position==0) fileOutStream.setLength(Integer.valueOf(filelength));//設置文件長度
123. fileOutStream.seek(position);//移動文件指定的位置開始寫入數據
124. byte[] buffer = new byte[1024];
125. int len = -1;
126. int length = position;
127. while( (len=inStream.read(buffer)) != -1){//從輸入流中讀取數據寫入到文件中
128. fileOutStream.write(buffer, 0, len);
129. length += len;
130. Properties properties = new Properties();
131. properties.put("length", String.valueOf(length));
132. FileOutputStream logFile = new FileOutputStream(new File(file.getParentFile(), file.getName()+".log"));
133. properties.store(logFile, null);//實時記錄文件的最後保存位置
134. logFile.close();
135. }
136. if(length==fileOutStream.length()) delete(id);
137. fileOutStream.close();
138. inStream.close();
139. outStream.close();
140. file = null;
141. }
142. } catch (Exception e) {
143. e.printStackTrace();
144. } finally {
145. try {
146. if(socket != null && !socket.isClosed()) socket.close();
147. } catch (IOException e) {}
148. }
149. }
151. }
153. public FileLog find(Long sourceid) {
154. return datas.get(sourceid);
155. }
157. // 保存上傳記錄
158. public void save(Long id, File saveFile) {
159. // 日後可以改成通過數據庫存放
160. datas.put(id, new FileLog(id, saveFile.getAbsolutePath()));
161. }
163. // 當文件上傳完畢，刪除記錄
164. public void delete(long sourceid) {
165. if (datas.containsKey(sourceid))
166. datas.remove(sourceid);
167. }
169. private class FileLog {
170. private Long id;
171. private String path;
173. public FileLog(Long id, String path) {
174. super();
175. this.id = id;
176. this.path = path;
177. }
179. public Long getId() {
180. return id;
181. }
183. public void setId(Long id) {
184. this.id = id;
185. }
187. public String getPath() {
188. return path;
189. }
191. public void setPath(String path) {
192. this.path = path;
193. }
195. }
196. }

ServerWindow.java

1. package com.android.socket.server;
3. import java.awt.BorderLayout;
4. import java.awt.Frame;
5. import java.awt.Label;
6. import java.awt.event.WindowEvent;
7. import java.awt.event.WindowListener;
9. public class ServerWindow extends Frame{
10. private SocketServer server;
11. private Label label;
13. public ServerWindow(String title){
14. super(title);
15. server = new SocketServer(8787);
16. label = new Label();
17. add(label, BorderLayout.PAGE_START);
18. label.setText("服務器已經啟動www.linuxidc.com");
19. this.addWindowListener(new WindowListener() {
20. @Override
21. public void windowOpened(WindowEvent e) {
22. new Thread(new Runnable() {
23. @Override
24. public void run() {
25. try {
26. server.start();
27. } catch (Exception e) {
28. e.printStackTrace();
29. }
30. }
31. }).start();
32. }
34. @Override
35. public void windowIconified(WindowEvent e) {
36. }
38. @Override
39. public void windowDeiconified(WindowEvent e) {
40. }
42. @Override
43. public void windowDeactivated(WindowEvent e) {
44. }
46. @Override
47. public void windowClosing(WindowEvent e) {
48. server.quit();
49. System.exit(0);
50. }
52. @Override
53. public void windowClosed(WindowEvent e) {
54. }
56. @Override
57. public void windowActivated(WindowEvent e) {
58. }
59. });
60. }
61. /**
62. * @param args
63. */
64. public static void main(String[] args) {
65. ServerWindow window = new ServerWindow("文件上傳服務端");
66. window.setSize(300, 300);
67. window.setVisible(true);
68. }
70. }

工具類StreamTool.java

1. package com.android.socket.utils;
3. import java.io.ByteArrayOutputStream;
4. import java.io.File;
5. import java.io.FileOutputStream;
6. import java.io.IOException;
7. import java.io.InputStream;
8. import java.io.PushbackInputStream;
10. public class StreamTool {
12. public static void save(File file, byte[] data) throws Exception {
13. FileOutputStream outStream = new FileOutputStream(file);
14. outStream.write(data);
15. outStream.close();
16. }
18. public static String readLine(PushbackInputStream in) throws IOException {
19. char buf[] = new char[128];
20. int room = buf.length;
21. int offset = 0;
22. int c;
23. loop: while (true) {
24. switch (c = in.read()) {
25. case -1:
26. case '\n':
27. break loop;
28. case '\r':
29. int c2 = in.read();
30. if ((c2 != '\n') && (c2 != -1)) in.unread(c2);
31. break loop;
32. default:
33. if (--room < 0) {
34. char[] lineBuffer = buf;
35. buf = new char[offset + 128];
36. room = buf.length - offset - 1;
37. System.arraycopy(lineBuffer, 0, buf, 0, offset);
39. }
40. buf[offset++] = (char) c;
41. break;
42. }
43. }
44. if ((c == -1) && (offset == 0)) return null;
45. return String.copyValueOf(buf, 0, offset);
46. }
48. /**
49. * 讀取流
50. * @param inStream
51. * @return 字節數組
52. * @throws Exception
53. */
54. public static byte[] readStream(InputStream inStream) throws Exception{
55. ByteArrayOutputStream outSteam = new ByteArrayOutputStream();
56. byte[] buffer = new byte[1024];
57. int len = -1;
58. while( (len=inStream.read(buffer)) != -1){
59. outSteam.write(buffer, 0, len);
60. }
61. outSteam.close();
62. inStream.close();
63. return outSteam.toByteArray();
64. }
65. }

Android客戶端代碼：