日本综合一区二区|亚洲中文天堂综合|日韩欧美自拍一区|男女精品天堂一区|欧美自拍第6页亚洲成人精品一区|亚洲黄色天堂一区二区成人|超碰91偷拍第一页|日韩av夜夜嗨中文字幕|久久蜜综合视频官网|精美人妻一区二区三区

RELATEED CONSULTING
相關(guān)咨詢
選擇下列產(chǎn)品馬上在線溝通
服務(wù)時(shí)間：8:30-17:00
你可能遇到了下面的問題
關(guān)閉右側(cè)工具欄

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案
面試突擊：什么是粘包和半包？怎么解決？

粘包和半包問題是數(shù)據(jù)傳輸中比較常見的問題，所謂的粘包問題是指數(shù)據(jù)在傳輸時(shí)，在一條消息中讀取到了另一條消息的部分?jǐn)?shù)據(jù)，這種現(xiàn)象就叫做粘包。比如發(fā)送了兩條消息，分別為“ABC”和“DEF”，那么正常情況下接收端也應(yīng)該收到兩條消息“ABC”和“DEF”，但接收端卻收到的是“ABCD”，像這種情況就叫做粘包，如下圖所示：

半包問題是指接收端只收到了部分?jǐn)?shù)據(jù)，而非完整的數(shù)據(jù)的情況就叫做半包。比如發(fā)送了一條消息是“ABC”，而接收端卻收到的是“AB”和“C”兩條信息，這種情況就叫做半包，如下圖所示：

PS：大部分情況下我們都把粘包問題和半包問題看成同一個(gè)問題，所以下文就用“粘包”問題來替代“粘包”和“半包”問題。

1.為什么會有粘包問題？

粘包問題發(fā)生在 TCP/IP 協(xié)議中，因?yàn)?TCP 是面向連接的傳輸協(xié)議，它是以“流”的形式傳輸數(shù)據(jù)的，而“流”數(shù)據(jù)是沒有明確的開始和結(jié)尾邊界的，所以就會出現(xiàn)粘包問題。

2.粘包問題代碼演示

接下來我們用代碼來演示一下粘包和半包問題，為了演示的直觀性，我會設(shè)置兩個(gè)角色：

  • 服務(wù)器端用來接收消息；
  • 客戶端用來發(fā)送一段固定的消息。

然后通過打印服務(wù)器端接收到的信息來觀察粘包問題。服務(wù)器端代碼實(shí)現(xiàn)如下：

/**
 * 服務(wù)器端（只負(fù)責(zé)接收消息）
 */
class ServSocket {
    // 字節(jié)數(shù)組的長度
    private static final int BYTE_LENGTH = 20;  
    public static void main(String[] args) throws IOException {
        // 創(chuàng)建 Socket 服務(wù)器
        ServerSocket serverSocket = new ServerSocket(8888);
        // 獲取客戶端連接
        Socket clientSocket = serverSocket.accept();
        // 得到客戶端發(fā)送的流對象
        try (InputStream inputStream = clientSocket.getInputStream()) {
            while (true) {
                // 循環(huán)獲取客戶端發(fā)送的信息
                byte[] bytes = new byte[BYTE_LENGTH];
                // 讀取客戶端發(fā)送的信息
                int count = inputStream.read(bytes, 0, BYTE_LENGTH);
                if (count > 0) {
                    // 成功接收到有效消息并打印
                    System.out.println("接收到客戶端的信息是:" + new String(bytes));
                }
                count = 0;
            }
        }
    }
}

客戶端實(shí)現(xiàn)代碼如下：

/**
 * 客戶端（只負(fù)責(zé)發(fā)送消息）
 */
static class ClientSocket {
    public static void main(String[] args) throws IOException {
        // 創(chuàng)建 Socket 客戶端并嘗試連接服務(wù)器端
        Socket socket = new Socket("127.0.0.1", 8888);
        // 發(fā)送的消息內(nèi)容
        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());
            }
        }
    }
}

以上程序的執(zhí)行結(jié)果如下圖所示：

