前言

关于我和WebSocket的缘:我从大二在计算机网络课上听老师讲过之后,第一次使用就到了毕业之后的第一份工作。直到最近换了工作,到了一家是含有IM社交聊天功能的app的时候,我觉得我现在可以谈谈我对WebSocket/Socket的一些看法了。要想做IM聊天app,就不得不理解WebSocket和Socket的原理了,听我一一道来。

目录

1.WebSocket使用场景

2.WebSocket诞生由来

3.谈谈WebSocket协议原理

4.WebSocket 和 Socket的区别与联系

5.iOS平台有哪些WebSocket和Socket的开源框架

6.iOS平台如何实现WebSocket协议

一.WebSocket的使用场景

1.社交聊天

最著名的就是微信,QQ,这一类社交聊天的app。这一类聊天app的特点是低延迟,高即时。即时是这里面要求最高的,如果有一个紧急的事情,通过IM软件通知你,假设网络环境良好的情况下,这条message还无法立即送达到你的客户端上,紧急的事情都结束了,你才收到消息,那么这个软件肯定是失败的。

2.弹幕

说到这里,大家一定里面想到了A站和B站了。确实,他们的弹幕一直是一种特色。而且弹幕对于一个视频来说,很可能弹幕才是精华。发弹幕需要实时显示,也需要和聊天一样,需要即时。

3.多玩家游戏

4.协同编辑

现在很多开源项目都是分散在世界各地的开发者一起协同开发,此时就会用到版本控制系统,比如Git,SVN去合并冲突。但是如果有一份文档,支持多人实时在线协同编辑,那么此时就会用到比如WebSocket了,它可以保证各个编辑者都在编辑同一个文档,此时不需要用到Git,SVN这些版本控制,因为在协同编辑界面就会实时看到对方编辑了什么,谁在修改哪些段落和文字。

5.股票基金实时报价

金融界瞬息万变——几乎是每毫秒都在变化。如果采用的网络架构无法满足实时性,那么就会给客户带来巨大的损失。几毫秒钱股票开始大跌,几秒以后才刷新数据,一秒钟的时间内,很可能用户就已经损失巨大财产了。

6.体育实况更新

全世界的球迷,体育爱好者特别多,当然大家在关心自己喜欢的体育活动的时候,比赛实时的赛况是他们最最关心的事情。这类新闻中最好的体验就是利用Websocket达到实时的更新!

7.视频会议/聊天

视频会议并不能代替和真人相见,但是他能让分布在全球天涯海角的人聚在电脑前一起开会。既能节省大家聚在一起路上花费的时间,讨论聚会地点的纠结,还能随时随地,只要有网络就可以开会。

8.基于位置的应用

越来越多的开发者借用移动设备的GPS功能来实现他们基于位置的网络应用。如果你一直记录用户的位置(比如运行应用来记录运动轨迹),你可以收集到更加细致化的数据。

9.在线教育

在线教育近几年也发展迅速。优点很多,免去了场地的限制,能让名师的资源合理的分配给全国各地想要学习知识的同学手上,Websocket是个不错的选择,可以视频聊天、即时聊天以及其与别人合作一起在网上讨论问题...

10.智能家居

这也是我一毕业加入的一个伟大的物联网智能家居的公司。考虑到家里的智能设备的状态必须需要实时的展现在手机app客户端上,毫无疑问选择了Websocket。

11.总结

从上面我列举的这些场景来看,一个共同点就是,高实时性!

二.WebSocket诞生由来

1.最开始的轮询Polling阶段

这种方式下,是不适合获取实时信息的,客户端和服务器之间会一直进行连接,每隔一段时间就询问一次。客户端会轮询,有没有新消息。这种方式连接数会很多,一个接受,一个发送。而且每次发送请求都会有Http的Header,会很耗流量,也会消耗CPU的利用率。

2.改进版的长轮询Long polling阶段

长轮询是对轮询的改进版,客户端发送HTTP给服务器之后,有没有新消息,如果没有新消息,就一直等待。当有新消息的时候,才会返回给客户端。在某种程度上减小了网络带宽和CPU利用率等问题。但是这种方式还是有一种弊端:例如假设服务器端的数据更新速度很快,服务器在传送一个数据包给客户端后必须等待客户端的下一个Get请求到来,才能传递第二个更新的数据包给客户端,那么这样的话,客户端显示实时数据最快的时间为2×RTT(往返时间),而且如果在网络拥塞的情况下,这个时间用户是不能接受的,比如在股市的的报价上。另外,由于http数据包的头部数据量往往很大(通常有400多个字节),但是真正被服务器需要的数据却很少(有时只有10个字节左右),这样的数据包在网络上周期性的传输,难免对网络带宽是一种浪费。

3.WebSocket诞生

现在急需的需求是能支持客户端和服务器端的双向通信,而且协议的头部又没有HTTP的Header那么大,于是,Websocket就诞生了!

上图就是Websocket和Polling的区别,从图中可以看到Polling里面客户端发送了好多Request,而下图,只有一个Upgrade,非常简洁高效。至于消耗方面的比较就要看下图了

上图中,我们先看蓝色的柱状图,是Polling轮询消耗的流量,

Use case A: 1,000 clients polling every second: Network throughput is (871 x 1,000) = 871,000 bytes = 6,968,000 bits per second (6.6 Mbps)

Use case B: 10,000 clients polling every second: Network throughput is (871 x 10,000) = 8,710,000 bytes = 69,680,000 bits per second (66 Mbps)

Use case C: 100,000 clients polling every 1 second: Network throughput is (871 x 100,000) = 87,100,000 bytes = 696,800,000 bits per second (665 Mbps)

而Websocket的Frame是 just two bytes of overhead instead of 871,仅仅用2个字节就代替了轮询的871字节!

Use case A: 1,000 clients receive 1 message per second: Network throughput is (2 x 1,000) = 2,000 bytes = 16,000 bits per second (0.015 Mbps)

Use case B: 10,000 clients receive 1 message per second: Network throughput is (2 x 10,000) = 20,000 bytes = 160,000 bits per second (0.153 Mbps)

Use case C: 100,000 clients receive 1 message per second: Network throughput is (2 x 100,000) = 200,000 bytes = 1,600,000 bits per second (1.526 Mbps)

