2. 程式人生 > >java Socket學習

java Socket學習

阿新 • • 發佈：2019-01-08

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

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

       客戶端程式碼

Java程式碼  收藏程式碼
  1. public class Client {  
  2.    public static void main(String args[]) throws Exception {  
  3.       //為了簡單起見，所有的異常都直接往外拋  
  4.       String host = "127.0.0.1";  //要連線的服務端IP地址  
  5.       int port = 8899;   //要連線的服務端對應的監聽埠  
  6.       //與服務端建立連線  
  7.       Socket client = new Socket(host, port);  
  8.       //建立連線後就可以往服務端寫資料了  
  9.       Writer writer = new OutputStreamWriter(client.getOutputStream());  
  10.       writer.write("Hello Server.");  
  11.       writer.flush();//寫完後要記得flush  
  12.       writer.close();  
  13.       client.close();  
  14.    }  
  15. }  
對於客戶端往Socket的輸出流裡面寫資料傳遞給服務端要注意一點，如果寫操作之後程式不是對應著輸出流的關閉，而是進行其他阻塞式的操作（比如從輸入流裡面讀資料），記住要flush一下，只有這樣服務端才能收到客戶端傳送的資料，否則可能會引起兩邊無限的互相等待。在稍後講到客戶端和服務端同時讀和寫的時候會說到這個問題。

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

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

       服務端程式碼

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

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

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

       客戶端程式碼

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

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

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

Java程式碼  收藏程式碼
  1. public class Server {  
  2.    public static void main(String args[]) throws IOException {  
  3.       //為了簡單起見，所有的異常資訊都往外拋  
  4.      int port = 8899;  
  5.       //定義一個ServerSocket監聽在埠8899上  
  6.      ServerSocket server = new ServerSocket(port);  
  7.       while (true) {  
  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.       }  
  34.    }  
  35. }  
在上面程式碼中我們用了一個死迴圈，在迴圈體裡面ServerSocket呼叫其accept方法試圖接收來自客戶端的連線請求。當沒有接收到請求的時候，程式會在這裡阻塞直到接收到來自客戶端的連線請求，之後會跟當前建立好連線的客戶端進行通訊，完了後會接著執行迴圈體再次嘗試接收新的連線請求。這樣我們的ServerSocket就能接收來自所有客戶端的連線請求了，並且與它們進行通訊了。這就實現了一個簡單的一個服務端與多個客戶端進行通訊的模式。

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

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

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

Java程式碼  收藏程式碼
  1. public class Server {  
  2.    public static void main(String args[]) throws IOException {  
  3.       //為了簡單起見，所有的異常資訊都往外拋  
  4.      int port = 8899;  
  5.       //定義一個ServerSocket監聽在埠8899上  
  6.      ServerSocket server = new ServerSocket(port);  
  7.       while (true) {  
  8.          //server嘗試接收其他Socket的連線請求，server的accept方法是阻塞式的  
  9.          Socket socket = server.accept();  
  10.          //每接收到一個Socket就建立一個新的執行緒來處理它  
  11.          new Thread(new Task(socket)).start();  
  12.       }  
  13.    }  
  14.    /** 
  15.     * 用來處理Socket請求的 
  16.    */  
  17.    static class Task implements Runnable {  
  18.       private Socket socket;  
  19.       public Task(Socket socket) {  
  20.          this.socket = socket;  
  21.       }  
  22.       public void run() {  
  23.          try {  
  24.             handleSocket();  
  25.          } catch (Exception e) {  
  26.             e.printStackTrace();  
  27.          }  
  28.       }  
  29.       /** 
  30.        * 跟客戶端Socket進行通訊 
  31.       * @throws Exception 
  32.        */  
  33.       private void handleSocket() throws Exception {  
  34.          BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));  
  35.          StringBuilder sb = new StringBuilder();  
  36.          String temp;  
  37.          int index;  
  38.          while ((temp=br.readLine()) != null) {  
  39.             System.out.println(temp);  
  40.             if ((index = temp.indexOf("eof")) != -1) {//遇到eof時就結束接收  
  41.              sb.append(temp.substring(0, index));  
  42.                 break;  
  43.             }  
  44.             sb.append(temp);  
  45.          }  
  46.          System.out.println("from client: " + sb);  
  47.          //讀完後寫一句  
  48.        Writer writer = new OutputStreamWriter(socket.getOutputStream());  
  49.          writer.write("Hello Client.");  
  50.          writer.write("eof\n");  
  51.          writer.flush();  
  52.          writer.close();  
  53.          br.close();  
  54.          socket.close();  
  55.       }  
  56.    }  
  57. }  
