Java Web 基礎（一） 基於TCP的Socket網絡編程

1、Socket簡單介紹

　　Socket通訊做爲Java網絡通信的基礎內容，集中了異常、I/O流模式等衆多知識點。學習Socket通訊，既可以瞭解真正的網絡通信原理，也可以加強對I/O流模式的理解。

　　1）Socket通訊分類

　　　　（一）基於TCP的Socket通訊：使用流式套接字，提供可靠、面向鏈接的通訊流。

　　　　（二）基於UDP的Socket通訊：使用數據報套接字，定義一種無鏈接服務，數據之間經過相互獨立的報文進行傳輸，是無序的，而且不保證可靠、無差錯。

　　2）Socket概念理解

　　金山詞霸中對Socket名詞解釋：插座、燈座、窩，引伸到計算機科學稱爲"套接字"。至於爲何要翻譯成"套接字"，能夠參考：https://www.zhihu.com/question/21383903/answer/18347271z對Socket歷史較爲詳細考證。

　　Socket曾經被翻譯爲"軟插座"，代表此處說的插座不是實際生活中的那種插座（硬插座），而是在計算機領域抽象出來的接口。若是在客戶端插座和服務器端插座之間連一條線（也就是數據交互的信道），那麼客戶端就可以與服務器端進行數據交互。

2、基於TCP的Socket通訊理論基礎

　　基於TCP/IP協議的網絡編程，就是利用TCP/IP協議在客戶端和服務器端之間創建通訊連接來實現數據交換。　具體的編程實現步驟以下：

　　1）服務器端建立其提供服務的端口號，即服務器端中提供服務的應用程序接口名稱。

　　　  服務器端ServerSocket： ServerSocket serverSocket = new ServerSocket(int port, int backlog);  ServerSocket做用是向操做系統註冊相應協議服務，申請端口並監聽這個端口是否有連接請求。其中port是端口號，backlog是服務器最多容許連接的客戶端數。註冊完成後，服務器分配此端口用於提供某一項進程服務。

　　2）服務器端（Server）和客戶端(Client)都建立各自的Socket對象。

　　    服務器端Socket:  Socket socket = serverSocket.accept();  服務器端建立一個socket對象用於等待客戶端socket的連接（accept方法是建立一個阻塞隊列，只有客戶端socket申請連接到服務器後，服務器端socket才能收到消息） 。若是服務器端socket收到客戶端的連接請求，那麼通過"三次握手"過程，創建客戶端與服務器端的鏈接。若是鏈接不成功，則拋出異常（詳見模塊三）。

          客戶端Socket： Socket socket = new Socket(String host, int port);  客戶端建立按一個socket對象用於連接具體服務器host的具體服務端口port，用於得到服務器進程的相應服務。

　　通過三次握手後，一個Socket通路就創建起來。此時，服務器端和客戶端就能夠開始通信了。

　　3）服務器端和客戶端打開連接到Socket通路的I/O流，按照必定協議進行數據通訊。

　　　　協議就是指發送與接受數據的編碼格式（計算機網絡中爲：語義、同步）。簡單說就是輸入和輸出的流必須匹配。

　　　　開啓網絡輸入流：網絡輸入流指的是從socket通道進入計算機內存的流。    socket.getInputStream();  返回值InputStream 輸入字節流

　　　　開啓網絡輸出流：網絡輸出流指的是從計算機內存走出到socket通道的流。 socket.getOutputStream(); 返回值OutputStream 輸出字節流

　　　　爲了通信方便，每每將低級流包裝成高級流進行服務端與客戶端之間的交互。

　　4）通訊完畢，關閉網絡流

　　　  通常而言，服務器端的流失不用關閉的，固然在某些條件下（好比服務器須要維護）也是須要關閉的。而客戶端通常都須要關閉。

 

3、Socket異常類

　　網絡通信中會遇到不少種錯誤，好比通信中斷、服務器維護拒絕訪問等等。下面稍微總結一下Socket通信中常見的異常類。

　　1）java.net.SocketTimeoutException套接字超時異常。常見緣由：網絡通路中斷，連接超時；

　　2）java.net.UnknowHostException未知主機異常。常見緣由：客戶端綁定的服務器IP或主機名不存在；

　　3）java.net.BindException綁定異常。常見緣由：端口被佔用；

　　4）java.net.ConnectException鏈接異常。常見緣由：服務器未啓動，客戶端申請服務；服務器拒絕服務，即服務器正在維護；

 