相同的每秒客户端轮询的次数,当次数高达10W/s的高频率次数的时候,Polling轮询需要消耗665Mbps,而Websocket仅仅只花费了1.526Mbps,将近435倍!!

三.谈谈WebSocket协议原理

Websocket是应用层第七层上的一个应用层协议,它必须依赖HTTP 协议进行一次握手 ,握手成功后,数据就直接从 TCP 通道传输,与 HTTP 无关了。

Websocket的数据传输是frame形式传输的,比如会将一条消息分为几个frame,按照先后顺序传输出去。这样做会有几个好处:

1)大数据的传输可以分片传输,不用考虑到数据大小导致的长度标志位不足够的情况。

2)和http的chunk一样,可以边生成数据边传递消息,即提高传输效率。

四.WebSocket 和 Socket的区别与联系

首先,Socket 其实并不是一个协议。它工作在 OSI 模型会话层(第5层),是为了方便大家直接使用更底层协议(一般是 TCP 或 UDP )而存在的一个抽象层。Socket是对TCP/IP协议的封装,Socket本身并不是协议,而是一个调用接口(API)。

Socket通常也称作”套接字”,用于描述IP地址和端口,是一个通信链的句柄。网络上的两个程序通过一个双向的通讯连接实现数据的交换,这个双向链路的一端称为一个Socket,一个Socket由一个IP地址和一个端口号唯一确定。应用程序通常通过”套接字”向网络发出请求或者应答网络请求。

Socket在通讯过程中,服务端监听某个端口是否有连接请求,客户端向服务端发送连接请求,服务端收到连接请求向客户端发出接收消息,这样一个连接就建立起来了。客户端和服务端也都可以相互发送消息与对方进行通讯,直到双方连接断开。

所以基于WebSocket和基于Socket都可以开发出IM社交聊天类的app

五.iOS平台有哪些WebSocket和Socket的开源框架

Socket开源框架有:CocoaAsyncSocketsocketio/socket.io-client-swift

WebSocket开源框架有:facebook/SocketRockettidwall/SwiftWebSocket

六.iOS平台如何实现WebSocket协议

Talk is cheap。Show me the code ——Linus Torvalds

我们今天来看看facebook/SocketRocket的实现方法

首先这是SRWebSocket定义的一些成员变量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@property (nonatomic, weak) id  delegate;
/**
 A dispatch queue for scheduling the delegate calls. The queue doesn't need be a serial queue.
 If `nil` and `delegateOperationQueue` is `nil`, the socket uses main queue for performing all delegate method calls.
 */
@property (nonatomic, strong) dispatch_queue_t delegateDispatchQueue;
/**
 An operation queue for scheduling the delegate calls.
 If `nil` and `delegateOperationQueue` is `nil`, the socket uses main queue for performing all delegate method calls.
 */
@property (nonatomic, strong) NSOperationQueue *delegateOperationQueue;
@property (nonatomic, readonly) SRReadyState readyState;
@property (nonatomic, readonly, retain) NSURL *url;
@property (nonatomic, readonly) CFHTTPMessageRef receivedHTTPHeaders;
// Optional array of cookies (NSHTTPCookie objects) to apply to the connections
@property (nonatomic, copy) NSArray *requestCookies;
// This returns the negotiated protocol.
// It will be nil until after the handshake completes.
@property (nonatomic, readonly, copy) NSString *protocol;

下面这些是SRWebSocket的一些方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// Protocols should be an array of strings that turn into Sec-WebSocket-Protocol.
- (instancetype)initWithURLRequest:(NSURLRequest *)request;
- (instancetype)initWithURLRequest:(NSURLRequest *)request protocols:(NSArray *)protocols;
- (instancetype)initWithURLRequest:(NSURLRequest *)request protocols:(NSArray *)protocols allowsUntrustedSSLCertificates:(BOOL)allowsUntrustedSSLCertificates;
// Some helper constructors.
- (instancetype)initWithURL:(NSURL *)url;
- (instancetype)initWithURL:(NSURL *)url protocols:(NSArray *)protocols;
- (instancetype)initWithURL:(NSURL *)url protocols:(NSArray *)protocols allowsUntrustedSSLCertificates:(BOOL)allowsUntrustedSSLCertificates;
// By default, it will schedule itself on +[NSRunLoop SR_networkRunLoop] using defaultModes.
- (void)scheduleInRunLoop:(NSRunLoop *)aRunLoop forMode:(NSString *)mode;
- (void)unscheduleFromRunLoop:(NSRunLoop *)aRunLoop forMode:(NSString *)mode;
// SRWebSockets are intended for one-time-use only.  Open should be called once and only once.
- (void)open;
- (void)close;
- (void)closeWithCode:(NSInteger)code reason:(NSString *)reason;
///--------------------------------------
#pragma mark Send
///--------------------------------------
//下面是4个发送的方法
/**
 Send a UTF-8 string or binary data to the server.
 @param message UTF-8 String or Data to send.
 @deprecated Please use `sendString:` or `sendData` instead.
 */
- (void)send:(id)message __attribute__((deprecated("Please use `sendString:` or `sendData` instead.")));
- (void)sendString:(NSString *)string;
- (void)sendData:(NSData *)data;
- (void)sendPing:(NSData *)data;
@end

对应5种状态的代理方法

1
2
3
4
5
6
7
8
9
10
11
12
///--------------------------------------
#pragma mark - SRWebSocketDelegate
///--------------------------------------
@protocol SRWebSocketDelegate - (void)webSocket:(SRWebSocket *)webSocket didReceiveMessage:(id)message;
@optional
- (void)webSocketDidOpen:(SRWebSocket *)webSocket;
- (void)webSocket:(SRWebSocket *)webSocket didFailWithError:(NSError *)error;
- (void)webSocket:(SRWebSocket *)webSocket didCloseWithCode:(NSInteger)code reason:(NSString *)reason wasClean:(BOOL)wasClean;
- (void)webSocket:(SRWebSocket *)webSocket didReceivePong:(NSData *)pongPayload;
// Return YES to convert messages sent as Text to an NSString. Return NO to skip NSData -> NSString conversion for Text messages. Defaults to YES.
- (BOOL)webSocketShouldConvertTextFrameToString:(SRWebSocket *)webSocket;
@end

