原文

前言

本文旨以實例的方式，使用CocoaAsyncSocket這個框架進行數據封包和拆包。來解決頻繁的數據發送下，導致的數據粘包、以及較大數據（例如圖片、錄音等等）的發送，導致的數據斷包。

本文實例Github地址:即時通訊的數據粘包、斷包處理實例。

注：文章內容屬於應用的范疇，內容相對簡單易懂。給大家對數據包的處理提供了一個思路， 希望能拋磚引玉。

它是樓主CocoaAsyncSocket系列Read篇解析的一個前置插曲，至於詳細的實現原理，作者會在後續的文章中寫出。

正文

一、什麼是粘包？

經常我們發現，如果用客戶端同一時間發送幾條數據，而服務端只能收到一大條數據，類似下圖：

如圖，由於傳輸的過程為數據流，經過TCP傳輸後，三條數據被合並成了一條，這就是數據粘包了。

那麼為什麼會造成粘包呢？

原來這是因為TCP使用了優化方法（Nagle算法）。

它將多次間隔較小且數據量小的數據，合並成一個大的數據塊，然後進行封包。

這麼做優點也很明顯，就是為了減少廣域網的小分組數目，從而減小網絡擁塞的出現。

具體的內容感興趣的可以看看這兩篇文章：

• TCP之Nagle算法&&延遲ACK

• TCP NAGLE算法和實現

而UDP就不會有這種情況，它不會使用塊的合並優化算法。

