JDK6.0学习笔记（十八）大文件传输-可靠传输

1. /**
2.  * 大文件传输-可靠传输
3.  * 与浏览器表单结合，控制机制由服务器端负责，
4.  * 客户端（静态网页）只需向服务器端上传文件即可
5.  * 将读取的数据及时的写入文件系统，解决服务器端内存的溢出
6.  * 必须设置表单的ENCTYPE属性为 multipart/form-data（传输文件内容）
7.  * */
8. import java.io.*;
9. import java.net.*;
11. public class TcpServer {
12.     public static void main(String[] args) throws IOException {
13.         ServerSocket serverSocket = new ServerSocket(9080);//监听9080断口，一旦接入一个新连接，
14.             //将立刻创建一个子线程处理连接，目的是进可能快，尽可能多的接受客户端的请求
15.         System.out.println("TcpServer在9080端口上侦听......");
16.         while (true) {
17.             try {
18.                 Socket socket = serverSocket.accept();
19.                 System.out.println("建立一个连接...");
20.                 // 创建TCP请求处理线程
21.                 RequestThread request = new RequestThread(socket);
22.                 request.start();
23.             } catch (Exception e) {
24.                 e.printStackTrace();
25.             }
26.         }
27.     }
28. }

 

1. /**
2.  * 子线程RequestThread类把主线程传来的Socket对象继续传递给SocketRequest功能类处理
3.  * 
4.  * 
5.  * */
6. import java.io.*;
7. import java.net.*;
9. public class RequestThread extends Thread {// 子线程RequestThread类继承Thred，多线程
10.     Socket socket = null;
12.     public RequestThread(Socket socket) {
13.         this.socket = socket;
14.     }
16.     public void run() {
17.         SocketRequest socketRequest = new SocketRequest(this.socket);// 功能类SocketRequest实例
18.         socketRequest.readData();
19.     }
20. }

暗暗