didReceiveMessage方法是必须实现的,用来接收消息的。

下面4个did方法分别对应着Open,Fail,Close,ReceivePong不同状态的代理方法

方法就上面这些了,我们实际来看看代码怎么写

先是初始化Websocket连接,注意此处ws://或者wss://连接有且最多只能有一个,这个是Websocket协议规定的

1
2
3
4
self.ws = [[SRWebSocket alloc] initWithURLRequest:[NSURLRequest requestWithURL:[NSURL URLWithString:[NSString 
stringWithFormat:@"%@://%@:%zd/ws", serverProto, serverIP, serverPort]]]];
    self.ws.delegate = delegate;
    [self.ws open];

发送消息

1
[self.ws send:message];

接收消息以及其他3个代理方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//这个就是接受消息的代理方法了,这里接受服务器返回的数据,方法里面就应该写处理数据,存储数据的方法了。
- (void)webSocket:(SRWebSocket *)webSocket didReceiveMessage:(id)message
{
    NSDictionary *data = [NetworkUtils decodeData:message];
    if (!data)
        return;
}
//这里是Websocket刚刚Open之后的代理方法。就想微信刚刚连接中,会显示连接中,当连接上了,就不显示连接中了,取消显示连接的方法就应该写在这里面
- (void)webSocketDidOpen:(SRWebSocket *)webSocket
{
    // Open = silent ping
    [self.ws receivedPing];
}
//这是关闭Websocket的代理方法
- (void)webSocket:(SRWebSocket *)webSocket didCloseWithCode:(NSInteger)code reason:(NSString *)reason wasClean:(BOOL)wasClean
{
    [self failedConnection:NSLS(Disconnected)];
}
//这里是连接Websocket失败的方法,这里面一般都会写重连的方法
- (void)webSocket:(SRWebSocket *)webSocket didFailWithError:(NSError *)error
{
    [self failedConnection:NSLS(Disconnected)];
}

最后

以上就是我想分享的一些关于Websocket的心得,文中如果有错误的地方,欢迎大家指点!一般没有微信QQ那么大用户量的app,用Websocket应该都可以完成IM社交聊天的任务。当用户达到亿级别,应该还有很多需要优化,优化性能各种的吧。

最后,微信和QQ的实现方法也许并不是只用Websocket和Socket这么简单,也许是他们自己开发的一套能支持这么大用户,大数据的,各方面也都优化都最优的方法。如果有开发和微信和QQ的大神看到这篇文章,可以留言说说看你们用什么方式实现的,也可以和我们一起分享,我们一起学习!我先谢谢大神们的指点了!

1,Android 客户端使用需要配置网络权限;

2,需要写一个自己的client类来继承WebsocketClient;实现websocket的状态回调和新消息的解析动作;

3,需要监控自己的client的链接状态,维持长链接;

4,发送和接收

下面贴出部分相关代码;

网络权限的不用说了吧!

client类:

常用状态回调方法有4个;

自己可以在对应的函数里面做响应的处理,比如当链接发生错误时要重新去打开该链接,收到消息时即时的保存聊天记录和发送系统通知来提醒用户查看新消息等等;

  1. <pre name="code" class="html"><span style="font-size:18px;">public class TestClient extends WebSocketClient {
  2. public TestClient(URI serverURI) {
  3. super(serverURI);
  4. }
  5. /***
  6. * 链接关闭
  7. */
  8. @Override
  9. public void onClose(int arg0, String arg1, boolean arg2) {
  10. }
  11. /***
  12. * 链接发生错误
  13. */
  14. @Override
  15. public void onError(Exception arg0) {
  16. }
  17. /**
  18. * 新消息
  19. */
  20. @Override
  21. public void onMessage(String arg0) {
  22. }
  23. /***
  24. * 链接打开
  25. */
  26. @Override
  27. public void onOpen(ServerHandshake arg0) {
  28. // TODO Auto-generated method stub
  29. }
  30. }
  31. </span>

下面是我聊天部分代码,有离线消息/PC同步/多对多的聊天;

