本文轉自：https://github.com/jasonGeng88/blog

本系列文章將整理到我在GitHub上的《Java面試指南》倉庫，更多精彩內容請到我的倉庫裡檢視
> https://github.com/h2pl/Java-Tutorial

喜歡的話麻煩點下Star哈

文章將同步到我的個人部落格：
> www.how2playlife.com

本文是微信公眾號【Java技術江湖】的《不可輕視的Java網路程式設計》其中一篇，本文部分內容來源於網路，為了把本文主題講得清晰透徹，也整合了很多我認為不錯的技術部落格內容，引用其中了一些比較好的部落格文章，如有侵權，請聯絡作者。

該系列博文會告訴你如何從計算機網路的基礎知識入手，一步步地學習Java網路基礎，從socket到nio、bio、aio和netty等網路程式設計知識，並且進行實戰，網路程式設計是每一個Java後端工程師必須要學習和理解的知識點，進一步來說，你還需要掌握Linux中的網路程式設計原理，包括IO模型、網路程式設計框架netty的進階原理，才能更完整地瞭解整個Java網路程式設計的知識體系，形成自己的知識框架。

為了更好地總結和檢驗你的學習成果，本系列文章也會提供部分知識點對應的面試題以及參考答案。

如果對本系列文章有什麼建議，或者是有什麼疑問的話，也可以關注公眾號【Java技術江湖】聯絡作者，歡迎你參與本系列博文的創作和修訂。

## 當前環境

1.  jdk == 1.8

## [](https://github.com/jasonGeng88/blog/blob/master/201708/java-socket.md#%E7%9F%A5%E8%AF%86%E7%82%B9)知識點

*   socket 的連線處理
*   IO 輸入、輸出流的處理
*   請求資料格式處理
*   請求模型最佳化

## [](https://github.com/jasonGeng88/blog/blob/master/201708/java-socket.md#%E5%9C%BA%E6%99%AF)場景

今天，和大家聊一下 JAVA 中的 socket 通訊問題。這裡採用最簡單的一請求一響應模型為例，假設我們現在需要向 baidu 站點進行通訊。我們用 JAVA 原生的 socket 該如何實現。

### [](https://github.com/jasonGeng88/blog/blob/master/201708/java-socket.md#%E5%BB%BA%E7%AB%8B-socket-%E8%BF%9E%E6%8E%A5)建立 socket 連線

首先，我們需要建立 socket 連線（_核心程式碼_）

<pre>import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketAddress;

// 初始化 socket
Socket socket = new Socket();
// 初始化遠端連線地址
SocketAddress remote = new InetSocketAddress(host, port);
// 建立連線
socket.connect(remote);
</pre>

### [](https://github.com/jasonGeng88/blog/blob/master/201708/java-socket.md#%E5%A4%84%E7%90%86-socket-%E8%BE%93%E5%85%A5%E8%BE%93%E5%87%BA%E6%B5%81)處理 socket 輸入輸出流

成功建立 socket 連線後，我們就能獲得它的輸入輸出流，通訊的本質是對輸入輸出流的處理。透過輸入流，讀取網路連線上傳來的資料，透過輸出流，將本地的資料傳出給遠端。

_socket 連線實際與處理檔案流有點類似，都是在進行 IO 操作。_

獲取輸入、輸出流程式碼如下：

<pre>// 輸入流
InputStream in = socket.getInputStream();
// 輸出流
OutputStream out = socket.getOutputStream();</pre>

關於 IO 流的處理，我們一般會用相應的包裝類來處理 IO 流，如果直接處理的話，我們需要對 `byte[]` 進行操作，而這是相對比較繁瑣的。如果採用包裝類，我們可以直接以`string`、`int`等型別進行處理，簡化了 IO 位元組操作。

下面以 `BufferedReader` 與 `PrintWriter` 作為輸入輸出的包裝類進行處理。

<pre>// 獲取 socket 輸入流
private BufferedReader getReader(Socket socket) throws IOException {
    InputStream in = socket.getInputStream();
    return new BufferedReader(new InputStreamReader(in));
}

// 獲取 socket 輸出流
private PrintWriter getWriter(Socket socket) throws IOException {
    OutputStream out = socket.getOutputStream();
    return new PrintWriter(new OutputStreamWriter(out));
}
</pre>

### [](https://github.com/jasonGeng88/blog/blob/master/201708/java-socket.md#%E6%95%B0%E6%8D%AE%E8%AF%B7%E6%B1%82%E4%B8%8E%E5%93%8D%E5%BA%94)資料請求與響應

有了 socket 連線、IO 輸入輸出流，下面就該向傳送請求資料，以及獲取請求的響應結果。