通過上述結(jié)果我們可以看出，服務(wù)器端發(fā)生了粘包問題，因?yàn)榭蛻舳税l(fā)送了 10 次固定的“Hi,Java.”的消息，正確的結(jié)果應(yīng)該是服務(wù)器端也接收到了 10 次固定消息“Hi,Java.”才對，但實(shí)際執(zhí)行結(jié)果并非如此。

3.解決方案

粘包問題的常見解決方案有以下 3 種：

  • 發(fā)送方和接收方固定發(fā)送數(shù)據(jù)的大小，當(dāng)字符長度不夠時(shí)用空字符彌補(bǔ)，有了固定大小之后就知道每條消息的具體邊界了，這樣就沒有粘包的問題了；
  • 在 TCP 協(xié)議的基礎(chǔ)上封裝一層自定義數(shù)據(jù)協(xié)議，在自定義數(shù)據(jù)協(xié)議中，包含數(shù)據(jù)頭（存儲數(shù)據(jù)的大?。┖?數(shù)據(jù)的具體內(nèi)容，這樣服務(wù)端得到數(shù)據(jù)之后，通過解析數(shù)據(jù)頭就可以知道數(shù)據(jù)的具體長度了，也就沒有粘包的問題了；
  • 以特殊的字符結(jié)尾，比如以“\n”結(jié)尾，這樣我們就知道數(shù)據(jù)的具體邊界了，從而避免了粘包問題（推薦方案）。

解決方案1：固定數(shù)據(jù)大小

收、發(fā)固定大小的數(shù)據(jù)，服務(wù)器端的實(shí)現(xiàn)代碼如下：

/**
* 服務(wù)器端，改進(jìn)版本一（只負(fù)責(zé)接收消息）
*/
static class ServSocketV1 {
 private static final int BYTE_LENGTH = 1024;  // 字節(jié)數(shù)組長度（收消息用）
 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];
             // 讀取客戶端發(fā)送的信息
             int count = inputStream.read(bytes, 0, BYTE_LENGTH);
             if (count > 0) {
                 // 接收到消息打印
                 System.out.println("接收到客戶端的信息是:" + new String(bytes).trim());
             }
             count = 0;
         }
     }
 }
}

客戶端的實(shí)現(xiàn)代碼如下：

/**
* 客戶端，改進(jìn)版一（只負(fù)責(zé)接收消息）
*/
static class ClientSocketV1 {
 private static final int BYTE_LENGTH = 1024;  // 字節(jié)長度
 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()) {
         // 將數(shù)據(jù)組裝成定長字節(jié)數(shù)組
         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);
         }
     }
 }
}

以上代碼的執(zhí)行結(jié)果如下圖所示：

優(yōu)缺點(diǎn)分析

從以上代碼可以看出，雖然這種方式可以解決粘包問題，但這種固定數(shù)據(jù)大小的傳輸方式，當(dāng)數(shù)據(jù)量比較小時(shí)會使用空字符來填充，所以會額外的增加網(wǎng)絡(luò)傳輸?shù)呢?fù)擔(dān)，因此不是理想的解決方案。

解決方案2：自定義請求協(xié)議

這種解決方案的實(shí)現(xiàn)思路是將請求的數(shù)據(jù)封裝為兩部分：消息頭（發(fā)送的數(shù)據(jù)大小）+消息體（發(fā)送的具體數(shù)據(jù)），它的格式如下圖所示：

此解決方案的實(shí)現(xiàn)分為以下 3 部分：

  • 編寫一個(gè)消息封裝類
  • 編寫客戶端
  • 編寫服務(wù)器端

接下來我們一一來實(shí)現(xiàn)。

① 消息封裝類

消息的封裝類中提供了兩個(gè)方法：一個(gè)是將消息轉(zhuǎn)換成消息頭 + 消息體的方法，另一個(gè)是讀取消息頭的方法，具體實(shí)現(xiàn)代碼如下：

/**
 * 消息封裝類
 */
