iOS 接入WebSocket

2018-06-23 本文已影响491人 FicowShen

WebSocket是什么

WebSocket协议是 基于TCP 的一种网络协议。
它实现了浏览器与服务器全双工(full-duplex)通信——允许服务器主动发送信息给客户端。

websocket与http的区别

WebSocket基本原理

帧协议：

      0                   1                   2                   3
      0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
     +-+-+-+-+-------+-+-------------+-------------------------------+
     |F|R|R|R| opcode|M| Payload len |    Extended payload length    |
     |I|S|S|S|  (4)  |A|     (7)     |             (16/64)           |
     |N|V|V|V|       |S|             |   (if payload len==126/127)   |
     | |1|2|3|       |K|             |                               |
     +-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - +
     |     Extended payload length continued, if payload len == 127  |
     + - - - - - - - - - - - - - - - +-------------------------------+
     |                               |Masking-key, if MASK set to 1  |
     +-------------------------------+-------------------------------+
     | Masking-key (continued)       |          Payload Data         |
     +-------------------------------- - - - - - - - - - - - - - - - +
     :                     Payload Data continued ...                :
     + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
     |                     Payload Data continued ...                |
     +---------------------------------------------------------------+

fin（1 bit）：指示该帧是否构成该消息的最终帧。大多数情况下，消息适合于一个单一的帧，这一点总是默认设置的。实验表明，Firefox 在 32K 之后创建了第二个帧。
rsv1，rsv2，rsv3（1 bit each）：必须为0，除非扩展里协商定义了非零值的含义。如果收到一个非零值，并且协商的扩展中没有一个定义这个非零值的含义，那么接收端必须抛出失败连接。
opcode（4bits）：展示了帧表示什么。以下值目前正在使用：
0x00：这个帧继续前面的有效载荷。
0x01：此帧包含文本数据。
0x02：这个帧包含二进制数据。
0x08：这个帧终止连接。
0x09：这个帧是一个 ping 。
0x0a：这个帧是一个 pong 。
（正如你所看到的，有足够的值未被使用，它们已被保留供将来使用）。
mask（1 bit）：指示连接是否掩盖。就目前而言，从客户端到服务器的每条消息都必须掩盖，如果规范没有掩盖，规范就会终止连接。
payload_len（7 bits）：有效载荷的长度。 WebSocket 的帧有以下长度括号：
0-125 表示有效载荷的长度。 126 表示以下两个字节表示长度，127 表示接下来的 8 个字节表示长度。所以有效负载的长度在〜7bit，16bit 和 64bit 括号内。
masking-key（32 bits）：从客户端发送到服务器的所有帧都被帧中包含的 32 位值掩盖。
payload：最可能被掩盖的实际数据。它的长度是 payload_len 的长度。

连接过程示意图

其他特点包括：
（1）建立在 TCP 协议之上，服务器端的实现比较容易。
（2）与 HTTP 协议有着良好的兼容性。默认端口也是80和443，并且握手阶段采用 HTTP 协议，因此握手时不容易屏蔽，能通过各种 HTTP 代理服务器。
（3）数据格式比较轻量，性能开销小，通信高效。
（4）可以发送文本，也可以发送二进制数据。
（5）没有同源限制，客户端可以与任意服务器通信。
（6）协议标识符是ws（如果加密，则为wss），服务器网址就是 URL。

WebSocket常见的使用场景

要求服务器可以主动向客户端推送信息，客户端也可以主动向服务器发送信息。(也可以采用HTTP/2)

iOS端利用SocketRocket实现WebSocket连接

示例代码如下，欢迎指正：

import Foundation
import SocketRocket
import Alamofire

/// Websocket连接中的通知
let FSWebSocketConnectingNotification = NSNotification.Name.init("FSWebSocketConnectingNotification")
/// Websocket连接成功的通知
let FSWebSocketDidOpenNotification = NSNotification.Name.init("FSWebSocketDidOpenNotification")
/// Websocket连接收到新消息的通知
let FSWebSocketDidReceiveMessageNotification = NSNotification.Name.init("FSWebSocketDidReceiveMessageNotification")
/// Websocket连接失败的通知
let FSWebSocketFailWithErrorNotification = NSNotification.Name.init("FSWebSocketFailWithErrorNotification")
/// Websocket连接已关闭的通知
let FSWebSocketDidCloseNotification = NSNotification.Name.init("FSWebSocketDidCloseNotification")

/// websocket连接地址，请输入有效的websocket地址！
let WSAddr = "ws://host:port/ws"

/// 心跳包发送间隔，3分钟
let PingDuration = 180

/// Websocket连接对象
class FSWebsocket: NSObject,SRWebSocketDelegate {
    
    static let `default` = FSWebsocket.init()
    /// 是否在断开连接后自动重连
    var autoReconnect = true
    
    private var reachabilityManager = NetworkReachabilityManager.init(host: "www.baidu.com")
    /// websocket连接地址
    private var addr = WSAddr
    /// websocket连接
    private var ws:SRWebSocket?
    /// 心跳包定时发送计时器
    private var heartbeatTimer:Timer?
    /// 重连计数器
    private var reconnectCount = 0
    
