iOS WebSocket长链接(Swift)

WebSocket-Swift

Starscream的使用

WebSocket 是 HTML5 一种新的协议。它实现了浏览器与服务器全双工通信,能更好的节省服务器资源和带宽并达到实时通讯,它建立在 TCP 之上,同 HTTP 一样通过 TCP 来传输数据,但是它和 HTTP 最大不同是:WebSocket 是一种双向通信协议.

现在很多第三方比如:融云,环信,网易云,腾讯云等等,都可以满足即时通讯的功能。而且技术成熟。但是当由于特殊要求不能使用第三方时,就可以使用WebSocket建立长链接,实现即时通讯功能。

目前Swift版本的WebSocket最好用的框架就应该是daltoniam的Starscream了。
Starscream库下载地址:Starscream

OC最好用的算是Facebook的SocketRocket,使用说明可以参考我的另一篇文章iOS WebSocket长链接

使用

一般一个项目在启动后的某个时机会启动创建一个长链接,如果多个地方需要,就可以封装为一个单例,全局使用。
可以使用podpod管理库, 在podfile中加入
pod 'Starscream', '~> 4.0.0'

在使用命令行工具cd到当前工程 安装
pod install

导入头文件import Starscream,即可使用。

1.首先创建一个名为WebSocketManager的单例类

    static let shard = WebSocketManager()

可以使用单例,也可以使用[alloc]init 根据情况自己选择

2.创建一个枚举,分别表示WebSocket的链接状态

enum WebSocketConnectType {
    case closed       //初始状态,未连接
    case connect      //已连接
    case disconnect   //连接后断开
    case reconnecting //重连中...
}

