您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 使用技巧 >> iOS 7 技巧

Swift Socket 收發不定長訊息的兩種做法與取捨

編輯:iOS 7 技巧

用 socket 維持一份長連線做雙向溝通並不難,真正麻煩的是「訊息長度不固定」。聊天系統就是最典型的場景:一句話可能兩個字,也可能兩百字。若雙方沒有約定邊界,接收端根本判斷不出一次 read 到底讀完了沒有。

業界常見的解法是在資料前面塞一段固定長度的封包標頭,把後續實際內容的長度寫在裡面。接收端先讀標頭、得知長度,再依長度讀完剩下的內容。下面以一個聊天室為例,示範三種實作方式,socket 這裡選用封裝好的 SwiftSocket 庫。

方法一:每則訊息拆成兩個封包送出

第一個封包固定 4 bytes,內容是後面實際訊息封包的長度;第二個封包才是真正的訊息本文。接收端先收 4 bytes 標頭,算出長度,再讀實際內容。

發送端:

// 發送消息
func sendMessage(msgtosend:NSDictionary){
    let msgdata=try? NSJSONSerialization.dataWithJSONObject(msgtosend,
                                                            options: .PrettyPrinted)
    var len:Int32=Int32(msgdata!.length)
    let data:NSMutableData=NSMutableData(bytes: &len, length: 4)
    self.socketClient!.send(data: data)   // 先送長度
    self.socketClient!.send(data:msgdata!) // 再送本文
}

接收端:

// 解析收到的消息
func readMsg()->NSDictionary?{
    // 先讀 4 byte 的長度
    if let data=self.tcpClient!.read(4){
        if data.count==4{
            let ndata=NSData(bytes: data, length: data.count)
            var len:Int32=0
            ndata.getBytes(&len, length: data.count)
            if let buff=self.tcpClient!.read(Int(len)){
                let msgd:NSData=NSData(bytes: buff, length: buff.count)
                let msgi:NSDictionary=(try!
                    NSJSONSerialization.JSONObjectWithData(msgd,
                        options: .MutableContainers)) as! NSDictionary
                return msgi
            }
        }
    }
    return nil
}

方法二:合併成一個封包,但保留標頭

這其實是方法一的整合版,只是把標頭與本文拼在同一個 buffer 裡一次送出,網路往返更少。接收邏輯完全不變。

客戶端發送:

// 發送消息
func sendMessage(msgtosend:NSDictionary){
    // 消息數據包
    let msgdata = try? NSJSONSerialization.dataWithJSONObject(msgtosend,
                        options: .PrettyPrinted)
    // 消息數據包大小
    var len:Int32=Int32(msgdata!.length)
    // 消息包頭數據
    let data:NSMutableData=NSMutableData(bytes: &len, length: 4)
    // 標頭後面接上真正的訊息本文
    data.appendData(msgdata!)
    // 一次送出合併後的封包
    self.socketClient!.send(data: data)
}

服務端同樣處理:

// 發送消息
func sendMsg(msg:NSDictionary){
    let jsondata=try? NSJSONSerialization.dataWithJSONObject(msg, options:
                       NSJSONWritingOptions.PrettyPrinted)
    var len:Int32=Int32(jsondata!.length)
    let data:NSMutableData=NSMutableData(bytes: &len, length: 4)
    data.appendData(jsondata!)
    self.tcpClient!.send(data: data)
}

方法三:完全不帶標頭,靠循環讀取

若雙方都是自己掌控、格式單純,也可以省掉標頭。發送端直接丟資料,接收端因為不知道實際長度,就固定大小反覆讀(例如每次 1024 bytes),直到某次讀到的數量小於 1024,即視為讀完。

先為 TCPClient 補上 readAll():

/*
 * 不指定長度來讀取數據
 */
public func readAll(timeout:Int = -1)->[UInt8]?{
    // 內容緩衝區
    var data:[UInt8] = [UInt8]()
    repeat{
        if let tempData = read(1024, timeout: timeout) {
            // 將每次讀到的資料附加到緩衝區
            data = data + tempData
            // 讀到的數量不足一批,代表已讀完
            if tempData.count < 1024 {
                break
            }
        }else{
            break
        }
    }while true
    return data
}

服務端的 ChatUser 管理類因此得以簡化,收發都不必再算長度:

// 客戶端管理類(便於服務端管理所有連接的客戶端)
class ChatUser:NSObject{
    var tcpClient:TCPClient?
    var username:String=""
    var socketServer:MyTcpSocketServer?

    // 解析收到的消息
    func readMsg()->NSDictionary?{
        if let buff=self.tcpClient!.readAll(){
            let msgd:NSData=NSData(bytes: buff, length: buff.count)
            let msgi:NSDictionary=(try!
                NSJSONSerialization.JSONObjectWithData(msgd,
                    options: .MutableContainers)) as! NSDictionary
            return msgi
        }
        return nil
    }

    // 循環接收消息
    func messageloop(){
        while true{
            if let msg=self.readMsg(){
                self.processMsg(msg)
            }else{
                self.removeme()
                break
            }
        }
    }

