springboot集成websocket实现心跳维持，防止自动断开

最新推荐文章于 2024-08-31 08:29:31 发布
最新推荐文章于 2024-08-31 08:29:31 发布
阅读量8.9k 收藏 12
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42226741/article/details/107333836
版权

1.maven依赖

                

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-websocket</artifactId>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</dependency>

 

2.前端代码

<!DOCTYPE HTML>
<html>
<head>
    <title>大屏A</title>
</head>

<body>
Welcome<br/>
<input id="text" type="text" /><button οnclick="send()">Send</button>    <button οnclick="closeWebSocket()">Close</button>
<div id="message">
</div>
</body>

<script type="text/javascript">
    var websocket = null;
    var wsGroupId = "20191009170924631538723061895168";
    var type = "screenA"
    var url = "ws://localhost:8080/ws/" + wsGroupId + "/" + type;
    //判断当前浏览器是否支持WebSocket
    if('WebSocket' in window){
        websocket = new WebSocket(url);
    }
    else{
        alert('Not support websocket')
    }

    //连接发生错误的回调方法
    websocket.onerror = function(){
        // setMessageInnerHTML("error");
         console.log(getNowTime() +' 发生异常了');
         reconnect(url);
    };

    //连接成功建立的回调方法
    websocket.onopen = function(event){
        //setMessageInnerHTML("open");
        console.log(getNowTime() +" Socket 已打开");  
        send("heartbeat");
        //心跳检测重置
        heartCheck.start()
    }

    //接收到消息的回调方法
    websocket.onmessage = function(event){
        //websocket.setMessageInnerHTML(event.data);
        // 维持心跳
        heartCheck.start();
        if(event.data !='heartbeat'){
            document.getElementById("text").value=event.data;
            console.log(event.data)
        }
        //window.location.href="http://www.jb51.net";
    }

    //连接关闭的回调方法
    websocket.onclose = function(){
       // websocket.setMessageInnerHTML("close");
        console.log(getNowTime() +" Socket已关闭");  
        reconnect(url)
    }

//    //监听窗口关闭事件，当窗口关闭时，主动去关闭websocket连接，防止连接还没断开就关闭窗口，server端会抛异常。
//     window.onbeforeunload = function(){
//         websocket.close();
//     }

    //将消息显示在网页上
 //    function setMessageInnerHTML(innerHTML){
 //        document.getElementById('message').innerHTML += innerHTML + '<br/>';
 //    }

    //关闭连接
 //    function closeWebSocket(){
 //        websocket.close();
//         lockReconnect= false;
//         reconnect(url);
//     }

    //发送消息
    function send(message){
       // var message = document.getElementById('text').value;
        websocket.send(message);
    }
    
    var lockReconnect = false;//避免重复连接
    //重试连接socket
    function reconnect(url) {
        if(lockReconnect) {
            return;
        };
        lockReconnect = true;
        //没连接上会一直重连，设置延迟避免请求过多
        tt && clearTimeout(tt);
        tt = setTimeout(function () {
            createWebSocket(url);
            lockReconnect = false;
        }, 10000);
    }
    //心跳检测
    var heartCheck = {
        timeout: 5000,
        timeoutObj: null,
        serverTimeoutObj: null,
        start: function(){
              console.log(getNowTime() +" Socket 心跳检测");  
            var self = this;
            this.timeoutObj && clearTimeout(this.timeoutObj);
            this.serverTimeoutObj && clearTimeout(this.serverTimeoutObj);
            this.timeoutObj = setTimeout(function(){
                //这里发送一个心跳，后端收到后，返回一个心跳消息，
                //onmessage拿到返回的心跳就说明连接正常
                console.log(getNowTime() +' Socket 连接重试');
                send("heartbeat");
                self.serverTimeoutObj = setTimeout(function() {
                    console.log(this);
                    close();
                }, self.timeout);
            }, this.timeout)
        }
    }

        /**
         * 获取系统当前时间
         * @returns
         */
        function p(s) {
            return s < 10 ? '0' + s : s;
         }
        function getNowTime() {
            var myDate = new Date();
            //获取当前年
            var year = myDate.getFullYear();
            //获取当前月
            var month = myDate.getMonth() + 1;
            //获取当前日
            var date = myDate.getDate();
            var h = myDate.getHours();       //获取当前小时数(0-23)
            var m = myDate.getMinutes();     //获取当前分钟数(0-59)
            var s = myDate.getSeconds();
            return year + '-' + p(month) + "-" + p(date) + " " + p(h) + ':' + p(m) + ":" + p(s);
        }