仅供参考;

  1. /***
  2. * <h2>WebSocket Android 客户端</h2>
  3. * <ol>
  4. * <li>Socket链接打开回调 {@link WebSocket#onOpen(ServerHandshake)},此处有
  5. * {@link SocketConstant#ON_OPEN} 广播发出;
  6. * <li>Socket链接出现异常错误时回调 {@link WebSocket#onError(Exception)},此处有
  7. * {@link SocketConstant#ON_ERROR}广播发出;
  8. * <li>Socket链接关闭回调 {@link WebSocket #onClose(int, String, boolean)},此处有
  9. * {@link SocketConstant#ON_CLOSES}广播发出;
  10. * <li>Socket链接接收消息回调 {@link WebSocket#onMessage(String)}
  11. * ,此处做收消息的逻辑的处理;包括发送消息服务器返回的发送结果,PC端同步接收的新消息,及外来的新消息;
  12. * <li>检测是否有消息遗漏 {@link WebSocket#checkMsgWebId(String, String)},参数为联系人和webId;
  13. * <li>取得正在桌面运行的activity的名称 {@link WebSocket#getRunningActivityName()}
  14. * <li>接收到的消息的处理 {@link WebSocket#messageHandle(MessageEntity, String)}
  15. * ,参数为消息实体和消息类型 (buyer/server)
  16. * <li>发送新消息的系统通知 {@link WebSocket#sendNotification(String)},参数为联系人;
  17. * <li>保存离线消息 {@link WebSocket#saveOffLineMsg(HashMap)},参数为接收到的离线消息集合;
  18. * <li>保存从服务端获取的联系人的webId {@link WebSocket#saveContactsWebID(HashMap)}
  19. * ,参数为以联系人为key以最大webId为值得map集合;
  20. * </ol>
  21. *
  22. * @author li'mingqi <a> 2014-3-19</a>
  23. *
  24. */
  25. public class WebSocket extends WebSocketClient {
  26. // 登陆返回的back_type字段
  27. public static final String LOGIN_RETURN_TYPE = "login";
  28. // 发送信息的back_type字段
  29. public static final String SEND_RETURN_TYPE = "send_result";
  30. // 接收信息的back_type字段
  31. public static final String RECEIVER_RETURN_TYPE = "msg";
  32. // 接收客服的信息的back_type字段
  33. public static final String GET_SERVER_RETURN_TYPE = "server_info";
  34. // 接收服务端返回对应联系人的最大顺序ID
  35. public static final String CONTACTS_MAX_WEBID_TYPE = "max_id_return";
  36. // 接收用户的离线消息
  37. public static final String USER_OFFLINE_MSG_TYPE = "offline";
  38. // 上下文对象
  39. private Context mContext;
  40. // socket返回json解析类对象
  41. private WebSocketParser mParser;
  42. // 系统通知管理
  43. public NotificationManager mNotificationManager;
  44. // 系统通知
  45. private Notification mNoti;
  46. // 意图
  47. private PendingIntent mIntent;
  48. // 该系统通知的 id
  49. public static final int NOTIFICATION_ID = 100;
  50. @SuppressWarnings("deprecation")
  51. public SGWebSocket(Context context, URI serverUri, Draft draft) {
  52. super(serverUri, draft);
  53. this.mContext = context;
  54. //新消息的解析类
  55. this.mParser = WebSocketParser.getInstance();
  56. //收到新消息发送的通知
  57. this.mNotificationManager = (NotificationManager) this.mContext
  58. .getSystemService(Context.NOTIFICATION_SERVICE);
  59. this.mNoti = new Notification(R.drawable.system_info, "您有新消息!",
  60. System.currentTimeMillis());
  61. }
  62. /***
  63. * send broadcast <SGSocketConstant>ON_CLOSES filter if this socket closed
  64. * socket 发生关闭时发送的广播,若想提示,可以接受并处理
  65. *
  66. */
  67. @Override
  68. public void onClose(int arg0, String arg1, boolean arg2) {
  69. // 更改保存的链接状态
  70. UserInfoUtil.saveSocket(mContext, false);
  71. mNotificationManager.cancelAll();
  72. Intent intent = new Intent(SocketConstant.ON_CLOSES);
  73. intent.putExtra(SocketConstant.ON_CLOSES, arg1.toString());
  74. mContext.sendBroadcast(intent);
  75. }
  76. /***
  77. * send broadcast <SGSocketConstant>ON_ERROR filter if this socket has error
  78. * socket 发生错误发送的广播,若想提示,可以接受并处理
  79. *
  80. */
  81. @Override
  82. public void onError(Exception arg0) {
  83. Intent intent = new Intent(SGSocketConstant.ON_ERROR);
  84. intent.putExtra(SGSocketConstant.ON_ERROR, arg0.toString());
  85. mContext.sendBroadcast(intent);
  86. this.close();
  87. }
  88. // 买家
  89. public static final String MSG_BUYER_TYPE = "1";
  90. // 客服
  91. public static final String MSG_SERVCER_TYPE = "2";
  92. // 游客
  93. // public static final String MSG_RANDOM_TYPE = "3";
  94. /***
  95. * receiver message from server 1,登陆返回 type
  96. * <WebSocket>LOGIN_RETURN_TYPE; 2,发送返回 type
  97. * <WebSocket>SEND_RETURN_TYPE; 3,接收信息返回 type
  98. * <WebSocket>RECEIVER_RETURN_TYPE;
  99. *
  100. * @throws InterruptedException
  101. */
  102. @Override
  103. public void onMessage(String content) {
  104. // parser
  105. try {
  106. JSONObject object = new JSONObject(content);
  107. Log.i("json", "卖家--" + object.toString());
  108. String back_type = object.getString("back_type");
  109. String activity = getRunningActivityName();
  110. if (SEND_RETURN_TYPE.equals(back_type)) {// 发送具体消息时返回发送结果
  111. // json解析
  112. MessageEntity entity = mParser.sendMessageParser(mContext,
  113. content);
  114. if ("true".equals(entity.getSend_state())) {// 发送成功
  115. // 判断是否是PC端发送的消息,若是PC端发送的消息,则在Android端做同步存储处理
  116. // 1,首先判断数据库中是否包含该条信息
  117. boolean has = MessageDB.getInstance(mContext)
  118. .findMessageByMsgId(entity.get_id());
  119. if (has) {
  120. // Android端发送
  121. MessageDB.getInstance(mContext).update(entity.get_id(),
  122. true, entity.getReceiverTime(),
  123. entity.getWebId());// 更新发送状态为已发送
  124. } else {
  125. // PC端发送,将该消息同步到Android端数据库
  126. entity.setSend_state(SocketConstant.MSG_SEND_SUCCESS_STATE);
  127. MessageDB.getInstance(mContext).insert(entity,
  128. SocketConstant.MSG_TYPE_BUYER);// 卖家发送给买家的
  129. // 通知聊天主页面,更新聊天列表
  130. pcSynAndroid(activity);
  131. }
  132. // 检测是否有消息遗漏
  133. checkMsgWebId(entity.getContacts(), entity.getWebId());
  134. Log.i("miss", "发送返回或者PC同步--" + entity.getContacts() + "--"
  135. + entity.getWebId());
  136. } else if ("false".equals(entity.getSend_state())) {// 发送失败
  137. MessageDB.getInstance(mContext).update(entity.get_id(),
  138. false, entity.getReceiverTime(), entity.getWebId());
  139. Toast.makeText(mContext, entity.getErrorText(),
  140. Toast.LENGTH_SHORT).show();
  141. }
  142. // 登陆返回 记录session
  143. } else if (LOGIN_RETURN_TYPE.equals(back_type)) {
  144. KApplication.session = object.getString("session_id");
  145. String str = object.getString("login_status");
  146. if ("true".equals(str)) {
  147. UserInfoUtil.saveSocket(mContext, true);
  148. // 生成json请求字符串
  149. String maxIdstring = SocketJsonUtil
  150. .getContactsCurrentWebId(UserInfoUtil
  151. .getUser(mContext)[0], "2", MessageDB
  152. .getInstance(mContext)
  153. .findAllContactsAndType());
  154. // 登陆成功,向服务器索取联系人的最大webId
  155. send(maxIdstring);
  156. Log.i("send", maxIdstring);
  157. } else if ("false".equals(str)) {
  158. UserInfoUtil.saveSocket(mContext, false);
  159. }
  160. } else if (RECEIVER_RETURN_TYPE.equals(back_type)) {// 接收到的具体聊天的信息
  161. // json解析
  162. MessageEntity entity = mParser.receiverMessagePrser(mContext,
  163. content);
  164. // 判断数据库中是否有该条消息,有则不处理,无则处理消息;
  165. if (!MessageDB.getInstance(mContext).findMessageByMsgId(
  166. entity.get_id())) {
  167. // 消息处理
  168. if (MSG_BUYER_TYPE.equals(entity.getSenderType())) {
  169. // 买家
  170. messageHandle(entity, SocketConstant.MSG_TYPE_BUYER);
  171. } else if (MSG_SERVCER_TYPE.equals(entity.getSenderType())) {
  172. // 卖家,客服
  173. messageHandle(entity, SocketConstant.MSG_TYPE_SERVER);
  174. }
  175. Log.i("miss", "没有该条消息");
  176. // 检测是否有消息遗漏
  177. checkMsgWebId(entity.getContacts(), entity.getWebId());
  178. }
  179. } else if (GET_SERVER_RETURN_TYPE.equals(back_type)) {// 获取闪聊客服返回的数据
  180. // 客服
  181. ServerEntity entity = mParser.serverInfoParser(content);// 客服对象
  182. Intent intent = new Intent(SocketConstant.GET_SERVER_INFO);
  183. intent.putExtra("server_info", entity);
  184. mContext.sendBroadcast(intent);
  185. } else if (CONTACTS_MAX_WEBID_TYPE.equals(back_type)) {
  186. // 返回的联系人最大的消息id
  187. HashMap<String, String> map = mParser.contactsMaxWebId(content);
  188. // 将联系人和其最大webId存入临时集合
  189. saveContactsWebID(map);
  190. // 开始请求服务器,释放离线消息给客户端;
  191. send(SocketJsonUtil.getOffLine(
  192. UserInfoUtil.getUser(mContext)[0], "2"));
  193. Log.i("send",
  194. SocketJsonUtil.getOffLine(
  195. UserInfoUtil.getUser(mContext)[0], "2"));
  196. } else if (USER_OFFLINE_MSG_TYPE.equals(back_type)) {
  197. // 用户的离线消息
  198. HashMap<String, ArrayList<MessageEntity>> map = mParser
  199. .offLineMsg(mContext, content);
  200. // 将离线消息入库
  201. saveOffLineMsg(map);
  202. }
  203. } catch (JSONException e) {
  204. this.close();
  205. }
  206. }
  207. /***
  208. * send broadcast <SocketConstant>ON_OPEN filter if this socket opened
  209. * socket 打开时发送的广播,若想提示,可以接受并处理
  210. *
  211. */
  212. @Override
  213. public void onOpen(ServerHandshake arg0) {
  214. Intent intent = new Intent(SGSocketConstant.ON_OPEN);
  215. mContext.sendBroadcast(intent);
  216. }
  217. /***
  218. * 检测正在运行tasktop的activity
  219. * @return current running activity name
  220. *
  221. */
  222. private String getRunningActivityName() {
  223. ActivityManager activityManager = (ActivityManager) mContext
  224. .getSystemService(Context.ACTIVITY_SERVICE);
  225. String runningActivity = activityManager.getRunningTasks(1).get(0).topActivity
  226. .getClassName();
  227. return runningActivity;
  228. }
  229. /***
  230. * send notification for this contacts
  231. * 发送通知
  232. * @param contacts
  233. *
  234. */
  235. @SuppressWarnings("deprecation")
  236. private void sendNotification(String contacts) {
  237. Intent intent = new Intent(mContext, MainActivity.class);
  238. mIntent = PendingIntent.getActivity(mContext, 100, intent, 0);
  239. mNoti.flags = Notification.FLAG_AUTO_CANCEL;
  240. mNoti.defaults = Notification.DEFAULT_VIBRATE;
  241. mNoti.setLatestEventInfo(mContext, "标题", "您有新消息!", mIntent);
  242. mNoti.contentView = new RemoteViews(mContext.getApplicationContext()
  243. .getPackageName(), R.layout.notification_item);
  244. mNoti.contentView.setTextViewText(R.id.noti_message, "收到来自" + contacts
  245. + "的新消息");
  246. mNotificationManager.notify(NOTIFICATION_ID, mNoti);
  247. }
  248. /***
  249. * 具体聊天收到的外来消息处理
  250. *
  251. * @param entity
  252. *            消息实体
  253. * @param messageType
  254. *            消息类型(买家/客服)
  255. */
  256. private void messageHandle(MessageEntity entity, String messageType) {
  257. String activity = getRunningActivityName();
  258. // 处于聊天的页面
  259. if ("com.ui.activity.ManageChartActivity".equals(activity)) {
  260. // 处于正在聊天对象的页面,将数据写入数据库,并发送广播更新页面数据
  261. if (KApplication.crurentContacts.equals(entity.getContacts())) {
  262. /**
  263. * 接收到的消息,消息实体entity的send_state字段状态设置为
  264. * MSG_SEND_SUCCESS_STATE(即201)
  265. **/
  266. entity.setSend_state(SocketConstant.MSG_SEND_SUCCESS_STATE);// 收到的信息,设置信息的状态
  267. entity.setRead(SocketConstant.READ_STATE);
  268. MessageDB.getInstance(mContext).insert(entity, messageType);// 将数据写入数据库,
  269. Intent intent = new Intent(SocketConstant.NEW_MESSAGE);
  270. intent.putExtra("newmsg", entity);
  271. mContext.sendBroadcast(intent);
  272. // 没有处于闪聊对象的页面,将数据写入数据库,发送系统通知
  273. } else {
  274. entity.setSend_state(SocketConstant.MSG_SEND_SUCCESS_STATE);// 收到的信息,设置信息的状态
  275. entity.setRead(SocketConstant.DEFAULT_READ_STATE);
  276. MessageDB.getInstance(mContext).insert(entity, messageType);
  277. if (KApplication.sp.getBoolean(RefreshUtils.noteFlag, false)) {
  278. sendNotification(entity.getContacts());
  279. }
  280. Intent intent = new Intent(
  281. SocketConstant.RECEIVER_NEW_MESSAGE);
  282. mContext.sendBroadcast(intent);
  283. }
  284. // 将数据写入数据库,发送系统通知
  285. } else {
  286. entity.setSend_state(SocketConstant.MSG_SEND_SUCCESS_STATE);// 收到的信息,设置信息的状态
  287. entity.setRead(SocketConstant.DEFAULT_READ_STATE);
  288. MessageDB.getInstance(mContext).insert(entity, messageType);
  289. Intent intent = new Intent();
  290. if ("com.ui.activity.ManageConversationActivity"
  291. .equals(activity)
  292. || "com.ui.activity.MainActivity"
  293. .equals(activity)) {
  294. intent.setAction(SocketConstant.RECEIVER_NEW_MESSAGE);// 聊天页面
  295. } else {
  296. intent.setAction(SocketConstant.RECEIVER_NEW_MESSAGE_OTHER);// 其他页面
  297. }
  298. mContext.sendBroadcast(intent);
  299. if (KApplication.sp.getBoolean(RefreshUtils.noteFlag, false)) {
  300. sendNotification(entity.getContacts());
  301. }
  302. }
  303. }
  304. /***
  305. * 电脑与手机同步信息
  306. *
  307. * @param currentActivity
  308. */
  309. public void pcSynAndroid(String currentActivity) {
  310. if ("com.iflashseller.ui.activity.ManageChartActivity"
  311. .equals(currentActivity)) {
  312. // 正好与该联系人对话的页面
  313. Intent intent = new Intent(SocketConstant.CHART_ACTIVITY);
  314. mContext.sendBroadcast(intent);
  315. } else {
  316. // 其他页面
  317. Intent intent = new Intent(SocketConstant.GROUPS_ACTIVITY);
  318. mContext.sendBroadcast(intent);
  319. }
  320. }
  321. /***
  322. * 检测是否有消息遗漏
  323. *
  324. * @param contacts
  325. *            联系人
  326. * @param webId
  327. *            服务端给出的消息Id
  328. */
  329. public void checkMsgWebId(String contacts, int webId) {
  330. // 集合中含有该联系人
  331. if (KApplication.webIds.containsKey(contacts)) {
  332. Log.i("miss", "保存的--" + KApplication.webIds.get(contacts));
  333. // 临时集合中保存的webId
  334. int c = KApplication.webIds.get(contacts);
  335. /***
  336. * 如果新收到的消息的webId大于临时集合中保存的改联系人的webId,且他们之间的差值大于1,
  337. * 则请求服务器推送疑似丢失的webId对应的消息
  338. */
  339. if (webId > c && (webId - 1) != c) {
  340. // id不连续
  341. for (int i = c + 1; i < webId; i++) {
  342. // 向服务器发送请求,获取遗漏的消息
  343. String miss = SocketJsonUtil.getMissMsg(
  344. UserInfoUtil.getUser(mContext)[0], "2", contacts,
  345. "1", i + "");
  346. this.send(miss);
  347. Log.i("miss", miss);
  348. }
  349. /***
  350. * 如果他们之间的差值正好为1,则修改临时集合的改联系人的webId,
  351. */
  352. } else if (webId > c && (webId - 1) == c) {
  353. KApplication.webIds.put(contacts, webId);
  354. Log.i("miss", "修改的--" + contacts + "--" + webId);
  355. }
  356. /****
  357. * 临时集合中没有改联系人的信息,则将该联系人的webId存入临时集合.
  358. */
  359. } else {
  360. KApplication.webIds.put(contacts, webId);
  361. Log.i("miss", "新增--" + contacts + "--" + webId);
  362. }
  363. }
  364. /***
  365. * 将从服务端获取的联系人的webId存入临时集合
  366. *
  367. * @param map
  368. */
  369. public void saveContactsWebID(HashMap<String, String> map) {
  370. Iterator<Entry<String, String>> iter = map.entrySet().iterator();
  371. while (iter.hasNext()) {
  372. Entry<String, String> es = iter.next();
  373. String contacts = es.getKey();
  374. String maxWebID = es.getValue();
  375. KApplication.webIds.put(contacts, Integer.parseInt(maxWebID));
  376. }
  377. }
  378. /***
  379. * 将离线消息入库
  380. *
  381. * @param map
  382. */
  383. public void saveOffLineMsg(HashMap<String, ArrayList<MessageEntity>> map) {
  384. Iterator<Entry<String, ArrayList<MessageEntity>>> iter = map.entrySet()
  385. .iterator();
  386. while (iter.hasNext()) {
  387. ArrayList<MessageEntity> msgs = iter.next().getValue();
  388. for (int i = 0; i < msgs.size(); i++) {
  389. threadSleep(100);
  390. MessageDB.getInstance(mContext).insert(msgs.get(i),
  391. SocketConstant.MSG_TYPE_BUYER);
  392. Log.i("write", "离线数据入库---" + msgs.get(i).toString());
  393. }
  394. /***
  395. * 如果服务端一次释放的离线消息大于等于10条,则继续请求释放离线消息.
  396. */
  397. if (msgs.size() >= 10) {
  398. send(SocketJsonUtil.getOffLine(
  399. UserInfoUtil.getUser(mContext)[0], "2"));
  400. Log.i("send",
  401. SocketJsonUtil.getOffLine(
  402. UserInfoUtil.getUser(mContext)[0], "2"));
  403. }
  404. }
  405. // 一轮消息入库结束,发送通知,更新UI;
  406. mContext.sendBroadcast(new Intent(
  407. SocketConstant.OFFLINE_MSG_RECEIVER_SUCCESS));
  408. }
  409. private void threadSleep(long time) {
  410. try {
  411. Thread.currentThread();
  412. Thread.sleep(time);
  413. } catch (InterruptedException e) {
  414. e.printStackTrace();
  415. }
  416. }
  417. }

