Java網絡編程和NIO詳解1:JAVA 中原生的 socket 通信機制
摘要:本文屬於原創,歡迎轉載,轉載請保留出處:https://github.com/jasonGeng88/blog
當前環境
-
jdk == 1.8
知識點
-
socket 的連接處理
-
IO 輸入、輸出流的處理
-
請求數據格式處理
-
請求模型優化
場景
今天,和大家聊一下 JAVA 中的 socket 通信問題。這裏采用最簡單的一請求一響應模型為例,假設我們現在需要向 baidu 站點進行通信。我們用 JAVA 原生的 socket 該如何實現。
建立 socket 連接
首先,我們需要建立 socket 連接(核心代碼)
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);
處理 socket 輸入輸出流
成功建立 socket 連接後,我們就能獲得它的輸入輸出流,通信的本質是對輸入輸出流的處理
socket 連接實際與處理文件流有點類似,都是在進行 IO 操作。
獲取輸入、輸出流代碼如下:
// 輸入流
InputStream in = socket.getInputStream();
// 輸出流
OutputStream out = socket.getOutputStream();
關於 IO 流的處理,我們一般會用相應的包裝類來處理 IO 流,如果直接處理的話,我們需要對 byte[]
進行操作,而這是相對比較繁瑣的。如果采用包裝類,我們可以直接以string
、int
等類型進行處理,簡化了 IO 字節操作。
下面以 BufferedReader
PrintWriter
作為輸入輸出的包裝類進行處理。
// 獲取 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));
}
數據請求與響應
有了 socket 連接、IO 輸入輸出流,下面就該向發送請求數據,以及獲取請求的響應結果。
因為有了 IO 包裝類的支持,我們可以直接以字符串的格式進行傳輸,由包裝類幫我們將數據裝換成相應的字節流。
因為我們與 baidu 站點進行的是 HTTP 訪問,所有我們不需要額外定義輸出格式。采用標準的 HTTP 傳輸格式,就能進行請求響應了(某些特定的 RPC 框架,可能會有自定義的通信格式)。
請求的數據內容處理如下:
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";
}
?
}
發送請求數據代碼如下:
// 發起請求
PrintWriter writer = getWriter(socket);
writer.write(HttpUtil.compositeRequest(host));
writer.flush();
接收響應數據代碼如下:
// 讀取響應
String msg;
BufferedReader reader = getReader(socket);
while ((msg = reader.readLine()) != null){
System.out.println(msg);
}
結果展示
至此,講完了原生 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 通信的結果。
public class Application {
?
public static void main(String[] args) {
?
new SocketHttpClient().start("www.baidu.com", 80);
?
}
}
結果輸出:
請求模型優化
這種方式,雖然實現功能沒什麽問題。但是我們細看,發現在 IO 寫入與讀取過程,是發生了 IO 阻塞的情況。即:
// 會發生 IO 阻塞 writer.write(HttpUtil.compositeRequest(host)); reader.readLine();
所以如果要同時請求10個不同的站點,如下:
public class SingleThreadApplication { public static void main(String[] args) { // HttpConstant.HOSTS 為 站點集合 for (String host: HttpConstant.HOSTS) { new SocketHttpClient().start(host, HttpConstant.PORT); } } }
它一定是第一個請求響應結束後,才會發起下一個站點處理。
這在服務端更明顯,雖然這裏的代碼是客戶端連接,但是具體的操作和服務端是差不多的。請求只能一個個串行處理,這在響應時間上肯定不能達標。
-
多線程處理
有人覺得這根本不是問題,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 處理,既利用了多線程的處理,又控制了系統的資源消耗。
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); } } }
關於啟動的線程數,一般 CPU 密集型會設置在 N+1(N為CPU核數),IO 密集型設置在 2N + 1。
這種方式,看起來是最優的了。那有沒有更好的呢,如果一個線程能同時處理多個 socket 連接,並且在每個 socket 輸入輸出數據沒有準備好的情況下,不進行阻塞,那是不是更優呢。這種技術叫做“IO多路復用”。在 JAVA 的 nio 包中,提供了相應的實現。
補充1:TCP客戶端與服務端
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(); } } 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(); } }
補充2:UDP客戶端和服務端
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(); } } 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(); } }
後續
-
JAVA 中是如何實現 IO多路復用
-
Java網絡編程和NIO詳解1:JAVA 中原生的 socket 通信機制