devbox
Monodyee
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

WebSocket服务端数据推送及心跳机制(Spring Boot + VUE)_websocket心跳包机制

作者：Monodyee | 2024-03-15 15:06:44

赞

踩

websocket心跳包机制

一、WebSocket简介

      HTML5规范在传统的web交互基础上为我们带来了众多的新特性，随着web技术被广泛用于web APP的开发，这些新特性得以推广和使用，而websocket作为一种新的web通信技术具有巨大意义。WebSocket是HTML5新增的协议，它的目的是在浏览器和服务器之间建立一个不受限的双向通信的通道，比如说，服务器可以在任意时刻发送消息给浏览器。支持双向通信。

二、WebSocket通信原理及机制

       websocket是基于浏览器端的web技术，那么它的通信肯定少不了http,websocket本身虽然也是一种新的应用层协议，但是它也不能够脱离http而单独存在。具体来讲，我们在客户端构建一个websocket实例，并且为它绑定一个需要连接到的服务器地址，当客户端连接服务端的时候，会向服务端发送一个消息报文

三、WebSocket特点和优点

  • 支持双向通信，实时性更强。
  • 更好的二进制支持。
  • 较少的控制开销。连接创建后，ws客户端、服务端进行数据交换时，协议控制的数据包头部较小。在不包含头部的情况下，服务端到客户端的包头只有2~10字节（取决于数据包长度），客户端到服务端的的话，需要加上额外的4字节的掩码。而HTTP协议每次通信都需要携带完整的头部。
  • 支持扩展。ws协议定义了扩展，用户可以扩展协议，或者实现自定义的子协议。（比如支持自定义压缩算法等）
  • 建立在tcp协议之上，服务端实现比较容易
  • 数据格式比较轻量，性能开销小，通信效率高
  • 和http协议有着良好的兼容性，默认端口是80和443,并且握手阶段采用HTTP协议，因此握手的时候不容易屏蔽，能通过各种的HTTP代理

四、WebSocket心跳机制

      在使用websocket过程中，可能会出现网络断开的情况，比如信号不好，或者网络临时性关闭，这时候websocket的连接已经断开，而浏览器不会执行websocket 的 onclose方法，我们无法知道是否断开连接，也就无法进行重连操作。如果当前发送websocket数据到后端，一旦请求超时，onclose便会执行，这时候便可进行绑定好的重连操作。

       心跳机制是每隔一段时间会向服务器发送一个数据包，告诉服务器自己还活着，同时客户端会确认服务器端是否还活着，如果还活着的话，就会回传一个数据包给客户端来确定服务器端也还活着，否则的话，有可能是网络断开连接了。需要重连~

五、在后端Spring Boot 和前端VUE中如何建立通信

1、在Spring Boot 中 pom.xml中添加 websocket依赖

  1. <dependency>
  2. 	<groupId>org.springframework.boot</groupId>
  3. 	<artifactId>spring-boot-starter-websocket</artifactId>
  4. </dependency>

2、创建 WebSocketConfig.java 开启websocket支持

  1. package com.example.demo.websocket;
  2.  
  3. import org.springframework.context.annotation.Bean;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.web.socket.server.standard.ServerEndpointExporter;
  6.  
  7. /**
  8.  * 开启WebSocket支持
  9.  * @author zh
  10.  */
  11. @Configuration
  12. public class WebSocketConfig {
  13.  
  14.     @Bean
  15.     public ServerEndpointExporter serverEndpointExporter() {
  16.  
  17.         return new ServerEndpointExporter();
  18.     }
  19.  
  20. }