因為有了 IO 包裝類的支援，我們可以直接以字串的格式進行傳輸，由包裝類幫我們將資料裝換成相應的位元組流。

因為我們與 baidu 站點進行的是 HTTP 訪問，所有我們不需要額外定義輸出格式。採用標準的 HTTP 傳輸格式，就能進行請求響應了（_某些特定的 RPC 框架，可能會有自定義的通訊格式_）。

請求的資料內容處理如下：

<pre>public class HttpUtil {

public static String compositeRequest(String host){

return "GET / HTTP/1.1\r\n" +
                "Host: " + host + "\r\n" +
                "User-Agent: curl/7.43.0\r\n" +
                "Accept: */*\r\n\r\n";
    }

}</pre>

傳送請求資料程式碼如下：

<pre>// 發起請求
PrintWriter writer = getWriter(socket);
writer.write(HttpUtil.compositeRequest(host));
writer.flush();</pre>

接收響應資料程式碼如下：

<pre>// 讀取響應
String msg;
BufferedReader reader = getReader(socket);
while ((msg = reader.readLine()) != null){
    System.out.println(msg);
}</pre>

### [](https://github.com/jasonGeng88/blog/blob/master/201708/java-socket.md#%E7%BB%93%E6%9E%9C%E5%B1%95%E7%A4%BA)結果展示

至此，講完了原生 socket 下的建立連線、傳送請求與接收響應的所有核心程式碼。

完整程式碼如下：

```
import java.io.*;import java.net.InetSocketAddress;import java.net.Socket;import java.net.SocketAddress;import com.test.network.util.HttpUtil; public class SocketHttpClient {     public void start(String host, int port) {         // 初始化 socket        Socket socket = new Socket();         try {            // 設定 socket 連線            SocketAddress remote = new InetSocketAddress(host, port);            socket.setSoTimeout(5000);            socket.connect(remote);             // 發起請求            PrintWriter writer = getWriter(socket);            System.out.println(HttpUtil.compositeRequest(host));            writer.write(HttpUtil.compositeRequest(host));            writer.flush();             // 讀取響應            String msg;            BufferedReader reader = getReader(socket);            while ((msg = reader.readLine()) != null){                System.out.println(msg);            }         } catch (IOException e) {            e.printStackTrace();        } finally {            try {                socket.close();            } catch (IOException e) {                e.printStackTrace();            }        }     } 	private BufferedReader getReader(Socket socket) throws IOException {        InputStream in = socket.getInputStream();        return new BufferedReader(new InputStreamReader(in));    }     private PrintWriter getWriter(Socket socket) throws IOException {        OutputStream out = socket.getOutputStream();        return new PrintWriter(new OutputStreamWriter(out));    } }
```

下面，我們透過例項化一個客戶端，來展示 socket 通訊的結果。

<pre>public class Application {

public static void main(String[] args) {

new SocketHttpClient().start("www.baidu.com", 80);

}
}</pre>

結果輸出：

