<em>Mac</em>Book项目 2009年学校开始实施<em>Mac</em>Book项目,所有师生配备一本<em>Mac</em>Book,并同步更新了校园无线网络。学校每周进行电脑技术更新,每月发送技术支持资料,极大改变了教学及学习方式。因此2011
2021-06-01 09:32:01
基於Java實現Socket程式設計入門
2022-03-10 13:00:34
認識Socket
socket，又稱通訊端，是在不同的程序間進行網路通訊的一種協定、約定或者說是規範。
對於socket程式設計，它更多的時候像是基於TCP/UDP等協定做的一層封裝或者說抽象，是一套系統所提供的用於進行網路通訊相關程式設計的介面。
建立socket的基本流程
我們以linux作業系統提供的基本api為例，瞭解建立一個socket通訊的基本流程：
可以看到本質上，socket是對tcp連線（當然也有可能是udp等其他連線）協定，在程式設計層面上的簡化和抽象。
1.最基本的Socket示範
1.1 單向通訊
首先，我們從只傳送和接收一次訊息的socket基礎程式碼開始：
伺服器端:
package com.marklux.socket.base;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
/**
* The very basic socket server that only listen one single message.
*/
public class BaseSocketServer {
private ServerSocket server;
private Socket socket;
private int port;
private InputStream inputStream;
private static final int MAX_BUFFER_SIZE = 1024;
public int getPort() {
return port;
}
public void setPort(int port) {
this.port = port;
}
public BaseSocketServer(int port) {
this.port = port;
}
public void runServerSingle() throws IOException {
this.server = new ServerSocket(this.port);
System.out.println("base socket server started.");
// the code will block here till the request come.
this.socket = server.accept();
this.inputStream = this.socket.getInputStream();
byte[] readBytes = new byte[MAX_BUFFER_SIZE];
int msgLen;
StringBuilder stringBuilder = new StringBuilder();
while ((msgLen = inputStream.read(readBytes)) != -1) {
stringBuilder.append(new String(readBytes,0,msgLen,"UTF-8"));
}
System.out.println("get message from client: " + stringBuilder);
inputStream.close();
socket.close();
server.close();
}
public static void main(String[] args) {
BaseSocketServer bs = new BaseSocketServer(9799);
try {
bs.runServerSingle();
}catch (IOException e) {
e.printStackTrace();
}
}
}使用者端:
package com.marklux.socket.base;
import java.io.IOException;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.net.Socket;
/**
* The very basic socket client that only send one single message.
*/
public class BaseSocketClient {
private String serverHost;
private int serverPort;
private Socket socket;
private OutputStream outputStream;
public BaseSocketClient(String host, int port) {
this.serverHost = host;
this.serverPort = port;
}
public void connetServer() throws IOException {
this.socket = new Socket(this.serverHost, this.serverPort);
this.outputStream = socket.getOutputStream();
// why the output stream?
}
public void sendSingle(String message) throws IOException {
try {
this.outputStream.write(message.getBytes("UTF-8"));
} catch (UnsupportedEncodingException e) {
System.out.println(e.getMessage());
}
this.outputStream.close();
this.socket.close();
}
public static void main(String[] args) {
BaseSocketClient bc = new BaseSocketClient("127.0.0.1",9799);
try {
bc.connetServer();
bc.sendSingle("Hi from mark.");
}catch (IOException e) {
e.printStackTrace();
}
}
}先執行伺服器端，再執行使用者端，就可以看到效果。
- 注意這裡的IO操作實現，我們使用了一個大小為
MAX_BUFFER_SIZE的byte陣列作為緩衝區，然後從輸入流中取出位元組放置到緩衝區，再從緩衝區中取出位元組構建到字串中去，這在輸入流檔案很大時非常有用，事實上，後面要講到的NIO也是基於這種思路實現的。
1.2 雙向通訊
上面的例子只實現了一次單向的通訊，這顯然有點浪費通道。socket連線支援全雙工的雙向通訊（底層是tcp），下面的例子中，伺服器端在收到使用者端的訊息後，將返回給使用者端一個回執。
並且我們使用了一些java.io包裝好的方法，來簡化整個通訊的流程（因為訊息長度不大，不再使用緩衝區）。
伺服器端:
public void runServer() throws IOException {
this.serverSocket = new ServerSocket(port);
this.socket = serverSocket.accept();
this.inputStream = socket.getInputStream();
String message = new String(inputStream.readAllBytes(), "UTF-8");
System.out.println("received message: " + message);
this.socket.shutdownInput(); // 告訴使用者端接收已經完畢，之後只能傳送
// write the receipt.
this.outputStream = this.socket.getOutputStream();
String receipt = "We received your message: " + message;
outputStream.write(receipt.getBytes("UTF-8"));
this.outputStream.close();
this.socket.close();
}使用者端:
public void sendMessage(String message) throws IOException {
this.socket = new Socket(host,port);
this.outputStream = socket.getOutputStream();
this.outputStream.write(message.getBytes("UTF-8"));
this.socket.shutdownOutput(); // 告訴伺服器，所有的傳送動作已經結束，之後只能接收
this.inputStream = socket.getInputStream();
String receipt = new String(inputStream.readAllBytes(), "UTF-8");
System.out.println("got receipt: " + receipt);
this.inputStream.close();
this.socket.close();
}注意這裡我們在伺服器端接受到訊息以及使用者端傳送訊息後，分別呼叫了
shutdownInput()和shutdownOutput()而不是直接close對應的stream，這是因為在關閉任何一個stream，都會直接導致socket的關閉，也就無法進行後面回執的傳送了。但是注意，呼叫
shutdownInput()和shutdownOutput()之後，對應的流也會被關閉，不能再次向socket傳送/寫入了。
2. 傳送更多的訊息：結束的界定
剛才的兩個例子中，每次開啟流，都只能進行一次寫入/讀取操作，結束後對應流被關閉，就無法再次寫入/讀取了。
在這種情況下，如果要傳送兩次訊息，就不得不建立兩個socket，既耗資源又麻煩。其實我們完全可以不關閉對應的流，只要分次寫入訊息就可以了。
但是這樣的話，我們就必須面對另一個問題：如何判斷一次訊息傳送的結束呢？
2.1 使用特殊符號
最簡單的辦法是使用一些特殊的符號來標記一次傳送完成，伺服器端只要讀到對應的符號就可以完成一次讀取，然後進行相關的處理操作。
下面的例子中我們使用換行符n來標記一次傳送的結束，伺服器端每接收到一個訊息，就列印一次，並且使用了Scanner來簡化操作:
伺服器端:
public void runServer() throws IOException {
this.server = new ServerSocket(this.port);
System.out.println("base socket server started.");
this.socket = server.accept();
// the code will block here till the request come.
this.inputStream = this.socket.getInputStream();
Scanner sc = new Scanner(this.inputStream);
while (sc.hasNextLine()) {
System.out.println("get info from client: " + sc.nextLine());
} // 迴圈接收並輸出訊息內容
this.inputStream.close();
socket.close();
}使用者端:
public void connetServer() throws IOException {
this.socket = new Socket(this.serverHost, this.serverPort);
this.outputStream = socket.getOutputStream();
}
public void send(String message) throws IOException {
String sendMsg = message + "n"; // we mark n as a end of line.
try {
this.outputStream.write(sendMsg.getBytes("UTF-8"));
} catch (UnsupportedEncodingException e) {
System.out.println(e.getMessage());
}
// this.outputStream.close();
// this.socket.shutdownOutput();
}
public static void main(String[] args) {
CycleSocketClient cc = new CycleSocketClient("127.0.0.1", 9799);
try {
cc.connetServer();
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
String line = sc.nextLine();
cc.send(line);
}
}catch (IOException e) {
e.printStackTrace();
}
}執行後效果是，使用者端每輸入一行文字按下回車後，伺服器端就會列印出對應的訊息讀取記錄。
2.2 根據長度界定
回到原點，我們之所以不好定位訊息什麼時候結束，是因為我們不能夠確定每次訊息的長度。
那麼其實可以先將訊息的長度傳送出去，當伺服器端知道訊息的長度後，就能夠完成一次訊息的接收了。
總的來說，傳送一次訊息變成了兩個步驟
- 傳送訊息的長度
- 傳送訊息
最後的問題就是，“傳送訊息的長度”這一步驟所傳送的位元組量必須是固定的，否則我們仍然會陷入僵局。
一般來說，我們可以使用固定的位元組數來儲存訊息的長度，比如規定前2個位元組就是訊息的長度，不過這樣我們能夠傳送的訊息最大長度也就被固定死了，以2個位元組為例，我們傳送的訊息最大長度不超過2^16個位元組即64K。
如果你瞭解一些字元的編碼，就會知道，其實我們可以使用變長的空間來儲存訊息的長度，比如：
第一個位元組首位為0：即0XXXXXXX，表示長度就一個位元組，最大128，表示128B
第一個位元組首位為110，那麼附帶後面一個位元組表示長度：即110XXXXX 10XXXXXX，最大2048，表示2K
第一個位元組首位為1110，那麼附帶後面二個位元組表示長度：即110XXXXX 10XXXXXX 10XXXXXX，最大131072，表示128K
依次類推
當然這樣實現起來會麻煩一些，因此下面的例子裡我們仍然使用固定的兩個位元組來記錄訊息的長度。
伺服器端:
public void runServer() throws IOException {
this.serverSocket = new ServerSocket(this.port);
this.socket = serverSocket.accept();
this.inputStream = socket.getInputStream();
byte[] bytes;
while (true) {
// 先讀第一個位元組
int first = inputStream.read();
if (first == -1) {
// 如果是-1，說明輸入流已經被關閉了，也就不需要繼續監聽了
this.socket.close();
break;
}
// 讀取第二個位元組
int second = inputStream.read();
int length = (first << 8) + second; // 用位運算將兩個位元組拼起來成為真正的長度
bytes = new byte[length]; // 構建指定長度的位元組大小來儲存訊息即可
inputStream.read(bytes);
System.out.println("receive message: " + new String(bytes,"UTF-8"));
}
}使用者端:
public void connetServer() throws IOException {
this.socket = new Socket(host,port);
this.outputStream = socket.getOutputStream();
}
public void sendMessage(String message) throws IOException {
// 首先要把message轉換成bytes以便處理
byte[] bytes = message.getBytes("UTF-8");
// 接下來傳輸兩個位元組的長度，依然使用移位實現
int length = bytes.length;
this.outputStream.write(length >> 8); // write預設一次只傳輸一個位元組
this.outputStream.write(length);
// 傳輸完長度後，再正式傳送訊息
this.outputStream.write(bytes);
}
public static void main(String[] args) {
LengthSocketClient lc = new LengthSocketClient("127.0.0.1",9799);
try {
lc.connetServer();
Scanner sc = new Scanner(System.in);
while (sc.hasNextLine()) {
lc.sendMessage(sc.nextLine());
}
} catch (IOException e) {
e.printStackTrace();
}
}3. 處理更多的連線：多執行緒
3.1 同時實現訊息的傳送與接收
在考慮伺服器端處理多連線之前，我們先考慮使用多執行緒改造一下原有的一對一對話範例。
在原有的例子中，訊息的接收方並不能主動地向對方傳送訊息，換句話說我們並沒有實現真正的互相對話，這主要是因為訊息的傳送和接收這兩個動作並不能同時進行，因此我們需要使用兩個執行緒，其中一個用於監聽鍵盤輸入並將其寫入socket，另一個則負責監聽socket並將接受到的訊息顯示。
出於簡單考慮，我們直接讓主執行緒負責鍵盤監聽和訊息傳送，同時另外開啟一個執行緒用於拉取訊息並顯示。
訊息拉取執行緒 ListenThread.java
public class ListenThread implements Runnable {
private Socket socket;
private InputStream inputStream;
public ListenThread(Socket socket) {
this.socket = socket;
}
@Override
public void run() throws RuntimeException{
try {
this.inputStream = socket.getInputStream();
} catch (IOException e) {
e.printStackTrace();
throw new RuntimeException(e.getMessage());
}
while (true) {
try {
int first = this.inputStream.read();
if (first == -1) {
// 輸入流已經被關閉，無需繼續讀取
throw new RuntimeException("disconnected.");
}
int second = this.inputStream.read();
int msgLength = (first<<8) + second;
byte[] readBuffer = new byte[msgLength];
this.inputStream.read(readBuffer);
System.out.println("message from [" + socket.getInetAddress() + "]: " + new String(readBuffer,"UTF-8"));
} catch (IOException e) {
e.printStackTrace();
throw new RuntimeException(e.getMessage());
}
}
}
}主執行緒，啟動時由使用者選擇是作為server還是client：
public class ChatSocket {
private String host;
private int port;
private Socket socket;
private ServerSocket serverSocket;
private OutputStream outputStream;
// 以伺服器端形式啟動，建立對談
public void runAsServer(int port) throws IOException {
this.serverSocket = new ServerSocket(port);
System.out.println("[log] server started at port " + port);
// 等待使用者端的加入
this.socket = serverSocket.accept();
System.out.println("[log] successful connected with " + socket.getInetAddress());
// 啟動監聽執行緒
Thread listenThread = new Thread(new ListenThread(this.socket));
listenThread.start();
waitAndSend();
}
// 以使用者端形式啟動，加入對談
public void runAsClient(String host, int port) throws IOException {
this.socket = new Socket(host, port);
System.out.println("[log] successful connected to server " + socket.getInetAddress());
Thread listenThread = new Thread(new ListenThread(this.socket));
listenThread.start();
waitAndSend();
}
public void waitAndSend() throws IOException {
this.outputStream = this.socket.getOutputStream();
Scanner sc = new Scanner(System.in);
while (sc.hasNextLine()) {
this.sendMessage(sc.nextLine());
}
}
public void sendMessage(String message) throws IOException {
byte[] msgBytes = message.getBytes("UTF-8");
int length = msgBytes.length;
outputStream.write(length>>8);
outputStream.write(length);
outputStream.write(msgBytes);
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
ChatSocket chatSocket = new ChatSocket();
System.out.println("select connect type: 1 for server and 2 for client");
int type = Integer.parseInt(scanner.nextLine().toString());
if (type == 1) {
System.out.print("input server port: ");
int port = scanner.nextInt();
try {
chatSocket.runAsServer(port);
} catch (IOException e) {
e.printStackTrace();
}
}else if (type == 2) {
System.out.print("input server host: ");
String host = scanner.nextLine();
System.out.print("input server port: ");
int port = scanner.nextInt();
try {
chatSocket.runAsClient(host, port);
} catch (IOException e) {
e.printStackTrace();
}
}
}
}3.2 使用執行緒池優化伺服器端並行能力
作為伺服器端，如果一次只跟一個使用者端建立socket連線，未免顯得太過浪費資源，因此我們完全可以讓伺服器端和多個使用者端建立多個socket。
那麼既然要處理多個連線，就不得不面對並行問題了（當然，你也可以寫回圈輪流處理）。我們可以使用多執行緒來處理並行，不過執行緒的建立和銷燬都會消耗大量的資源和時間，所以最好一步到位，用一個執行緒池來實現。
下面給出一個示範性質的伺服器端程式碼：
public class SocketServer {
public static void main(String args[]) throws Exception {
// 監聽指定的埠
int port = 55533;
ServerSocket server = new ServerSocket(port);
// server將一直等待連線的到來
System.out.println("server將一直等待連線的到來");
//如果使用多執行緒，那就需要執行緒池，防止並行過高時建立過多執行緒耗盡資源
ExecutorService threadPool = Executors.newFixedThreadPool(100);
while (true) {
Socket socket = server.accept();
Runnable runnable=()->{
try {
// 建立好連線後，從socket中獲取輸入流，並建立緩衝區進行讀取
InputStream inputStream = socket.getInputStream();
byte[] bytes = new byte[1024];
int len;
StringBuilder sb = new StringBuilder();
while ((len = inputStream.read(bytes)) != -1) {
// 注意指定編碼格式，傳送方和接收方一定要統一，建議使用UTF-8
sb.append(new String(bytes, 0, len, "UTF-8"));
}
System.out.println("get message from client: " + sb);
inputStream.close();
socket.close();
} catch (Exception e) {
e.printStackTrace();
}
};
threadPool.submit(runnable);
}
}
}4. 連線保活
我想你不難發現一個問題，那就是當socket連線成功建立後，如果中途發生異常導致其中一方斷開連線，此時另一方是無法發現的，只有在再次嘗試傳送/接收訊息才會因為丟擲異常而退出。
簡單的說，就是我們維持的socket連線，是一個長連線，但我們沒有保證它的時效性，上一秒它可能還是可以用的，但是下一秒就不一定了。
4.1 使用心跳包
保證連線隨時可用的最常見方法就是定時傳送心跳包，來檢測連線是否正常。這對於實時性要求很高的服務而言，還是非常重要的（比如訊息推播）。
大體的方案如下：
- 雙方約定好心跳包的格式，要能夠區別於普通的訊息。
- 使用者端每隔一定時間，就向伺服器端傳送一個心跳包
- 伺服器端每接收到心跳包時，將其拋棄
- 如果使用者端的某個心跳包傳送失敗，就可以判斷連線已經斷開
- 如果對實時性要求很高，伺服器端也可以定時檢查使用者端傳送心跳包的頻率，如果超過一定時間沒有傳送可以認為連線已經斷開
4.2 斷開時重連
使用心跳包必然會增加頻寬和效能的負擔，對於普通的應用我們其實並沒有必要使用這種方案，如果訊息傳送時丟擲了連線異常，直接嘗試重新連線就好了。
跟上面的方案對比，其實這個丟擲異常的訊息就充當了心跳包的角色。
總的來說，連線是否要保活，如何保活，需要根據具體的業務場景靈活地思考和客製化。
到此這篇關於基於Java實現Socket程式設計入門的文章就介紹到這了,更多相關Java Socket程式設計入門內容請搜尋it145.com以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援it145.com！
相關文章
-
黑科技的輕簡出行，告別「電量焦慮症」：Anker氮化鎵超能充系列
综合看Anker超能充系列的性价比很高，并且与不仅和iPhone12/苹果<em>Mac</em>Book很配，而且适合多设备充电需求的日常使用或差旅场景，不管是安卓还是Switch同样也能用得上它，希望这次分享能给准备购入充电器的小伙伴们有所
2021-06-01 09:31:42
-
吳亦凡廠牌首秀，L4WUDU居然忘詞了，Rapper和明星比還是有差距！
除了L4WUDU与吴亦凡已经多次共事，成为了明面上的厂牌成员，吴亦凡还曾带领20XXCLUB全队参加2020年的一场音乐节，这也是20XXCLUB首次全员合照，王嗣尧Turbo、陈彦希Regi、<em>Mac</em> Ova Seas、林渝植等人全部出场。然而让
2021-06-01 09:31:34
-
IPFS、Chia、Bzz和ICP挖礦該怎麼選？哪一個更有優勢？
目前应用IPFS的机构：1 谷歌<em>浏览器</em>支持IPFS分布式协议 2 万维网 (历史档案博物馆)数据库 3 火狐<em>浏览器</em>支持 IPFS分布式协议 4 EOS 等数字货币数据存储 5 美国国会图书馆，历史资料永久保存在 IPFS 6 加
2021-06-01 09:31:24
-
有哪些事是買了雪佛蘭後才知道的？美事偷著樂，開拓者車主隨聊
开拓者的车机是兼容苹果和<em>安卓</em>，虽然我不怎么用，但确实兼顾了我家人的很多需求：副驾的门板还配有解锁开关，有的时候老婆开车，下车的时候偶尔会忘记解锁，我在副驾驶可以自己开门：第二排设计很好，不仅配置了一个很大的
2021-06-01 09:30:48
-
iPhone12在618最新定價，跌價幅度超過1400元，還等iPhone13嗎？
不仅是<em>安卓</em>手机，苹果手机的降价力度也是前所未有了，iPhone12也“跳水价”了，发布价是6799元，如今已经跌至5308元，降价幅度超过1400元，最新定价确认了。iPhone12是苹果首款5G手机，同时也是全球首款5nm芯片的智能机，它
2021-06-01 09:30:45