4、Java創建Socket通信

 　　1）服務器端與客戶端創建鏈接

 1 package day05;
 2 
 3 import java.io.IOException;
 4 import java.net.ServerSocket;
 5 import java.net.Socket;
 6 
 7 /**
 8  * 服務器端
 9  * @author forget406
10  *
11  */
12 public class Server {
13     
14     private ServerSocket serverSocket;
15     
16     /** 在操做系統中註冊8000端口服務，並監聽8000端口  */
17     public Server() {
18         try {
19             /* public ServerSocket(int port, int backlog) 
20              *  port表示端口號，backlog表示最多支持鏈接數  */
21             serverSocket = new ServerSocket(8000, 3);
22         } catch (IOException e) {
23             e.printStackTrace();
24         }
25     }
26     
27     /** 與客戶端交互  */
28     public void start() {
29         try {
30             System.out.println("等待用戶連接...");
31             /* 建立Socket對象: public Socket accept() 
32              * 等待客戶端連接，直到客戶端連接到此端口  */
33             Socket socket = serverSocket.accept();
34             System.out.println("連接成功，能夠通信！");
35         } catch (IOException e) {
36             // TODO Auto-generated catch block
37             e.printStackTrace();
38         }
39     }
40     
41     public static void main(String[] args) {
42         Server server = new Server();
43         server.start();
44     }
45 }
46 
47 ==============================================
48 
49 package day05;
50 
51 import java.io.IOException;
52 import java.net.Socket;
53 import java.net.UnknownHostException;
54 
55 /**
56  * 客戶端
57  * @author forget406
58  *
59  */
60 public class Client {
61     
62     private Socket socket;
63     
64     /** 申請與服務器端口鏈接  */
65     public Client() {
66         try {
67             /* 請求與服務器端口創建鏈接
68              * 並申請服務器8000端口的服務*/
69             socket = new Socket("localhost", 8000);
70         } catch (UnknownHostException e) {
71             e.printStackTrace();
72         } catch (IOException e) {
73             e.printStackTrace();
74         }
75     }
76     
77     /** 與服務器交互  */
78     public void start() {
79         
80     }
81     
82     public static void main(String[] args) {
83         Client client = new Client();
84         client.start();
85     }
86 }

服務器端結果：

 

5、Java實現C/S模式Socket通信

　　1）客戶端向服務器端發送消息（單向通訊）：服務器只能接受數據，客戶端只能發送數據。這是因爲socket綁定了從客戶端到服務器的一條通訊通路。

  1 package day05;
  2 
  3 import java.io.BufferedReader;
  4 import java.io.IOException;
  5 import java.io.InputStream;
  6 import java.io.InputStreamReader;
  7 import java.net.ServerSocket;
  8 import java.net.Socket;
  9 
 10 /**
 11  * 服務器端
 12  * @author forget406
 13  *
 14  */
 15 public class Server {
 16     
 17     private ServerSocket serverSocket;
 18     
 19     /** 在操做系統中註冊8000端口服務，並監聽8000端口  */
 20     public Server() {
 21         try {
 22             /* public ServerSocket(int port, int backlog) 
 23              *  port表示端口號，backlog表示最多支持鏈接數  */
 24             serverSocket = new ServerSocket(8000, 3);
 25         } catch (IOException e) {
 26             e.printStackTrace();
 27         }
 28     }
 29     
 30     /** 與客戶端單向交互  */
 31     public void start() {
 32         System.out.println("等待用戶連接...");
 33         try {
 34             /* 建立Socket對象: public Socket accept() 
 35              * 等待客戶端連接，直到客戶端連接到此端口  */
 36             Socket socket = serverSocket.accept();
 37             System.out.println("用戶連接成功，開始通信！");
 38             
 39             /* 服務器開始與客戶端通信  */
 40             while(true) {
 41                 // 開啓服務器socket端口到服務器內存的網路輸入字節流
 42                 InputStream is                    
 43                     = socket.getInputStream();  
 44                 // 在服務器內存中將網絡字節流轉換成字符流
 45                 InputStreamReader isr  
 46                     = new InputStreamReader(
 47                         is, "UTF-8"
 48                     );
 49                 // 包裝成按行讀取字符流
 50                 BufferedReader br
 51                     = new BufferedReader(isr);
 52                 
 53                 /* 中途網絡可能斷開
 54                  * 1)Windows的readLine會直接拋出異常
 55                  * 2)Linux的readLine則會返回null*/
 56                 String msg = null;
 57                 if((msg = br.readLine()) != null) {
 58                     System.out.println("客戶端說：" +
 59                                         msg
 60                                       );
 61                 }
 62                 
 63             }
 64             
 65         } catch (IOException e) {
 66             System.out.println("連接失敗");
 67             e.printStackTrace();
 68         }
 69     }
 70     
 71     public static void main(String[] args) {
 72         Server server = new Server();
 73         server.start();
 74     }
 75 }
 76 
 77 ===========================================
 78 
 79 package day05;
 80 
 81 import java.io.IOException;
 82 import java.io.OutputStream;
 83 import java.io.OutputStreamWriter;
 84 import java.io.PrintWriter;
 85 import java.net.Socket;
 86 import java.net.UnknownHostException;
 87 import java.util.Scanner;
 88 
 89 /**
 90  * 客戶端
 91  * @author forget406
 92  *
 93  */
 94 public class Client {
 95     
 96     private Socket socket;
 97     
 98     /** 申請與服務器端口鏈接  */
 99     public Client() {
100         try {
101             /* 請求與服務器端口創建鏈接
102              * 並申請服務器8000端口的服務*/
103             socket = new Socket("localhost", 8000);
104         } catch (UnknownHostException e) {
105             e.printStackTrace();
106         } catch (IOException e) {
107             e.printStackTrace();
108         }
109     }
110     
111     /** 與服務器單向交互  */
112     public void start() {
113         try {
114             // 開啓客戶端內存到客戶端socket端口的網絡輸出流
115             OutputStream os 
116                 = socket.getOutputStream();
117             // 將客戶端網絡輸出字節流包裝成網絡字符流
118             OutputStreamWriter osw
119                 = new OutputStreamWriter(os, "UTF-8");
120             // 將輸出字符流包裝成字符打印流
121             PrintWriter pw 
122                 = new PrintWriter(osw, true);
123             // 來自鍵盤的標準輸入字節流
124             Scanner sc = new Scanner(System.in);
125             while(true) {
126                 // 打印來自鍵盤的字符串(字節數組)
127                 pw.println(sc.nextLine());
128             }
129             
130         } catch (IOException e) {
131             e.printStackTrace();
132         }
133     }
134     
135     public static void main(String[] args) {
136         Client client = new Client();
137         client.start();
138     }
139 }