這個時候需要注意的是，BufferedReader的readLine方法是一次讀一行的，這個方法是阻塞的，直到它讀到了一行資料為止程式才會繼續往下執行，那麼readLine什麼時候才會讀到一行呢？直到程式遇到了換行符或者是對應流的結束符readLine方法才會認為讀到了一行，才會結束其阻塞，讓程式繼續往下執行。所以我們在使用BufferedReader的readLine讀取資料的時候一定要記得在對應的輸出流裡面一定要寫入換行符（流結束之後會自動標記為結束，readLine可以識別），寫入換行符之後一定記得如果輸出流不是馬上關閉的情況下記得flush一下，這樣資料才會真正的從緩衝區裡面寫入。對應上面的程式碼我們的客戶端程式應該這樣寫： Java程式碼  收藏程式碼
  1. public class Client {  
  2.    public static void main(String args[]) throws Exception {  
  3.       //為了簡單起見，所有的異常都直接往外拋  
  4.      String host = "127.0.0.1";  //要連線的服務端IP地址  
  5.      int port = 8899;   //要連線的服務端對應的監聽埠  
  6.      //與服務端建立連線  
  7.      Socket client = new Socket(host, port);  
  8.       //建立連線後就可以往服務端寫資料了  
  9.      Writer writer = new OutputStreamWriter(client.getOutputStream());  
  10.       writer.write("Hello Server.");  
  11.       writer.write("eof\n");  
  12.       writer.flush();  
  13.       //寫完以後進行讀操作  
  14.      BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream()));  
  15.       StringBuffer sb = new StringBuffer();  
  16.       String temp;  
  17.       int index;  
  18.       while ((temp=br.readLine()) != null) {  
  19.          if ((index = temp.indexOf("eof")) != -1) {  
  20.             sb.append(temp.substring(0, index));  
  21.             break;  
  22.          }  
  23.          sb.append(temp);  
  24.       }  
  25.       System.out.println("from server: " + sb);  
  26.       writer.close();  
  27.       br.close();  
  28.       client.close();  
  29.    }  
  30. }  

      4、設定超時時間

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

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

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

       5、接收資料亂碼

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

