作者 | 磊哥
來(lái)源 | Java面試真題解析（ID：aimianshi666）
粘包和半包問(wèn)題是數據傳輸中比較常見(jiàn)的問(wèn)題，所謂的粘包問(wèn)題是指數據在傳輸時(shí)，在一條消息中讀取到了另一條消息的部分數據，這種現象就叫做粘包。比如發(fā)送了兩條消息，分別為“ABC”和“DEF”，那么正常情況下接收端也應該收到兩條消息“ABC”和“DEF”，但接收端卻收到的是“ABCD”，像這種情況就叫做粘包，如下圖所示：
半包問(wèn)題是指接收端只收到了部分數據，而非完整的數據的情況就叫做半包。比如發(fā)送了一條消息是“ABC”，而接收端卻收到的是“AB”和“C”兩條信息，這種情況就叫做半包，如下圖所示：
PS：大部分情況下我們都把粘包問(wèn)題和半包問(wèn)題看成同一個(gè)問(wèn)題，所以下文就用“粘包”問(wèn)題來(lái)替代“粘包”和“半包”問(wèn)題。
粘包問(wèn)題發(fā)生在 TCP/IP 協(xié)議中，因為 TCP 是面向連接的傳輸協(xié)議，它是以“流”的形式傳輸數據的，而“流”數據是沒(méi)有明確的開(kāi)始和結尾邊界的，所以就會(huì )出現粘包問(wèn)題。
接下來(lái)我們用代碼來(lái)演示一下粘包和半包問(wèn)題，為了演示的直觀(guān)性，我會(huì )設置兩個(gè)角色：
然后通過(guò)打印服務(wù)器端接收到的信息來(lái)觀(guān)察粘包問(wèn)題。服務(wù)器端代碼實(shí)現如下：
/**
* 服務(wù)器端（只負責接收消息）
*/
class ServSocket {
// 字節數組的長(cháng)度
private static final int BYTE_LENGTH = 20;
public static void main(String[] args) throws IOException {
// 創(chuàng )建 Socket 服務(wù)器
ServerSocket serverSocket = new ServerSocket(8888);
// 獲取客戶(hù)端連接
Socket clientSocket = serverSocket.accept();
// 得到客戶(hù)端發(fā)送的流對象
try (InputStream inputStream = clientSocket.getInputStream()) {
while (true) {
// 循環(huán)獲取客戶(hù)端發(fā)送的信息
byte[] bytes = new byte[BYTE_LENGTH];
// 讀取客戶(hù)端發(fā)送的信息
int count = inputStream.read(bytes, 0, BYTE_LENGTH);
if (count > 0) {
// 成功接收到有效消息并打印
System.out.println('接收到客戶(hù)端的信息是:' + new String(bytes));
}
count = 0;
}
}
}
}
客戶(hù)端實(shí)現代碼如下：
/**
* 客戶(hù)端（只負責發(fā)送消息）
*/
static class ClientSocket {
public static void main(String[] args) throws IOException {
// 創(chuàng )建 Socket 客戶(hù)端并嘗試連接服務(wù)器端
Socket socket = new Socket('127.0.0.1', 8888);
// 發(fā)送的消息內容
final String message = 'Hi,Java.';
// 使用輸出流發(fā)送消息
try (OutputStream outputStream = socket.getOutputStream()) {
// 給服務(wù)器端發(fā)送 10 次消息
for (int i = 0; i < 10; i++) {
// 發(fā)送消息
outputStream.write(message.getBytes());
}
}
}
}
以上程序的執行結果如下圖所示：
粘包問(wèn)題的常見(jiàn)解決方案有以下 3 種：
發(fā)送方和接收方固定發(fā)送數據的大小，當字符長(cháng)度不夠時(shí)用空字符彌補，有了固定大小之后就知道每條消息的具體邊界了，這樣就沒(méi)有粘包的問(wèn)題了；
在 TCP 協(xié)議的基礎上封裝一層自定義數據協(xié)議，在自定義數據協(xié)議中，包含數據頭（存儲數據的大?。┖?數據的具體內容，這樣服務(wù)端得到數據之后，通過(guò)解析數據頭就可以知道數據的具體長(cháng)度了，也就沒(méi)有粘包的問(wèn)題了；
以特殊的字符結尾，比如以“\n”結尾，這樣我們就知道數據的具體邊界了，從而避免了粘包問(wèn)題（推薦方案）。
收、發(fā)固定大小的數據，服務(wù)器端的實(shí)現代碼如下：
/**
* 服務(wù)器端，改進(jìn)版本一（只負責接收消息）
*/
static class ServSocketV1 {
private static final int BYTE_LENGTH = 1024; // 字節數組長(cháng)度（收消息用）
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(9091);
// 獲取到連接
Socket clientSocket = serverSocket.accept();
try (InputStream inputStream = clientSocket.getInputStream()) {
while (true) {
byte[] bytes = new byte[BYTE_LENGTH];
// 讀取客戶(hù)端發(fā)送的信息
int count = inputStream.read(bytes, 0, BYTE_LENGTH);
if (count > 0) {
// 接收到消息打印
System.out.println('接收到客戶(hù)端的信息是:' + new String(bytes).trim());
}
count = 0;
}
}
}
}
客戶(hù)端的實(shí)現代碼如下：
/**
* 客戶(hù)端，改進(jìn)版一（只負責接收消息）
*/
static class ClientSocketV1 {
private static final int BYTE_LENGTH = 1024; // 字節長(cháng)度
public static void main(String[] args) throws IOException {
Socket socket = new Socket('127.0.0.1', 9091);
final String message = 'Hi,Java.'; // 發(fā)送消息
try (OutputStream outputStream = socket.getOutputStream()) {
// 將數據組裝成定長(cháng)字節數組
byte[] bytes = new byte[BYTE_LENGTH];
int idx = 0;
for (byte b : message.getBytes()) {
bytes[idx] = b;
idx++;
}
// 給服務(wù)器端發(fā)送 10 次消息
for (int i = 0; i < 10; i++) {
outputStream.write(bytes, 0, BYTE_LENGTH);
}
}
}
}
以上代碼的執行結果如下圖所示：
從以上代碼可以看出，雖然這種方式可以解決粘包問(wèn)題，但這種固定數據大小的傳輸方式，當數據量比較小時(shí)會(huì )使用空字符來(lái)填充，所以會(huì )額外的增加網(wǎng)絡(luò )傳輸的負擔，因此不是理想的解決方案。
這種解決方案的實(shí)現思路是將請求的數據封裝為兩部分：消息頭（發(fā)送的數據大?。?消息體（發(fā)送的具體數據），它的格式如下圖所示：
編寫(xiě)一個(gè)消息封裝類(lèi)
編寫(xiě)客戶(hù)端
編寫(xiě)服務(wù)器端
接下來(lái)我們一一來(lái)實(shí)現。
消息的封裝類(lèi)中提供了兩個(gè)方法：一個(gè)是將消息轉換成消息頭 + 消息體的方法，另一個(gè)是讀取消息頭的方法，具體實(shí)現代碼如下：
/**
* 消息封裝類(lèi)
*/
class SocketPacket {
// 消息頭存儲的長(cháng)度(占 8 字節)
static final int HEAD_SIZE = 8;
/**
* 將協(xié)議封裝為:協(xié)議頭 + 協(xié)議體
* @param context 消息體(String 類(lèi)型)
* @return byte[]
*/
public byte[] toBytes(String context) {
// 協(xié)議體 byte 數組
byte[] bodyByte = context.getBytes();
int bodyByteLength = bodyByte.length;
// 最終封裝對象
byte[] result = new byte[HEAD_SIZE + bodyByteLength];
// 借助 NumberFormat 將 int 轉換為 byte[]
NumberFormat numberFormat = NumberFormat.getNumberInstance();
numberFormat.setMinimumIntegerDigits(HEAD_SIZE);
numberFormat.setGroupingUsed(false);
// 協(xié)議頭 byte 數組
byte[] headByte = numberFormat.format(bodyByteLength).getBytes();
// 封裝協(xié)議頭
System.arraycopy(headByte, 0, result, 0, HEAD_SIZE);
// 封裝協(xié)議體
System.arraycopy(bodyByte, 0, result, HEAD_SIZE, bodyByteLength);
return result;
}
/**
* 獲取消息頭的內容(也就是消息體的長(cháng)度)
* @param inputStream
* @return
*/
public int getHeader(InputStream inputStream) throws IOException {
int result = 0;
byte[] bytes = new byte[HEAD_SIZE];
inputStream.read(bytes, 0, HEAD_SIZE);
// 得到消息體的字節長(cháng)度
result = Integer.valueOf(new String(bytes));
return result;
}
}
客戶(hù)端中我們添加一組待發(fā)送的消息，隨機給服務(wù)器端發(fā)送一個(gè)消息，實(shí)現代碼如下：
/**
* 客戶(hù)端
*/
class MySocketClient {
public static void main(String[] args) throws IOException {
// 啟動(dòng) Socket 并嘗試連接服務(wù)器
Socket socket = new Socket('127.0.0.1', 9093);
// 發(fā)送消息合集（隨機發(fā)送一條消息）
final String[] message = {'Hi,Java.', 'Hi,SQL~', '關(guān)注公眾號|Java中文社群.'};
// 創(chuàng )建協(xié)議封裝對象
SocketPacket socketPacket = new SocketPacket();
try (OutputStream outputStream = socket.getOutputStream()) {
// 給服務(wù)器端發(fā)送 10 次消息
for (int i = 0; i < 10; i++) {
// 隨機發(fā)送一條消息
String msg = message[new Random().nextInt(message.length)];
// 將內容封裝為:協(xié)議頭+協(xié)議體
byte[] bytes = socketPacket.toBytes(msg);
// 發(fā)送消息
outputStream.write(bytes, 0, bytes.length);
outputStream.flush();
}
}
}
}
服務(wù)器端使用線(xiàn)程池來(lái)處理每個(gè)客戶(hù)端的業(yè)務(wù)請求，實(shí)現代碼如下：
/**
* 服務(wù)器端
*/
class MySocketServer {
public static void main(String[] args) throws IOException {
// 創(chuàng )建 Socket 服務(wù)器端
ServerSocket serverSocket = new ServerSocket(9093);
// 獲取客戶(hù)端連接
Socket clientSocket = serverSocket.accept();
// 使用線(xiàn)程池處理更多的客戶(hù)端
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(100, 150, 100,
TimeUnit.SECONDS, new LinkedBlockingQueue<>(1000));
threadPool.submit(() -> {
// 客戶(hù)端消息處理
processMessage(clientSocket);
});
}
/**
* 客戶(hù)端消息處理
* @param clientSocket
*/
private static void processMessage(Socket clientSocket) {
// Socket 封裝對象
SocketPacket socketPacket = new SocketPacket();
// 獲取客戶(hù)端發(fā)送的消息對象
try (InputStream inputStream = clientSocket.getInputStream()) {
while (true) {
// 獲取消息頭(也就是消息體的長(cháng)度)
int bodyLength = socketPacket.getHeader(inputStream);
// 消息體 byte 數組
byte[] bodyByte = new byte[bodyLength];
// 每次實(shí)際讀取字節數
int readCount = 0;
// 消息體賦值下標
int bodyIndex = 0;
// 循環(huán)接收消息頭中定義的長(cháng)度
while (bodyIndex <= (bodyLength - 1) &&
(readCount = inputStream.read(bodyByte, bodyIndex, bodyLength)) != -1) {
bodyIndex += readCount;
}
bodyIndex = 0;
// 成功接收到客戶(hù)端的消息并打印
System.out.println('接收到客戶(hù)端的信息:' + new String(bodyByte));
}
} catch (IOException ioException) {
System.out.println(ioException.getMessage());
}
}
}
以上程序的執行結果如下：
此解決方案雖然可以解決粘包問(wèn)題，但消息的設計和代碼的實(shí)現復雜度比較高，所以也不是理想的解決方案。
以特殊字符結尾就可以知道流的邊界了，它的具體實(shí)現是：使用 Java 中自帶的 BufferedReader 和 BufferedWriter，也就是帶緩沖區的輸入字符流和輸出字符流，通過(guò)寫(xiě)入的時(shí)候加上 \n 來(lái)結尾，讀取的時(shí)候使用 readLine 按行來(lái)讀取數據，這樣就知道流的邊界了，從而解決了粘包的問(wèn)題。服務(wù)器端實(shí)現代碼如下：
/**
* 服務(wù)器端，改進(jìn)版三(只負責收消息)
*/
static class ServSocketV3 {
public static void main(String[] args) throws IOException {
// 創(chuàng )建 Socket 服務(wù)器端
ServerSocket serverSocket = new ServerSocket(9092);
// 獲取客戶(hù)端連接
Socket clientSocket = serverSocket.accept();
// 使用線(xiàn)程池處理更多的客戶(hù)端
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(100, 150, 100,
TimeUnit.SECONDS, new LinkedBlockingQueue<>(1000));
threadPool.submit(() -> {
// 消息處理
processMessage(clientSocket);
});
}
/**
* 消息處理
* @param clientSocket
*/
private static void processMessage(Socket clientSocket) {
// 獲取客戶(hù)端發(fā)送的消息流對象
try (BufferedReader bufferedReader = new BufferedReader(
new InputStreamReader(clientSocket.getInputStream()))) {
while (true) {
// 按行讀取客戶(hù)端發(fā)送的消息
String msg = bufferedReader.readLine();
if (msg != null) {
// 成功接收到客戶(hù)端的消息并打印
System.out.println('接收到客戶(hù)端的信息:' + msg);
}
}
} catch (IOException ioException) {
ioException.printStackTrace();
}
}
}
PS：上述代碼使用了線(xiàn)程池來(lái)解決多個(gè)客戶(hù)端同時(shí)訪(fǎng)問(wèn)服務(wù)器端的問(wèn)題，從而實(shí)現了一對多的服務(wù)器響應。
客戶(hù)端的實(shí)現代碼如下：
/**
* 客戶(hù)端，改進(jìn)版三(只負責發(fā)送消息)
*/
static class ClientSocketV3 {
public static void main(String[] args) throws IOException {
// 啟動(dòng) Socket 并嘗試連接服務(wù)器
Socket socket = new Socket('127.0.0.1', 9092);
final String message = 'Hi,Java.'; // 發(fā)送消息
try (BufferedWriter bufferedWriter = new BufferedWriter(
new OutputStreamWriter(socket.getOutputStream()))) {
// 給服務(wù)器端發(fā)送 10 次消息
for (int i = 0; i < 10; i++) {
// 注意:結尾的 \n 不能省略,它表示按行寫(xiě)入
bufferedWriter.write(message + '\n');
// 刷新緩沖區(此步驟不能省略)
bufferedWriter.flush();
}
}
}
}
以上代碼的執行結果如下圖所示：
以特殊符號作為粘包的解決方案的最大優(yōu)點(diǎn)是實(shí)現簡(jiǎn)單，但存在一定的局限性，比如當一條消息中間如果出現了結束符就會(huì )造成半包的問(wèn)題，所以如果是復雜的字符串要對內容進(jìn)行編碼和解碼處理，這樣才能保證結束符的正確性。
粘包和半包問(wèn)題是數據傳輸中比較常見(jiàn)的問(wèn)題，它的解決方案有很多，比較常見(jiàn)的解決方案有：設置固定的數據傳輸大小、自定義請求協(xié)議的封裝，在請求頭中加入傳輸數據的長(cháng)度、使用特殊符號作為結束符等。
<END>
聯(lián)系客服
