暂无图片
暂无图片
暂无图片
暂无图片
暂无图片
首页 / WebSocket实现Web端即时通信

WebSocket实现Web端即时通信

ytao 2021-09-27
215

前言

WebSocket 是HTML5开始提供的一种在浏览器和服务器间进行全双工通信的协议。目前很多没有使用WebSocket进行客户端服务端实时通信的web应用，大多使用设置规则时间的轮询，或者使用长轮询较多来处理消息的实时推送。这样势必会较大程度浪费服务器和带宽资源，而我们现在要讲的WebSocket正是来解决该问题而出现，使得B/S架构的应用拥有C/S架构一样的实时通信能力。

HTTP和WebSocket比较

HTTP

HTTP协议是半双工协议，也就是说在同一时间点只能处理一个方向的数据传输，同时HTTP消息也是过于庞大，里面包含大量消息头数据，真正在消息处理中很多数据不是必须的，这也是对资源的浪费。

  • 定时轮询：定时轮询就是客户端定时去向服务器发送HTTP请求，看是否有数据，服务器接受到请求后，返回数据给客户端，本次连接也会随着关闭。该实现方案最简单，但是会存在消息延迟和大量浪费服务器和带宽资源。

  • 长轮询：长轮询与定时轮询一样，也是通过HTTP请求实现，但这里不是定时发送请求。客户端发送请求给服务端，这时服务端会hold住该请求，当有数据过来或者超时时返回给请求的客户端并开始下一轮的请求。

WebSocket

WebSocket在客户端和服务端只需一次请求，就会在客户端和服务端建立一条通信通道，可以实时相互传输数据，并且不会像HTTP那样携带大量请求头等信息。因为WebSocket是基于TCP双向全双工通信的协议，所以支持在同一时间点处理发送和接收消息，做到实时的消息处理。

  • 建立WebSocket连接：建立WebSocket连接，首先客户端先要向服务端发送一个特殊的HTTP请求，使用的协议不是http
    或 https
    ，而是使用过 ws
    或 wss
    (一个非安全的，一个安全的，类似前两者之间的差别)，请求头里面要附加一个申请协议升级的信息 Upgrade:websocket
    ，还有随机生成一个 Sec-WebSocket-Key
    的值，及版本信息 Sec-WebSocket-Version
    等等。服务端收到客户端的请求后，会解析该请求的信息，包括请求协议升级，版本校验，以及将 Sec-WebSocket-Key
    的加密后以 sec-websocket-accept
    的值返回给客户端，这样客户端和服务端的连接就建立了。

  • 关闭WebSocket连接：客户端和服务端都可发送一个close控制帧，另一端主动关闭连接。

HTTP轮询和WebSocket生命周期示意图

服务端

