Websocket定时监控+开关+参数传递

最新推荐文章于 2025-03-11 14:29:47 发布
最新推荐文章于 2025-03-11 14:29:47 发布
阅读量1.2k 收藏 3
点赞数
分类专栏： 开发 文章标签： websocket 网络 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/imagezx/article/details/130720593
版权
文章介绍了如何利用WebSocket进行设备温度监控，通过配置WebSocket实现服务器与客户端的长连接，避免频繁HTTP请求造成的资源浪费。同时，文中提到了一个定时任务控制层，用于开启和关闭温度监控任务，任务开关使用了ScheduledFuture和ThreadPoolTaskScheduler。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

举个例子，当开发中遇到了这样的需求时

需求：需要定时监控多个设备的温度情况，并且需要设置开关控制监控任务

       因为需要定时不断的给前端返回我们业务处理好的数据，这个时候HTTP请求显然不能很好的满足我们的需求，除非用定时器不断的发请求，这样会造成资源的浪费，而websocket是一种长连接，一旦连接服务端就就可以不断地向客户端推送数据，不用一直三次握手四次握手。

       因此这里采用websocket的方式来实现业务

1. 配置WebSocket首先需要建立WebSocket的配置类

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

/**
 * websocket 配置
 * 
 * @author 
 */
@Configuration
public class WebSocketConfig
{
    @Bean
    public ServerEndpointExporter serverEndpointExporter()
    {
        return new ServerEndpointExporter();
    }
}

 2.具体配置WebSocket

import com.alibaba.fastjson2.JSON;
import com.github.pagehelper.PageInfo;
import com.ruoyi.common.constant.HttpStatus;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.redis.RedisCache;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.spring.SpringUtils;
import com.ruoyi.framework.websocket.SemaphoreUtils;
import com.ruoyi.framework.websocket.WebSocketUsers;
import com.ruoyi.system.domain.Equipment;
import com.ruoyi.system.service.IEquipmentService;
import constant.Constants;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import javax.websocket.*;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Semaphore;

/**
 * websocket 消息处理
 *
 * @author 
 */

//交给Spring来管理
@Component
//建立连接的端点
@ServerEndpoint("/websocket/{id}")
public class WebSocketServer {
    /**
     * WebSocketServer 日志控制器
     */
    private static final Logger LOGGER = LoggerFactory.getLogger(WebSocketServer.class);

    /**
     * 默认最多允许同时在线人数100
     */
    public static int socketMaxOnlineCount = 100;

    /**
     * 信号量控制在线人数
     */
    private static Semaphore socketSemaphore = new Semaphore(socketMaxOnlineCount);


    /**
     * concurrent包的线程安全Set，用来存放每个客户端对应的MyWebSocket对象。
     */
    public static ConcurrentHashMap<Integer, WebSocketServer> webSocketSet = new ConcurrentHashMap<Integer, WebSocketServer>();

    /**
     * concurrent包的线程安全hashMap,用来存放每一个session里的参数信息
     */
    private static ConcurrentHashMap<String, String> hashMap = new ConcurrentHashMap<>();

    /**
     * 与某个客户端的连接会话，需要通过它来给客户端发送数据
     */
    private Session session;

    /**
     * 传过来的id 1:搜索设备,2:温度报警,3:查询设备是否断开连接
     */
    private Integer id = 0;


    /**
     * 连接建立成功调用的方法
     */
    @OnOpen
    public void onOpen(@PathParam(value = "id") Integer param, Session session) throws Exception {
        boolean semaphoreFlag = false;
        // 尝试获取信号量
        semaphoreFlag = SemaphoreUtils.tryAcquire(socketSemaphore);
        if (!semaphoreFlag) {
            // 未获取到信号量
            LOGGER.error("\n 当前在线人数超过限制数- {}", socketMaxOnlineCount);
            //WebSocketUsers.sendMessageToUserByText(session, "忙碌中,请稍后再试...");
            session.close();
        } else {
            // 添加用户
            //WebSocketUsers.put(session.getId(), session);
            //接收客户端编号并且加入到set集合当中
            id = param;
            this.session = session;
            webSocketSet.put(param, this);

            //获取session当中的参数
            Map<String, List<String>> map = session.getRequestParameterMap();
            if (!map.isEmpty()){
                //把取出来的参数存入hashmap当中
                //当连接为ws://127.0.0.1:8080/websocket/2?equipmentIds=1时
                hashMap.put(session.getId(),map.get("equipmentIds").get(0));
            }
            LOGGER.info("\n 建立连接 - {}", session);
            //LOGGER.info("\n 当前人数 - {}", WebSocketUsers.getUsers().size());
        }
    }

