客戶端與服務端Socket通訊原理詳解

Main-zy發表於2015-10-29
客戶端服務端

Java Socket程式設計

       對於Java Socket程式設計而言，有兩個概念，一個是ServerSocket，一個是Socket。服務端和客戶端之間通過Socket建立連線，之後它們就可以進行通訊了。首先ServerSocket將在服務端監聽某個埠，當發現客戶端有Socket來試圖連線它時，它會accept該Socket的連線請求，同時在服務端建立一個對應的Socket與之進行通訊。這樣就有兩個Socket了，客戶端和服務端各一個。

       對於Socket之間的通訊其實很簡單，服務端往Socket的輸出流裡面寫東西，客戶端就可以通過Socket的輸入流讀取對應的內容。Socket與Socket之間是雙向連通的，所以客戶端也可以往對應的Socket輸出流裡面寫東西，然後服務端對應的Socket的輸入流就可以讀出對應的內容。下面來看一些服務端與客戶端通訊的例子：

      1、客戶端寫服務端讀

       服務端程式碼

 

Java程式碼  收藏程式碼
  1. public class Server {  
  2.    
  3.    public static void main(String args[]) throws IOException {  
  4.       //為了簡單起見，所有的異常資訊都往外拋  
  5.       int port = 8899;  
  6.       //定義一個ServerSocket監聽在埠8899上  
  7.       ServerSocket server = new ServerSocket(port);  
  8.       //server嘗試接收其他Socket的連線請求，server的accept方法是阻塞式的  
  9.       Socket socket = server.accept();  
  10.       //跟客戶端建立好連線之後，我們就可以獲取socket的InputStream，並從中讀取客戶端發過來的資訊了。  
  11.       Reader reader = new InputStreamReader(socket.getInputStream());  
  12.       char chars[] = new char[64];  
  13.       int len;  
  14.       StringBuilder sb = new StringBuilder();  
  15.       while ((len=reader.read(chars)) != -1) {  
  16.          sb.append(new String(chars, 0, len));  
  17.       }  
  18.       System.out.println("from client: " + sb);  
  19.       reader.close();  
  20.       socket.close();  
  21.       server.close();  
  22.    }  
  23.      
  24. }  

        

服務端從Socket的InputStream中讀取資料的操作也是阻塞式的，如果從輸入流中沒有讀取到資料程式會一直在那裡不動，直到客戶端往Socket的輸出流中寫入了資料，或關閉了Socket的輸出流。當然，對於客戶端的Socket也是同樣如此。在操作完以後，整個程式結束前記得關閉對應的資源，即關閉對應的IO流和Socket。

 

       客戶端程式碼

Java程式碼  收藏程式碼
  1. public class Client {  
  2.    
  3.    public static void main(String args[]) throws Exception {  
  4.       //為了簡單起見，所有的異常都直接往外拋  
  5.       String host = "127.0.0.1";  //要連線的服務端IP地址  
  6.       int port = 8899;   //要連線的服務端對應的監聽埠  
  7.       //與服務端建立連線  
  8.       Socket client = new Socket(host, port);  
  9.       //建立連線後就可以往服務端寫資料了  
  10.       Writer writer = new OutputStreamWriter(client.getOutputStream());  
  11.       writer.write("Hello Server.");  
  12.       writer.flush();//寫完後要記得flush  
  13.       writer.close();  
  14.       client.close();  
  15.    }  
  16.      
  17. }  

       

對於客戶端往Socket的輸出流裡面寫資料傳遞給服務端要注意一點，如果寫操作之後程式不是對應著輸出流的關閉，而是進行其他阻塞式的操作（比如從輸入流裡面讀資料），記住要flush一下，只有這樣服務端才能收到客戶端傳送的資料，否則可能會引起兩邊無限的互相等待。在稍後講到客戶端和服務端同時讀和寫的時候會說到這個問題。

 

      2、客戶端和服務端同時讀和寫

       前面已經說了Socket之間是雙向通訊的，它既可以接收資料，同時也可以傳送資料。

       服務端程式碼

 