class SocketPacket {
    // 消息頭存儲的長度(占 8 字節(jié))
    static final int HEAD_SIZE = 8;

    /**
     * 將協(xié)議封裝為:協(xié)議頭 + 協(xié)議體
     * @param context 消息體(String 類型)
     * @return byte[]
     */
    public byte[] toBytes(String context) {
        // 協(xié)議體 byte 數(shù)組
        byte[] bodyByte = context.getBytes();
        int bodyByteLength = bodyByte.length;
        // 最終封裝對象
        byte[] result = new byte[HEAD_SIZE + bodyByteLength];
        // 借助 NumberFormat 將 int 轉(zhuǎn)換為 byte[]
        NumberFormat numberFormat = NumberFormat.getNumberInstance();
        numberFormat.setMinimumIntegerDigits(HEAD_SIZE);
        numberFormat.setGroupingUsed(false);
        // 協(xié)議頭 byte 數(shù)組
        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;
    }

    /**
     * 獲取消息頭的內(nèi)容(也就是消息體的長度)
     * @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);
        // 得到消息體的字節(jié)長度
        result = Integer.valueOf(new String(bytes));
        return result;
    }
}

② 客戶端

客戶端中我們添加一組待發(fā)送的消息，隨機(jī)給服務(wù)器端發(fā)送一個(gè)消息，實(shí)現(xiàn)代碼如下：

/**
 * 客戶端
 */
class MySocketClient {
    public static void main(String[] args) throws IOException {
        // 啟動(dòng) Socket 并嘗試連接服務(wù)器
        Socket socket = new Socket("127.0.0.1", 9093);
        // 發(fā)送消息合集（隨機(jī)發(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++) {
                // 隨機(jī)發(fā)送一條消息
                String msg = message[new Random().nextInt(message.length)];
                // 將內(nèi)容封裝為:協(xié)議頭+協(xié)議體
                byte[] bytes = socketPacket.toBytes(msg);
                // 發(fā)送消息
                outputStream.write(bytes, 0, bytes.length);
                outputStream.flush();
            }
        }
    }
}

③ 服務(wù)器端

服務(wù)器端使用線程池來處理每個(gè)客戶端的業(yè)務(wù)請求，實(shí)現(xiàn)代碼如下：

/**
 * 服務(wù)器端
 */
class MySocketServer {
    public static void main(String[] args) throws IOException {
        // 創(chuàng)建 Socket 服務(wù)器端
        ServerSocket serverSocket = new ServerSocket(9093);
        // 獲取客戶端連接
        Socket clientSocket = serverSocket.accept();
        // 使用線程池處理更多的客戶端
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(100, 150, 100,
                TimeUnit.SECONDS, new LinkedBlockingQueue<>(1000));
        threadPool.submit(() -> {
            // 客戶端消息處理
            processMessage(clientSocket);
        });
    }
    /**
     * 客戶端消息處理
     * @param clientSocket
     */
    private static void processMessage(Socket clientSocket) {
        // Socket 封裝對象
        SocketPacket socketPacket = new SocketPacket();
        // 獲取客戶端發(fā)送的消息對象
        try (InputStream inputStream = clientSocket.getInputStream()) {
            while (true) {
                // 獲取消息頭(也就是消息體的長度)
                int bodyLength = socketPacket.getHeader(inputStream);
                // 消息體 byte 數(shù)組
                byte[] bodyByte = new byte[bodyLength];
                // 每次實(shí)際讀取字節(jié)數(shù)
                int readCount = 0;
                // 消息體賦值下標(biāo)
                int bodyIndex = 0;
                // 循環(huán)接收消息頭中定義的長度
                while (bodyIndex <= (bodyLength - 1) &&
                        (readCount = inputStream.read(bodyByte, bodyIndex, bodyLength)) != -1) {
                    bodyIndex += readCount;
                }
                bodyIndex = 0;
                // 成功接收到客戶端的消息并打印
                System.out.println("接收到客戶端的信息:" + new String(bodyByte));
            }
        } catch (IOException ioException) {
            System.out.println(ioException.getMessage());
        }
    }
}