    override init() {
        super.init()
        
        NotificationCenter.default.addObserver(self, selector: #selector(appWillEnterForeground), name: NSNotification.Name.UIApplicationWillEnterForeground, object: nil)
        NotificationCenter.default.addObserver(self, selector: #selector(appDidEnterBackground), name: NSNotification.Name.UIApplicationDidEnterBackground, object: nil)
        
        // 切换网络自动重连
        reachabilityManager?.listener = { [weak self] (networkReachabilityStatus) in
            // 正在连接中或已经连接成功，不需要重连
            if self?.ws?.readyState == .CONNECTING || self?.ws?.readyState == .OPEN{
                return
            }
            // 设置自动重连才会进行自动重连
            if let s = self, s.autoReconnect{
                self?.reconnect()
            }
        }
        reachabilityManager?.startListening()
    }
    deinit {
        NotificationCenter.default.removeObserver(self)
    }
    
    @objc func appDidEnterBackground(){
        
        close()
    }
    @objc func appWillEnterForeground(){
        
        reconnect()
    }
    
    // MARK: - Send Message
    
    @discardableResult
    func sendJSON(_ json:[AnyHashable : Any]) -> NSError?{
        let jsonData = try? JSONSerialization.data(withJSONObject: json, options: JSONSerialization.WritingOptions.prettyPrinted)
        return self.sendData(jsonData)
    }
    
    @discardableResult
    func sendData(_ data:Data?) -> NSError?{
        
        guard ws?.readyState == SRReadyState.OPEN else{
            return NSError.init(domain: "FSWebsocket", code: SRStatusCodeGoingAway.rawValue, userInfo: nil)
        }
        ws?.send(data)
        return nil
    }
    
    // MARK: - Connection Management
    
    /// 连接websocket服务器
    func open(){
        
        let url = URL(string: self.addr)
        assert(url != nil)
        
        self.ws = SRWebSocket.init(url: url!)
        ws?.delegate = self
        ws?.open()
        NotificationCenter.default.post(name: FSWebSocketConnectingNotification, object: self)
    }
    
    /// 重新连接
    private func reconnect(){
        
        if !autoReconnect{
            return
        }
        if reconnectCount > 64 {
            return
        }
        
        let seconds = DispatchTime.now().uptimeNanoseconds + UInt64(reconnectCount) * NSEC_PER_SEC
        let time = DispatchTime.init(uptimeNanoseconds: seconds)
        DispatchQueue.main.asyncAfter(deadline: time) {
            self.ws?.close()
            self.ws = nil
            
            self.open()
        }
        
        if reconnectCount == 0 {
            reconnectCount = 1
        }
        reconnectCount *= 2
    }
    
    /// 关闭连接
    func close(){
        
        self.destroyHeartbeat()
        
        self.ws?.close()
        self.ws = nil
        
        resetConnectCount()
    }
    
    /// 发送心跳包
    @objc func heartbeat(){
        
        guard ws?.readyState == SRReadyState.OPEN else{
            return
        }
        self.ws?.sendPing(nil)
    }
    /// 启动心跳
    private func startHeartbeat(){
        
        let timer = Timer.init(timeInterval: TimeInterval(PingDuration), target: self, selector: #selector(heartbeat), userInfo: nil, repeats: true)
        self.heartbeatTimer = timer
        RunLoop.current.add(timer, forMode: RunLoopMode.commonModes)
    }
    /// 停止心跳
    private func destroyHeartbeat(){
        
        self.heartbeatTimer?.invalidate()
        self.heartbeatTimer = nil
    }
    /// 重置重连尝试次数
    private func resetConnectCount(){
        
        reconnectCount = 0
    }
    
    
    // MARK: - SRWebSocketDelegate
    
    func webSocketDidOpen(_ webSocket: SRWebSocket!) {
        
        self.resetConnectCount()
        self.startHeartbeat()
        NotificationCenter.default.post(name: FSWebSocketDidOpenNotification, object: self)
    }
    
    func webSocket(_ webSocket: SRWebSocket!, didReceiveMessage message: Any!) {
        
        guard let msgString = message as? NSString else{
            return
        }
        guard let msgData = msgString.data(using: String.Encoding.utf8.rawValue) else{
            return
        }
        // 如果传输的是JSON数据，可以使用JSONSerialization将JSON字符串转换为字典
        guard let msgJSON = try? JSONSerialization.jsonObject(with: msgData, options: JSONSerialization.ReadingOptions.allowFragments) else{
            return
        }
        NotificationCenter.default.post(name: FSWebSocketDidReceiveMessageNotification, object: self, userInfo: ["message":msgJSON])
    }
    
    func webSocket(_ webSocket: SRWebSocket!, didFailWithError error: Error!) {

        NotificationCenter.default.post(name: FSWebSocketFailWithErrorNotification, object: self, userInfo: ["error": error])
        // 连接失败：
        if (error as NSError).code == 50{
            // 断网，不重连
            return
        }
        // 当前页面不需要使用websocket，不重连
        // 重连次数超过限制，不重连
        reconnect()
    }
    
    func webSocket(_ webSocket: SRWebSocket!, didReceivePong pongPayload: Data!) {
        // 心跳包响应回调
    }
    
    func webSocket(_ webSocket: SRWebSocket!, didCloseWithCode code: Int, reason: String!, wasClean: Bool) {
        
        // 连接被关闭
        NotificationCenter.default.post(name: FSWebSocketDidCloseNotification, object: self, userInfo: ["code": code, "reason": reason, "wasClean": wasClean])
        
        close()
    }
}

参考资料：
WebSocket 教程
 iOS websocket接入
 [iOS] 接入WebSocket记录 + 一些个人经验
 解读 JavaScript 之深入探索 WebSockets 和 HTTP/2
IETF Tools - The WebSocket Protocol

iOS 接入WebSocket

WebSocket是什么

WebSocket基本原理

WebSocket常见的使用场景

iOS端实现WebSocket连接的参考方案

SocketRocket

SocketIO

Starscream

iOS端利用SocketRocket实现WebSocket连接

猜你喜欢

热点阅读