Java程式碼  收藏程式碼
  1. public class Server {  
  2.    
  3.    public static void main(String args[]) throws IOException {  
  4.       //為了簡單起見，所有的異常資訊都往外拋  
  5.       int port = 8899;  
  6.       //定義一個ServerSocket監聽在埠8899上  
  7.       ServerSocket server = new ServerSocket(port);  
  8.       //server嘗試接收其他Socket的連線請求，server的accept方法是阻塞式的  
  9.       Socket socket = server.accept();  
  10.       //跟客戶端建立好連線之後，我們就可以獲取socket的InputStream，並從中讀取客戶端發過來的資訊了。  
  11.       Reader reader = new InputStreamReader(socket.getInputStream());  
  12.       char chars[] = new char[64];  
  13.       int len;  
  14.       StringBuilder sb = new StringBuilder();  
  15.       while ((len=reader.read(chars)) != -1) {  
  16.          sb.append(new String(chars, 0, len));  
  17.       }  
  18.       System.out.println("from client: " + sb);  
  19.       //讀完後寫一句  
  20.       Writer writer = new OutputStreamWriter(socket.getOutputStream());  
  21.       writer.write("Hello Client.");  
  22.       writer.flush();  
  23.       writer.close();  
  24.       reader.close();  
  25.       socket.close();  
  26.       server.close();  
  27.    }  
  28.      
  29. }  

        

在上述程式碼中首先我們從輸入流中讀取客戶端傳送過來的資料，接下來我們再往輸出流裡面寫入資料給客戶端，接下來關閉對應的資原始檔。而實際上上述程式碼可能並不會按照我們預先設想的方式執行，因為從輸入流中讀取資料是一個阻塞式操作，在上述的while迴圈中當讀到資料的時候就會執行迴圈體，否則就會阻塞，這樣後面的寫操作就永遠都執行不了了。除非客戶端對應的Socket關閉了阻塞才會停止，while迴圈也會跳出。針對這種可能永遠無法執行下去的情況的解決方法是while迴圈需要在裡面有條件的跳出來，縱觀上述程式碼，在不斷變化的也只有取到的長度len和讀到的資料了，len已經是不能用的了，唯一能用的就是讀到的資料了。針對這種情況，通常我們都會約定一個結束標記，當客戶端傳送過來的資料包含某個結束標記時就說明當前的資料已經傳送完畢了，這個時候我們就可以進行迴圈的跳出了。那麼改進後的程式碼會是這個樣子：

Java程式碼  收藏程式碼
  1. public class Server {  
  2.    
  3.    public static void main(String args[]) throws IOException {  
  4.       //為了簡單起見，所有的異常資訊都往外拋  
  5.       int port = 8899;  
  6.       //定義一個ServerSocket監聽在埠8899上  
  7.       ServerSocket server = new ServerSocket(port);  
  8.       //server嘗試接收其他Socket的連線請求，server的accept方法是阻塞式的  
  9.       Socket socket = server.accept();  
  10.       //跟客戶端建立好連線之後，我們就可以獲取socket的InputStream，並從中讀取客戶端發過來的資訊了。  
  11.       Reader reader = new InputStreamReader(socket.getInputStream());  
  12.       char chars[] = new char[64];  
  13.       int len;  
  14.       StringBuilder sb = new StringBuilder();  
  15.       String temp;  
  16.       int index;  
  17.       while ((len=reader.read(chars)) != -1) {  
  18.          temp = new String(chars, 0, len);  
  19.          if ((index = temp.indexOf("eof")) != -1) {//遇到eof時就結束接收  
  20.             sb.append(temp.substring(0, index));  
  21.             break;  
  22.          }  
  23.          sb.append(temp);  
  24.       }  
  25.       System.out.println("from client: " + sb);  
  26.       //讀完後寫一句  
  27.       Writer writer = new OutputStreamWriter(socket.getOutputStream());  
  28.       writer.write("Hello Client.");  
  29.       writer.flush();  
  30.       writer.close();  
  31.       reader.close();  
  32.       socket.close();  
  33.       server.close();  
  34.    }  
  35.      
  36. }  

       

在上述程式碼中，當服務端讀取到客戶端傳送的結束標記，即“eof”時就會結束資料的接收，終止迴圈，這樣後續的程式碼又可以繼續進行了。

 

       客戶端程式碼