這裡說到了就順便提一下，由於它支持的是一對多的模式，所以接收端的skbuff(套接字緩沖區）采用了鏈式結構來記錄每一個到達的UDP包，在每個UDP包中就有了消息頭（消息來源地址，端口等信息）。

當然除了優化算法，TCP和UDP都會因為下面兩種情況造成粘包：

• 發送端需要等緩沖區滿才發送出去，造成粘包

• 接收方不及時接收緩沖區的包，造成多個包接收。

二、什麼是斷包？

斷包應該還是比較好理解的，比如我們發送一條很大的數據包，類似圖片和錄音等等，很顯然一次發送或者讀取數據的緩沖區大小是有限的，所以我們會分段去發送或者讀取數據。

類似下圖：

無論是粘包還是斷包，如果我們要正確解析數據，那麼必須要使用一種合理的機制去解包。這個機制的思路其實很簡單：

• 我們在封包的時候給每個數據包加一個長度或者一個開始結束標記。

• 然後我們拆包的時候就能區分每個數據包了，再按照長度或者分解符去分拆成各個數據包。

Talk is cheap. Show me the code

三、實例：基於CocoaAsyncSocket的封包，拆包處理。

開始動手之前，我們需要去理解下面這幾個方法

//讀取數據，有數據就會觸發代理
- (void)readDataWithTimeout:(NSTimeInterval)timeout tag:(long)tag;
//直到讀到這個長度的數據，才會觸發代理
- (void)readDataToLength:(NSUInteger)length withTimeout:(NSTimeInterval)timeout tag:(long)tag;
//直到讀到data這個邊界，才會觸發代理
- (void)readDataToData:(NSData *)data withTimeout:(NSTimeInterval)timeout tag:(long)tag;

還記得我們之前講：iOS即時通訊，從入門到“放棄”？中提到過，這個框架每次讀取數據，必須手動的去調用上述這些read方法，而我們之前的實現思路是，第一次連接成功的代理觸發後調用：

- (void)readDataWithTimeout:(NSTimeInterval)timeout tag:(long)tag;

之後每次收到消息之後，都在去調用一次這個方法，超時為-1，即不超時。這樣我們每次收到消息，都會即時觸發我們讀取消息的代理：

- (void)socket:(GCDAsyncSocket *)sock didReadData:(NSData *)data withTag:(long)tag

然而這麼做顯然沒有考慮數據的拆包，如果我們一條一條的發送文字信息，自然沒什麼問題。如果我們一次發送數條，或者發送大圖片。那麼問題就出來了，我們解析出來的數據顯然是不對的。

這時候我們就需要另外兩個read方法了，一個是讀取到指定長度，另一個是讀取到指定邊界。

我們通過自己定義的數據邊界，去調用這兩個方法，而觸發的讀取代理，得到的數據才是正確的一個包的數據。

所以我們的核心思路有了：

1.封包的時候給每個包的數據加一個標記，來標明數據的長度和類型（類型顯然是需要的，我們需要知道它是文本、圖片、還是錄音等等，來用正確的方式處理這個數據）。

2.拆包的時候，先獲取到我們給每個包的標記，然後根據標記的數據長度，去獲取數據。最後再根據標記的類型去處理數據。（文字輸出、圖片展示、錄音播放等等）。

接著我們可以開始動手了：

這裡我們首先需要一個服務端，一個客戶端。為了簡單，我們都用OC來實現。

其中我們客戶端用手機，服務端我們用Xcode模擬器。（由於Xcode只能同一時間運行一個模擬器...）

這裡我們用客戶端封包發送數據，然後服務端拆包解析數據。

我們先來看看客戶端的代碼：

static  NSString * Khost = @"10.10.100.48";
static const uint16_t Kport = 6969;
//建立連接
- (BOOL)connect
{
    return  [gcdSocket connectToHost:Khost onPort:Kport error:nil];
}

初始化略過了，大家可以看看github中的代碼，這裡需要說的是，為了連接上本機的服務端，我們這裡的host為服務端的IP地址：

端口為6969（只需和服務端accpet端口一致即可）。

注意：如果大家要運行github上的demo，只需修改這個host地址即可，把它改成你電腦（服務端）的IP地址。

接著我們來看看write方法，我們在該方法中進行封包：

//發送消息
- (void)sendMsg
{

    NSData *data  = [@"你好" dataUsingEncoding:NSUTF8StringEncoding];
    NSData *data1  = [@"豬頭" dataUsingEncoding:NSUTF8StringEncoding];
    NSData *data2  = [@"先生" dataUsingEncoding:NSUTF8StringEncoding];


    NSData *data3  = [@"今天天氣好" dataUsingEncoding:NSUTF8StringEncoding];
    NSData *data4  = [@"吃飯了嗎" dataUsingEncoding:NSUTF8StringEncoding];

    [self sendData:data :@"txt"];
    [self sendData:data1 :@"txt"];
    [self sendData:data2 :@"txt"];
    [self sendData:data3 :@"txt"];
    [self sendData:data4 :@"txt"];

    NSString *filePath = [[NSBundle mainBundle]pathForResource:@"test1" ofType:@"jpg"];

    NSData *data5 = [NSData dataWithContentsOfFile:filePath];

    [self sendData:data5 :@"img"];
}

- (void)sendData:(NSData *)data :(NSString *)type
{
    NSUInteger size = data.length;

    NSMutableDictionary *headDic = [NSMutableDictionary dictionary];
    [headDic setObject:type forKey:@"type"];
    [headDic setObject:[NSString stringWithFormat:@"%ld",size] forKey:@"size"];
    NSString *jsonStr = [self dictionaryToJson:headDic];


    NSData *lengthData = [jsonStr dataUsingEncoding:NSUTF8StringEncoding];


    NSMutableData *mData = [NSMutableData dataWithData:lengthData];
    //分界
    [mData appendData:[GCDAsyncSocket CRLFData]];

    [mData appendData:data];


    //第二個參數，請求超時時間
    [gcdSocket writeData:mData withTimeout:-1 tag:110];

}
- (NSString *)dictionaryToJson:(NSDictionary *)dic
{
    NSError *error = nil;
    NSData *jsonData = [NSJSONSerialization dataWithJSONObject:dic options:NSJSONWritingPrettyPrinted error:&error];
    return [[NSString alloc] initWithData:jsonData encoding:NSUTF8StringEncoding];
}

總共上述兩個方法，也很簡單，我們發送了6條數據，前5條為文本形式，最後一條是一個20多M的圖片。當我們點擊發送的時候會觸發這個方法，這6條數據會被同時發出。

這裡我們來看看我們是如何封包的：

• 我們定義了一個headDic，這個是我們數據包的頭部，裡面裝了這個數據包的大小和類型信息（當然，你可以裝更多的其他標識信息。）然後我們把它轉成了json，最後轉成data。

• 然後我們把這個head拼在最前面，接著拼了一個：

[GCDAsyncSocket CRLFData]

這個是什麼呢？其實它就是一個\r\n。我們用它來做頭部的邊界。（又或者我們可以規定一個固定的頭部長度，來作為邊界，這裡僅僅是提供給大家一個思路）。

• 最後我們把真正的數據包給拼接上。

注：如果你想的更遠的話，甚至可以在結尾，再拼一個包結束的標識符，後面我們會講到為什麼可以這麼做。這裡暫時先這樣。

就這樣，我們完成了數據的封包和發送。

客戶端有了，接著我們來看看服務端是如何來拆包的：

首先我們需要監聽本機6969端口。(完整代碼可以見github)

static const uint16_t Kport = 6969;

//等待連接
- (BOOL)accept
{
    NSError *error = nil;

    BOOL isSuccess =   [gcdSocket acceptOnPort:Kport error:&error];
    if (isSuccess) {
        NSLog(@"監聽成功6969端口成功，等待連接");
        return YES;
    }else{
        NSLog(@"監聽失敗，原因：%@",error);
        return NO;
    }
}

當客戶端連接上來後，調用成功接收到客戶端連接的代理方法：

- (void)socket:(GCDAsyncSocket *)sock didAcceptNewSocket:(GCDAsyncSocket *)newSocket
{
    NSLog(@"接受到socket連接");
    
    [_sockets addObject:newSocket];
    [newSocket readDataToData:[GCDAsyncSocket CRLFData] withTimeout:-1 tag:110];
}

這裡需要注意的是，成功接收到連接後，調用代理我們必須把新生成的這個newSocket保存起來，如果它被銷毀了，那麼連接就斷開了，這裡我們把它放到了一個數組中去了。

這裡需要注意的是，成功連接後，我們就調用了：

[newSocket readDataToData:[GCDAsyncSocket CRLFData] withTimeout:-1 tag:110];

還記得我們封包的時候，數據包頭部之後拼了這麼一個分解符data。這樣，當有數據包傳輸過來我們就能獲取到這個數據包的頭部（後面的信息先不讀取）。

接著我們來看看服務端的read代理方法是如何拆包的：

- (void)socket:(GCDAsyncSocket *)sock didReadData:(NSData *)data withTag:(long)tag
{
    //先讀取到當前數據包頭部信息
    if (!currentPacketHead) {
        currentPacketHead = [NSJSONSerialization
                             JSONObjectWithData:data
                             options:NSJSONReadingMutableContainers
                             error:nil];

        NSUInteger packetLength = [currentPacketHead[@"size"] integerValue];
        //讀到數據包的大小
        [sock readDataToLength:packetLength withTimeout:-1 tag:110];

        return;
    }
    if (!currentPacketHead) {
        NSLog(@"error：當前數據包的頭為空");
        //斷開連接
        [self disConnect];
        return;
    }

    //正式的包處理
    NSUInteger packetLength = [currentPacketHead[@"size"] integerValue];
    //說明數據有問題
    if (packetLength <= 0 || data.length != packetLength) {
        NSLog(@"error：當前數據包數據大小不正確");
        [self disConnect];
        return;
    }

    NSString *type = currentPacketHead[@"type"];
    if ([type isEqualToString:@"img"]) {
        NSLog(@"圖片設置成功");
        self.recvImg.image = [UIImage imageWithData:data];
    }else{

        NSString *msg = [[NSString alloc]initWithData:data encoding:NSUTF8StringEncoding];
        NSLog(@"收到消息:%@",msg);
    }

    currentPacketHead = nil;

    [sock readDataToData:[GCDAsyncSocket CRLFData] withTimeout:-1 tag:110];
}

這個方法也很簡單，我們判斷，如果currentPacketHead（當前數據包的頭部）為空，則說明這次讀取，是一個頭部信息，我們去獲取到該數據包的頭部信息。並且調用下一次讀取，讀取長度為從頭部信息中取出來的數據包長度：

[sock readDataToLength:packetLength withTimeout:-1 tag:110];

這樣當GCDAsyncSocket中數據緩沖區長度達到我們需要讀取的length就能觸發代理方法的第二次回調。（具體原理實現會在樓主的GCDAsyncSocket解析的後續系列Read篇中去講，敬請期待）。

這時候因為currentPacketHead不為空，所以我們就知道是去獲取一個數據包，我們從頭部信息中拿到數據包的類型，如果是文本或者圖片，則分別輸出或展示到屏幕上。讀取完成後我們再次調用：

[sock readDataToData:[GCDAsyncSocket CRLFData] withTimeout:-1 tag:110];

這樣就開始了下一個數據包的頭部信息讀取。

就這樣，整個數據拆包的處理就完成了。

接著我們來講講我們之前所說的為什麼可以在數據包之後加一個結束標識符。我們數據很可能在傳輸的過程中，丟失了一部分，或者頭部信息不可讀，導致我們無法正常讀取這個數據包。

可能我們會有一個應用場景，當出現錯誤包的時候，我們就直接拋棄掉它，直接開始下一個數據包的讀取（當然現實中，我們往往是需要重新發送，這裡僅僅是舉一個應用場景）。這樣這個結束標識符就起作用了，我們可以直接把數據讀取到這個錯誤包的結束標識處，不做任何處理，這樣相當於丟棄掉這個錯誤包了。

最後我們來看看運行效果：

我們客戶端手機連接上服務器後，點擊發送，發出我們上述客戶端寫的6條數據，在我們服務端，按照順序接受到數據如圖：

寫在結尾：

本來不打算寫應用篇的，但是很多朋友在問數據包相關的內容，而且正好之後的Read篇會涉及到這些，所以就當為了後面的內容做一個鋪墊吧。

關於IM的路還有很長，路漫漫其修遠兮，吾將上下而求索。