3.创建连接

 // MARK: - 公开方法,外部调用
    func connectSocket(_ paremeters: Any?) {

paremeters可以是外部传入的参数。

4.接收消息
包括连接成功的消息,发送的文本消息,连接失败的消息,等等。
新版的库,将所有的消息接收都封装在了一个代理方法里面,老版的是分开的。老版本的代理我写在了最下面,可以参考一下,有助于理解。
遵循代理,实现代理,接收消息:

   webSocket?.delegate = self

消息接收:

   func didReceive(event: WebSocketEvent, client: WebSocket) {
     //接收各种消息
   }

5.关闭连接

 /// 断开链接
 func disconnect()

6.为保持长链接的连接状态,需要定时向后台发送消息,就是俗称的:心跳包。
需要创建一个定时器,固定时间发送ping消息。

7.重新连接

/// 重新连接
func reConnectSocket()

8.链接断开情况处理:
首先判断是否是主动断开,并且记录这个操作状态:
如果是主动断开就不作处理。
如果不是主动断开链接,需要做重新连接的逻辑.

    /// 用于判断是否主动关闭长连接,如果是主动断开连接,连接失败的代理中,就不用执行 重新连接方法
    private var isActivelyClose:Bool = false

代码如下:

//
//  WebSocketManager.swift
//  SwiftTools
//
//  Created by 网易词典 on 2019/12/1.
//  Copyright © 2019 xuanhe. All rights reserved.
//

import UIKit
import Starscream


// MARK: - WebSocket代理
//这里即设置代理,稍后还会发通知.使用情况不一样.
protocol WebSocketManagerDelegate: class {
    /// 建立连接成功通知
    func webSocketManagerDidConnect(manager: WebSocketManager)
    /// 断开链接通知,参数 `isReconnecting` 表示是否处于等待重新连接状态。
    func webSocketManagerDidDisconnect(manager: WebSocketManager, error: Error?)
    /// 接收到消息后的回调(String)
    func webSocketManagerDidReceiveMessage(manager: WebSocketManager, text: String)
    /// 接收到消息后的回调(Data)
    func webSocketManagerDidReceiveData(manager: WebSocketManager, data: Data)
}

enum WebSocketConnectType {
    case closed       //初始状态,未连接
    case connect      //已连接
    case disconnect   //连接后断开
    case reconnecting //重连中...
}



class WebSocketManager: NSObject {
    /// 单例,可以使用单例,也可以使用[alloc]init 根据情况自己选择
    static let shard = WebSocketManager()
    /// WebSocket对象
    private var webSocket : WebSocket?
    /// 是否连接
    var isConnected : Bool = false
    /// 代理
    weak var delegate: WebSocketManagerDelegate?

    private var heartbeatInterval: TimeInterval = 5
    
    /// 重连次数
    private var reConnectCount: Int = 0
    //存储要发送给服务端的数据,本案例不实现此功能,如有需求自行实现
    private var sendDataArray = [String]()
    

    ///心跳包定时器
    var heartBeatTimer: Timer?
    ///网络监听定时器
    var netWorkTimer:Timer?
    
    
    var connectType : WebSocketConnectType = .closed
    /// 用于判断是否主动关闭长连接,如果是主动断开连接,连接失败的代理中,就不用执行 重新连接方法
    private var isActivelyClose:Bool = false
    
    /// 当前是否有网络,👇👇👇👇👇应该由各自项目提供,本处为了方便,简历一个属性作为临时变量
    private var isHaveNet:Bool = true

    
    override init() {
        // webSocket.advancedDelegate = self

    }
    
    // MARK: - 公开方法,外部调用
    func connectSocket(_ paremeters: Any?) {
        guard let url = URL(string: "http://localhost:8888") else {
            return
        }

        self.isActivelyClose = false

        var request = URLRequest(url: url)
        request.timeoutInterval = 5
        
        //添加头信息
        request.setValue("headers", forHTTPHeaderField: "Cookie")
        request.setValue("CustomeDeviceInfo", forHTTPHeaderField: "DeviceInfo")
        webSocket = WebSocket(request: request)
        webSocket?.delegate = self

        webSocket?.connect()
        // 自定义队列,一般不需要设置,默认主队列
        //webSocket?.callbackQueue = DispatchQueue(label: "com.vluxe.starscream.myapp")

    }
    /// 发送消息
    func sendMessage(_ text: String) {
        if self.isHaveNet {
            // 有网络直接发消息
            if self.connectType == .connect {  //已经连接
                self.webSocket?.write(string: text)
            }else if self.connectType == .reconnecting {
                self.sendDataArray.append(text)
            }else if self.connectType == .disconnect {
                reConnectSocket()
            }else{
                self.sendDataArray.append(text)
            }
            
        } else {
            // 无网络的时候的操作
            //1.提示无网络
            //2.存储消息
            self.sendDataArray.append(text)
            //等待来网
            guard isActivelyClose else {
                initNetWorkTestingTimer()
                return
            }
        }
    }
    /// 断开链接
    func disconnect() {
        self.isActivelyClose = true
        self.connectType = .disconnect
        webSocket?.disconnect()
        destoryHeartBeat()
        destoryNetWorkStartTesting()
    }
    /// 重新连接
    func reConnectSocket() {
        if self.reConnectCount > 10 { //重连10次
            self.reConnectCount = 0;
            return
        }
        //重连10次,每两次间隔5s
        DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 5) {
            if self.connectType == .reconnecting {
                return
            }
            /// 连接
            self.connectSocket(nil)
            self.reConnectCount = self.reConnectCount + 1
        }
    }
    
    // MARK: - 网络监听
    func networkNotifation() {
        //外部最好也传进来一个网络变化的通知
        //当断开网络时候,不在进行重新连接
        
        //当网络恢复的时候,重新连接,根据自己业务进行更新.
        
        //更新网络状态
        isHaveNet = false
    }
   
    
    // MARK: - 私有方法
    /// 初始化心跳
    private func initHeartBeat() {
        
        if self.heartBeatTimer != nil {
            return
        }
        self.heartBeatTimer = Timer(timeInterval: 1, target: self, selector: #selector(sendHeartBeat), userInfo: nil, repeats: true)
        RunLoop.current.add(self.heartBeatTimer!, forMode: RunLoop.Mode.common)
    }
    
    private func initNetWorkTestingTimer() {
        if self.netWorkTimer != nil {
            return
        }
        self.netWorkTimer = Timer(timeInterval: 5, target: self, selector: #selector(noNetWorkStartTesting), userInfo: nil, repeats: true)
        RunLoop.current.add(self.netWorkTimer!, forMode: RunLoop.Mode.common)
    }
    
    /// 心跳
    @objc private func sendHeartBeat() {
        if self.isConnected {
            let text = "ping的内容,和服务器商定"
            if let data = text.data(using: String.Encoding.utf8) {
                webSocket?.write(ping: data)
            }
            
            // 我在网上查阅资料显示,也可以使用webSocket?.write(string: "")
            // 即: webSocket?.write(string: text)
            // write方法中ping和text是一样的,只是传入的枚举不一样,可以参考源代码
        }else{
            // 发现没有连接,根据需求做判断
        }
    }
    
    /// 没有网络的时候开始定时 -- 用于网络检测
    @objc private func noNetWorkStartTesting() {
        //有网络
        if isHaveNet {//这里可以根据业务需要修改
            //1.关闭网络监测定时器
            destoryNetWorkStartTesting()
            //2.重新连接
            reConnectSocket()
        }
    }
    
    //关闭心跳定时器
    private func destoryHeartBeat() {
        self.heartBeatTimer?.invalidate()
        self.heartBeatTimer = nil
    }
    
    //关闭网络监测定时器
    private func destoryNetWorkStartTesting() {
        self.netWorkTimer?.invalidate()
        self.netWorkTimer = nil
    }
    
}

extension WebSocketManager: WebSocketDelegate{
    func didReceive(event: WebSocketEvent, client: WebSocket) {
        switch event {
            case .connected(let headers):
                isConnected = true
                delegate?.webSocketManagerDidConnect(manager: self)
                
                _ = "连接成功,在这里处理成功后的逻辑,比如将发送失败的消息重新发送等等..."
                print("websocket is connected: \(headers)")
                break
            case .disconnected(let reason, let code):
                isConnected = false
                
                let error = NSError(domain: reason, code: Int(code), userInfo: nil) as Error
                    delegate?.webSocketManagerDidDisconnect(manager: self, error: error)
                
                self.connectType = .disconnect
                if self.isActivelyClose {
                    self.connectType = .closed
                } else {
                    self.connectType = .disconnect
                    destoryHeartBeat() //断开心跳定时器
                    if self.isHaveNet {
                        reConnectSocket()  //重新连接
                    } else {
                        initNetWorkTestingTimer()
                    }
                }
                print("websocket is disconnected: \(reason) with code: \(code)")
                break
            case .text(let string):
                delegate?.webSocketManagerDidReceiveMessage(manager: self, text: string)
            
             //当全局都需要数据时,这里使用通知.
                let dic = ["text" : string]
                NotificationCenter.default.post(name: NSNotification.Name(rawValue: "webSocketManagerDidReceiveMessage"), object: dic)
                print("Received text: \(string)")
                break
            case .binary(let data):
                print("Received data: \(data.count)")
                break
            case .ping(_):
                print("ping")
                break
            case .pong(_):
                print("pong")
                break
            case .viabilityChanged(_):
                break
            case .reconnectSuggested(_):
                break
            case .cancelled:
                isConnected = false
            case .error(let error):
                isConnected = false
                handleError(error)
        }
    }
    
    // custom
    func handleError(_ error: Error?) {
        if let e = error as? WSError {
            print("websocket encountered an error: \(e.message)")
        } else if let e = error {
            print("websocket encountered an error: \(e.localizedDescription)")
        } else {
            print("websocket encountered an error")
        }
    }
    
    
    // MARK: - 老版本的代理,不要了
    /// 👇👇👇👇👇👇👇👇👇👇
    ///都是分开的,现在都合成一个了,就是上面的didReceive,但是可以参考一下,理解逻辑,.知道哪些是重要的
    /// 连接成功后的回调
    func websocketDidConnect(socket: WebSocketClient) {
        print(#function)
    }
    /// 断开连接后的回调
    func websocketDidDisconnect(socket: WebSocketClient, error: Error?) {
        print(#function)
    }
    
    /// 接收到消息后的回调(String)
    func websocketDidReceiveMessage(socket: WebSocketClient, text: String) {
        print(#function)
    }
    /// 接收到消息后的回调(Data)
    func websocketDidReceiveData(socket: WebSocketClient, data: Data) {
        print(#function)
    }
    
    ///  👆👆👆👆👆👆👆👆👆👆👆
    
}

说明:

代理里面已经是全部的逻辑了,但是有一些细节需要特殊说明,也需要我们自行处理:

  1. 外部接收消息,是使用代理还是使用通知??
    当我们的长链接只需要在某一个页面使用的时候,我们创建了一个代理,在实现页面需要实现代理即可。
    当我们需要全局使用的时候,请使用通知,代理不准确。
    下面代码两种方法,请使用其中一个:
  delegate?.webSocketManagerDidReceiveMessage(manager: self, text: string)
            
  //当全局都需要数据时,这里使用通知.
  let dic = ["text" : string]
  NotificationCenter.default.post(name: NSNotification.Name(rawValue: "webSocketManagerDidReceiveMessage"), object: dic)
  1. webSocket代理里面,我只写基本的处理逻辑,需要根据项目处理不同状态下的逻辑。
  2. 当消息发送失败的时候,消息处理逻辑我们没有实现完全。项目代码里面有写。存储要发送给服务端的数据,本案例不实现此功能,如有需求自行实现。做法就是我们把发送失败的消息存起来,链接成功后重新发送。
  3. 重连次数,我设置的是10次,可以自行修改
  4. 当前是否有网络的判断,我写了一个bool变量,需要替换成我们项目里面网络状态判断的相关代码。
  5. 可以自定义队列,一般不需要设置,默认主队列。我没有处理在其他队列情况的逻辑。

本文参考了文章:
SSRWebSocket

推荐阅读更多精彩内容