Java程式碼  收藏程式碼
  1. public class Client {  
  2.    
  3.    public static void main(String args[]) throws Exception {  
  4.       //為了簡單起見，所有的異常都直接往外拋  
  5.      String host = "127.0.0.1";  //要連線的服務端IP地址  
  6.      int port = 8899;   //要連線的服務端對應的監聽埠  
  7.      //與服務端建立連線  
  8.      Socket client = new Socket(host, port);  
  9.       //建立連線後就可以往服務端寫資料了  
  10.      Writer writer = new OutputStreamWriter(client.getOutputStream());  
  11.       writer.write("Hello Server.");  
  12.       writer.flush();  
  13.       //寫完以後進行讀操作  
  14.      Reader reader = new InputStreamReader(client.getInputStream());  
  15.       char chars[] = new char[64];  
  16.       int len;  
  17.       StringBuffer sb = new StringBuffer();  
  18.       while ((len=reader.read(chars)) != -1) {  
  19.          sb.append(new String(chars, 0, len));  
  20.       }  
  21.       System.out.println("from server: " + sb);  
  22.       writer.close();  
  23.       reader.close();  
  24.       client.close();  
  25.    }  
  26.      
  27. }  

       

在上述程式碼中我們先是給服務端傳送了一段資料，之後讀取服務端返回來的資料，跟之前的服務端一樣在讀的過程中有可能導致程式一直掛在那裡，永遠跳不出while迴圈。這段程式碼配合服務端的第一段程式碼就正好讓我們分析服務端永遠在那裡接收資料，永遠跳不出while迴圈，也就沒有之後的服務端返回資料給客戶端，客戶端也就不可能接收到服務端返回的資料。解決方法如服務端第二段程式碼所示，在客戶端傳送資料完畢後，往輸出流裡面寫入結束標記告訴服務端資料已經傳送完畢了，同樣服務端返回資料完畢後也發一個標記告訴客戶端。那麼修改後的客戶端程式碼就應該是這個樣子：
Java程式碼  收藏程式碼
  1. public class Client {  
  2.    
  3.    public static void main(String args[]) throws Exception {  
  4.       //為了簡單起見，所有的異常都直接往外拋  
  5.      String host = "127.0.0.1";  //要連線的服務端IP地址  
  6.      int port = 8899;   //要連線的服務端對應的監聽埠  
  7.      //與服務端建立連線  
  8.      Socket client = new Socket(host, port);  
  9.       //建立連線後就可以往服務端寫資料了  
  10.      Writer writer = new OutputStreamWriter(client.getOutputStream());  
  11.       writer.write("Hello Server.");  
  12.       writer.write("eof");  
  13.       writer.flush();  
  14.       //寫完以後進行讀操作  
  15.      Reader reader = new InputStreamReader(client.getInputStream());  
  16.       char chars[] = new char[64];  
  17.       int len;  
  18.       StringBuffer sb = new StringBuffer();  
  19.       String temp;  
  20.       int index;  
  21.       while ((len=reader.read(chars)) != -1) {  
  22.          temp = new String(chars, 0, len);  
  23.          if ((index = temp.indexOf("eof")) != -1) {  
  24.             sb.append(temp.substring(0, index));  
  25.             break;  
  26.          }  
  27.          sb.append(new String(chars, 0, len));  
  28.       }  
  29.       System.out.println("from server: " + sb);  
  30.       writer.close();  
  31.       reader.close();  
  32.       client.close();  
  33.    }  
  34.      
  35. }  
  36.    

       

我們日常使用的比較多的都是這種客戶端傳送資料給服務端，服務端接收資料後再返回相應的結果給客戶端這種形式。只是客戶端和服務端之間不再是這種一對一的關係，而是下面要講到的多個客戶端對應同一個服務端的情況。

      3、多個客戶端連線同一個服務端

       像前面講的兩個例子都是服務端接收一個客戶端的請求之後就結束了，不能再接收其他客戶端的請求了，這往往是不能滿足我們的要求的。通常我們會這樣做：