</script>
</html>

 

 

3.后台代码

      

/**
 * @author feiyang
 */
@ServerEndpoint(value = "/ws/{wsGroupId}/{type}")
@Component
public class WebSocket {

    private static final Logger logger = LoggerFactory.getLogger(WebSocket.class);

    private static SessionStorage sessionStorage = SessionStorage.getInstance();

    private static Map<String, String> sessionGroup = new ConcurrentHashMap<>(16);

    /**
     * 连接建立成功调用的方法
     * @param session
     * @param type
     * @param wsGroupId
     * @throws Exception
     */
    @OnOpen
    public void onOpen(@PathParam("wsGroupId") String wsGroupId, @PathParam("type") String type, Session session) {
        sessionGroup.put(session.getId(), wsGroupId);
        sessionStorage.putSession(session, wsGroupId, type);
        session.setMaxIdleTimeout(3600000);
        logger.info("websocket连接成功 sessionId:" + session.getId());
        logger.info("websocket连接成功 type:" + type);
        logger.info("websocket连接成功 wsGroupId:" + wsGroupId);
        logger.info("websocket链接数量：" + sessionGroup.size());
    }

    /**
     * 连接关闭调用的方法
     */
    @OnClose
    public void onClose(@PathParam("wsGroupId") String wsGroupId, @PathParam("type") String type, Session session) {
        logger.info("websocket连接关闭成功 sessionId:" + session.getId());
        logger.info(type);
        logger.info(sessionGroup.get(session.getId()));
        SessionStorage.getInstance().removeSession(sessionGroup.get(session.getId()), type);
    }