3、创建 WebSocketServer.java 链接

  1. package com.example.demo.websocket;
  2.  
  3. import com.alibaba.fastjson.JSON;
  4. import org.slf4j.Logger;
  5. import org.slf4j.LoggerFactory;
  6. import org.springframework.stereotype.Component;
  7.  
  8. import javax.websocket.*;
  9. import javax.websocket.server.ServerEndpoint;
  10. import java.io.IOException;
  11. import java.util.HashMap;
  12. import java.util.Map;
  13. import java.util.concurrent.CopyOnWriteArraySet;
  14.  
  15.  
  16. @ServerEndpoint("/websocket/testsocket")
  17. @Component
  18. public class WebSocketServer {
  19.  
  20.     private static Logger log = LoggerFactory.getLogger(WebSocketServer.class);
  21.     //静态变量，用来记录当前在线连接数。应该把它设计成线程安全的。
  22.     private static int onlineCount = 0;
  23.     //concurrent包的线程安全Set，用来存放每个客户端对应的MyWebSocket对象。
  24.     private static CopyOnWriteArraySet<WebSocketServer> webSocketSet = new CopyOnWriteArraySet<WebSocketServer>();
  25.  
  26.     //与某个客户端的连接会话，需要通过它来给客户端发送数据
  27.     private Session session;
  28.  
  29.     /**
  30.      * 连接建立成功调用的方法*/
  31.     @OnOpen
  32.     public void onOpen(Session session) {
  33.         this.session = session;
  34.         webSocketSet.add(this);     //加入set中
  35.         addOnlineCount();           //在线数加1
  36.         log.info("有新窗口开始监听,当前在线人数为" + getOnlineCount());
  37.         try {
  38.             sendMessage("连接成功");
  39.         } catch (Exception e) {
  40.             log.error("websocket IO异常");
  41.         }
  42.     }
  43.  
  44.     /**
  45.      * 连接关闭调用的方法
  46.      */
  47.     @OnClose
  48.     public void onClose(Session session) {
  49.         try {
  50.             webSocketSet.remove(this);  //从set中删除
  51.             subOnlineCount();           //在线数减1
  52.             session.close();
  53.             log.info("有一连接关闭！当前在线人数为" + getOnlineCount());
  54.         } catch (IOException e) {
  55.             e.printStackTrace();
  56.         }
  57.     }
  58.  
  59.     /**
  60.      * 收到客户端消息后调用的方法
  61.      *
  62.      * @param message 客户端发送过来的消息*/
  63.     @OnMessage
  64.     public void onMessage(String message, Session session) {
  65.         log.info("收到的信息:"+message);
  66.         Map<String, Object> maps = new HashMap<>();
  67.         maps.put("type", message);
  68.         this.sendInfo(maps);
  69.     }
  70.  
  71.     /**
  72.      *
  73.      * @param session
  74.      * @param error
  75.      */
  76.     @OnError
  77.     public void onError(Session session, Throwable error) {
  78.         log.error("发生错误");
  79.         error.printStackTrace();
  80.     }
  81.     /**
  82.      * 实现服务器主动推送
  83.      */
  84.     public void sendMessage(Object obj)  {
  85.         try {
  86.             synchronized (this.session) {
  87.                 this.session.getBasicRemote().sendText((JSON.toJSONString(obj)));
  88.             }
  89.         } catch (Exception e) {
  90.             e.printStackTrace();
  91.         }
  92.  
  93.     }
  94.  
  95.  
  96.     /**
  97.      * 群发自定义消息
  98.      * */
  99.     public static void sendInfo(Object obj) {
  100.         for (WebSocketServer item : webSocketSet) {
  101.             try {
  102.                 item.sendMessage(obj);
  103.             } catch (Exception e) {
  104.                 continue;
  105.             }
  106.         }
  107.     }
  108.  
  109.     public static synchronized int getOnlineCount() {
  110.         return onlineCount;
  111.     }
  112.  
  113.     public static synchronized void addOnlineCount() {
  114.         WebSocketServer.onlineCount++;
  115.     }
  116.  
  117.     public static synchronized void subOnlineCount() {
  118.         WebSocketServer.onlineCount--;
  119.     }
  120. }
  121.