Java程式碼  收藏程式碼
  1. public class Server {  
  2.    
  3.    public static void main(String args[]) throws IOException {  
  4.       //為了簡單起見，所有的異常資訊都往外拋  
  5.      int port = 8899;  
  6.       //定義一個ServerSocket監聽在埠8899上  
  7.      ServerSocket server = new ServerSocket(port);  
  8.       while (true) {  
  9.          //server嘗試接收其他Socket的連線請求，server的accept方法是阻塞式的  
  10.        Socket socket = server.accept();  
  11.          //跟客戶端建立好連線之後，我們就可以獲取socket的InputStream，並從中讀取客戶端發過來的資訊了。  
  12.        Reader reader = new InputStreamReader(socket.getInputStream());  
  13.          char chars[] = new char[64];  
  14.          int len;  
  15.          StringBuilder sb = new StringBuilder();  
  16.          String temp;  
  17.          int index;  
  18.          while ((len=reader.read(chars)) != -1) {  
  19.             temp = new String(chars, 0, len);  
  20.             if ((index = temp.indexOf("eof")) != -1) {//遇到eof時就結束接收  
  21.                 sb.append(temp.substring(0, index));  
  22.                 break;  
  23.             }  
  24.             sb.append(temp);  
  25.          }  
  26.          System.out.println("from client: " + sb);  
  27.          //讀完後寫一句  
  28.        Writer writer = new OutputStreamWriter(socket.getOutputStream());  
  29.          writer.write("Hello Client.");  
  30.          writer.flush();  
  31.          writer.close();  
  32.          reader.close();  
  33.          socket.close();  
  34.       }  
  35.    }  
  36.      
  37. }  

       

在上面程式碼中我們用了一個死迴圈，在迴圈體裡面ServerSocket呼叫其accept方法試圖接收來自客戶端的連線請求。當沒有接收到請求的時候，程式會在這裡阻塞直到接收到來自客戶端的連線請求，之後會跟當前建立好連線的客戶端進行通訊，完了後會接著執行迴圈體再次嘗試接收新的連線請求。這樣我們的ServerSocket就能接收來自所有客戶端的連線請求了，並且與它們進行通訊了。這就實現了一個簡單的一個服務端與多個客戶端進行通訊的模式。

       上述例子中雖然實現了一個服務端跟多個客戶端進行通訊，但是還存在一個問題。在上述例子中，我們的服務端處理客戶端的連線請求是同步進行的，每次接收到來自客戶端的連線請求後，都要先跟當前的客戶端通訊完之後才能再處理下一個連線請求。這在併發比較多的情況下會嚴重影響程式的效能，為此，我們可以把它改為如下這種非同步處理與客戶端通訊的方式：

Java程式碼  收藏程式碼
  1. public class Server {  
  2.      
  3.    public static void main(String args[]) throws IOException {  
  4.       //為了簡單起見，所有的異常資訊都往外拋  
  5.      int port = 8899;  
  6.       //定義一個ServerSocket監聽在埠8899上  
  7.      ServerSocket server = new ServerSocket(port);  
  8.       while (true) {  
  9.          //server嘗試接收其他Socket的連線請求，server的accept方法是阻塞式的  
  10.          Socket socket = server.accept();  
  11.          //每接收到一個Socket就建立一個新的執行緒來處理它  
  12.          new Thread(new Task(socket)).start();  
  13.       }  
  14.    }  
  15.      
  16.    /** 
  17.     * 用來處理Socket請求的 
  18.    */  
  19.    static class Task implements Runnable {  
  20.    
  21.       private Socket socket;  
  22.         
  23.       public Task(Socket socket) {  
  24.          this.socket = socket;  
  25.       }  
  26.         
  27.       public void run() {  
  28.   
  29.          try {  
  30.   
  31.             handleSocket();  
  32.          } catch (Exception e) {  
  33.             e.printStackTrace();  
  34.          }  
  35.       }  
  36.         
  37.       /** 
  38.        * 跟客戶端Socket進行通訊 
  39.        * @throws Exception 
  40.        */  
  41.       private void handleSocket() throws Exception {  
  42.          Reader reader = new InputStreamReader(socket.getInputStream());  
  43.          char chars[] = new char[64];  
  44.          int len;  
  45.          StringBuilder sb = new StringBuilder();  
  46.          String temp;  
  47.          int index;  
  48.          while ((len=reader.read(chars)) != -1) {  
  49.             temp = new String(chars, 0, len);  
  50.             if ((index = temp.indexOf("eof")) != -1) {//遇到eof時就結束接收  
  51.              sb.append(temp.substring(0, index));  
  52.                 break;  
  53.             }  
  54.             sb.append(temp);  
  55.          }  
  56.          System.out.println("from client: " + sb);  
  57.          //讀完後寫一句  
  58.        Writer writer = new OutputStreamWriter(socket.getOutputStream());  
  59.          writer.write("Hello Client.");  
  60.          writer.flush();  
  61.          writer.close();  
  62.          reader.close();  
  63.          socket.close();  
  64.       }  
  65.         
  66.    }  
  67.      
  68. }  

       