    /**
     * 连接关闭时处理
     */
    @OnClose
    public void onClose(Session session) {
        LOGGER.info("\n 关闭连接 - {}", session);
        // 移除用户
        WebSocketUsers.remove(session.getId());
        webSocketSet.remove(id);
        // 获取到信号量则需释放
        SemaphoreUtils.release(socketSemaphore);
    }

    /**
     * 抛出异常时处理
     */
    @OnError
    public void onError(Session session, Throwable exception) throws Exception {
        if (session.isOpen()) {
            // 关闭连接
            session.close();
        }
        String sessionId = session.getId();
        LOGGER.info("\n 连接异常 - {}", sessionId);
        LOGGER.info("\n 异常信息 - {}", exception);
        // 移出用户
        //WebSocketUsers.remove(sessionId);
        // 获取到信号量则需释放
        SemaphoreUtils.release(socketSemaphore);
    }

    public void sendMessage(String message) throws IOException {
        synchronized (session) {
            getSession().getBasicRemote().sendText(message);
        }
    }

    /**
     * 服务器接收到客户端消息时调用的方法
     */
    @OnMessage
    public void onMessage(String message, Session session) throws Exception {
       //业务
    }


    /**
     * 给指定的人发送消息
     *
     * @param message
     */
    public static void sendToMessageById(Integer id, String message) {
        try {
            if (webSocketSet.get(id) != null) {
                webSocketSet.get(id).sendMessage(message);
            } else {
                System.out.println("webSocketSet中没有此key，不推送消息");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public Session getSession() {
        return session;
    }

    public static ConcurrentHashMap<String, String> getHashMap() {
        return hashMap;
    }
}

3.信号量工具类(控制在线连接数)

import java.util.concurrent.Semaphore;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 信号量相关处理
 * 
 * @author ruoyi
 */
public class SemaphoreUtils
{
    /**
     * SemaphoreUtils 日志控制器
     */
    private static final Logger LOGGER = LoggerFactory.getLogger(SemaphoreUtils.class);

    /**
     * 获取信号量
     * 
     * @param semaphore
     * @return
     */
    public static boolean tryAcquire(Semaphore semaphore)
    {
        boolean flag = false;

        try
        {
            flag = semaphore.tryAcquire();
        }
        catch (Exception e)
        {
            LOGGER.error("获取信号量异常", e);
        }

        return flag;
    }

    /**
     * 释放信号量
     * 
     * @param semaphore
     */
    public static void release(Semaphore semaphore)
    {

        try
        {
            semaphore.release();
        }
        catch (Exception e)
        {
            LOGGER.error("释放信号量异常", e);
        }
    }
}

4.控制层监控任务开关

    private ScheduledFuture<?> futureAlarmTempMonitor;

    /**
     * 用来存储温度配置信息
     */
    public static ConcurrentHashMap<String, String> hashMap = new ConcurrentHashMap<>();

    /**
     * 用来存储每一台设备的报警定时任务
     */
    public static ConcurrentHashMap<Long,ScheduledFuture<?>> equipmentTask=new ConcurrentHashMap<>();

    @Bean
    public ThreadPoolTaskScheduler threadPoolTaskScheduler() {
        return new ThreadPoolTaskScheduler();
    }

    /**
     * 开启温度监控定时任务（整帧检测）
     *
     */
    @ApiOperation("开启温度监控定时任务")
    @Log(title = "开启温度监控定时任务", businessType = BusinessType.INSERT)
    @PostMapping("/startAlarmTempMonitor")
    public AjaxResult startAlarmTempMonitor(@RequestBody TempAlarmConfig tempAlarmConfig) {
        //将温度配置的参数存入hashMap当中
        hashMap.put(Constants.Temp_Alarm_Config +tempAlarmConfig.getEquipmentId(), JSON.toJSONString(tempAlarmConfig));
        //方法会创建一个定时计划ScheduledFuture，在这个方法需要添加两个参数，Runnable（线程接口类） 和CronTrigger（定时任务触发器）
        /* 该种方法可以使用cron表达式 最小单位为秒
        futureAlarmTempMonitor = threadPoolTaskScheduler.schedule(new TempAlarmRunnable(), new Trigger() {
            @Override
            public Date nextExecutionTime(TriggerContext triggerContext) {
                //周期为帧频执行一次
                return new CronTrigger(CronExpressionUtils.conversion(imageFramerate)).nextExecutionTime(triggerContext);
            }
        });*/
        //定时计划，最小单位为毫秒，在这里每五秒执行一次
        futureAlarmTempMonitor = threadPoolTaskScheduler.scheduleWithFixedDelay(new TempAlarmRunnable(), 5000);
        //把定时任务保存进hashMap当中
        equipmentTask.put(tempAlarmConfig.getEquipmentId(), futureAlarmTempMonitor);
        System.out.println("开启温度监控定时任务");
        //报警配置存到数据库当中
        //业务

        return AjaxResult.success();
    }

    @ApiOperation("关闭温度监控定时任务")
    @PostMapping("/stopAlarmTempMonitor/{equipmentId}")
    //这个id在TempAlarmConfig实体类当中 
    public AjaxResult stopAlarmTempMonitor(@PathVariable Long equipmentId){
        if (!equipmentTask.isEmpty()){
            ScheduledFuture<?> scheduledFuture = equipmentTask.get(equipmentId);
            scheduledFuture.cancel(true);
        }
        System.out.println("关闭温度监控定时任务");
        return AjaxResult.success();
    }

5.实现Runnable接口

import cn.hutool.core.collection.CollectionUtil;
import com.alibaba.fastjson2.JSON;
import com.ruoyi.common.constant.Constants;
import com.ruoyi.common.utils.spring.SpringUtils;
import com.ruoyi.system.domain.AlarmData;
import com.ruoyi.system.domain.Equipment;
import com.ruoyi.system.domain.TempAlarmConfig;
import com.ruoyi.system.domain.TempData;
import com.ruoyi.system.sdk.SdkManager;
import com.ruoyi.system.service.IAlarmDataService;
import com.ruoyi.system.service.IEquipmentService;
import com.ruoyi.system.service.ITempAlarmConfigService;
import com.ruoyi.web.controller.thermometry.AlarmDataController;
import com.ruoyi.web.controller.websocket.WebSocketServer;
import com.ruoyi.web.core.config.EquipmentContext;
import org.springframework.beans.factory.annotation.Autowired;

import javax.swing.*;
import java.util.concurrent.ConcurrentHashMap;


/**
 * 监控温度报警线程
 * sendToMessageById:2  表示监控温度报警的webSocket
 */
public class TempAlarmRunnable implements Runnable {

    @Override
    public void run() {
        if (CollectionUtil.isNotEmpty(WebSocketServer.webSocketSet)) {
            //取出存入hashMap当中的值
            ConcurrentHashMap<String, String> hashMap = AlarmDataController.hashMap;
            //取出对应的设备ID 2表示对应的温度报警webSocket
            String sessionId = WebSocketServer.webSocketSet.get(2).getSession().getId();
            String equipmentId = WebSocketServer.getHashMap().get(sessionId);
            if (!hashMap.isEmpty()) {
                String s = hashMap.get(Constants.Temp_Alarm_Config + equipmentId);
                //获取温度报警配置参数
                TempAlarmConfig tempAlarmConfig = JSON.parseObject(s, TempAlarmConfig.class);
                selectAlarmData(tempAlarmConfig);
            }
        }
    }

    public void selectAlarmData(TempAlarmConfig tempAlarmConfig) {
 
       //给前台返回消息
       WebSocketServer.sendToMessageById(2,JSON.toJSONString(业务));
    }
}

that's all

websocket++库
03-05
WebSocket++库是一个开源的C++库，专门用于实现WebSocket协议，该协议允许在Web浏览器和其他服务器之间进行全双工通信。WebSocket++库的设计目标是提供一个轻量级、高效且易于使用的WebSocket客户端和服务器实现，它...
WebSocket
aw4269的博客
09-10 261
WebSocket是什么？ WebSocket是一种在单个TCP连接上进行全双向通信的协议。WebSocket使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。在WebSocket API中，浏览器和服务器只需要完成一次握手，两者之间就直接可以创建持久性的连接，并进行双向数据传输。Websocket 通过HTTP/1.1 协议的101状态码进行握手。 ...
websocket介绍
实事求是，艰苦奋斗，小小的梦想，终将实现。
03-09 1615
websocket协议是基于TCP的一种新的网络协议。它实现了浏览器与服务器的全双工通讯-允许服务器主动发起信息个客户端， websocket’是一种持久协议，http是非持久协议。 使用场景：现在很多网站都有实时推送的需求，比如聊天，客服咨询等。 早期没有websocket的时候，是通过ajax轮询，由于http请求，服务器无法给浏览器主动发送数据，因此需要浏览器定时给服务器发送请求（比如1s一次），服务器把最新的数据响应给浏览器。这种模式的缺点就是浪费性能和资源。 websocket使用 H5中使用.
SpringBoot + WebSocket 实时监控异常
最新发布
tangjieqing的博客
03-11 391
此异常非彼异常，标题所说的异常是业务上的异常。最近做了一个需求，消防的设备巡检，如果巡检发现异常，通过手机端提交，后台的实时监控页面实时获取到该设备的信息及位置，然后安排员工去处理。因为需要服务端主动向客户端发送消息，所以很容易的就想到了用WebSocket来实现这一功能。WebSocket就不做介绍了，上链接：前端略微复杂，需要在一张位置分布图上进行鼠标描点定位各个设备和根据不同屏幕大小渲染，本文不做介绍，只是简单地用页面样式进行效果呈现。
websocket创建连接时传递参数
jiaboboyu的博客
11-09 8498
websocket创建连接时并传递参数
WebSocket建立连接传参常用方式
Hank的专栏
06-10 2万+
websocket基础入门之参数获取
websocket如何携带header或参数
热门推荐
weixin_44330810的博客
09-16 5万+
websocket如何携带header或参数
websocket++的客户端&服务端demo
03-01
WebSocket++是C++实现的一个WebSocket协议库，它提供了一个轻量级、高性能的框架，用于在客户端和服务端之间建立实时的、双向通信的连接。WebSocket协议是HTML5的一部分，允许Web应用绕过HTTP的限制，直接与服务器...
websocket+sockjs+stompjs详解及实例代码
12-14
最近有项目需求要用到websocket,刚开始以为很简单，但是随着遇到问题，深入了解，才知道websocket并不是想象中的那么简单，这篇文章主要是考虑websocket在客户端的使用。 1.http与websocket http超文本传输协议，...
springboot+websocket+Stomp+RabbitMq 实现多人聊天室
08-26
Spring Boot的简洁性，WebSocket的实时性，STOMP的易用性，以及RabbitMQ的可靠消息传递，共同构建了一个强大的实时通信平台。在实际开发中，根据项目需求，还可以进一步添加更多的功能，如消息历史记录、表情支持、...
SpringBoot+nacos+websocket+redis+mysql+mybatis-plus微服务项目实战
01-11
开发者可以利用SpringBoot快速搭建服务，通过Nacos实现服务治理，使用WebSocket进行实时通信，借助Redis缓存数据并提高响应速度，同时利用MySQL和Oracle存储业务数据。Swagger2帮助我们清晰地定义和展示API，而...
可观测性-Metrics-Spring Websocket监控
laker的博客
06-29 1894
介绍：DistributionSummary用于计算一组值的分布统计信息，如平均值、最大值、最小值和百分位数等。适用场景：适用于度量一组值的分布情况，如请求响应时间、响应大小等。测量响应大小分布示例// 记录响应大小 summary . record(2048);// 记录响应大小 summary . record(512);// 记录响应大小 // 获取统计结果 long count = summary . count();
java WebSocket带参数处理使用
overturn的博客
12-06 3045
二、java代码调用，往websocker赋数据。三、测试是否连接成功以及推送信息。1、webSocket实现代码。
Vue+Websocket 带参数使用
weixin_47156901的博客
01-29 7039
Websocket 带参数使用 在页面初始化的时候就建立Websocket vue 前台 1.在data（）{定义websocket=null} 2.在methods（）{}以下方法 //打开一个websocket webSocket() { const wsurl = localhost:端口号 + "/deviceMonitorWebSocket/" + _self.userId +"/"+deviceId; _self.websoc
websocket链接携带参数
zc_huiyanruju的博客
06-05 2567
websocket链接携带参数。
webSocket入门级配置
2301_77577184的博客
09-13 857
dv.innerText = data.msg + ' ---- ' + data.time // 将消息和时间显示在 div 中。var div = document.querySelector('div') // 获取用于显示消息的 div 元素。var dv = document.createElement('div') // 创建一个新的 div 元素。conn.send(JSON.stringify(msg)) // 将消息对象转成 JSON 字符串发送。
websocket系列:如何在websocket建立连接时传递参数
弹指天下
09-03 1万+
websocket系列:如何在websocket建立连接时传递参数 主要采用2种方式： 1. 路径参数PathVariable 2. 查询参数RequestParam
WebSocket配置
m0_73321385的博客
06-19 5821
在实现WebSocket服务端时，需要查看具体的WebSocket服务端实现，确认支持的WebSocket协议版本号，并进行相应的配置。在WebSocket连接建立后，服务端和客户端可以互相发送心跳包，以保证连接的活性。3. 实现心跳包发送和接收机制：通过WebSocket客户端和服务端提供的接口函数实现心跳包的发送和接收机制，并根据具体的应用场景进行相应的调整。5. WebSocket心跳包：由于WebSocket连接是持久化的，需要保证连接的稳定性，服务端和客户端通常需要配置心跳包机制来维护连接。
websocket onclose方法如何关闭一个websocket链接
05-10
在JavaScript中，可以使用`close()`方法来关闭WebSocket连接。例如： ```javascript var socket = new WebSocket('ws://localhost:8080'); socket.onclose = function(event) { console.log('WebSocket closed: ', event); }; // 关闭连接 socket.close(); ``` 在`close()`方法中，你也可以传递两个参数，分别为`code`和`reason`，用于指定关闭的状态码和原因。例如： ```javascript socket.close(1000, 'Closing connection'); ``` 这将发送状态码1000和关闭原因“Closing connection”来关闭WebSocket连接。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值