4、创建一个测试调用websocket发送消息 TimerSocketMessage.java (用定时器发送推送消息

  1. package com.example.demo.websocket;
  2.  
  3. import org.springframework.scheduling.annotation.EnableScheduling;
  4. import org.springframework.scheduling.annotation.Scheduled;
  5. import org.springframework.stereotype.Component;
  6.  
  7. import java.util.HashMap;
  8. import java.util.Map;
  9.  
  10.  
  11. @Component
  12. @EnableScheduling
  13. public class TimerSocketMessage {
  14.  
  15.     /**
  16.      * 推送消息到前台
  17.      */
  18.     @Scheduled(cron = "*/1 * * * * * ")
  19.     public void SocketMessage(){
  20.         Map<String, Object> maps = new HashMap<>();
  21.         maps.put("type", "sendMessage");
  22.         maps.put("data","11111");
  23.         WebSocketServer.sendInfo(maps);
  24.     }
  25. }

5、在VUE中创建和后端 websocket服务的连接并建立心跳机制。

  1. <template>
  2.   <div class="hello">
  3.     <h1> websocket 消息推送测试：{{data}}</h1>
  4.  
  5.  
  6.   </div>
  7. </template>
  8.  
  9. <script>
  10. export default {
  11.   name: 'HelloWorld',
  12.   data () {
  13.     return {
  14.       data:0,
  15.       timeout: 28 * 1000,//30秒一次心跳
  16.       timeoutObj: null,//心跳心跳倒计时
  17.       serverTimeoutObj: null,//心跳倒计时
  18.       timeoutnum: null,//断开 重连倒计时
  19.       websocket: null,
  20.     }
  21.   },
  22.   created () {
  23.     // 初始化websocket
  24.     this.initWebSocket()
  25.   },
  26.   methods:{
  27.     initWebSocket () {
  28.       let url = 'ws://localhost:8086/websocket/testsocket'
  29.       this.websocket = new WebSocket(url)
  30.       // 连接错误
  31.       this.websocket.onerror = this.setErrorMessage
  32.  
  33.       // 连接成功
  34.       this.websocket.onopen = this.setOnopenMessage
  35.  
  36.       // 收到消息的回调
  37.       this.websocket.onmessage = this.setOnmessageMessage
  38.  
  39.       // 连接关闭的回调
  40.       this.websocket.onclose = this.setOncloseMessage
  41.  
  42.       // 监听窗口关闭事件，当窗口关闭时，主动去关闭websocket连接，防止连接还没断开就关闭窗口，server端会抛异常。
  43.       window.onbeforeunload = this.onbeforeunload
  44.     },
  45.     reconnect () { // 重新连接
  46.       if(this.lockReconnect) return;
  47.       this.lockReconnect = true;
  48.       //没连接上会一直重连，设置延迟避免请求过多
  49.       this.timeoutnum && clearTimeout(this.timeoutnum);
  50.       this.timeoutnum = setTimeout(() => {
  51.         //新连接
  52.         this.initWebSocket();
  53.         this.lockReconnect = false;
  54.       }, 5000);
  55.     },
  56.     reset () { // 重置心跳
  57.       // 清除时间
  58.       clearTimeout(this.timeoutObj);
  59.       clearTimeout(this.serverTimeoutObj);
  60.       // 重启心跳
  61.       this.start();
  62.     },
  63.     start () { // 开启心跳
  64.       this.timeoutObj && clearTimeout(this.timeoutObj);
  65.       this.serverTimeoutObj && clearTimeout(this.serverTimeoutObj);
  66.       this.timeoutObj = setTimeout(() => {
  67.         // 这里发送一个心跳，后端收到后，返回一个心跳消息，
  68.         if (this.websocket && this.websocket.readyState == 1) { // 如果连接正常
  69.           this.websocketsend('heartbeat');
  70.         } else { // 否则重连
  71.           this.reconnect();
  72.         }
  73.         this.serverTimeoutObj = setTimeout(() => {
  74.           //超时关闭
  75.           this.websocket.close();
  76.         }, this.timeout);
  77.  
  78.       }, this.timeout)
  79.     },
  80.     setOnmessageMessage (event) {
  81.       let obj = JSON.parse(event.data);
  82.       console.log("obj",obj)
  83.       switch(obj.type) {
  84.         case 'heartbeat':
  85.           //收到服务器信息，心跳重置
  86.           this.reset();
  87.           break;
  88.         case 'sendMessage':
  89.           this.data = obj.data
  90.           console.log("接收到的服务器消息：",obj.data)
  91.       }
  92.  
  93.     },
  94.     setErrorMessage () {
  95.       //重连
  96.       this.reconnect();
  97.       console.log("WebSocket连接发生错误" + '   状态码：' + this.websocket.readyState)
  98.     },
  99.     setOnopenMessage () {
  100.       //开启心跳
  101.       this.start();
  102.       console.log("WebSocket连接成功" + '   状态码：' + this.websocket.readyState)
  103.     },
  104.     setOncloseMessage () {
  105.       //重连
  106.       this.reconnect();
  107.       console.log( "WebSocket连接关闭" + '   状态码：' + this.websocket.readyState)
  108.     },
  109.     onbeforeunload () {
  110.       this.closeWebSocket();
  111.     },
  112.     //websocket发送消息
  113.     websocketsend(messsage) {
  114.       this.websocket.send(messsage)
  115.     },
  116.     closeWebSocket() { // 关闭websocket
  117.       this.websocket.close()
  118.     },
  119.   }
  120. }
  121. </script>
  122.  
  123. <!-- Add "scoped" attribute to limit CSS to this component only -->
  124. <style scoped>
  125. h1, h2 {
  126.   font-weight: normal;
  127. }
  128. ul {
  129.   list-style-type: none;
  130.   padding: 0;
  131. }
  132. li {
  133.   display: inline-block;
  134.   margin: 0 10px;
  135. }
  136. a {
  137.   color: #42b983;
  138. }
  139. </style>

6、启动项目开始测试结果

 

学如逆水行舟，不进则退。心似平原跑马，易放难收。全栈工程师是指掌握多种技能，并能利用多种技能独立完成产品的人。 也叫全端工程师(同时具备前端和后台能力)，英文Full Stack engineer。【人工智能】【区块链】【系统/网络/运维】【云计算/大数据】【数据库】【移动开发】【后端开发】【游戏开发】【UI设计】【微服务】【爬虫】【Java】【Go】【C++】【PHP】【Python】【Android/IOS】【HTML/CSS】【JavaScript】【Node】【VUE】【ReactNaive】。。。

欢迎各位大神萌新一起专研分享各行各业技术!

IT全栈工程师技术交流群：593674370

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Monodyee/article/detail/242120
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号