在上面程式碼中，每次ServerSocket接收到一個新的Socket連線請求後都會新起一個執行緒來跟當前Socket進行通訊，這樣就達到了非同步處理與客戶端Socket進行通訊的情況。

       在從Socket的InputStream中接收資料時，像上面那樣一點點的讀就太複雜了，有時候我們就會換成使用BufferedReader來一次讀一行，如：

Java程式碼  收藏程式碼
  1. public class Server {  
  2.    
  3.    public static void main(String args[]) throws IOException {  
  4.       //為了簡單起見，所有的異常資訊都往外拋  
  5.      int port = 8899;  
  6.       //定義一個ServerSocket監聽在埠8899上  
  7.      ServerSocket server = new ServerSocket(port);  
  8.       while (true) {  
  9.          //server嘗試接收其他Socket的連線請求，server的accept方法是阻塞式的  
  10.          Socket socket = server.accept();  
  11.          //每接收到一個Socket就建立一個新的執行緒來處理它  
  12.          new Thread(new Task(socket)).start();  
  13.       }  
  14.    }  
  15.      
  16.    /** 
  17.     * 用來處理Socket請求的 
  18.    */  
  19.    static class Task implements Runnable {  
  20.    
  21.       private Socket socket;  
  22.         
  23.       public Task(Socket socket) {  
  24.          this.socket = socket;  
  25.       }  
  26.         
  27.       public void run() {  
  28.          try {  
  29.             handleSocket();  
  30.          } catch (Exception e) {  
  31.             e.printStackTrace();  
  32.          }  
  33.       }  
  34.         
  35.       /** 
  36.        * 跟客戶端Socket進行通訊 
  37.       * @throws Exception 
  38.        */  
  39.       private void handleSocket() throws Exception {  
  40.          BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));  
  41.          StringBuilder sb = new StringBuilder();  
  42.          String temp;  
  43.          int index;  
  44.          while ((temp=br.readLine()) != null) {  
  45.             System.out.println(temp);  
  46.             if ((index = temp.indexOf("eof")) != -1) {//遇到eof時就結束接收  
  47.              sb.append(temp.substring(0, index));  
  48.                 break;  
  49.             }  
  50.             sb.append(temp);  
  51.          }  
  52.          System.out.println("from client: " + sb);  
  53.          //讀完後寫一句  
  54.        Writer writer = new OutputStreamWriter(socket.getOutputStream());  
  55.          writer.write("Hello Client.");  
  56.          writer.write("eof\n");  
  57.          writer.flush();  
  58.          writer.close();  
  59.          br.close();  
  60.          socket.close();  
  61.       }  
  62.    }  
  63. }  

       

