JAVA編寫一個可以上傳文件的服務器和客戶端，具體內容如下
服務端
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
|
class Server { public static void main(String[] args) throws Exception { //建立服務端Socket ServerSocket ss = new ServerSocket(10005); //接收客戶端Socket Socket fileLoaderSocket = ss.accept(); //打印連接信息 String ip = fileLoaderSocket.getInetAddress().getHostAddress(); System.out.println(ip + "...conncected"); //接收文件，并保存 InputStream in = fileLoaderSocket.getInputStream(); //實例化對象fileSave OutputStream fileSave = new FileOutputStream("E:\\3.mp3"); //建立數組buf byte[] buf = new byte[1024]; int len = 0; //判斷是否讀到文件末尾 while((len=in.read(buf)) != -1) { fileSave.write(buf, 0, len); //刷新 fileSave.flush(); } //返回文件復制情況信息 BufferedWriter out = new BufferedWriter(new OutputStreamWriter(fileLoaderSocket.getOutputStream())); out.write("文件上傳成功"); //刷新 out.flush(); //資源關閉 ss.close(); fileLoaderSocket.close(); fileSave.close(); } } |
客戶端：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
class Client{ public static void main(String[] args) throws Exception { //建立Socket服務 Socket fileLoaderSocket = new Socket("168.168.168.94", 10005); //從客戶端本地讀取文件,并寫入socket的輸出流中 OutputStream out = fileLoaderSocket.getOutputStream(); //實例化對象fileReader InputStream fileRead = new FileInputStream("G:\\2.mp3"); //建立數組 byte[] buf = new byte[1024]; int len = 0; //判斷是否讀到文件末尾 while((len=fileRead.read(buf)) != -1) { out.write(buf, 0, len); } //告訴服務端，文件已傳輸完畢 fileLoaderSocket.shutdownOutput(); //獲取從服務端反饋的信息 BufferedReader in = new BufferedReader(new InputStreamReader(fileLoaderSocket.getInputStream())); String serverBack = in.readLine(); System.out.println(serverBack); //資源關閉 fileLoaderSocket.close(); fileRead.close(); } } |
下面的程序是從別處直接照搬過來的，供學習參考：
Java Socket編程
對于Java Socket編程而言，有兩個概念，一個是ServerSocket，一個是Socket。服務端和客戶端之間通過Socket建立連接，之后它們就可以進行通信了。首先ServerSocket將在服務端監聽某個端口，當發現客戶端有Socket來試圖連接它時，它會accept該Socket的連接請求，同時在服務端建立一個對應的Socket與之進行通信。這樣就有兩個Socket了，客戶端和服務端各一個。
對于Socket之間的通信其實很簡單，服務端往Socket的輸出流里面寫東西，客戶端就可以通過Socket的輸入流讀取對應的內容。Socket與Socket之間是雙向連通的，所以客戶端也可以往對應的Socket輸出流里面寫東西，然后服務端對應的Socket的輸入流就可以讀出對應的內容。下面來看一些服務端與客戶端通信的例子：
1.客戶端寫服務端讀
服務端Java代碼
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
public class Server { public static void main(String args[]) throws IOException { //為了簡單起見，所有的異常信息都往外拋 int port = 8899; //定義一個ServerSocket監聽在端口8899上 ServerSocket server = new ServerSocket(port); //server嘗試接收其他Socket的連接請求，server的accept方法是阻塞式的 Socket socket = server.accept(); //跟客戶端建立好連接之后，我們就可以獲取socket的InputStream，并從中讀取客戶端發過來的信息了。 Reader reader = new InputStreamReader(socket.getInputStream()); char chars[] = new char[64]; int len; StringBuilder sb = new StringBuilder(); while ((len=reader.read(chars)) != -1) { sb.append(new String(chars, 0, len)); } System.out.println("from client: " + sb); reader.close(); socket.close(); server.close(); } } |
服務端從Socket的InputStream中讀取數據的操作也是阻塞式的，如果從輸入流中沒有讀取到數據程序會一直在那里不動，直到客戶端往Socket的輸出流中寫入了數據，或關閉了Socket的輸出流。當然，對于客戶端的Socket也是同樣如此。在操作完以后，整個程序結束前記得關閉對應的資源，即關閉對應的IO流和Socket。
客戶端Java代碼
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
public class Client { public static void main(String args[]) throws Exception { //為了簡單起見，所有的異常都直接往外拋 String host = "127.0.0.1"; //要連接的服務端IP地址 int port = 8899; //要連接的服務端對應的監聽端口 //與服務端建立連接 Socket client = new Socket(host, port); //建立連接后就可以往服務端寫數據了 Writer writer = new OutputStreamWriter(client.getOutputStream()); writer.write("Hello Server."); writer.flush();//寫完后要記得flush writer.close(); client.close(); } } |
對于客戶端往Socket的輸出流里面寫數據傳遞給服務端要注意一點，如果寫操作之后程序不是對應著輸出流的關閉，而是進行其他阻塞式的操作（比如從輸入流里面讀數據），記住要flush一下，只有這樣服務端才能收到客戶端發送的數據，否則可能會引起兩邊無限的互相等待。在稍后講到客戶端和服務端同時讀和寫的時候會說到這個問題。
2.客戶端和服務端同時讀和寫
前面已經說了Socket之間是雙向通信的，它既可以接收數據，同時也可以發送數據。
服務端Java代碼
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
public class Server { public static void main(String args[]) throws IOException { //為了簡單起見，所有的異常信息都往外拋 int port = 8899; //定義一個ServerSocket監聽在端口8899上 ServerSocket server = new ServerSocket(port); //server嘗試接收其他Socket的連接請求，server的accept方法是阻塞式的 Socket socket = server.accept(); //跟客戶端建立好連接之后，我們就可以獲取socket的InputStream，并從中讀取客戶端發過來的信息了。 Reader reader = new InputStreamReader(socket.getInputStream()); char chars[] = new char[64]; int len; StringBuilder sb = new StringBuilder(); while ((len=reader.read(chars)) != -1) { sb.append(new String(chars, 0, len)); } System.out.println("from client: " + sb); //讀完后寫一句 Writer writer = new OutputStreamWriter(socket.getOutputStream()); writer.write("Hello Client."); writer.flush(); writer.close(); reader.close(); socket.close(); server.close(); } } |
在上述代碼中首先我們從輸入流中讀取客戶端發送過來的數據，接下來我們再往輸出流里面寫入數據給客戶端，接下來關閉對應的資源文件。而實際上上述代碼可能并不會按照我們預先設想的方式運行，因為從輸入流中讀取數據是一個阻塞式操作，在上述的while循環中當讀到數據的時候就會執行循環體，否則就會阻塞，這樣后面的寫操作就永遠都執行不了了。除非客戶端對應的Socket關閉了阻塞才會停止，while循環也會跳出。針對這種可能永遠無法執行下去的情況的解決方法是while循環需要在里面有條件的跳出來，縱觀上述代碼，在不斷變化的也只有取到的長度len和讀到的數據了，len已經是不能用的了，唯一能用的就是讀到的數據了。針對這種情況，通常我們都會約定一個結束標記，當客戶端發送過來的數據包含某個結束標記時就說明當前的數據已經發送完畢了，這個時候我們就可以進行循環的跳出了。那么改進后的代碼會是這個樣子：
Java代碼
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
public class Server { public static void main(String args[]) throws IOException { //為了簡單起見，所有的異常信息都往外拋 int port = 8899; //定義一個ServerSocket監聽在端口8899上 ServerSocket server = new ServerSocket(port); //server嘗試接收其他Socket的連接請求，server的accept方法是阻塞式的 Socket socket = server.accept(); //跟客戶端建立好連接之后，我們就可以獲取socket的InputStream，并從中讀取客戶端發過來的信息了。 Reader reader = new InputStreamReader(socket.getInputStream()); char chars[] = new char[64]; int len; StringBuilder sb = new StringBuilder(); String temp; int index; while ((len=reader.read(chars)) != -1) { temp = new String(chars, 0, len); if ((index = temp.indexOf("eof")) != -1) {//遇到eof時就結束接收 sb.append(temp.substring(0, index)); break; } sb.append(temp); } System.out.println("from client: " + sb); //讀完后寫一句 Writer writer = new OutputStreamWriter(socket.getOutputStream()); writer.write("Hello Client."); writer.flush(); writer.close(); reader.close(); socket.close(); server.close(); } } |
在上述代碼中，當服務端讀取到客戶端發送的結束標記，即“eof”時就會結束數據的接收，終止循環，這樣后續的代碼又可以繼續進行了。
客戶端Java代碼
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
public class Client { public static void main(String args[]) throws Exception { //為了簡單起見，所有的異常都直接往外拋 String host = "127.0.0.1"; //要連接的服務端IP地址 int port = 8899; //要連接的服務端對應的監聽端口 //與服務端建立連接 Socket client = new Socket(host, port); //建立連接后就可以往服務端寫數據了 Writer writer = new OutputStreamWriter(client.getOutputStream()); writer.write("Hello Server."); writer.flush(); //寫完以后進行讀操作 Reader reader = new InputStreamReader(client.getInputStream()); char chars[] = new char[64]; int len; StringBuffer sb = new StringBuffer(); while ((len=reader.read(chars)) != -1) { sb.append(new String(chars, 0, len)); } System.out.println("from server: " + sb); writer.close(); reader.close(); client.close(); } } |
在上述代碼中我們先是給服務端發送了一段數據，之后讀取服務端返回來的數據，跟之前的服務端一樣在讀的過程中有可能導致程序一直掛在那里，永遠跳不出while循環。這段代碼配合服務端的第一段代碼就正好讓我們分析服務端永遠在那里接收數據，永遠跳不出while循環，也就沒有之后的服務端返回數據給客戶端，客戶端也就不可能接收到服務端返回的數據。解決方法如服務端第二段代碼所示，在客戶端發送數據完畢后，往輸出流里面寫入結束標記告訴服務端數據已經發送完畢了，同樣服務端返回數據完畢后也發一個標記告訴客戶端。那么修改后的客戶端代碼就應該是這個樣子：
Java代碼
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
public class Client { public static void main(String args[]) throws Exception { //為了簡單起見，所有的異常都直接往外拋 String host = "127.0.0.1"; //要連接的服務端IP地址 int port = 8899; //要連接的服務端對應的監聽端口 //與服務端建立連接 Socket client = new Socket(host, port); //建立連接后就可以往服務端寫數據了 Writer writer = new OutputStreamWriter(client.getOutputStream()); writer.write("Hello Server."); writer.write("eof"); writer.flush(); //寫完以后進行讀操作 Reader reader = new InputStreamReader(client.getInputStream()); char chars[] = new char[64]; int len; StringBuffer sb = new StringBuffer(); String temp; int index; while ((len=reader.read(chars)) != -1) { temp = new String(chars, 0, len); if ((index = temp.indexOf("eof")) != -1) { sb.append(temp.substring(0, index)); break; } sb.append(new String(chars, 0, len)); } System.out.println("from server: " + sb); writer.close(); reader.close(); client.close(); } } |
我們日常使用的比較多的都是這種客戶端發送數據給服務端，服務端接收數據后再返回相應的結果給客戶端這種形式。只是客戶端和服務端之間不再是這種一對一的關系，而是下面要講到的多個客戶端對應同一個服務端的情況。
3.多個客戶端連接同一個服務端
像前面講的兩個例子都是服務端接收一個客戶端的請求之后就結束了，不能再接收其他客戶端的請求了，這往往是不能滿足我們的要求的。通常我們會這樣做：
Java代碼
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
public class Server { public static void main(String args[]) throws IOException { //為了簡單起見，所有的異常信息都往外拋 int port = 8899; //定義一個ServerSocket監聽在端口8899上 ServerSocket server = new ServerSocket(port); while (true) { //server嘗試接收其他Socket的連接請求，server的accept方法是阻塞式的 Socket socket = server.accept(); //跟客戶端建立好連接之后，我們就可以獲取socket的InputStream，并從中讀取客戶端發過來的信息了。 Reader reader = new InputStreamReader(socket.getInputStream()); char chars[] = new char[64]; int len; StringBuilder sb = new StringBuilder(); String temp; int index; while ((len=reader.read(chars)) != -1) { temp = new String(chars, 0, len); if ((index = temp.indexOf("eof")) != -1) {//遇到eof時就結束接收 sb.append(temp.substring(0, index)); break; } sb.append(temp); } System.out.println("from client: " + sb); //讀完后寫一句 Writer writer = new OutputStreamWriter(socket.getOutputStream()); writer.write("Hello Client."); writer.flush(); writer.close(); reader.close(); socket.close(); } } } |
在上面代碼中我們用了一個死循環，在循環體里面ServerSocket調用其accept方法試圖接收來自客戶端的連接請求。當沒有接收到請求的時候，程序會在這里阻塞直到接收到來自客戶端的連接請求，之后會跟當前建立好連接的客戶端進行通信，完了后會接著執行循環體再次嘗試接收新的連接請求。這樣我們的ServerSocket就能接收來自所有客戶端的連接請求了，并且與它們進行通信了。這就實現了一個簡單的一個服務端與多個客戶端進行通信的模式。
上述例子中雖然實現了一個服務端跟多個客戶端進行通信，但是還存在一個問題。在上述例子中，我們的服務端處理客戶端的連接請求是同步進行的，每次接收到來自客戶端的連接請求后，都要先跟當前的客戶端通信完之后才能再處理下一個連接請求。這在并發比較多的情況下會嚴重影響程序的性能，為此，我們可以把它改為如下這種異步處理與客戶端通信的方式：
Java代碼
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
|
public class Server { public static void main(String args[]) throws IOException { //為了簡單起見，所有的異常信息都往外拋 int port = 8899; //定義一個ServerSocket監聽在端口8899上 ServerSocket server = new ServerSocket(port); while (true) { //server嘗試接收其他Socket的連接請求，server的accept方法是阻塞式的 Socket socket = server.accept(); //每接收到一個Socket就建立一個新的線程來處理它 new Thread(new Task(socket)).start(); } } /** * 用來處理Socket請求的 */ static class Task implements Runnable { private Socket socket; public Task(Socket socket) { this.socket = socket; } public void run() { try { handleSocket(); } catch (Exception e) { e.printStackTrace(); } } /** * 跟客戶端Socket進行通信 * @throws Exception */ private void handleSocket() throws Exception { Reader reader = new InputStreamReader(socket.getInputStream()); char chars[] = new char[64]; int len; StringBuilder sb = new StringBuilder(); String temp; int index; while ((len=reader.read(chars)) != -1) { temp = new String(chars, 0, len); if ((index = temp.indexOf("eof")) != -1) {//遇到eof時就結束接收 sb.append(temp.substring(0, index)); break; } sb.append(temp); } System.out.println("from client: " + sb); //讀完后寫一句 Writer writer = new OutputStreamWriter(socket.getOutputStream()); writer.write("Hello Client."); writer.flush(); writer.close(); reader.close(); socket.close(); } } } |
在上面代碼中，每次ServerSocket接收到一個新的Socket連接請求后都會新起一個線程來跟當前Socket進行通信，這樣就達到了異步處理與客戶端Socket進行通信的情況。
在從Socket的InputStream中接收數據時，像上面那樣一點點的讀就太復雜了，有時候我們就會換成使用BufferedReader來一次讀一行，如：
Java代碼
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
|
public class Server { public static void main(String args[]) throws IOException { //為了簡單起見，所有的異常信息都往外拋 int port = 8899; //定義一個ServerSocket監聽在端口8899上 ServerSocket server = new ServerSocket(port); while (true) { //server嘗試接收其他Socket的連接請求，server的accept方法是阻塞式的 Socket socket = server.accept(); //每接收到一個Socket就建立一個新的線程來處理它 new Thread(new Task(socket)).start(); } } /** * 用來處理Socket請求的 */ static class Task implements Runnable { private Socket socket; public Task(Socket socket) { this.socket = socket; } public void run() { try { handleSocket(); } catch (Exception e) { e.printStackTrace(); } } /** * 跟客戶端Socket進行通信 * @throws Exception */ private void handleSocket() throws Exception { BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream())); StringBuilder sb = new StringBuilder(); String temp; int index; while ((temp=br.readLine()) != null) { System.out.println(temp); if ((index = temp.indexOf("eof")) != -1) {//遇到eof時就結束接收 sb.append(temp.substring(0, index)); break; } sb.append(temp); } System.out.println("from client: " + sb); //讀完后寫一句 Writer writer = new OutputStreamWriter(socket.getOutputStream()); writer.write("Hello Client."); writer.write("eof\n"); writer.flush(); writer.close(); br.close(); socket.close(); } } } |
這個時候需要注意的是，BufferedReader的readLine方法是一次讀一行的，這個方法是阻塞的，直到它讀到了一行數據為止程序才會繼續往下執行，那么readLine什么時候才會讀到一行呢？直到程序遇到了換行符或者是對應流的結束符readLine方法才會認為讀到了一行，才會結束其阻塞，讓程序繼續往下執行。所以我們在使用BufferedReader的readLine讀取數據的時候一定要記得在對應的輸出流里面一定要寫入換行符（流結束之后會自動標記為結束，readLine可以識別），寫入換行符之后一定記得如果輸出流不是馬上關閉的情況下記得flush一下，這樣數據才會真正的從緩沖區里面寫入。對應上面的代碼我們的客戶端程序應該這樣寫：
Java代碼
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
public class Client { public static void main(String args[]) throws Exception { //為了簡單起見，所有的異常都直接往外拋 String host = "127.0.0.1"; //要連接的服務端IP地址 int port = 8899; //要連接的服務端對應的監聽端口 //與服務端建立連接 Socket client = new Socket(host, port); //建立連接后就可以往服務端寫數據了 Writer writer = new OutputStreamWriter(client.getOutputStream()); writer.write("Hello Server."); writer.write("eof\n"); writer.flush(); //寫完以后進行讀操作 BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream())); StringBuffer sb = new StringBuffer(); String temp; int index; while ((temp=br.readLine()) != null) { if ((index = temp.indexOf("eof")) != -1) { sb.append(temp.substring(0, index)); break; } sb.append(temp); } System.out.println("from server: " + sb); writer.close(); br.close(); client.close(); } } |
4.設置超時時間
假設有這樣一種需求，我們的客戶端需要通過Socket從服務端獲取到XX信息，然后給用戶展示在頁面上。我們知道Socket在讀數據的時候是阻塞式的，如果沒有讀到數據程序會一直阻塞在那里。在同步請求的時候我們肯定是不能允許這樣的情況發生的，這就需要我們在請求達到一定的時間后控制阻塞的中斷，讓程序得以繼續運行。Socket為我們提供了一個setSoTimeout()方法來設置接收數據的超時時間，單位是毫秒。當設置的超時時間大于0，并且超過了這一時間Socket還沒有接收到返回的數據的話，Socket就會拋出一個SocketTimeoutException。
假設我們需要控制我們的客戶端在開始讀取數據10秒后還沒有讀到數據就中斷阻塞的話我們可以這樣做：
Java代碼
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
public class Client { public static void main(String args[]) throws Exception { //為了簡單起見，所有的異常都直接往外拋 String host = "127.0.0.1"; //要連接的服務端IP地址 int port = 8899; //要連接的服務端對應的監聽端口 //與服務端建立連接 Socket client = new Socket(host, port); //建立連接后就可以往服務端寫數據了 Writer writer = new OutputStreamWriter(client.getOutputStream()); writer.write("Hello Server."); writer.write("eof\n"); writer.flush(); //寫完以后進行讀操作 BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream())); //設置超時間為10秒 client.setSoTimeout(10*1000); StringBuffer sb = new StringBuffer(); String temp; int index; try { while ((temp=br.readLine()) != null) { if ((index = temp.indexOf("eof")) != -1) { sb.append(temp.substring(0, index)); break; } sb.append(temp); } } catch (SocketTimeoutException e) { System.out.println("數據讀取超時。"); } System.out.println("from server: " + sb); writer.close(); br.close(); client.close(); } } |
5.接收數據亂碼
對于這種服務端或客戶端接收中文亂碼的情況通常是因為數據發送時使用的編碼跟接收時候使用的編碼不一致。比如有下面這樣一段服務端代碼：
Java代碼
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
|
public class Server { public static void main(String args[]) throws IOException { //為了簡單起見，所有的異常信息都往外拋 int port = 8899; //定義一個ServerSocket監聽在端口8899上 ServerSocket server = new ServerSocket(port); while (true) { //server嘗試接收其他Socket的連接請求，server的accept方法是阻塞式的 Socket socket = server.accept(); //每接收到一個Socket就建立一個新的線程來處理它 new Thread(new Task(socket)).start(); } } /** * 用來處理Socket請求的 */ static class Task implements Runnable { private Socket socket; public Task(Socket socket) { this.socket = socket; } public void run() { try { handleSocket(); } catch (Exception e) { e.printStackTrace(); } } /** * 跟客戶端Socket進行通信 * @throws Exception */ private void handleSocket() throws Exception { BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream(), "GBK")); StringBuilder sb = new StringBuilder(); String temp; int index; while ((temp=br.readLine()) != null) { System.out.println(temp); if ((index = temp.indexOf("eof")) != -1) {//遇到eof時就結束接收 sb.append(temp.substring(0, index)); break; } sb.append(temp); } System.out.println("客戶端: " + sb); //讀完后寫一句 Writer writer = new OutputStreamWriter(socket.getOutputStream(), "UTF-8"); writer.write("你好，客戶端。"); writer.write("eof\n"); writer.flush(); writer.close(); br.close(); socket.close(); } } } |
這里用來測試我就弄的混亂了一點。在上面服務端代碼中我們在定義輸入流的時候明確定義了使用GBK編碼來讀取數據，而在定義輸出流的時候明確指定了將使用UTF-8編碼來發送數據。如果客戶端上送數據的時候不以GBK編碼來發送的話服務端接收的數據就很有可能會亂碼；同樣如果客戶端接收數據的時候不以服務端發送數據的編碼，即UTF-8編碼來接收數據的話也極有可能會出現數據亂碼的情況。所以，對于上述服務端代碼，為使我們的程序能夠讀取對方發送過來的數據，而不出現亂碼情況，我們的客戶端應該是這樣的：
Java代碼
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
public class Client { public static void main(String args[]) throws Exception { //為了簡單起見，所有的異常都直接往外拋 String host = "127.0.0.1"; //要連接的服務端IP地址 int port = 8899; //要連接的服務端對應的監聽端口 //與服務端建立連接 Socket client = new Socket(host, port); //建立連接后就可以往服務端寫數據了 Writer writer = new OutputStreamWriter(client.getOutputStream(), "GBK"); writer.write("你好，服務端。"); writer.write("eof\n"); writer.flush(); //寫完以后進行讀操作 BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream(), "UTF-8")); //設置超時間為10秒 client.setSoTimeout(10*1000); StringBuffer sb = new StringBuffer(); String temp; int index; try { while ((temp=br.readLine()) != null) { if ((index = temp.indexOf("eof")) != -1) { sb.append(temp.substring(0, index)); break; } sb.append(temp); } } catch (SocketTimeoutException e) { System.out.println("數據讀取超時。"); } System.out.println("服務端: " + sb); writer.close(); br.close(); client.close(); } } |
以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支持服務器之家。
原文鏈接：http://blog.csdn.net/hlhakey/article/details/47030295