至于数据库的一部分代码就不贴出了,无非是增删改查。

下面贴出部分监控链接状态的代码,以保证能即时的收到消息;

  1. public class LApplication extends Application {
  2. public static String TAG = LApplication.class.getSimpleName();
  3. /** 接收消息广播 **/
  4. private LPullReceiver mPullReceiver;
  5. /** 是否是正在登录 **/
  6. public static boolean isLoging = false;
  7. /** socket管理类 **/
  8. private LPushManager mWebSocket;
  9. @Override
  10. public void onCreate() {
  11. super.onCreate();
  12. /***
  13. * 注册接收消息的广播
  14. */
  15. mPullReceiver = new LPullReceiver();
  16. // 广播过滤
  17. IntentFilter filter = new IntentFilter();
  18. // 时钟信息发生变化
  19. filter.addAction(Intent.ACTION_TIME_TICK);
  20. // 开机广播
  21. filter.addAction(Intent.ACTION_BOOT_COMPLETED);
  22. // 网络状态发生变化
  23. filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
  24. // 屏幕打开
  25. filter.addAction(Intent.ACTION_SCREEN_ON);
  26. // 注册广播
  27. registerReceiver(mPullReceiver, filter);
  28. // 实例化socket管理类
  29. mWebSocket = new LPushManager(getApplicationContext());
  30. // 应用重启一次,默认socket为关闭状态
  31. LPushUser.saveSocket(getApplicationContext(), false);
  32. // 默认链接没有被拒绝
  33. LPushUser.saveConnect(getApplicationContext(), false);
  34. // 1,获取当前时间
  35. long currentTime = System.currentTimeMillis();
  36. SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  37. Date date = new Date(currentTime);
  38. String time = sdf.format(date);
  39. // 修改标记的时间,保证5分钟内链接一次
  40. LPushUser.saveOpenTime(getApplicationContext(), time);
  41. }
  42. /**
  43. * 广播接口类
  44. * <ol>
  45. * <li>接收时钟发生变化的广播
  46. * <li>接收网络发生变化的广播
  47. * <li>接收开机发送广播
  48. * <li>接收用户登录后发送的广播
  49. * </ol>
  50. *
  51. * @author li'mingqi
  52. *
  53. */
  54. class LPullReceiver extends BroadcastReceiver {
  55. @SuppressLint("SimpleDateFormat")
  56. @Override
  57. public void onReceive(Context context, Intent intent) {
  58. String action = intent.getAction();
  59. if (Intent.ACTION_TIME_TICK.equals(action)
  60. || ConnectivityManager.CONNECTIVITY_ACTION.equals(action)
  61. || Intent.ACTION_BOOT_COMPLETED.equals(action)
  62. || Intent.ACTION_SCREEN_ON.equals(action)) {
  63. if (LPushUser.GETLOG(getApplicationContext()))
  64. Log.i("lpush",
  65. "socket的链接状态----"
  66. + LPushUser
  67. .getSocket(getApplicationContext())
  68. + "是否正在链接--" + isLoging + "----" + action);
  69. // 当时钟或者网络发生变化或者socket关闭或者发生异常时或者开机 时,判断socket连接是否出现异常
  70. if (!LPushUser.getSocket(getApplicationContext()) && !isLoging
  71. && LPushUser.getSocketEnable(getApplicationContext())
  72. && !"".equals(IP) && !"".equals(PORT)
  73. && !LPushUser.getConnectState(getApplicationContext())) {
  74. // 掉线,执行登录动作
  75. if (LNetworkUtil.netIsEnable(getApplicationContext())) {
  76. mWebSocket.secondMethod(IP, PORT);
  77. // 开始登录了,标记打开时间
  78. // 1,获取当前时间
  79. long currentTime = System.currentTimeMillis();
  80. SimpleDateFormat sdf = new SimpleDateFormat(
  81. "yyyy-MM-dd HH:mm:ss");
  82. Date date = new Date(currentTime);
  83. String time = sdf.format(date);
  84. // 修改标记的时间,保证5分钟嗅探链接一次
  85. LPushUser.saveOpenTime(getApplicationContext(), time);
  86. }
  87. } else {
  88. // APP端已经处于链接正常状态 -----5分钟嗅探链接一次
  89. // 1,获取当前时间
  90. long currentTime = System.currentTimeMillis();
  91. SimpleDateFormat sdf = new SimpleDateFormat(
  92. "yyyy-MM-dd HH:mm:ss");
  93. Date date = new Date(currentTime);
  94. String time = sdf.format(date);
  95. // 2,比对链接打开时间
  96. long minTime = LStringManager.dateDifference(
  97. LPushUser.getOpenTime(getApplicationContext()),
  98. time);
  99. if (LPushUser.GETLOG(getApplicationContext())) {
  100. Log.i("lpush",
  101. "链接时长----现在时间:"
  102. + time
  103. + ";保存时间:"
  104. + LPushUser
  105. .getOpenTime(getApplicationContext())
  106. + ";时差" + minTime + "分钟");
  107. }
  108. if (minTime >= 5) {
  109. // 大于等于5分钟,则重新链接
  110. // 5分钟之后重新链接
  111. // 修改被拒绝状态
  112. if (LPushUser.getConnectState(getApplicationContext())) {
  113. LPushUser.saveConnect(getApplicationContext(),
  114. false);
  115. }
  116. if (LNetworkUtil.netIsEnable(getApplicationContext())
  117. && LPushUser
  118. .getSocketEnable(getApplicationContext())) {
  119. mWebSocket.secondMethod(IP, PORT);
  120. // 修改标记的时间,保证5分钟嗅探链接一次
  121. LPushUser.saveOpenTime(getApplicationContext(),
  122. time);
  123. }
  124. }
  125. }
  126. }
  127. }
  128. }
  129. /***
  130. * 设置推送功能的使用与否,默认使用推送功能,若是关闭推送功能请设置false;
  131. *
  132. * @param enable
  133. *            是否使用
  134. *
  135. *            li'mingqi
  136. */
  137. protected void setLPushEnable(boolean enable) {
  138. LPushUser.saveSocketEnable(getApplicationContext(), enable);
  139. }
  140. /***
  141. *
  142. *
  143. * @param ip
  144. *            ip信息
  145. * @param port
  146. *            端口信息
  147. *
  148. *            li'mingqi
  149. */
  150. protected void setSocketIPInfo(String ip, String port) {
  151. this.IP = ip;
  152. this.PORT = port;
  153. }
  154. /**
  155. * 设置用户的Uid
  156. *
  157. * @param uid
  158. *            li'mingqi
  159. */
  160. public void setUserInfo(int uid, String code) {
  161. /***
  162. * 数据验证
  163. */
  164. // if (0 == uid || null == code || "".equals(code)) {
  165. // Log.e(TAG, "您输入的用户ID或者CODE值为空");
  166. // new NullPointerException("您输入的用户ID或者CODE值为空").printStackTrace();
  167. // return;
  168. // }
  169. // 保存用户ID
  170. LPushUser.saveUserID(getApplicationContext(), uid);
  171. // 保存用户CODE
  172. LPushUser.saveUserCode(getApplicationContext(), code);
  173. // 重启链接
  174. mWebSocket.close();
  175. }
  176. /***
  177. * 设置是否查看日志
  178. *
  179. * @param flag
  180. *            是否查看日志
  181. * @version 1.2 li'mingqi
  182. */
  183. public void openLogInfo(boolean flag) {
  184. LPushUser.SAVELOG(getApplicationContext(), flag);
  185. }
  186. /***
  187. * socket链接重置,服务器一直处于拒绝链接状态,客户端链接一次遭拒后标记了遭拒的状态,重置之后可进行再次开启链接;
  188. *
  189. * @version 1.3 li'mingqi
  190. */
  191. private void reset() {
  192. LPushUser.saveConnect(getApplicationContext(), false);
  193. }
  194. }