這個時候需要注意的是，BufferedReader的readLine方法是一次讀一行的，這個方法是阻塞的，直到它讀到了一行資料為止程式才會繼續往下執行，那麼readLine什麼時候才會讀到一行呢？直到程式遇到了換行符或者是對應流的結束符readLine方法才會認為讀到了一行，才會結束其阻塞，讓程式繼續往下執行。所以我們在使用BufferedReader的readLine讀取資料的時候一定要記得在對應的輸出流裡面一定要寫入換行符（流結束之後會自動標記為結束，readLine可以識別），寫入換行符之後一定記得如果輸出流不是馬上關閉的情況下記得flush一下，這樣資料才會真正的從緩衝區裡面寫入。對應上面的程式碼我們的客戶端程式應該這樣寫：
Java程式碼  收藏程式碼
  1. public class Client {  
  2.   
  3.    public static void main(String args[]) throws Exception {  
  4.       //為了簡單起見，所有的異常都直接往外拋  
  5.      String host = "127.0.0.1";  //要連線的服務端IP地址  
  6.      int port = 8899;   //要連線的服務端對應的監聽埠  
  7.      //與服務端建立連線  
  8.      Socket client = new Socket(host, port);  
  9.       //建立連線後就可以往服務端寫資料了  
  10.      Writer writer = new OutputStreamWriter(client.getOutputStream());  
  11.       writer.write("Hello Server.");  
  12.       writer.write("eof\n");  
  13.       writer.flush();  
  14.       //寫完以後進行讀操作  
  15.      BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream()));  
  16.       StringBuffer sb = new StringBuffer();  
  17.       String temp;  
  18.       int index;  
  19.       while ((temp=br.readLine()) != null) {  
  20.          if ((index = temp.indexOf("eof")) != -1) {  
  21.             sb.append(temp.substring(0, index));  
  22.             break;  
  23.          }  
  24.          sb.append(temp);  
  25.       }  
  26.       System.out.println("from server: " + sb);  
  27.       writer.close();  
  28.       br.close();  
  29.       client.close();  
  30.    }  
  31. }  

  

      4、設定超時時間

       假設有這樣一種需求，我們的客戶端需要通過Socket從服務端獲取到XX資訊，然後給使用者展示在頁面上。我們知道Socket在讀資料的時候是阻塞式的，如果沒有讀到資料程式會一直阻塞在那裡。在同步請求的時候我們肯定是不能允許這樣的情況發生的，這就需要我們在請求達到一定的時間後控制阻塞的中斷，讓程式得以繼續執行。Socket為我們提供了一個setSoTimeout()方法來設定接收資料的超時時間，單位是毫秒。當設定的超時時間大於0，並且超過了這一時間Socket還沒有接收到返回的資料的話，Socket就會丟擲一個SocketTimeoutException。

       假設我們需要控制我們的客戶端在開始讀取資料10秒後還沒有讀到資料就中斷阻塞的話我們可以這樣做：

 

Java程式碼  收藏程式碼
  1. public class Client {  
  2.    
  3.    public static void main(String args[]) throws Exception {  
  4.       //為了簡單起見，所有的異常都直接往外拋  
  5.      String host = "127.0.0.1";  //要連線的服務端IP地址  
  6.      int port = 8899;   //要連線的服務端對應的監聽埠  
  7.      //與服務端建立連線  
  8.      Socket client = new Socket(host, port);  
  9.       //建立連線後就可以往服務端寫資料了  
  10.      Writer writer = new OutputStreamWriter(client.getOutputStream());  
  11.       writer.write("Hello Server.");  
  12.       writer.write("eof\n");  
  13.       writer.flush();  
  14.       //寫完以後進行讀操作  
  15.      BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream()));  
  16.       //設定超時間為10秒  
  17.      client.setSoTimeout(10*1000);  
  18.       StringBuffer sb = new StringBuffer();  
  19.       String temp;  
  20.       int index;  
  21.       try {  
  22.          while ((temp=br.readLine()) != null) {  
  23.             if ((index = temp.indexOf("eof")) != -1) {  
  24.                 sb.append(temp.substring(0, index));  
  25.                 break;  
  26.             }  
  27.             sb.append(temp);  
  28.          }  
  29.       } catch (SocketTimeoutException e) {  
  30.          System.out.println("資料讀取超時。");  
  31.       }  
  32.       System.out.println("from server: " + sb);  
  33.       writer.close();  
  34.       br.close();  
  35.       client.close();  
  36.    }  
  37. }  
  38.   
  39.    

       5、接收資料亂碼

       對於這種服務端或客戶端接收中文亂碼的情況通常是因為資料傳送時使用的編碼跟接收時候使用的編碼不一致。比如有下面這樣一段服務端程式碼：