1. /**
2.  * 功能类SocketRequest 
3.  * */
4. import java.io.*;
5. import java.net.*;
7. public class SocketRequest {
8.     private Socket socket = null;
10.     private InputStream input = null;
12.     private String uri;
14.     private StringBuffer request = new StringBuffer(); // 用于保存所有内容
16.     private int CONTENT_LENGTH = 0; // 实际包内容数据长
18.     private boolean bePost = false;
20.     private boolean beHttpResponse = false;
22.     private boolean beChucked = false;
24.     private boolean beGet = false;
26.     private byte crlf13 = (byte) 13; // '\r'
28.     private byte crlf10 = (byte) 10; // '\n'
30.     private String requestFile = System.currentTimeMillis() + "";
32.     public SocketRequest(Socket socket) {
33.         try {
34.             this.socket = socket;
35.             this.input = socket.getInputStream();
36.         } catch (IOException ioe) {
37.             ioe.printStackTrace();
38.         }
39.     }
41.     public void readData() {
42.         // 解析 获得InputStream的数据
43.         ReadHeader(); // 头部
45.         if (beChucked) // 为Chucked
46.         {
47.             int ChuckSize = 0;
48.             while ((ChuckSize = getChuckSize()) > 0) // 多个Chucked
49.             {
50.                 readLenData(ChuckSize + 2);// 读取定长数据
51.             }
52.             readLenData(2); // 最后的2位
53.         }
55.         if (CONTENT_LENGTH > 0) {
56.             readBody(CONTENT_LENGTH);// 读取报文体数据
57.         }
59.         try {
60.             this.socket.close();
61.         } catch (Exception e) {
62.             e.printStackTrace();
63.         }
64.     }
66.     private void readLenData(int size) // 读取定长数据
67.     {
68.         int readed = 0; // 已经读取数
69.         try {
70.             int available = 0; // 可读数
71.             if (available > (size - readed))
72.                 available = size - readed;
73.             while (readed < size) {
74.                 while (available == 0) {
75.                     // 等到有数据可读
76.                     available = input.available(); // 可读数
77.                 }
78.                 if (available > (size - readed))
79.                     available = size - readed; // 剩余数
80.                 if (available > 2048)
81.                     available = 2048; // size-readed--剩余数
82.                 byte[] buffer = new byte[available];
83.                 int reading = input.read(buffer);
85.                 request = request.append(new String(buffer, 0, reading));
87.                 readed += reading; // 已读字符
88.             }
89.         } catch (IOException e) {
90.             System.out.println("Read readLenData Error!");
91.         }
92.     }
94.     private void readBody(int size) {
95.         int readed = 0; // 已经读取数
96.         try {
97.             int available = 0; // 可读数
98.             if (available > (size - readed))
99.                 available = size - readed;
100.             while (readed < size) {
101.                 while (available == 0) {
102.                     // 等到有数据可读
103.                     available = input.available(); // 可读数
104.                 }
105.                 if (available > (size - readed))
106.                     available = size - readed; // 剩余数
107.                 if (available > 2048)
108.                     available = 2048; // size-readed--剩余数
109.                 byte[] buffer = new byte[available];
110.                 int reading = input.read(buffer);
112.                 // request=request.append(new String(buffer,0,reading));
113.                 if (!new File(this.requestFile).exists())
114.                     this.createFile(this.requestFile);
115.                 this.writeIntoFile(this.requestFile, buffer, available, readed);
117.                 readed += reading; // 已读字节数
118.             }
119.         } catch (IOException e) {
120.             System.out.println("Read Body Error!");
121.         }
122.     }
124.     private void ReadHeader() // 读取头部 并获得大小
125.     {
126.         byte[] crlf = new byte[1];
127.         int crlfNum = 0; // 已经连接的回车换行数 crlfNum=4为头部结束
128.         try {
129.             while (input.read(crlf) != -1) // 读取头部
130.             {
131.                 if (crlf[0] == crlf13 || crlf[0] == crlf10) {
132.                     crlfNum++;
133.                 } else {
134.                     crlfNum = 0;
135.                 }
136.                 request = request.append(new String(crlf, 0, 1));
137.                 if (crlfNum == 4)
138.                     break;
139.             }
140.         } catch (IOException e) {
141.             System.out.println("Read Http Header Error!");
142.             return;
143.         }
145.         String tempStr = (new String(request)).toUpperCase();
147.         // 这里只处理了GET与POST方法，其它的其它类型 暂不支持
148.         String strMethod = tempStr.substring(0, 4);
149.         if (strMethod.equals("GET ")) {
150.             beGet = true;
151.         } else if (strMethod.equals("POST")) {
152.             bePost = true;
153.             getContentlen_Chucked(tempStr);
154.         } else {
155.             System.out.println("不支持的HTTP包类型");
156.         }
157.     }
159.     private void getContentlen_Chucked(String tempStr) // 获得长度 CONTENT-LENGTH 或
160.     // 是否为CHUNKED型
161.     {
162.         String ss1 = "CONTENT-LENGTH:";
163.         String ss2 = new String("TRANSFER-ENCODING: CHUNKED");
165.         int clIndex = tempStr.indexOf(ss1);
166.         int chuckIndex = tempStr.indexOf(ss2); // 为CHUNKED型
167.         byte requst[] = tempStr.getBytes();
168.         if (clIndex != -1) {
169.             // 从clIndex+1起至\r\n
170.             StringBuffer sb = new StringBuffer();
172.             for (int i = (clIndex + 16);; i++) {
173.                 if (requst[i] != (byte) 13 && requst[i] != (byte) 10) {
174.                     sb.append((char) requst[i]);
175.                 } else
176.                     break;
177.             }
179.             CONTENT_LENGTH = Integer.parseInt(sb.toString());
180.         }
181.         if (chuckIndex != -1)
182.             beChucked = true;
183.     }
185.     private int getChuckSize() // Chuck大小
186.     {
187.         byte[] crlf = new byte[1];
188.         StringBuffer sb1 = new StringBuffer();
190.         int crlfNum = 0; // 已经连接的回车换行数 crlfNum=4为头部结束
192.         try {
193.             while (input.read(crlf) != -1) // 读取头部
194.             {
195.                 if (crlf[0] == crlf13 || crlf[0] == crlf10) {
196.                     crlfNum++;
197.                 } else {
198.                     crlfNum = 0;
199.                 }
200.                 sb1.append((char) crlf[0]);
201.                 request = request.append(new String(crlf, 0, 1));
202.                 if (crlfNum == 2)
203.                     break;
204.             }
205.         } catch (IOException e) {
206.             System.out.println("Read Http Package Error!");
207.             return 0;
208.         }
210.         return Integer.parseInt((sb1.toString()).trim(), 16); // 16进制
211.     }
213.     private void writeIntoFile(String filePath, byte[] bytes, int realLength,
214.             int finishedFileSize) throws IOException {
215.         File newFile = new File(filePath);
216.         RandomAccessFile raf = new RandomAccessFile(newFile, "rw");
217.         raf.seek(finishedFileSize);
218.         raf.write(bytes, 0, realLength);
219.         raf.close();
220.     }
222.     private void createFile(String filePath) throws IOException {
223.         File newFile = new File(filePath);
224.         RandomAccessFile raf = new RandomAccessFile(newFile, "rw");
225.         raf.close();
226.     }
227. }