以上程序的執(zhí)行結(jié)果如下：

從上述結(jié)果可以看出，消息通訊正常，客戶端和服務(wù)器端的交互中并沒有出現(xiàn)粘包問題。

優(yōu)缺點(diǎn)分析

此解決方案雖然可以解決粘包問題，但消息的設(shè)計(jì)和代碼的實(shí)現(xiàn)復(fù)雜度比較高，所以也不是理想的解決方案。

解決方案3：特殊字符結(jié)尾

以特殊字符結(jié)尾就可以知道流的邊界了，它的具體實(shí)現(xiàn)是：使用 Java 中自帶的 BufferedReader 和 BufferedWriter，也就是帶緩沖區(qū)的輸入字符流和輸出字符流，通過寫入的時(shí)候加上 \n 來結(jié)尾，讀取的時(shí)候使用 readLine 按行來讀取數(shù)據(jù)，這樣就知道流的邊界了，從而解決了粘包的問題。服務(wù)器端實(shí)現(xiàn)代碼如下：

/**
 * 服務(wù)器端，改進(jìn)版三(只負(fù)責(zé)收消息)
 */
static class ServSocketV3 {
    public static void main(String[] args) throws IOException {
        // 創(chuàng)建 Socket 服務(wù)器端
        ServerSocket serverSocket = new ServerSocket(9092);
        // 獲取客戶端連接
        Socket clientSocket = serverSocket.accept();
        // 使用線程池處理更多的客戶端
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(100, 150, 100,
                TimeUnit.SECONDS, new LinkedBlockingQueue<>(1000));
        threadPool.submit(() -> {
            // 消息處理
            processMessage(clientSocket);
        });
    }
    /**
     * 消息處理
     * @param clientSocket
     */
    private static void processMessage(Socket clientSocket) {
        // 獲取客戶端發(fā)送的消息流對象
        try (BufferedReader bufferedReader = new BufferedReader(
                new InputStreamReader(clientSocket.getInputStream()))) {
            while (true) {
                // 按行讀取客戶端發(fā)送的消息
                String msg = bufferedReader.readLine();
                if (msg != null) {
                    // 成功接收到客戶端的消息并打印
                    System.out.println("接收到客戶端的信息:" + msg);
                }
            }
        } catch (IOException ioException) {
            ioException.printStackTrace();
        }
    }
}

PS：上述代碼使用了線程池來解決多個(gè)客戶端同時(shí)訪問服務(wù)器端的問題，從而實(shí)現(xiàn)了一對多的服務(wù)器響應(yīng)。

客戶端的實(shí)現(xiàn)代碼如下：

/**
 * 客戶端，改進(jìn)版三(只負(fù)責(zé)發(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++) {
                // 注意:結(jié)尾的 \n 不能省略,它表示按行寫入
                bufferedWriter.write(message + "\n");
                // 刷新緩沖區(qū)(此步驟不能省略)
                bufferedWriter.flush();
            }
        }
    }
}

以上代碼的執(zhí)行結(jié)果如下圖所示：

優(yōu)缺點(diǎn)分析

以特殊符號作為粘包的解決方案的最大優(yōu)點(diǎn)是實(shí)現(xiàn)簡單，但存在一定的局限性，比如當(dāng)一條消息中間如果出現(xiàn)了結(jié)束符就會造成半包的問題，所以如果是復(fù)雜的字符串要對內(nèi)容進(jìn)行編碼和解碼處理，這樣才能保證結(jié)束符的正確性。

總結(jié)

粘包和半包問題是數(shù)據(jù)傳輸中比較常見的問題，它的解決方案有很多，比較常見的解決方案有：設(shè)置固定的數(shù)據(jù)傳輸大小、自定義請求協(xié)議的封裝，在請求頭中加入傳輸數(shù)據(jù)的長度、使用特殊符號作為結(jié)束符等。


網(wǎng)站欄目：面試突擊：什么是粘包和半包？怎么解決？
本文來源：http://www.dlmjj.cn/article/cciophj.html