这里服务端利用Netty的WebSocket开发。这里首先实现服务端启动类，然后自定义处理器来处理WebSocket的消息。

  1. package com.ytao.websocket;

  3. import io.netty.bootstrap.ServerBootstrap;
  4. import io.netty.channel.*;
  5. import io.netty.channel.nio.NioEventLoopGroup;
  6. import io.netty.channel.socket.SocketChannel;
  7. import io.netty.channel.socket.nio.NioServerSocketChannel;
  8. import io.netty.handler.codec.http.HttpObjectAggregator;
  9. import io.netty.handler.codec.http.HttpServerCodec;
  10. import io.netty.handler.logging.LogLevel;
  11. import io.netty.handler.logging.LoggingHandler;
  12. import io.netty.handler.stream.ChunkedWriteHandler;

  14. /**
  15.  * Created by YANGTAO on 2019/11/17 0017.
  16.  */
  17. public class WebSocketServer {

  19.     public static String HOST = "127.0.0.1";
  20.     public static int PORT = 8806;

  22.     public static void startUp() throws Exception {
  23.         // 监听端口的线程组
  24.         EventLoopGroup bossGroup = new NioEventLoopGroup();
  25.         // 处理每一条连接的数据读写的线程组
  26.         EventLoopGroup workerGroup = new NioEventLoopGroup();
  27.         // 启动的引导类
  28.         ServerBootstrap serverBootstrap = new ServerBootstrap();
  29.         try {
  30.             serverBootstrap.group(bossGroup, workerGroup)
  31.                     .channel(NioServerSocketChannel.class)
  32.                     .childHandler(new ChannelInitializer<SocketChannel>() {
  33.                         @Override
  34.                         protected void initChannel(SocketChannel ch) throws Exception{
  35.                             ChannelPipeline pipeline = ch.pipeline();
  36.                             pipeline.addLast("logger", new LoggingHandler(LogLevel.INFO));
  37.                             // 将请求和返回消息编码或解码成http
  38.                             pipeline.addLast("http-codec", new HttpServerCodec());
  39.                             // 使http的多个部分组合成一条完整的http
  40.                             pipeline.addLast("aggregator", new HttpObjectAggregator(65536));
  41.                             // 向客户端发送h5文件，主要是来支持websocket通信
  42.                             pipeline.addLast("http-chunked", new ChunkedWriteHandler());
  43.                             // 服务端自定义处理器
  44.                             pipeline.addLast("handler", new WebSocketServerHandler());
  45.                         }
  46.                     })
  47.                     // 开启心跳机制
  48.                     .childOption(ChannelOption.SO_KEEPALIVE, true)
  49.                     .handler(new ChannelInitializer<NioServerSocketChannel>() {
  50.                         protected void initChannel(NioServerSocketChannel ch) {
  51.                             System.out.println("WebSocket服务端启动中...");
  52.                         }
  53.                     });

  55.             Channel ch = serverBootstrap.bind(HOST, PORT).sync().channel();
  56.             System.out.println("WebSocket host: "+ch.localAddress().toString().replace("/",""));
  57.             ch.closeFuture().sync();
  58.         }catch (Exception e){
  59.             e.printStackTrace();
  60.         }finally {
  61.             bossGroup.shutdownGracefully();
  62.             workerGroup.shutdownGracefully();
  63.         }

  65.     }

  67.     public static void main(String[] args) throws Exception {
  68.         startUp();
  69.     }
  70. }

