Java網絡編程和NIO詳解1：JAVA 中原生的 socket 通訊機制

時間  2019-11-11
標籤 java 網絡 編程 nio 詳解 中原 生的 socket 通訊 機制 欄目 Java 简体版
原文   原文鏈接

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

本系列文章將整理到我在GitHub上的《Java面試指南》倉庫，更多精彩內容請到個人倉庫裏查看git

https://github.com/h2pl/Java-Tutorialgithub

喜歡的話麻煩點下Star哈面試

文章將同步到個人我的博客：編程

www.how2playlife.com後端

本文是微信公衆號【Java技術江湖】的《不可輕視的Java網絡編程》其中一篇，本文部份內容來源於網絡，爲了把本文主題講得清晰透徹，也整合了不少我認爲不錯的技術博客內容，引用其中了一些比較好的博客文章，若有侵權，請聯繫做者。服務器

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

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

若是對本系列文章有什麼建議，或者是有什麼疑問的話，也能夠關注公衆號【Java技術江湖】聯繫做者，歡迎你參與本系列博文的創做和修訂。多線程

<!-- more -->

當前環境

  1. jdk == 1.8

知識點

  • socket 的鏈接處理
  • IO 輸入、輸出流的處理
  • 請求數據格式處理
  • 請求模型優化

場景

今天，和你們聊一下 JAVA 中的 socket 通訊問題。這裏採用最簡單的一請求一響應模型爲例，假設咱們如今須要向 baidu 站點進行通訊。咱們用 JAVA 原生的 socket 該如何實現。

創建 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>

處理 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>

數據請求與響應

有了 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>

結果展現

至此，講完了原生 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>

結果輸出：

Java網絡編程和NIO詳解1：JAVA 中原生的 socket 通訊機制

請求模型優化

這種方式，雖然實現功能沒什麼問題。可是咱們細看，發如今 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() {br/>@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() {br/>@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() {br/>@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() {br/>@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>

後續

  • JAVA 中是如何實現 IO多路複用
  • Netty 下的實現異步請求的
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程