UI界面显示部分就不贴出了,后面贴出Application类的目的就是监控各种手机系统的广播来嗅探自己的websocket链接的状态;用来维持它以保证能即时的收到消息;

Websocket实现即时通讯的更多相关文章

  1. Android WebSocket实现即时通讯功能

    最近做这个功能,分享一下.即时通讯(Instant Messaging)最重要的毫无疑问就是即时,不能有明显的延迟,要实现IM的功能其实并不难,目前有很多第三方,比如极光的JMessage,都比较容易 ...

  2. WebSocket与即时通讯

    HTTP 协议有一个缺陷:通信只能由客户端发起!HTTP 协议做不到服务器主动向客户端推送信息.这种单向请求的特点,注定了如果服务器有连续的状态变化,客户端要获知就非常麻烦.我们只能使用"轮 ...

  3. JavaEE7 HTML5利用WebSocket实现即时通讯

    HTML5给Web浏览器带来了全双工TCP连接websocket标准服务器的能力. 换句话说,浏览器能够与服务器建立连接,通过已建立的通信信道来发送和接收数据而不需要由HTTP协议引入额外其他的开销来 ...

  4. Web端即时通讯技术盘点:短轮询、Comet、Websocket、SSE

    1. 前言 Web端即时通讯技术因受限于浏览器的设计限制,一直以来实现起来并不容易,主流的Web端即时通讯方案大致有4种:传统Ajax短轮询.Comet技术.WebSocket技术.SSE(Serve ...

  5. 使用 HTML5 webSocket API实现即时通讯的功能

    project下载地址:http://download.csdn.net/detail/wangshuxuncom/6430191 说明: 本project用于展示怎样使用 HTML5 webSock ...

  6. websocket做手机页面聊天与PC页面聊天一对一的即时通讯

    当时要写这个需求的时候,很头痛,手机端页面的客服功能,相当于QQ这样一个一对一聊天室功能了,瞬间蒙蔽的我也不知道用什么去写这个东西,一开始用ajax,定时器去写,写着写着发现这尼玛不在同一个页面怎么做 ...

  7. java Activiti6 工作流引擎 websocket 即时聊天 SSM源码 支持手机即时通讯聊天

    即时通讯:支持好友,群组,发图片.文件,消息声音提醒,离线消息,保留聊天记录 (即时聊天功能支持手机端,详情下面有截图) 工作流模块---------------------------------- ...

  8. java ssm 后台框架平台 项目源码 websocket 即时通讯 IM quartz springmvc

    官网 http://www.fhadmin.org/D 集成安全权限框架shiro  Shiro 是一个用 Java 语言实现的框架,通过一个简单易用的 API 提供身份验证和授权,更安全,更可靠E ...

  9. [开源] .NETCore websocket 即时通讯组件---ImCore

    前言 ImCore 是一款 .NETCore 下利用 WebSocket 实现的简易.高性能.集群即时通讯组件,支持点对点通讯.群聊通讯.上线下线事件消息等众多实用性功能. 开源地址:https:// ...

随机推荐

  1. swiper 逆向轮播

    在调用swiper的div上加dir="rtl"就行了,例子见下面链接 http://www.swiper.com.cn/demo/26-rtl.html <div clas ...

  2. 01-初识MySQL数据库

    一.数据库概述 1.什么是数据 描述事物特征的符号记录称为数据,描述事物的符号既可以是数字,也可以是文字.图片,图像.声音.语言等,数据由多种表现形式,它们都可以经过数字化后存入计算机.如: name ...

  3. ef core自动映射

    原回答:https://stackoverflow.com/questions/26957519/ef-core-mapping-entitytypeconfiguration 一.反射 protec ...

  4. 指定的 CGI 应用程序遇到错误,服务器终止了该进程。

    遇到这种错误只需要把这个项目的Cookies删除再重新启动就行了

  5. Trie for string LeetCode

    Trie build and search class TrieNode { public: TrieNode * next[]; bool is_word; TrieNode(bool b = fa ...

  6. 浅析Kubernetes的工作原理

    先放一张Kubernetes的架构图: 整体来看,是一个老大,多个干活的这种结构,基本上所有的分布式系统都是这样,但是里面的组件名称就纷繁复杂,下面将一一解析. 1.元数据存储与集群维护 作为一个集群 ...

  7. Java对象引用和对象赋值

    关于对象与引用之间的一些基本概念. 初学Java时,在很长一段时间里,总觉得基本概念很模糊.后来才知道,在许多Java书中,把对象和对象的引用混为一谈.可是,如果我分不清对象与对象引用,那实在没法很好 ...

  8. css实现图片等比例缩放

    <div class="box"> <img src="01.jpg"/> </div> .box{ } //只要给图片设置 ...

  9. avuex

    今天做了的avuex终于发现了问题.作为前端小白,解决花了一上午,这是因为以前没有用过框架.还好终于憋出来了.具体如下,还望不要嘲笑自己 查找好久原来是没有仔细看文档的原因,一定要记住,这是一个技术活 ...

  10. java testng框架的windows自动化-自动运行testng程序下篇

    本文旨在让读者简单了解testng的自动运行 接上文https://www.cnblogs.com/xuezhezlr/p/9213456.html,文章大致把testng中比较特殊的两个xml形式说 ...