iOS WebSocket-SocketRocket框架使用

1. 关于Socket 与 WebSocket基本概念

关于Socket

我们都知道socket是套接字，描述ip地址和端口，它本身并不是协议，而是一个调用接口，为了大家直接使用更底层的协议（TCP或UDP），是对TCP/IP 或 UDP/IP的封装。socket处于网络层中的第五层，是一个抽象层。

关于WebSocket

websocket是一个协议，是基于http协议的，是建立在TCP连接之上的，是应用层上的一个应用层协议，和socket不是一个概念。
它实现了浏览器与服务器全双工(full-duplex)通信——允许服务器主动发送信息给客户端

WebSocket的特点

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

WebSocket和HTTP协议

WebSocket 是 HTML5 开始提供的一种在单个 TCP 连接上进行全双工通讯的协议。
HTTP 协议是一种无状态的、无连接的、单向的应使用层协议。它采使用了请求/响应模型。通信请求只能由用户端发起，服务端对请求做出应答解决。这种通信模型有一个弊端：HTTP 协议无法实现服务器主动向用户端发起消息。这种单向请求的特点，注定了假如服务器有连续的状态变化，用户端要获知就非常麻烦。大多数 Web 应使用程序将通过频繁的异步JavaScript和XML（AJAX）请求实现长轮询。轮询的效率低，非常白费资源（由于必需不停连接，或者者 HTTP 连接始终打开）。
WebSocket 连接允许用户端和服务器之间进行全双工通信，以便任一方都可以通过建立的连接将数据推送到另一端。WebSocket 只要要建立一次连接，即可以一直保持连接状态。这相比于轮询方式的不停建立连接显然效率要大大提高。

WebSocket与Socket的关系

Socket其实并不是一个协议，而是为了方便用TCP或者UDP而笼统出来的一层，是位于应使用层和传输控制层之间的一组接口。是应使用层与TCP/IP协议族通信的中间软件笼统层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对使用户来说，一组简单的接口就是一律，让Socket去组织数据，以符合指定的协议。当两台主机通信时，必需通过Socket连接，Socket则利使用TCP/IP协议建立TCP连接。TCP连接则更依靠于底层的IP协议，IP协议的连接则依赖于链路层等更低层次。
WebSocket则是一个典型的应使用层协议。
区别是Socket是传输控制层协议，WebSocket是应使用层协议

2. WebSocket框架

SocketRocket

SocketRocket是facebook封装的websocket开源库，采用纯Objective-C编写。
使用者需要自己实现心跳机制，以及适配断网重连等情况

SocketIO

SocketIO将WebSocket、AJAX和其它的通信方式全部封装成了统一的通信接口，也就是说，我们在使用SocketIO时，不用担心兼容问题，底层会自动选用最佳的通信方式。因此说，WebSocket是SocketIO的一个子集。
另外，如果后端采用的是原生WebSocket，不建议大家使用SocketIO。
因为SocketIO定制了专有的协议，并不是纯粹的WebSocket，可能会遭遇适配问题。
不过，SocketIO的API极其易用！！！

Starscream

采用Swift编写

3. iOS端利用SocketRocket实现WebSocket连接

3.1 SocketRocket 集成

使用cocoapods

只需要在podfile文件中加入pod 'SocketRocket'，然后执行pod install就可以了

使用Socket源码

• 添加SocketRocket源码文件
• 添加依赖库
  在Build Phases -> Link Binary With Libraries里加入如下frameworks：
  libicucore.dylib
  CFNetwork.framework
  Security.framework
  Foundation.framework

3.2 SocketRocket 使用

直接上代码

XTWebSocket.h

#import <Foundation/Foundation.h>
#import <UIKit/UIKit.h>
NS_ASSUME_NONNULL_BEGIN

@protocol XTWebSocketDelegate <NSObject>
@optional
- (void)xtWebSocketDidReceiveMessage:(NSString *)message;
@end