Java程式碼  收藏程式碼
  1. public class Server {  
  2.    
  3.    public static void main(String args[]) throws IOException {  
  4.       //為了簡單起見，所有的異常資訊都往外拋  
  5.       int port = 8899;  
  6.       //定義一個ServerSocket監聽在埠8899上  
  7.       ServerSocket server = new ServerSocket(port);  
  8.       while (true) {  
  9.          //server嘗試接收其他Socket的連線請求，server的accept方法是阻塞式的  
  10.          Socket socket = server.accept();  
  11.          //每接收到一個Socket就建立一個新的執行緒來處理它  
  12.          new Thread(new Task(socket)).start();  
  13.       }  
  14.    }  
  15.      
  16.    /** 
  17.     * 用來處理Socket請求的 
  18.     */  
  19.    static class Task implements Runnable {  
  20.    
  21.       private Socket socket;  
  22.         
  23.       public Task(Socket socket) {  
  24.          this.socket = socket;  
  25.       }  
  26.         
  27.       public void run() {  
  28.          try {  
  29.             handleSocket();  
  30.          } catch (Exception e) {  
  31.             e.printStackTrace();  
  32.          }  
  33.       }  
  34.         
  35.       /** 
  36.        * 跟客戶端Socket進行通訊 
  37.       * @throws Exception 
  38.        */  
  39.       private void handleSocket() throws Exception {  
  40.          BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream(), "GBK"));  
  41.          StringBuilder sb = new StringBuilder();  
  42.          String temp;  
  43.          int index;  
  44.          while ((temp=br.readLine()) != null) {  
  45.             System.out.println(temp);  
  46.             if ((index = temp.indexOf("eof")) != -1) {//遇到eof時就結束接收  
  47.              sb.append(temp.substring(0, index));  
  48.                 break;  
  49.             }  
  50.             sb.append(temp);  
  51.          }  
  52.          System.out.println("客戶端: " + sb);  
  53.          //讀完後寫一句  
  54.        Writer writer = new OutputStreamWriter(socket.getOutputStream(), "UTF-8");  
  55.          writer.write("你好，客戶端。");  
  56.          writer.write("eof\n");  
  57.          writer.flush();  
  58.          writer.close();  
  59.          br.close();  
  60.          socket.close();  
  61.       }  
  62.    }  
  63. }  

       

這裡用來測試我就弄的混亂了一點。在上面服務端程式碼中我們在定義輸入流的時候明確定義了使用GBK編碼來讀取資料，而在定義輸出流的時候明確指定了將使用UTF-8編碼來傳送資料。如果客戶端上送資料的時候不以GBK編碼來傳送的話服務端接收的資料就很有可能會亂碼；同樣如果客戶端接收資料的時候不以服務端傳送資料的編碼，即UTF-8編碼來接收資料的話也極有可能會出現資料亂碼的情況。所以，對於上述服務端程式碼，為使我們的程式能夠讀取對方傳送過來的資料，而不出現亂碼情況，我們的客戶端應該是這樣的：
Java程式碼  收藏程式碼
  1. public class Client {  
  2.    
  3.    public static void main(String args[]) throws Exception {  
  4.       //為了簡單起見，所有的異常都直接往外拋  
  5.      String host = "127.0.0.1";  //要連線的服務端IP地址  
  6.      int port = 8899;   //要連線的服務端對應的監聽埠  
  7.      //與服務端建立連線  
  8.      Socket client = new Socket(host, port);  
  9.       //建立連線後就可以往服務端寫資料了  
  10.      Writer writer = new OutputStreamWriter(client.getOutputStream(), "GBK");  
  11.       writer.write("你好，服務端。");  
  12.       writer.write("eof\n");  
  13.       writer.flush();  
  14.       //寫完以後進行讀操作  
  15.      BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream(), "UTF-8"));  
  16.       //設定超時間為10秒  
  17.      client.setSoTimeout(10*1000);  
  18.       StringBuffer sb = new StringBuffer();  
  19.       String temp;  
  20.       int index;  
  21.       try {  
  22.          while ((temp=br.readLine()) != null) {  
  23.             if ((index = temp.indexOf("eof")) != -1) {  
  24.                 sb.append(temp.substring(0, index));  
  25.                 break;  
  26.             }  
  27.             sb.append(temp);  
  28.          }  
  29.       } catch (SocketTimeoutException e) {  
  30.          System.out.println("資料讀取超時。");  
  31.       }  
  32.       System.out.println("服務端: " + sb);  
  33.       writer.close();  
  34.       br.close();  
  35.       client.close();  
  36.    }  
  37. }  

相關文章