客戶端輸入：

服務器端結果：

 　　2）客戶端與服務器端雙向通訊：客戶端與服務器交互，可以實現服務器對客戶端的應答，這更像是P2P模式。此時，雙方socket端口均綁定來回一對通訊通路。

  1 package day05;
  2 
  3 import java.io.BufferedReader;
  4 import java.io.IOException;
  5 import java.io.InputStreamReader;
  6 import java.io.OutputStreamWriter;
  7 import java.io.PrintWriter;
  8 import java.net.ServerSocket;
  9 import java.net.Socket;
 10 import java.util.Scanner;
 11 
 12 /**
 13  * 服務器端
 14  * @author forget406
 15  *
 16  */
 17 public class Server {
 18     
 19     private ServerSocket serverSocket;
 20     
 21     /** 在操做系統中註冊8000端口服務，並監聽8000端口  */
 22     public Server() {
 23         try {
 24             /* public ServerSocket(int port, int backlog) 
 25              *  port表示端口號，backlog表示最多支持鏈接數  */
 26             serverSocket = new ServerSocket(8000, 3);
 27         } catch (IOException e) {
 28             e.printStackTrace();
 29         }
 30     }
 31     
 32     /** 與客戶端單向交互  */
 33     @SuppressWarnings("resource")
 34     public void start() {
 35         System.out.println("等待用戶連接...");
 36         try {
 37             /* 建立Socket對象: public Socket accept() 
 38              * 等待客戶端連接，直到客戶端連接到此端口  */
 39             Socket socket = serverSocket.accept();
 40             System.out.println("用戶連接成功，開始通信！");
 41                 
 42             /* 服務器接收客戶端數據  */
 43             InputStreamReader isr 
 44                 = new InputStreamReader(
 45                     socket.getInputStream(),
 46                     "UTF-8"
 47                 );
 48             BufferedReader br 
 49                 = new BufferedReader(isr);
 50             String msgReceive = null;
 51             String msgSend    = null;
 52             
 53             /* 服務器向客戶端發送數據  */
 54             OutputStreamWriter osw
 55                 = new OutputStreamWriter(
 56                     socket.getOutputStream(), 
 57                     "UTF-8"
 58                 );
 59             PrintWriter pw 
 60                 = new PrintWriter(osw, true);
 61             Scanner sc = new Scanner(System.in);
 62             
 63             while(true) {            
 64                 if((msgReceive = br.readLine()) != null) {
 65                     System.out.println("客戶端說：" + msgReceive);
 66                 }
 67                 
 68                 if((msgSend = sc.nextLine()) != null) {
 69                     pw.println(msgSend);
 70                 }
 71             }
 72             
 73         } catch (IOException e) {
 74             System.out.println("連接失敗");
 75             e.printStackTrace();
 76         }
 77     }
 78     
 79     public static void main(String[] args) {
 80         Server server = new Server();
 81         server.start();
 82     }
 83 }
 84 
 85 ============================================
 86 
 87 package day05;
 88 
 89 import java.io.BufferedReader;
 90 import java.io.IOException;
 91 import java.io.InputStreamReader;
 92 import java.io.OutputStreamWriter;
 93 import java.io.PrintWriter;
 94 import java.net.Socket;
 95 import java.net.UnknownHostException;
 96 import java.util.Scanner;
 97 
 98 /**
 99  * 客戶端
100  * @author forget406
101  *
102  */
103 public class Client {
104     
105     private Socket socket;
106     
107     /** 申請與服務器端口鏈接  */
108     public Client() {
109         try {
110             /* 請求與服務器端口創建鏈接
111              * 並申請服務器8000端口的服務*/
112             socket = new Socket("localhost", 8000);
113         } catch (UnknownHostException e) {
114             e.printStackTrace();
115         } catch (IOException e) {
116             e.printStackTrace();
117         }
118     }
119     
120     /** 與服務器單向交互  */
121     @SuppressWarnings("resource")
122     public void start() {
123         try {
124             /* 客戶端向服務器發送數據  */
125             OutputStreamWriter osw
126                 = new OutputStreamWriter(
127                     socket.getOutputStream(), 
128                     "UTF-8"
129                 );
130             PrintWriter pw 
131                 = new PrintWriter(osw, true);
132             Scanner sc = new Scanner(System.in);
133             
134             /* 客戶端接收服務器數據  */
135             InputStreamReader isr 
136                 = new InputStreamReader(
137                     socket.getInputStream(),
138                     "UTF-8"
139                 );
140             BufferedReader br 
141                 = new BufferedReader(isr);
142             String msgReceive = null;
143             String msgSend    = null;
144             
145             while(true) {
146                 if((msgSend = sc.nextLine()) != null) {
147                     pw.println(msgSend);
148                 }
149                 if((msgReceive = br.readLine()) != null) {
150                     System.out.println("服務器說：" + msgReceive);
151                 }            
152             }
153             
154         } catch (IOException e) {
155             System.out.println("連接失敗！");
156             e.printStackTrace();
157         }
158     }
159     
160     
161     public static void main(String[] args) {
162         Client client = new Client();
163         client.start();
164         
165     }
166 }