@interface XTWebSocket : NSObject
@property (nonatomic,weak) id <XTWebSocketDelegate> delegate;
- (instancetype)initWithServerIp:(NSString *__nullable)serverIp;
- (void)connectWebSocket;
- (void)closeWebSocket;

- (void)sendMsg:(NSString *)msg;

@end
NS_ASSUME_NONNULL_END

XTWebSocket.m

#import "XTWebSocket.h"
#import "SRWebSocket.h"
#import "AFNetworkReachabilityManager.h"

static int const kHeartbeatDuration = 3*60;
static NSString *kDefaultWebSocketUrl = @"ws://";

@interface XTWebSocket ()<SRWebSocketDelegate>
@property (nonatomic,strong) SRWebSocket *socket;
@property (strong, nonatomic) NSTimer *heatBeat;
@property (assign, nonatomic) NSTimeInterval reConnectTime;

@property (nonatomic,strong) NSString *serverIpString;

@property (nonatomic,assign) BOOL autoReconnect;
@end

@implementation XTWebSocket

- (instancetype)initWithServerIp:(NSString *__nullable)serverIp {
    if (self = [super init]) {
        if (!serverIp) {
            self.serverIpString = kDefaultWebSocketUrl;
        }else{
            self.serverIpString = serverIp;
        }
        [self addNoti];

    }
    return self;
}

#pragma mark - Public -
- (void)connectWebSocket {
    self.autoReconnect = YES;
    [self initWebSocket];
}
- (void)closeWebSocket {
    self.autoReconnect = NO;
    [self close];
}

- (void)sendMsg:(NSString *)msg {
    if (self.socket && self.socket.readyState == SR_OPEN) {
        // 只有在socket状态为SR_OPEN 时，才可以发送消息
        // 在socket状态不为SR_OPEN，可以将消息放进队列里，在websocket连上时，再发送
        [self.socket sendString:msg error:nil];
    }
}

#pragma mark - Private -

#pragma mark -- WebSocket
//初始化 WebSocket
- (void)initWebSocket{
    if (_socket) {
        return;
    }
    
    NSURL *url = [NSURL URLWithString:self.serverIpString];
    //请求
    NSMutableURLRequest *request = [[NSMutableURLRequest alloc]initWithURL:url cachePolicy:NSURLRequestUseProtocolCachePolicy timeoutInterval:10];
    //初始化请求`
    _socket = [[SRWebSocket alloc] initWithURLRequest:request];
    //代理协议`
    _socket.delegate = self;
    //直接连接
    [_socket open];
}


#pragma mark - NOTI  -
- (void)addNoti {
    // 监听网络变化
    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(handleNetWorkStatusChanged) name:@"XTNOTICE_NETWORK_STATUS_CHANGED" object:nil];
    
}

// 网络变化
- (void)handleNetWorkStatusChanged {
    // 断网时，关闭websocket
    if(![AFNetworkReachabilityManager sharedManager].reachable){
        [self close];
    }else{
        // 网络连上时，重新连接websocket
        if ((self.socket.readyState == SR_OPEN || self.socket.readyState == SR_CONNECTING) && self.socket) {
            return;
        }
        [self reConnect];
    }
}

#pragma mark - Heart Timer -
//保活机制 探测包
- (void)startHeartbeat {
    self.heatBeat = [NSTimer scheduledTimerWithTimeInterval:kHeartbeatDuration target:self selector:@selector(heartbeatAction) userInfo:nil repeats:YES];
    [self.heatBeat setFireDate:[NSDate distantPast]];
    [[NSRunLoop currentRunLoop] addTimer:_heatBeat forMode:NSRunLoopCommonModes];
}


//断开连接时销毁心跳
- (void)destoryHeartbeat{
    [self.heatBeat invalidate];
    self.heatBeat = nil;
}

// 发送心跳
- (void)heartbeatAction {
    if (self.socket.readyState == SR_OPEN) {
        [self.socket sendString:@"heart" error:nil];
        NSLog(@"XTWebSocket heartbeatAction");
    }
}