    /**
     * 收到客户端消息后调用的方法
     * @param message
     * @param session
     */
    @OnMessage
    public void onMessage(@PathParam("wsGroupId") String wsGroupId, @PathParam("type") String type,String message, Session session) {
        try {
            logger.info(message);
            sessionStorage.sendTextSingle( wsGroupId,  type,  message);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 发生错误时调用
     * @param session
     * @param error
     */
    @OnError
    public void onError(Session session, Throwable error) {
        logger.info("websocket连接失败 sessionId:" + session.getId());
    }
}

 

 

package com.example.springtest01.socket;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Async;
import org.springframework.util.StringUtils;

import javax.websocket.Session;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 *
 * 作为对外的工具类
 * @author zhoukx
 */
public class SessionStorage {
    private Map<String, Map<String, Session>> sessionStore = new ConcurrentHashMap<>();

    private static volatile SessionStorage storage;

    private static final Logger logger = LoggerFactory.getLogger(SessionStorage.class);

    private static final String  FLAG_HEART_BEAT = "heartbeat";

    private SessionStorage() {
    }

    /**
     *   双端检索机制创建一个   SessionStorage 实例
     * @return
     */
    public static synchronized SessionStorage getInstance() {
        if(storage == null) {
            synchronized(SessionStorage.class) {
                if(storage == null) {
                    storage = new SessionStorage();
                }
            }
        }
        return storage;
    }

    /**
     * 将ws连接会话分组保存
     * @author  feiyang
     * @param session
     * @param wsGroupId
     * @param type
     * @return  void
     * @date    2019/9/19
     * @throws
     */
    public void putSession(Session session, String wsGroupId, String type) {
        if(session != null) {
            Map<String, Session> sessionGroup = this.sessionStore.get(wsGroupId);
            if (sessionGroup == null) {
               sessionGroup = new ConcurrentHashMap<>(16);
               this.sessionStore.put(wsGroupId, sessionGroup);
            }
            sessionGroup.put(type, session);
        }
    }

    /**
     * ws连接关闭时删除会话
     * @author  feiyang
     * @param wsGroupId
     * @param type
     * @return  void
     * @date    2019/9/19
     * @throws
     */
    public void removeSession(String wsGroupId, String type) {
        Map<String, Session> sessionGroup = sessionStore.get(wsGroupId);
        sessionGroup.remove(type);
        if (sessionGroup.isEmpty()) {
            this.sessionStore.remove(wsGroupId);
        }
    }

    /**
     * 获取指定ws连接会话
     * @author  feiyang
     * @param wsGroupId
     * @param type
     * @return  javax.websocket.Session
     * @date    2019/9/19
     * @throws
     */
    public Session getSession(String wsGroupId, String type) {
        Map<String, Session> sessionGroup = this.sessionStore.get(wsGroupId);
        return sessionGroup.get(type);
    }

    /**
     * 获取指定ws连接会话组全部session
     * @author  feiyang
     * @param wsGroupId
     * @return  java.util.List<javax.websocket.Session>
     * @date    2019/9/19
     * @throws
     */
    public List<Session> getSessions(String wsGroupId) {
        Session[] sessions = new Session[]{};
        Map<String, Session> sessionGroup = this.sessionStore.get(wsGroupId);
        return Arrays.asList(sessionGroup.values().toArray(sessions));
    }

    /**
     * 获取全部的会话
     * @author  feiyang
     * @param
     * @return  java.util.List<javax.websocket.Session>
     * @date    2019/9/19
     * @throws
     */
    public List<Session> getAllSession() {
        List<Session> sessionList = new ArrayList<>();
        for (Map<String, Session> sessionGroup : sessionStore.values()) {
            Session[] sessions = new Session[]{};
            sessionList.addAll(Arrays.asList(sessionGroup.values().toArray(sessions)));
        }
        return sessionList;
    }

    /**
     * 针对单个会话发送文本消息
     * @author  feiyang
     * @param wsGroupId
     * @param type
     * @param text
     * @return  void
     * @date    2019/9/19
     * @throws
     */
    @Async
    public void sendTextSingle(String wsGroupId, String type, String text){
        try {
            Session session = getSession(wsGroupId, type);
            if (session.isOpen()) {
                session.getBasicRemote().sendText(text);
                if (text.equals(FLAG_HEART_BEAT)) {
                    logger.info("socket维持链接状态：" + text);
                } else {
                    logger.info("已发送》》》》》" + text);
                }

            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 针对会话组发送文本信息
     * @author  feiyang
     * @param wsGroupId
     * @param text
     * @return  void
     * @date    2019/9/19
     * @throws
     */
    @Async
    public void  sendTextGroup(String wsGroupId, String text) {
        try {
            List<Session> sessions = getSessions(wsGroupId);
                for(Session session : sessions) {
                    if (session.isOpen()) {
                        session.getBasicRemote().sendText(text);
                        logger.info("已发送》》》》》" + text);
                    }
                }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

//    /**
//     * 针对全部会话发送消息
//     * @author  feiyang
//     * @param text
//     * @return  void
//     * @date    2019/9/19
//     * @throws
//     */
//    public void sendTextAll(String text) {
//        try {
//            List<Session> sessions = getAllSession();
//            for(Session session : sessions) {
//                if (session.isOpen()) {
//                    session.getBasicRemote().sendText(text);
//                    logger.info("已发送》》》》》" + text);
//                }
//            }
//        } catch (IOException e) {
//            e.printStackTrace();
//        }
//    }
}

 

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;

@Configuration
public class WebSocketConfig {

    @Bean
    public ServerEndpointExporter serverEndpointExporter (){
        return new ServerEndpointExporter();
    }
}
西门吹雪@
关注
采用Websocket实现的单设备登录的SpringBoot的后端部分
09-09
在本文中，我们将深入探讨如何使用SpringBoot框架和WebSocket技术来实现单设备登录功能。SpringBoot简化了Java应用的开发过程，而WebSocket则提供了一种双向通信机制，使得服务器和客户端可以实时交换数据。 首先，...
springboot集成websocket，服务端心跳检测
zhuguoli200851的博客
05-20 463
【代码】springboot集成websocket，服务端心跳检测。
实现websocket心跳检测，断线重连机制
SR003的博客
07-20 995
实现websocket心跳检测，断线重连机制
使用 Spring Boot3.3 + Thymeleaf + WebSocket 实现服务端数据推送及心跳机制
最新发布
竹林幽深
08-31 1073
本文详细介绍了如何在 Spring Boot 项目中使用 WebSocket 实现服务端数据推送和心跳机制。通过结合 Thymeleaf 模板引擎和 Bootstrap，我们实现了一个简单的前端页面，并展示了 WebSocket 的基本用法。WebSocket 的心跳机制有助于保持连接的稳定性，在实际项目中可以根据需要进一步优化心跳策略和消息处理逻辑。今天就讲到这里，如果有问题需要咨询，大家可以直接留言或扫下方二维码来知识星球。
springboot websocket 实时刷新 添加心跳机制（亲测可用版）
weixin_43833048的博客
05-30 1万+
思路 在我之前的一篇文章当中写到了websocket的实时刷新，但是有个问题没有解决，就是长时间没有数据的时候，这个连接就会自动断开，然后再次进行连接的话，需要再次进行连接。如果加入心跳机制的话，10秒钟客户端向服务端发送数据，服务端接收到数据，发条消息，告诉客户端我还在，客户端接收到消息，知道我们还是连接的状态，就没有必要再进行连接。如果客户端发送的消息，服务端没有对这个消息进行响应，则说明已经断开连接，则需要重新连接。 服务端代码如下： package cn.lsmsp.alarm.snmp.confi
SpringBoot集成WebSocket实现消息实时推送（提供Gitee源码）
黄团团的个人博客
06-22 4262
在最近的工作当中，客户反应需要实时接收消息提醒，这个功能虽然不大，但不过也用到了一些新的技术，于是我这边写一个关于我如何实现这个功能、编写、测试到部署服务器，归纳到这篇博客中进行总结。
SpringBoot实现WebSocket心跳机制
qq_35019521的博客
11-16 7024
SpringBoot实现WebSocket心跳检测，检测数据写入CSV文件
SpringBoot+WebSocket实战与心跳机制
qq_42582773的博客
09-24 1万+
SpringBoot集成WebSocket
WebSocket服务端数据推送及心跳机制(Spring Boot + VUE)
askuld的博客
08-17 7539
HTML5规范在传统的web交互基础上为我们带来了众多的新特性，随着web技术被广泛用于web APP的开发，这些新特性得以推广和使用，而websocket作为一种新的web通信技术具有巨大意义。WebSocket是HTML5新增的协议，它的目的是在浏览器和服务器之间建立一个不受限的双向通信的通道，比如说，服务器可以在任意时刻发送消息给浏览器。支持双向通信。
springboot整合webSocket：鉴权，心跳检测，wss请求，nginx配置、集群部署
qq_35683545的博客
07-07 5942
从nginx配置看，进行了负载均衡，服务进行了集群部署，项目部署在多台机器上，如此，当一个客户端用户和一台机器建立了链接，客户端自然是不会再去和其他机器建立连接，同时一般建立连接成功时，还会断开旧的连接，这样就不能和新的机器建立连接。其中要监听listen 80端口，尤其注意的是要注意这下面2个配置必须加上，否则建立连接成功立刻就会断掉。注意，使用wss调用需要在nginx配置ssl证书，否则部署到服务器是无法建立websocket连接的。收到客户端发送到服务器发给接收者的消息时，
建立WebSocket心跳机制(Spring Boot + VUE)
qq_18244417的博客
06-17 5548
一、WebSocket 简介“HTML5 规范在传统的 web 交互基础上为我们带来了众多的新特性，随着 web 技术被广泛用于 web APP 的开发，这些新特性得以推广和使用，而 we...
完美解决spring websocket自动断开连接再创建引发的问题
08-31
在Spring框架中集成WebSocket技术，可以为实时通信提供强大的支持，例如在线聊天、实时推送等。然而，在实际应用中，可能会遇到WebSocket连接自动断开后，由于Web Session超时，导致用户重新创建连接时出现问题。...
springboot websocket demo
06-17
2. **SpringBoot集成WebSocket**: SpringBoot提供了Spring Framework的WebSocket支持，通过`@EnableWebSocket`或`@WebSocketConfigurer`注解配置WebSocket。此外，还可以使用`WebSocketMessageBrokerConfigurer`接口...
springboot websocket demo 支持重连 浏览器桌面推送
06-02
2. **SpringBoot集成WebSocket**： 在SpringBoot项目中，我们可以使用Spring框架提供的WebSocket支持来实现WebSocket功能。首先，需要在`pom.xml`文件中引入`spring-boot-starter-websocket`依赖： ```xml ...
基于Springboot+websocket+layui仿QQ在线聊天系统毕业源码案例设计.zip
02-24
在Spring Boot项目中，可以通过Spring Websocket模块集成WebSocket，实现聊天室的消息推送功能。 Layui是一个流行的前端UI框架，它提供了丰富的组件和样式，用于快速构建美观且响应式的页面。在本项目中，Layui主要...
WebSocket（一）：SpringBoot整合与Socketjs心跳重连实现
热门推荐
菜鸡也有大佬梦
08-30 1万+
一.概念 1.单播(Unicast) ：点对点，私信私聊 2.多播，也叫组播(Multicast)（特地人群）: 多人聊天，发布订阅 3.广播(Broadcast)(所有人): 游戏公告，发布订阅 二.Springboot整合Websocket 1.依赖 后端 org.springframework.boot spring-boot-starter-websocket 2.定义两个消息发送的实...
Java springboot使用webscoket包含心跳机制
trench的博客
01-15 858
【代码】Java springboot使用webscoket包含心跳机制。
SpringBoot+WebSocket 消息推送 校验 心跳机制 PING-PONG 用户分组等
TCLms的博客
06-21 4591
WebSocket PING-PONG心跳机制，只需要服务端发送PING，客户端会自动回应PONG，本文中使用了两个@OnMassage注解一个用于接收Text消息，一个用于接收PONG响应消息，此外还有二进制格式（InputStream，byte[],ByteBuffer等）。 消息推送，聊天室，用户聊天等。
WebSocket服务端数据推送及心跳机制(Spring Boot + VUE)：
SunPeng的博客
01-25 2820
WebSocket服务端数据推送及心跳机制(Spring Boot + VUE)：
springboot集成websocket实现消息推送
10-13
要实现Spring Boot集成WebSocket实现消息推送，需要进行以下步骤： 1. 添加Spring Boot WebSocket依赖 2. 创建WebSocket配置类 3. 创建WebSocket处理器类 4. 创建WebSocket拦截器类 5. 创建WebSocket消息模型类 6. 在Spring Boot中使用WebSocket 下面是一个简单的示例代码： 1. 添加Spring Boot WebSocket依赖 在pom.xml文件中添加以下依赖： ``` <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-websocket</artifactId> </dependency> ``` 2. 创建WebSocket配置类 创建一个WebSocket配置类，用于配置WebSocket相关的参数，如下所示： ``` @Configuration @EnableWebSocket public class WebSocketConfig implements WebSocketConfigurer { @Override public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) { registry.addHandler(new WebSocketHandler(), "/websocket").addInterceptors(new WebSocketInterceptor()); } } ``` 3. 创建WebSocket处理器类 创建一个WebSocket处理器类，用于处理WebSocket连接、断开连接和接收消息等操作，如下所示： ``` public class WebSocketHandler extends TextWebSocketHandler { private static final List<WebSocketSession> sessions = new CopyOnWriteArrayList<>(); @Override public void afterConnectionEstablished(WebSocketSession session) throws Exception { sessions.add(session); } @Override public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception { sessions.remove(session); } @Override protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception { for (WebSocketSession s : sessions) { s.sendMessage(message); } } } ``` 4. 创建WebSocket拦截器类 创建一个WebSocket拦截器类，用于拦截WebSocket连接请求，如下所示： ``` public class WebSocketInterceptor implements HandshakeInterceptor { @Override public boolean beforeHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, Map<String, Object> attributes) throws Exception { return true; } @Override public void afterHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler, Exception exception) { } } ``` 5. 创建WebSocket消息模型类 创建一个WebSocket消息模型类，用于封装WebSocket消息，如下所示： ``` public class WebSocketMessage { private String content; public String getContent() { return content; } public void setContent(String content) { this.content = content; } } ``` 6. 在Spring Boot中使用WebSocket 在Spring Boot中使用WebSocket非常简单，只需要在Controller中注入WebSocketSession即可，如下所示： ``` @Controller public class WebSocketController { @Autowired private WebSocketSession session; @MessageMapping("/send") public void send(WebSocketMessage message) throws Exception { session.sendMessage(new TextMessage(message.getContent())); } } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值