CocoaAsyncSocket框架的简单封装

在iOS开发中使用socket（CFNetwork），一般都是用第三方库AsyncSocket。

参考博客：http://my.oschina.net/worldligang/blog/396881?fromerr=WRR1ZAie

CocoaAsyncSocket的git下载地址：https://github.com/robbiehanson/CocoaAsyncSocket

下载CocoaAsyncSocket的文件，导入runloop中的AsyncSocket.h和AsyncSocket.m文件。

以下就是封装的CocoaAsyncSocket工具类DLSocketServe。

 //
 //  DLSocketServe.h
 //  AsnycSocketDemo
 //
 //  Created by wiseman on 15/12/23.
 //  Copyright (c) 2015年 wiseman. All rights reserved.
 //
 #import <Foundation/Foundation.h>
 #import "AsyncSocket.h"

 enum{
     SocketOfflineByServer,      //服务器掉线
     SocketOfflineByUser,        //用户断开
     SocketOfflineByWifiCut,     //wifi 断开
 };

 @interface DLSocketServe : NSObject<AsyncSocketDelegate>

 @property (strong,nonatomic) AsyncSocket * socket;

 @property (retain,nonatomic) NSTimer *heartTimer; //心跳计时器

 +(DLSocketServe *)sharedSocketServe;

 //socket连接
 -(void)startConnetSocket;

 //断开socket连接
 -(void)cutOffSocket;

 //发送消息
 -(void)sendMessage:(id)message;
 @end

 //
 //  DLSocketServe.m
 //  AsnycSocketDemo
 //
 //  Created by wiseman on 15/12/23.
 //  Copyright (c) 2015年 wiseman. All rights reserved.
 //

 #define HOST @"192.168.1.1"
 #define PORT 8080

 #define TIME_OUT 20

 //设置读取超时 -1 表示不会使用超时
 #define READ_TIME_OUT -1

 //设置写入超时 -1表示不会使用超时
 #define WRITW_TIME_OUT -1
 #define MAX_BUFFER 1024

 #import "DLSocketServe.h"

 @implementation DLSocketServe

 static DLSocketServe *socketServe = nil;

 //创建一个单例方法
 +(DLSocketServe *)sharedSocketServe{
     //@synchronized 的作用是创建一个互斥锁，保证此时没有其它线程对self对象进行修改。这个是objective-c的一个锁定令牌，防止self对象在同一时间内被其它线程访问，起到线程的保护作用。 一般在公用变量的时候使用，如单例模式或者操作类的static变量中使用。
     @synchronized(self){
         if(socketServe == nil) {
             socketServe = [[[self class] alloc] init];
         }
     }
     return socketServe;
 }

 +(instancetype)allocWithZone:(struct _NSZone *)zone{
     @synchronized(self){
         if (socketServe == nil) {
             socketServe = [super allocWithZone:zone];
             return socketServe;
         }
     }
     return nil;
 }

 -(void)startConnetSocket{
     self.socket = [[AsyncSocket alloc]initWithDelegate:self];
     [self.socket setRunLoopModes:@[NSRunLoopCommonModes]];
     if (![self SocketOpen:HOST port:PORT]) {

     }
 }

 -(NSInteger)SocketOpen:(NSString *)addr port:(NSInteger)port{
     if (!([self.socket isConnected])) {
         NSError *error = nil;
         [self.socket connectToHost:addr onPort:port withTimeout:TIME_OUT error:&error];
     }
     return ;
 }

 //发送消息
 -(void)sendMessage:(id)message{
     //向服务器发送数据
     NSData *cmdData = [message dataUsingEncoding:NSUTF8StringEncoding];
     [self.socket writeData:cmdData withTimeout:WRITW_TIME_OUT tag:];
 }

 #pragma mark - AsyncSocket代理
 -(void)onSocket:(AsyncSocket *)sock didConnectToHost:(NSString *)host port:(UInt16)port{
     NSLog(@"这是异步返回的连接成功");

     //通过定时器不断的发送消息，来检测长连接
     self.heartTimer = [NSTimer scheduledTimerWithTimeInterval: target:self selector:@selector(checkLongConnectByServe) userInfo:nil repeats:YES];
     [self.heartTimer fire];
 }

 //心跳连接
 -(void)checkLongConnectByServe{
     //向服务器发送固定的消息，来检测长连接
     NSString *longConnect = @"connect is here";
     NSData *data = [longConnect dataUsingEncoding:NSUTF8StringEncoding];
     [self.socket writeData:data withTimeout: tag:];
 }

 //断开连接
 //1.用户手动断开连接
 -(void)cutOffSocket{
     self.socket.userData = SocketOfflineByUser;
     //cutOffSocket 是用户断开连接之后，不在尝试重新连接
     [self.socket disconnect];
 }

 //2.wifi断开，socket断开连接
 -(void)onSocket:(AsyncSocket *)sock willDisconnectWithError:(NSError *)err{

     NSData * unreadData = [sock unreadData]; // ** This gets the current buffer
     if(unreadData.length > ) {
 //        socket出错会回调onSocket:willDisconnectWithError:方法，可以通过unreadData来读取未来得及读取的buffer。
         [self onSocket:sock didReadData:unreadData withTag:];

     } else {

         //wifi断开之后，会回调onSocket:willDisconnectWithError:方法，err.code == 57,这个时候设置self.socket.userData = SocketOfflineByWifiCut
         NSLog(@" willDisconnectWithError %ld   err = %@",sock.userData,[err description]);
         if (err.code == ) {
             self.socket.userData = SocketOfflineByWifiCut;
         }

     }

 }

 //重新连接
 //socket断开之后会回调  在onSocketDidDisconnect回调方法里面，会根据self.socket.userData来判断是否需要重新连接。
 -(void)onSocketDidDisconnect:(AsyncSocket *)sock{
     NSLog(@"%ld",sock.userData);
     if (sock.userData == SocketOfflineByServer) {
         //服务器掉线，重连
         [self startConnetSocket];
     }
     else if (sock.userData == SocketOfflineByUser){
         //如果由用户断开，不进行重连
         return;
     }
     else if (sock.userData == SocketOfflineByWifiCut){
         //wifi断开，不进行重连
         return;
     }
 }

 //发送消息成功之后回调
 -(void)onSocket:(AsyncSocket *)sock didWriteDataWithTag:(long)tag{
     //发送消息成功之后会调用onSocket:didWriteDataWithTag:,在这个方法里可以进行读取消息。
     //读取消息
     [self.socket readDataWithTimeout:- buffer:nil bufferOffset: maxLength:MAX_BUFFER tag:];
 }

 //接受消息成功之后回调
 -(void)onSocket:(AsyncSocket *)sock didReadData:(NSData *)data withTag:(long)tag{
     //服务端返回消息数据量比较大时，可能分多次返回。所以在读取消息的时候，设置MAX_BUFFER表示每次最多读取多少，当data.length < MAX_BUFFER我们认为有可能是接受完一个完整的消息，然后才解析

     if (data.length < MAX_BUFFER) {
         //收到结果解析
         NSDictionary *dic = [NSJSONSerialization JSONObjectWithData:data options:NSJSONReadingMutableLeaves error:nil];
         NSLog(@"%@",dic);
         //解析出来的消息，可以通过通知，代理，block等传递出去

     }

     [self.socket readDataWithTimeout:READ_TIME_OUT buffer:nil bufferOffset: maxLength:MAX_BUFFER tag:];

 }

 - (void)onSocket:(AsyncSocket *)sock didAcceptNewSocket:(AsyncSocket *)newSocket
 {
     NSLog(@"didAcceptNewSocket");
 }

 @end

封装好之后，使用：

导入：#import "DLSocketServe.h"

 DLSocketServe *socketServe = [DLSocketServe sharedSocketServe];
 //socket连接前先断开连接以免之前socket连接没有断开导致闪退
 [socketServe cutOffSocket];
 socketServe.socket.userData = SocketOfflineByServer;
 [socketServe startConnectSocket];

 //发送消息 @"hahaha"只是举个列子，具体根据服务端的消息格式
 [socketServe sendMessage:@"hahaha"];