//重连机制
- (void)reConnect{
    if (!self.autoReconnect) {
        return;
    }
    
    //每隔一段时间重连一次
    // 重连间隔时间 可以根据业务调整
    if (_reConnectTime > 60) {
        _reConnectTime = 60;
    }
    
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(_reConnectTime * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        self.socket = nil;
        [self initWebSocket];
    });
    
    if (_reConnectTime == 0) {
        _reConnectTime = 2;
    }else{
        _reConnectTime *= 2;
    }
}

- (void)resetConnectTime {
    self.reConnectTime = 0;
}

// 关闭Socket
- (void)close {
    [self destoryHeartbeat];
    [self.socket close];
    self.socket = nil;
    [self resetConnectTime];
}

#pragma mark -- SRWebSocketDelegate
//收到服务器消息是回调
- (void)webSocket:(SRWebSocket *)webSocket didReceiveMessage:(id)message{
    NSLog(@"XTWebSocket didReceiveMessage：%@",message);
    if ([message isKindOfClass:[NSString class]]) {
        NSString *msg = (NSString *)message;
        if ([self.delegate respondsToSelector:@selector(xtWebSocketDidReceiveMessage:)]) {
            [self.delegate xtWebSocketDidReceiveMessage:msg];
        }
    }
}

//连接成功
- (void)webSocketDidOpen:(SRWebSocket *)webSocket{
    NSLog(@"XTWebSocket DidOpen");
    [self resetConnectTime];
    [self startHeartbeat];
    
    // 下面逻辑，根据业务情况处理
    if (self.socket != nil) {
        // 只有 SR_OPEN 开启状态才能调 send 方法啊，不然要崩
        if (_socket.readyState == SR_OPEN) {
            NSString *jsonString = @"{\"sid\": \"13b313a3-fea9-4e28-9e56-352458f7007f\"}";
            [_socket sendString:jsonString error:nil];  //发送数据包

        } else if (_socket.readyState == SR_CONNECTING) {
            NSLog(@"正在连接中，重连后其他方法会去自动同步数据");
            // 每隔2秒检测一次 socket.readyState 状态，检测 10 次左右
            // 只要有一次状态是 SR_OPEN 的就调用 [ws.socket send:data] 发送数据
            // 如果 10 次都还是没连上的，那这个发送请求就丢失了，这种情况是服务器的问题了，小概率的
            // 代码有点长，我就写个逻辑在这里好了
            
        } else if (_socket.readyState == SR_CLOSING || _socket.readyState == SR_CLOSED) {
            // websocket 断开了，调用 reConnect 方法重连
        }
    }
}


//连接失败的回调
- (void)webSocket:(SRWebSocket *)webSocket didFailWithError:(NSError *)error{
    NSLog(@"XTWebSocket didFailWithError %@",error);
    // 1.判断当前网络环境，如果断网了就不要连了，等待网络到来，在发起重连
    // 2.判断调用层是否需要连接，例如用户都没在聊天界面，连接上去浪费流量
    
    if (error.code == 50 || ![AFNetworkReachabilityManager sharedManager].reachable) {
        // 网络异常不重连
        return;
    }
    [self reConnect];
}

//连接断开的回调
- (void)webSocket:(SRWebSocket *)webSocket didCloseWithCode:(NSInteger)code reason:(NSString *)reason wasClean:(BOOL)wasClean{
    NSLog(@"XTWebSocket Close code %ld reason %@",(long)code,reason);
    // 连接断开时，自动重连
    // 是否重连可根据具体业务处理
    if (![AFNetworkReachabilityManager sharedManager].reachable) {
        return;
    }
    [self reConnect];
}

- (void)webSocket:(SRWebSocket *)webSocket didReceivePong:(NSData *)pongPayload {
    NSLog(@"XTWebSocket Pong");
}

#pragma mark - 其他 -
- (void)dealloc {
    NSLog(@"LFC: dealloc: %@", self);
    [[NSNotificationCenter defaultCenter] removeObserver:self];
}

@end