上面启动类和HTTP协议的类似，所以较好理解。启动类启动后，我们需要处理WebSocket请求，这里自定义 WebSocketServerHandler
。我们在处理中设计的业务逻辑有，如果只有一个连接来发送信息聊天，那么我们就以服务器自动回复，如果存在一个以上，我们就将信息发送给其他人。

  1. package com.ytao.websocket;

  3. import io.netty.channel.Channel;
  4. import io.netty.channel.ChannelHandlerContext;
  5. import io.netty.channel.ChannelPromise;
  6. import io.netty.channel.SimpleChannelInboundHandler;
  7. import io.netty.handler.codec.http.FullHttpRequest;
  8. import io.netty.handler.codec.http.websocketx.*;
  9. import java.time.LocalDateTime;
  10. import java.time.format.DateTimeFormatter;
  11. import java.util.Date;
  12. import java.util.Map;
  13. import java.util.concurrent.ConcurrentHashMap;

  15. /**
  16.  * Created by YANGTAO on 2019/11/17 0017.
  17.  */
  18. public class WebSocketServerHandler extends SimpleChannelInboundHandler<Object> {

  20.     private WebSocketServerHandshaker handshaker;

  22.     private static Map<String, ChannelHandlerContext> channelHandlerContextConcurrentHashMap = new ConcurrentHashMap<>();

  24.     private static final Map<String, String> replyMap = new ConcurrentHashMap<>();
  25.     static {
  26.         replyMap.put("博客", "https://ytao.top");
  27.         replyMap.put("公众号", "ytao公众号");
  28.         replyMap.put("在吗", "在");
  29.         replyMap.put("吃饭了吗", "吃了");
  30.         replyMap.put("你好", "你好");
  31.         replyMap.put("谁", "ytao");
  32.         replyMap.put("几点", "现在本地时间："+LocalDateTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
  33.     }

  35.     @Override
  36.     public void messageReceived(ChannelHandlerContext channelHandlerContext, Object msg) throws Exception{
  37.         channelHandlerContextConcurrentHashMap.put(channelHandlerContext.channel().toString(), channelHandlerContext);
  38.         // http
  39.         if (msg instanceof FullHttpRequest){
  40.             handleHttpRequest(channelHandlerContext, (FullHttpRequest) msg);
  41.         }else if (msg instanceof WebSocketFrame){ // WebSocket
  42.             handleWebSocketFrame(channelHandlerContext, (WebSocketFrame) msg);
  43.         }
  44.     }

  46.     @Override
  47.     public void channelReadComplete(ChannelHandlerContext channelHandlerContext) throws Exception{
  48.         if (channelHandlerContextConcurrentHashMap.size() > 1){
  49.             for (String key : channelHandlerContextConcurrentHashMap.keySet()) {
  50.                 ChannelHandlerContext current = channelHandlerContextConcurrentHashMap.get(key);
  51.                 if (channelHandlerContext == current)
  52.                     continue;
  53.                 current.flush();
  54.             }
  55.         }else {
  56.             // 单条处理
  57.             channelHandlerContext.flush();
  58.         }
  59.     }

  61.     private void handleHttpRequest(ChannelHandlerContext channelHandlerContext, FullHttpRequest request) throws Exception{
  62.         // 验证解码是否异常
  63.         if (!"websocket".equals(request.headers().get("Upgrade")) || request.decoderResult().isFailure()){
  64.             // todo send response bad
  65.             System.err.println("解析http信息异常");
  66.             return;
  67.         }

  69.         // 创建握手工厂类
  70.         WebSocketServerHandshakerFactory factory = new WebSocketServerHandshakerFactory(
  71.           "ws:/".concat(channelHandlerContext.channel().localAddress().toString()),
  72.                 null,
  73.                 false
  74.         );
  75.         handshaker = factory.newHandshaker(request);

  77.         if (handshaker == null)
  78.             WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(channelHandlerContext.channel());
  79.         else
  80.             // 响应握手消息给客户端
  81.             handshaker.handshake(channelHandlerContext.channel(), request);

  83.     }

  85.     private void handleWebSocketFrame(ChannelHandlerContext channelHandlerContext, WebSocketFrame webSocketFrame){
  86.         // 关闭链路
  87.         if (webSocketFrame instanceof CloseWebSocketFrame){
  88.             handshaker.close(channelHandlerContext.channel(), (CloseWebSocketFrame) webSocketFrame.retain());
  89.             return;
  90.         }

  92.         // Ping消息
  93.         if (webSocketFrame instanceof PingWebSocketFrame){
  94.             channelHandlerContext.channel().write(
  95.               new PongWebSocketFrame(webSocketFrame.content().retain())
  96.             );
  97.             return;
  98.         }

  100.         // Pong消息
  101.         if (webSocketFrame instanceof PongWebSocketFrame){
  102.             // todo Pong消息处理
  103.         }

  105.         // 二进制消息
  106.         if (webSocketFrame instanceof BinaryWebSocketFrame){
  107.             // todo 二进制消息处理
  108.         }

  110.         // 拆分数据
  111.         if (webSocketFrame instanceof ContinuationWebSocketFrame){
  112.             // todo 数据被拆分为多个websocketframe处理
  113.         }

  115.         // 文本信息处理
  116.         if (webSocketFrame instanceof TextWebSocketFrame){
  117.             // 推送过来的消息
  118.             String  msg = ((TextWebSocketFrame) webSocketFrame).text();
  119.             System.out.println(String.format("%s 收到消息 : %s", new Date(), msg));

  121.             String responseMsg = "";
  122.             if (channelHandlerContextConcurrentHashMap.size() > 1){
  123.                 responseMsg = msg;
  124.                 for (String key : channelHandlerContextConcurrentHashMap.keySet()) {
  125.                     ChannelHandlerContext current = channelHandlerContextConcurrentHashMap.get(key);
  126.                     if (channelHandlerContext == current)
  127.                         continue;
  128.                     Channel channel = current.channel();
  129.                     channel.write(
  130.                             new TextWebSocketFrame(responseMsg)
  131.                     );
  132.                 }
  133.             }else {
  134.                 // 自动回复
  135.                 responseMsg = this.answer(msg);
  136.                 if(responseMsg == null)
  137.                     responseMsg = "暂时无法回答你的问题 ->_->";
  138.                 System.out.println("回复消息："+responseMsg);
  139.                 Channel channel = channelHandlerContext.channel();
  140.                 channel.write(
  141.                         new TextWebSocketFrame("【服务端】" + responseMsg)
  142.                 );
  143.             }
  144.         }

  146.     }

  148.     private String answer(String msg){
  149.         for (String key : replyMap.keySet()) {
  150.             if (msg.contains(key))
  151.                 return replyMap.get(key);
  152.         }
  153.         return null;
  154.     }

  156.     @Override
  157.     public void exceptionCaught(ChannelHandlerContext channelHandlerContext, Throwable throwable){
  158.         throwable.printStackTrace();
  159.         channelHandlerContext.close();
  160.     }

  162.     @Override
  163.     public void close(ChannelHandlerContext channelHandlerContext, ChannelPromise promise) throws Exception {
  164.         channelHandlerContextConcurrentHashMap.remove(channelHandlerContext.channel().toString());
  165.         channelHandlerContext.close(promise);
  166.     }

  168. }

刚建立连接时，第一次握手有HTTP协议处理，所以 WebSocketServerHandler#messageReceived
会判断是HTTP还是WebSocket，如果是HTTP时，交由 WebSocketServerHandler#handleHttpRequest
处理，里面会去验证请求，并且处理握手后将消息返回给客户端。如果不是HTTP协议，而是WebSocket协议时，处理交给 WebSocketServerHandler#handleWebSocketFrame
处理，进入WebSocket处理后，这里面有判断消息属于哪种类型，里面包括 CloseWebSocketFrame
， PingWebSocketFrame
， PongWebSocketFrame
， BinaryWebSocketFrame
， ContinuationWebSocketFrame
， TextWebSocketFrame
，他们都是 WebSocketFrame
的子类，并且 WebSocketFrame
又继承自 DefaultByteBufHolder
。

channelHandlerContextConcurrentHashMap
是缓存WebSocket已连接的信息，因为我们实现的需求要记录连接数量，当有连接关闭时我们要删除以缓存的连接，所以在 WebSocketServerHandler#close
中要移除缓存。

最后的发送文本到客户端，根据连接数量判断。如果连接数量不大于1，那么，我们"价值一个亿的AI核心代码" WebSocketServerHandler#answer
来回复客户端消息。否则除了本次接收的连接，消息会发送给其他所有连接的客户端。

客户端

客户端使用JS实现WebSocket的操作，目前主流的浏览器基本都支持WebSocket。支持情况如图：

客户端H5的代码实现：

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <meta name="viewport" content="width=device-width, initial-scale=1" />
  6.     <title>ytao-websocket</title>
  7.     <script src="http://libs.baidu.com/jquery/2.0.0/jquery.min.js"></script>
  8.     <style type="text/css">
  9.         #msgContent{
  10.             line-height:200%;
  11.             width: 500px;
  12.             height: 300px;
  13.             resize: none;
  14.             border-color: #FF9900;
  15.         }
  16.         .clean{
  17.             background-color: white;
  18.         }
  19.         .send{
  20.             border-radius: 10%;
  21.             background-color: #2BD56F;
  22.         }
  23.         @media screen and (max-width: 600px) {
  24.             #msgContent{
  25.                 line-height:200%;
  26.                 width: 100%;
  27.                 height: 300px;
  28.             }
  29.         }
  30.     </style>
  31. </head>
  32. <script>
  33.     var socket;
  34.     var URL = "ws://127.0.0.1:8806/ytao";

  36.     connect();

  38.     function connect() {
  39.         $("#status").html("<span>连接中.....</span>");
  40.         window.WebSocket = !window.WebSocket == true? window.MozWebSocket : window.WebSocket;
  41.         if(window.WebSocket){
  42.             socket = new WebSocket(URL);
  43.             socket.onmessage = function(event){
  44.                 var msg = event.data + "\n";
  45.                 addMsgContent(msg);
  46.             };

  48.             socket.onopen = function(){
  49.                 $("#status").html("<span style='background-color: #44b549'>WebSocket已连接</span>");
  50.             };

  52.             socket.onclose = function(){
  53.                 $("#status").html("<span style='background-color: red'>WebSocket已断开连接</span>");
  54.                 setTimeout("connect()", 3000);
  55.             };
  56.         }else{
  57.             $("#status").html("<span style='background-color: red'>该浏览器不支持WebSocket协议！</span>");
  58.         }
  59.     }

  61.     function addMsgContent(msg) {
  62.         var contet = $("#msgContent").val() + msg;
  63.         $("#msgContent").val(contet)
  64.     }

  66.     function clean() {
  67.         $("#msgContent").val("");
  68.     }

  70.     function getUserName() {
  71.         var n = $("input[name=userName]").val();
  72.         if (n == "")
  73.             n = "匿名";
  74.         return n;
  75.     }

  77.     function send(){
  78.         var message = $("input[name=message]").val();
  79.         if(!window.WebSocket) return;
  80.         if ($.trim(message) == ""){
  81.             alert("不能发送空消息！");
  82.             return;
  83.         }
  84.         if(socket.readyState == WebSocket.OPEN){
  85.             var msg = "【我】" + message + "\n";
  86.             this.addMsgContent(msg);
  87.             socket.send("【"+getUserName()+"】"+message);
  88.             $("input[name=message]").val("");
  89.         }else{
  90.             alert("无法建立WebSocket连接！");
  91.         }
  92.     }

  94.     $(document).keyup(function(){
  95.         if(event.keyCode ==13){
  96.             send()
  97.         }
  98.     });
  99. </script>
  100. <body>
  101.     <div style="text-align: center;">
  102.         <div id="status">
  103.             <span>连接中.....</span>
  104.         </div>
  105.         <div>
  106.             <h2>信息面板</h2>
  107.             <textarea id="msgContent" readonly="readonly"></textarea>
  108.         </div>
  109.         <div>
  110.             <input class="clean" type="button" value="清除聊天纪录" onclick="clean()" />
  111.             <input type="text" name="userName" value="" placeholder="用户名"/>
  112.         </div>
  113.         <hr>
  114.         <div>
  115.             <form onsubmit="return false">
  116.                 <input type="text" name="message" value="" placeholder="请输入消息"/>
  117.                 <input class="send" type="button" name="msgBtn" value="send" onclick="send()"/>
  118.             </form>
  119.         </div>
  120.         <div>
  121.             <br><br>
  122.             <img src="http://yangtao.ytao.top/ytao%E5%85%AC%E4%BC%97%E5%8F%B7.jpg">
  123.         </div>
  124.     </div>
  125. </body>
  126. </html>