Java程式碼  收藏程式碼
  1. public class Server {  
  2.    public static void main(String args[]) throws IOException {  
  3.       //為了簡單起見，所有的異常資訊都往外拋  
  4.       int port = 8899;  
  5.       //定義一個ServerSocket監聽在埠8899上  
  6.       ServerSocket server = new ServerSocket(port);  
  7.       while (true) {  
  8.          //server嘗試接收其他Socket的連線請求，server的accept方法是阻塞式的  
  9.          Socket socket = server.accept();  
  10.          //每接收到一個Socket就建立一個新的執行緒來處理它  
  11.          new Thread(new Task(socket)).start();  
  12.       }  
  13.    }  
  14.    /** 

  15. 相關推薦

    記一次java socket學習(簡單實用多執行緒，實現多對多群聊)

    學習過程是艱苦，學習結束是快樂的 目錄 用 [TOC]來生成目錄： 本來想寫一些文字描述描述，可是想不出來說啥。。。所以直接記錄程式碼了。。。 程式碼塊 因為喜歡把常量都提取出來 所以上來就是常量類： public class Const

    java Socket學習

    Java Socket程式設計        對於Java Socket程式設計而言，有兩個概念，一個是ServerSocket，一個是Socket。服務端和客戶端之間通過Socket建立連線，之後它們就可以進行通訊了。首先ServerSocket將在服務端監聽某個埠，當

    java基礎學習總結（十七）：Java Socket

    一、 什麼是Socket          Socket的概念很簡單，它是網路上執行的兩個程式間雙向通訊的一端，既可以接收請求，也可以傳送請求，利用它可以較為方便地編寫網路上資料的傳遞。 所以簡而言之，Socket就是程序通訊的端點

    JAVA Socket 程式設計學習

    import java.io.*; import java.net.Socket; /** * 伺服器端執行緒處理類 * Created by Administrator on 2017/9/28. */ public class ServerThread extends Thread {

    Java Socket 程式設計學習（4）

    Java 利用Socket實現UDP客戶端和伺服器端 伺服器端： ServerBean類 package yang.socket.udp; import java.io.IOException; import java.net.DatagramPacket; impo

    Java Socket 程式設計學習（3）

    Java Socket 程式設計學習，利用DatagramSocket和DatagramPacket實現UDP資料傳輸 場景描述： 客戶端建立資料包，繫結伺服器地址和埠，向伺服器傳送資料；伺服器繫結埠，從埠接受資料 伺服器程式碼： ServerBean類 package y

    分散式服務架構學習（一）：實現自己的RPC框架（採用Java Socket）

    RPC實現原理圖： 1、Service API對應服務介面。 HelloService.java程式碼如下： package com.shan.rpc.service; public interface HelloService { public String

    [Java]Socket和ServerSocket學習

    對於即時類應用或者即時類的遊戲，HTTP協議很多時候無法滿足於我們的需求。這會，Socket對於我們來說就非常實用了。 下面是本次學習的筆記。主要分異常型別、互動原理、Socket、ServerSocket、多執行緒這幾個方面闡述。 異常型別 在瞭解Socket的內容

    [Java]Socket和ServerSocket學習筆記

    對於即時類應用或者即時類的遊戲，HTTP協議很多時候無法滿足於我們的需求。這會，Socket對於我們來說就非常實用了。下面是本次學習的筆記。主要分異常型別、互動原理、Socket、ServerSocket、多執行緒這幾個方面闡述。 異常型別 在瞭解Socket的內容之前，先要了解一下涉及到的一些異常型別

    從jedis的TCP連線建立來學習Java Socket

    在很多教材或者教程上,通常都是很簡單的一個例子來演示如何使用Java進行TCP通訊.在這款廣泛被使用的開源元件中,我們能夠更好的學習到一個企業級的元件在TCP連線的處理上,更應該關注哪些方面.有哪些是我們應該掌握或者瞭解的TCP知識.TCP協議本身相當複雜

    Java Socket網絡編程學習筆記（一）

    out 消息 服務端 soc stream ron () tro throws 0.前言 　　其實大概半年前就已經看過網絡編程Socket的知識了（傳統IO），但是因為長時間的不使用導致忘的一幹二凈，最近正好準備校招，又重新看了網絡編程這一章，　　是傳統IO（BIO）

    java NIO 學習

    之間 理解 poll 利用 .com 根據 handler react 階段 一、了解Unix網絡編程5種I/O模型 1.1、阻塞式I/O模型 阻塞I/O(blocking I/O）模型，進程調用recvfrom，其系統調用直到數據報到達且被拷貝到應用進程的緩沖區中或者發

    java IO 學習筆記

    key 網絡 java io writer 讀取 方式 訪問 resources str 1.IO的數據源有： 文件 管道 網絡 內存緩存 讀寫方式有字符讀寫 reader writer ，字節讀寫 Stream。 2.IO的異常處理： try with reso

    轉：深入Java集合學習系列：HashSet的實現原理

    是否 abstract arc html 源代碼 cat param body static 0.參考文獻 深入Java集合學習系列：HashSet的實現原理 1.HashSet概述： 　　HashSet實現Set接口，由哈希表（實際上是一個HashMap實例）支持。它

    Java Web學習筆記-1

    根路徑 text .get set 接口 context cat 方法 web應用 1.servlet理論上可以處理多種形式的請求響應形式 ,http只是其中之一 ,所以HttpServletRequest、 HttpServletResponse分別是ServletReq

    java註解學習筆記

    ati type類 包括 generated override stack color 類繼承 boolean 今天看了下有關java註解的視頻學習資料在。做點筆記： 學java註解的目的： 能看別人代碼，特別是框架代碼。由於肯定與註解有關。 編程更簡潔，代碼清晰。

    java OO學習後的感悟

    連接 設計 業務 一定的 需要 計算 學習 感悟 思想 通過了一個多月的學習，我對Java這門課程有了一定的了解，什麽面相對象，繼承，封裝，多態，抽象，等都比較了解。通過學習我明白了Java是一門簡單的語言，因為它的思維是貼合人的思想的。人的思想和計算機語言共通，

    java後臺 學習順序

    ring pst 順序 nat 接口 如果 5% blank ati 按順序學這些：流程控制語句、類和對象、接口和抽象類、多態、封裝、繼承、數組、集合、IO編程、線程 ，再學JavaWeb，又習慣稱Java企業級應用（Java EE），Java EE的基礎是servlet,

    java入門學習筆記之1(類的定義，代碼的編譯執行)

    spa hex nts 自動調用 [] alt vim 進制 技術 這篇文章講解Java代碼的基本執行過程 我們先拋開各種JAVA IDE,開發工具，只使用文本編輯器，以突出最本質的東西。 在Linux環境下，我們編輯一個文件： vim HelloWorld.java

    [Java Web學習]Tomcat啟動時報war exploded: Error during artifact deployment

    con nim except ins ann ppr 時報 ostc med 報錯：Artifact FirstWeb:war exploded: Error during artifact deployment. See server log for details. S