[![](https://github.com/jasonGeng88/blog/raw/master/201708/assets/java-socket-01.png)](https://github.com/jasonGeng88/blog/blob/master/201708/assets/java-socket-01.png)

## [](https://github.com/jasonGeng88/blog/blob/master/201708/java-socket.md#%E8%AF%B7%E6%B1%82%E6%A8%A1%E5%9E%8B%E4%BC%98%E5%8C%96)請求模型最佳化

這種方式，雖然實現功能沒什麼問題。但是我們細看，發現在 IO 寫入與讀取過程，是發生了 IO 阻塞的情況。即：

```
// 會發生 IO 阻塞writer.write(HttpUtil.compositeRequest(host));reader.readLine();
```

所以如果要同時請求10個不同的站點，如下：

<pre>public class SingleThreadApplication {

public static void main(String[] args) {

// HttpConstant.HOSTS 為 站點集合
        for (String host: HttpConstant.HOSTS) {

new SocketHttpClient().start(host, HttpConstant.PORT);

}

}
}</pre>

它一定是第一個請求響應結束後，才會發起下一個站點處理。

_這在服務端更明顯，雖然這裡的程式碼是客戶端連線，但是具體的操作和服務端是差不多的。請求只能一個個序列處理，這在響應時間上肯定不能達標。_

*   多執行緒處理

有人覺得這根本不是問題，JAVA 是多執行緒的程式語言。對於這種情況，採用多執行緒的模型再合適不過。

```
public class MultiThreadApplication {     public static void main(String[] args) {         for (final String host: HttpConstant.HOSTS) {             Thread t = new Thread(new Runnable() {                public void run() {                    new SocketHttpClient().start(host, HttpConstant.PORT);                }            });             t.start();         }    }}
```

這種方式起初看起來挺有用的，但併發量一大，應用會起很多的執行緒。都知道，在伺服器上，每一個執行緒實際都會佔據一個檔案控制程式碼。而伺服器上的控制程式碼數是有限的，而且大量的執行緒，造成的執行緒間切換的消耗也會相當的大。所以這種方式在併發量大的場景下，一定是承載不住的。

*   多執行緒 + 執行緒池 處理

既然執行緒太多不行，那我們控制一下執行緒建立的數目不就行了。只啟動固定的執行緒數來進行 socket 處理，既利用了多執行緒的處理，又控制了系統的資源消耗。

<pre>public class ThreadPoolApplication {

public static void main(String[] args) {

ExecutorService executorService = Executors.newFixedThreadPool(8);

for (final String host: HttpConstant.HOSTS) {

Thread t = new Thread(new Runnable() {
                public void run() {
                    new SocketHttpClient().start(host, HttpConstant.PORT);
                }
            });

executorService.submit(t);
            new SocketHttpClient().start(host, HttpConstant.PORT);

}

}
}</pre>

_關於啟動的執行緒數，一般 CPU 密集型會設定在 N+1（N為CPU核數），IO 密集型設定在 2N + 1。_

這種方式，看起來是最優的了。那有沒有更好的呢，如果一個執行緒能同時處理多個 socket 連線，並且在每個 socket 輸入輸出資料沒有準備好的情況下，不進行阻塞，那是不是更優呢。這種技術叫做“IO多路複用”。在 JAVA 的 nio 包中，提供了相應的實現。

## 補充1：TCP客戶端與服務端

<pre>public class TCP客戶端 {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
  public void run() {
                try {
                    Socket s = new Socket("127.0.0.1",1234);    //構建IO
  InputStream is = s.getInputStream();
  OutputStream os = s.getOutputStream();    BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os));
  //向伺服器端傳送一條訊息
  bw.write("測試客戶端和伺服器通訊，伺服器接收到訊息返回到客戶端\n");
  bw.flush();    //讀取伺服器返回的訊息
  BufferedReader br = new BufferedReader(new InputStreamReader(is));
  String mess = br.readLine();
  System._out_.println("伺服器："+mess);
  } catch (UnknownHostException e) {
                    e.printStackTrace();
  } catch (IOException e) {
                    e.printStackTrace();
  }
            }
        }).start();
  }
}</pre>

<pre>public class TCP服務端 {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
  public void run() {
                try {
                    ServerSocket ss = new ServerSocket(1234);
 while (true) {
                        System._out_.println("啟動伺服器....");
  Socket s = ss.accept();
  System._out_.println("客戶端:" + s.getInetAddress().getLocalHost() + "已連線到伺服器");
  BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
  //讀取客戶端傳送來的訊息
  String mess = br.readLine();
  System._out_.println("客戶端：" + mess);
  BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
  bw.write(mess + "\n");
  bw.flush();
  }
                } catch (IOException e) {
                    e.printStackTrace();
  }
            }
        }).start();
  }
}</pre>

## 補充2：UDP客戶端和服務端

<pre>public class UDP客戶端 {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
  public void run() {
                byte []arr = "Hello Server".getBytes();
 try {
                    InetAddress inetAddress = InetAddress.getLocalHost();
  DatagramSocket datagramSocket = new DatagramSocket();
  DatagramPacket datagramPacket = new DatagramPacket(arr, arr.length, inetAddress, 1234);
  datagramSocket.send(datagramPacket);
  System._out_.println("send end");
  } catch (UnknownHostException e) {
                    e.printStackTrace();
  } catch (SocketException e) {
                    e.printStackTrace();
  } catch (IOException e) {
                    e.printStackTrace();
  }
            }
        }).start();
  }
}</pre>

<pre>public class UDP服務端 {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
  public void run() {
                try {
                    DatagramSocket datagramSocket = new DatagramSocket(1234);
 byte[] buffer = new byte[1024];
  DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
  datagramSocket.receive(packet);
  System._out_.println("server recv");
  String msg = new String(packet.getData(), "utf-8");
  System._out_.println(msg);
  } catch (SocketException e) {
                    e.printStackTrace();
  } catch (IOException e) {
                    e.printStackTrace();
  }
            }
        }).start();
  }
}
</pre>

## [](https://github.com/jasonGeng88/blog/blob/master/201708/java-socket.md#%E5%90%8E%E7%BB%AD)後續

*   JAVA 中是如何實現 IO多路複用
*   Netty 下的實現非同步請求的

Java網路程式設計和NIO詳解1：JAVA 中原生的 socket 通訊機制

相關文章