用 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 崩潰。