溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
這篇文章主要講解了“如何用JAVA的socket”，文中的講解內容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“如何用JAVA的socket”吧！
jdk == 1.8
socket 的連接處理
IO 輸入、輸出流的處理
請求數據格式處理
請求模型優化
這里采用最簡單的一請求一響應模型為例，假設我們現在需要向 baidu 站點進行通信。
首先，我們需要建立 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 連接實際與處理文件流有點類似，都是在進行 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 包中，提供了相應的實現。
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();
}
}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的socket”的內容了，經過本文的學習后，相信大家對如何用JAVA的socket這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
