程序師世界是廣大編程愛好者互助、分享、學習的平台，程序師世界有你更精彩！
設為首頁 加入收藏
首頁
編程語言
C語言|JAVA編程
Python編程
網頁編程
ASP編程|PHP編程
JSP編程
數據庫知識
MYSQL數據庫|SqlServer數據庫
Oracle數據庫|DB2數據庫
 程式師世界 >> 編程語言 >> JAVA編程 >> 關於JAVA >> 轉：Java Socket編程

轉：Java Socket編程

編輯：關於JAVA

轉：Java Socket編程。本站提示廣大學習愛好者：（轉：Java Socket編程）文章只能為提供參考，不一定能成為您想要的結果。以下是轉：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;  
  23.   public Task(Socket socket) {  
  24.  this.socket = socket;  
  25.   }  
  27.   public void run() {  
  28.   
  29.  try {  
  30.   
  31. handleSocket();  
  32.  } catch (Exception e) {  
  33. e.printStackTrace();  
  34.  }  
  35.   }  
  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.   }  
  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;  
  23.   public Task(Socket socket) {  
  24.  this.socket = socket;  
  25.   }  
  27.   public void run() {  
  28.  try {  
  29. handleSocket();  
  30.  } catch (Exception e) {  
  31. e.printStackTrace();  
  32.  }  
  33.   }  
  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;  
  23.   public Task(Socket socket) {  
  24.  this.socket = socket;  
  25.   }  
  27.   public void run() {  
  28.  try {  
  29. handleSocket();  
  30.  } catch (Exception e) {  
  31. e.printStackTrace();  
  32.  }  
  33.   }  
  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. }  

轉自：

http://elim.iteye.com/blog/1979837

  1. 上一頁:
  2. 下一頁:
關於JAVA
Eclipse下快速打開本地文件插件Open Explorer教程

 Open Explorer插件可以快
在Eclipse中開發Apache Derby應用程序

概述本文的目的是向您展示如何在 Eclipse
Ruby on rails開發從頭來（windows）（十一）-訂單（Order）

在上次的內容裡，我們實現了清空購物車和金額的格
java類中應用Jfreechart的簡略實例

java類中應用Jfreechart的簡略實例。本站提示廣大
Java理論與實踐: 垃圾收集簡史

Java 語言可能是使用最廣泛的依賴於垃圾收集
JavaEE學習中，PreparedStatement 的復雜運用 和 引見（java 學習中的小記載）

JavaEE學習中，PreparedStatement 的復
相關文章
閱讀排行榜
“一成不變”的弊端(java) 用Maven插件生成Mybatis代碼的完成辦法 周全懂得Java中的外部類和匿名類 學Java-圖書銷售系統-POJO類 java Arrays類詳解及實例代碼 使用reflect得到數組中的內容 java顯示以後的體系時光 用C++寫的CGI程序 關於對類的解釋 用Java保存位圖文件 JDBC從入門到精通專題講座一
熱門圖文
Excel數據導入Mysql數據庫的實現代碼 PHP驗證碼在驗證頁面中的應用分析 使用PHP計算兩個路徑的相對路徑 virtual memory exhausted: Cannot allocate memory，exhaustedallocate 類型轉換，哈密頓回路 Servlet 是什麼？ 單片機匯編語言C語言有哪些區別? C# 類型基礎——你可能忽略的技術細節
欄目導航
JAVA編程入門知識關於JAVAJ2EEJ2SEJ2MEJAVA綜合教程
Copyright © 程式師世界 All Rights Reserved