PS: 只是初步實現，有些bug沒有改進。相似QQ的完善版本代碼會在後續的文章中更新。

 

6、心得體會

　　上述代碼實現的是C/S模型的簡化版本，即P2P模式---客戶端與服務器端一對一進行交互通訊。事實上，服務器能夠並行與多臺客戶機進行數據收發與交互，這須要運用到Java多線程的知識，這將會在後續文章中分析。

　　I/O流模式的選取原則：

　　1. 選擇合適的節點流。在Socket網絡編程中，節點流分別是socket.getInputStream和socket.getOutputStream，均爲字節流。

　　　1.1）選擇合適方向的流。輸入流socket.getInputStream、InputStreamReader、BufferedReader；輸出流socket.getOutputStream、OutputStreamWriter、PrintWriter。

　　   1.2）選擇字節流和字符流。網絡通訊在實際通訊線路中傳遞的是比特流（字節流）；而字符流只會出如今計算機內存中。

　　2. 選擇合適的包裝流。在選擇I/O流時，節點流是必須的，而包裝流則是可選的；節點流類型只能存在一種，而包裝流則能存在多種（注意區分：是一種或一對，而不是一個）。

　　　2.1）選擇符合功能要求的流。若是須要讀寫格式化數據，選擇DataInputStream/DataOutputStream；而BufferedReader/BufferedWriter則提供緩衝區功能，可以提升格式化讀寫的效率。

　      2.2）選擇合適方向的包裝流。基本與節點流一致。當選擇了多個包裝流後，可使用流之間的多層嵌套功能，不過流的嵌套在物理實現上是組合關係，所以彼此之間沒有順序。