JS这里实现相对较简单，主要用到：

  • newWebSocket(URL)
    创建WebSocket对象

  • onopen()
    打开连接

  • onclose()
    关闭连接

  • onmessage
    接收消息

  • send()
    发送消息

当断开连接后，客户端这边重新发起连接，直到连接成功为止。

启动

客户端和服务端连接后，我们从日志和请求中可以看到上面所提到的验证信息。

客户端：

服务端：

启动服务端后，先实验我们"价值一个亿的AI"，只有一个连接用户时，发送信息结果如图：

多个用户连接，这里使用三个连接用户群聊。

用户一：

用户二：

用户三：

到目前为止，WebSocket已帮助我们实现即时通信的需求，相信大家也基本入门了WebSocket的基本使用。

总结

通过本文了解，可以帮助大家入门WebSocket并且解决当前可能存在的一些Web端的通信问题。我曾经在两个项目中也有看到该类解决方案都是通过定时轮询去做的，也或多或少对服务器资源造成一定的浪费。因为WebSocket本身是较复杂的，它提供的API也是比较多，所以在使用过程，要去真正使用好或去优化它，并不是一件很简单的事，也是需要根据现实场景针对性的去做。

关注【ytao】，更多的好文输出


数据库
文章转载自ytao，如果涉嫌侵权，请发送邮件至：contact@modb.pro进行举报，并提供相关证据，一经查实，墨天轮将立刻删除相关内容。

评论