    // 處理收到的消息
    func processMsg(msg:NSDictionary){
        if msg["cmd"] as! String=="nickname"{
            self.username=msg["nickname"] as! String
        }
        self.socketServer!.processUserMsg(user: self, msg: msg)
    }

    // 發送消息(不再需要提供長度)
    func sendMsg(msg:NSDictionary){
        let jsondata=try? NSJSONSerialization.dataWithJSONObject(msg, options:
                           NSJSONWritingOptions.PrettyPrinted)
        self.tcpClient!.send(data: jsondata!)
    }

    // 移除該客戶端
    func removeme(){
        self.socketServer!.removeUser(self)
    }

    // 關閉連接
    func kill(){
        self.tcpClient!.close()
    }
}

客戶端(ViewController.swift)同樣受益,發送端一行搞定,接收端改呼叫 readAll():

import UIKit

class ViewController: UIViewController {

    // 消息輸入框
    @IBOutlet weak var textFiled: UITextField!
    // 消息輸出列表
    @IBOutlet weak var textView: UITextView!

    // socket 服務端封裝類
    var socketServer:MyTcpSocketServer?
    // socket 客戶端類
    var socketClient:TCPClient?

    override func viewDidLoad() {
        super.viewDidLoad()

        // 啟動服務器
        socketServer = MyTcpSocketServer()
        socketServer?.start()

        // 初始化客戶端並連線
        processClientSocket()
    }

    // 初始化客戶端,並連接服務器
    func processClientSocket(){
        socketClient=TCPClient(addr: "localhost", port: 8080)
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0), {
            () -> Void in

            // 讀取並解析服務端來的消息
            func readmsg()->NSDictionary?{
                if let buff=self.socketClient!.readAll(){
                    let msgd:NSData=NSData(bytes: buff, length: buff.count)
                    let msgi:NSDictionary =
                        (try! NSJSONSerialization.JSONObjectWithData(msgd,
                            options: .MutableContainers)) as! NSDictionary
                    return msgi
                }
                return nil
            }

            // 連接服務器
            let (success,msg)=self.socketClient!.connect(timeout: 5)
            if success{
                dispatch_async(dispatch_get_main_queue(), {
                    self.alert("connect success", after: { })
                })

                // 送出一個隨機暱稱
                let msgtosend=["cmd":"nickname","nickname":"游客\(Int(arc4random()%1000))"]
                self.sendMessage(msgtosend)

                // 持續接收服務端消息
                while true{
                    if let msg=readmsg(){
                        dispatch_async(dispatch_get_main_queue(), {
                            self.processMessage(msg)
                        })
                    }else{
                        break
                    }
                }
            }else{
                dispatch_async(dispatch_get_main_queue(), {
                    self.alert(msg,after: { })
                })
            }
        })
    }

    // 「發送消息」按鈕
    @IBAction func sendMsg(sender: AnyObject) {
        let content=textFiled.text!
        let message=["cmd":"msg","content":content]
        self.sendMessage(message)
        textFiled.text=nil
    }

    // 發送消息
    func sendMessage(msgtosend:NSDictionary){
        let msgdata=try? NSJSONSerialization.dataWithJSONObject(msgtosend,
                                                                    options: .PrettyPrinted)
        self.socketClient!.send(data:msgdata!)
    }

    // 處理服務器回傳的消息
    func processMessage(msg:NSDictionary){
        let cmd:String=msg["cmd"] as! String
        switch(cmd){
        case "msg":
            self.textView.text = self.textView.text +
                (msg["from"] as! String) + ": " + (msg["content"] as! String) + "\n"
        default:
            print(msg)
        }
    }

    // 彈出提示框
    func alert(msg:String,after:()->(Void)){
        let alertController = UIAlertController(title: "",
            message: msg, preferredStyle: .Alert)
        self.presentViewController(alertController, animated: true, completion: nil)

        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 7), dispatch_get_main_queue(),{
            alertController.dismissViewControllerAnimated(false, completion: nil)
        })
    }

    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
    }
}

該選哪一種?

三種做法各有代價。方法一邏輯最直白,但每則訊息兩次 send,在高頻通訊下系統呼叫次數翻倍。方法二是實務上最主流的選擇,一次 I/O 完成,標頭也讓協議具備擴充空間(例如放訊息類型、序號)。方法三寫起來最省事,卻有明顯缺陷:它依賴「讀到的數量小於 1024 就代表結束」這個假設,一旦訊息長度剛好是 1024 的整數倍,就會多等一輪才判定結束;訊息過大時也容易與下一則資料黏在一起。

所以正式專案通常會走方法二,並把標頭設計得比 4 bytes 更完整一些——除了長度,再放版本號與指令碼,後續要加功能就不必破壞相容性。另外別忘了在標頭長度上設一個上限校驗,否則收到惡意或損壞的封包時,企圖配置數 GB 的緩衝區會直接讓 App 崩潰。

  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved