springboot集成websocket

已于 2024-09-03 14:42:54 修改
阅读量268 收藏 3
点赞数 6
文章标签： spring boot websocket 后端
于 2024-08-19 15:28:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40400735/article/details/141326198
版权

pom.xml

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

WebSocketConfig.java

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

@Configuration
public class WebSocketConfig {
    /**
     * 	注入ServerEndpointExporter，
     * 	这个bean会自动注册使用了@ServerEndpoint注解声明的Websocket endpoint
     */
    @Bean
    public ServerEndpointExporter serverEndpointExporter() {
        return new ServerEndpointExporter();
    }

}

Application

解决spring bean无法注入问题，如：在websocket中使用redis

@Slf4j
@SpringBootApplication
@EnableScheduling
@EnableAspectJAutoProxy
public class Application {
    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(Application.class);
        ConfigurableApplicationContext ctx = app.run(args);
        
        /**解决spring bean无法注入问题*/
        WebSocket.setApplicationContext(ctx);
        /**解决spring bean无法注入问题*/
    }
}

WebSocket.java

结合 springboot集成redis,redis常用工具类及redis队列使用
如果不需要删除redis相关代码就行

import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSONObject;
import com.linus.config.redis.RedisUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.ApplicationContext;
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.Set;
import java.util.concurrent.ConcurrentHashMap;

/**
 * Description: websocker服务类
 * @date: 2024/7/26
 */
@Slf4j
@Component
@ServerEndpoint("/websocket/{userId}") //此注解相当于设置访问URL
public class WebSocket {
    private Session session;
    private String userId;

    //线程安全的map，用来保存每个客户端对应的WebSocket对象
    private static ConcurrentHashMap<String, WebSocket> webSocketMap = new ConcurrentHashMap<>();
    //缓存消息的redis key
    final String WEBSOCKET_CACHE_MESSAGE_REDIS_KEY = "WEBSOCKET_CACHE_MESSAGE_REDIS_KEY";
    
    /*************解决spring bean无法注入问题**************/
    private static ApplicationContext applicationContext;

    public static void setApplicationContext(ApplicationContext applicationContext) {
        WebSocket.applicationContext = applicationContext;
    }
    /*************解决spring bean无法注入问题**************/
    
    /**
     * 连接成功
     * @OnOpen注解：websocket 连接成功后，触发该注解修饰的方法
     * @param session
     */
    @OnOpen
    public void onOpen(Session session, @PathParam(value = "userId") String userId) {
        try {
            this.session = session;
            this.userId = userId;
            if (webSocketMap.containsKey(userId)) {
                webSocketMap.remove(userId);
                webSocketMap.put(userId, this);
            } else {
                webSocketMap.put(userId, this);
            }
            log.info("【websocket消息】有新的连接，总数为:" + webSocketMap.size());
            //取出消息列表
            RedisUtil redisUtil = applicationContext.getBean(RedisUtil.class);
            while (redisUtil.hasKey(WEBSOCKET_CACHE_MESSAGE_REDIS_KEY+":"+userId)) {
                String message = (String) redisUtil.lLeftPop(WEBSOCKET_CACHE_MESSAGE_REDIS_KEY + ":" + userId);
                if (StrUtil.isEmpty(message)) {
                    log.info("用户" + userId + "没有缓存的消息");
                } else {
                    //todo 发送消息-发送后清除缓存的消息
                    sendInfoByUserId(userId, message);
                    log.info("用户" + userId + "缓存的消息发送成功");
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 接收消息
     * @OnMessage注解：客户端发送消息时，触发该注解声明的方法
     * @param message
     * @return
     */
    @OnMessage
    public void onMessage(String message) {
        log.info("【websocket消息】收到客户端消息userId:" + userId + ",接收信息：" + message);
        if (webSocketMap.containsKey(userId)) {
            try {
                JSONObject obj = new JSONObject();
                obj.put("cmd","heart");
                obj.put("msgTxt", "心跳");
                sendInfoByUserId(this.userId,obj.toJSONString());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    /**
     * 连接关闭
     * @OnClose注解：websocket断开连接后，触发该注解修饰的方法
     * @param session
     */
    @OnClose
    public void onClose(Session session) {
        try {
            if (webSocketMap.containsKey(userId)) {
                webSocketMap.remove(userId);
            }
            log.info("【websocket消息】连接断开，总数为:" + webSocketMap.size());
            // userStatusMessage();
        } catch (Exception e) {
        }
    }
    /**
     * 连接异常
     * @OnError注解：当建立的连接出现异常后，触发该注解修饰的方法
     * @param session
     * @param throwable
     */
    @OnError
    public void onError(Session session,Throwable throwable) {
        log.info("【websocket消息】连接异常:" + throwable.getMessage());
    }
    /**
     * 服务器给指定WebSocket客户端发送信息
     * @param userId
     * @param message
     */
    public void sendInfoByUserId(String userId, String message) {
        System.out.println("后端发送前端web数据userId:" + userId + "发送消息：" + message);
        try {
            if (webSocketMap.containsKey(userId)) {
                webSocketMap.get(userId).session.getBasicRemote().sendText(message);
            } else {
                log.info("用户" + userId + "没有连接");
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
    /**
     * 服务器给指定WebSocket客户端发送信息,如果未连接，缓存到redis
     * @param userId
     * @param message
     */
    public void sendInfoByUserId_cache(String userId, String message) {
        System.out.println("后端发送前端web数据userId:" + userId + "发送消息：" + message);
        try {
            if (webSocketMap.containsKey(userId)) {
                webSocketMap.get(userId).session.getBasicRemote().sendText(message);
            } else {
                log.info("用户" + userId + "没有连接");
                //把新消息缓存到redis列表
                RedisUtil redisUtil = applicationContext.getBean(RedisUtil.class);
                redisUtil.rSet(WEBSOCKET_CACHE_MESSAGE_REDIS_KEY+":"+userId,message);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
    /**
     * 服务器给全部连接客户端发送信息
     * @param message
     */
    public void sendInfoAll(String message) {
        try {
            webSocketMap.values().forEach(ws -> ws.session.getAsyncRemote().sendText(message));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 此为单点消息(多人)
     * @param userIds
     * @param message
     */
    public void sendInfoByUserIds(String[] userIds, String message) {
        for (String userId : userIds) {
            sendInfoByUserId(userId, message);
        }
    }
    /**
     * 此为单点消息(多人),如果未连接缓存消息到redis
     * @param userIds
     * @param message
     */
    public void sendInfoByUserIds_cache(String[] userIds, String message) {
        for (String userId : userIds) {
            sendInfoByUserId_cache(userId, message);
        }
    }
    /**
     * 获取全部连接用户的id
     * @return
     */
    public Set<String> getAllUserIds() {
        return webSocketMap.keySet();
    }

}

socket.js

uniapp
class Socket {
    constructor(options) {
        this.socketUrl = 'ws://117.72.37.178:24908/websocket/';
        this.socketStart = false;
        this.heartbeatTimer = null;
        this.user = null;
        this.initSocketListeners();
    }
    initSocketListeners() {
        uni.onSocketOpen(() => {
            this.socketStart = true;
            console.log('WebSocket连接已打开！');
            this.startHeartbeat();
        });
        uni.onSocketMessage(res => {
            const data = JSON.parse(res.data);
            this.acceptMessage && this.acceptMessage(data);
        });
        uni.onSocketClose(() => {
            console.log('WebSocket 已关闭！');
            this.socketStart = false;
            this.reconnect();
        });
        uni.onSocketError(() => {
            console.log('WebSocket连接打开失败，请检查！');
            this.socketStart = false;
            this.reconnect();
        });
    }
    init(callback) {
		this.user = uni.getStorageSync('user')
        if (this.socketUrl && this.user.id) {
            if (!this.socketStart) {
                const url = `${this.socketUrl}${this.user.id}_app`;
                console.log("启动 socketUrl 连接地址:", url);
                uni.connectSocket({ url, method: 'GET' });
                callback && callback();
            } else {
                console.log('webSocket已经启动了');
            }
        } else {
            console.log('config/baseUrl socketUrl为空');
        }
    }
    send(data) {
        return new Promise((resolve, reject) => {
            uni.sendSocketMessage({
                data: JSON.stringify(data),
                success: resolve,
                fail: reject
            });
        });
    }
    startHeartbeat() {
        this.heartbeatTimer = setInterval(() => {
            this.send({ type: "心跳", userUid: this.user.id })
                .catch(() => {
                    console.log('心跳发送失败');
                    this.reconnect();
                });
        }, 10000);
    }
    stopHeartbeat() {
        clearInterval(this.heartbeatTimer);
        this.heartbeatTimer = null;
    }
    reconnect() {
        this.stopHeartbeat();
        setTimeout(() => {
            this.init();
        }, 5000);
    }
    closeSocket() {
        uni.closeSocket();
		this.user = null;
        this.socketStart = false;
        this.stopHeartbeat();
    }
}

const mySocket = new Socket();
export default mySocket;
vue
export const WebsocketMixin = {
  mounted() {
    this.initWebSocket();
  },
  destroyed: function () {
    // 离开页面生命周期函数
    this.websocketOnclose();
  },
  methods:{
    initWebSocket: function () {
      console.log("------------WebSocket连接成功");
      // WebSocket与普通的请求所用协议有所不同，ws等同于http，wss等同于https
      var userId = store.getters.userInfo.id;
      if(!this.socketUrl.startsWith('/')){
        this.socketUrl = '/' + this.socketUrl
      }
      if(!this.socketUrl.endsWith('/')){
        this.socketUrl = this.socketUrl + '/'
      }
      let url = window._CONFIG['domianURL'].replace("https://","wss://").replace("http://","ws://") + this.socketUrl + userId;

      this.websock = new WebSocket(url);
      this.websock.onopen = this.websocketOnopen;
      this.websock.onerror = this.websocketOnerror;
      this.websock.onmessage = this.websocketOnmessage;
      this.websock.onclose = this.websocketOnclose;
    },
    websocketOnopen: function () {
      console.log("WebSocket连接成功");
    },
    websocketOnerror: function (e) {
      console.log("WebSocket连接发生错误");
      this.reconnect();
    },
    websocketOnclose: function (e) {
      this.reconnect();
    },
    websocketSend(text) {
      // 数据发送
      try {
        this.websock.send(text);
      } catch (err) {
        console.log("send failed (" + err.code + ")");
      }
    },
    reconnect() {
      var that = this;
      if(that.lockReconnect) return;
      that.lockReconnect = true;
      //没连接上会一直重连，设置延迟避免请求过多
      setTimeout(function () {
        console.info("尝试重连...");
        that.initWebSocket();
        that.lockReconnect = false;
      }, 5000);
    },
  }
}
qq_40400735
关注
SpringBoot集成WebSocket长连接实际应用详解
08-19
SpringBoot集成WebSocket长连接实际应用详解 本文主要介绍了SpringBoot集成WebSocket长连接实际应用详解，通过示例代码详细介绍了WebSocket的应用场景和实现方式，对大家的学习或者工作具有一定的参考学习价值。 ...
SpringBoot集成WebSocket实现前后端消息互传的方法
08-25
SpringBoot集成WebSocket实现前后端消息互传的方法 SpringBoot集成WebSocket实现前后端消息互传的方法是当前互联网技术中的一种常见的实现方式。WebSocket是一种基于TCP的网络协议，能够实现浏览器与服务器的全双工...
Springboot集成websocket
囚徒之困
05-23 4503
Springboot集成websocket
SpringBoot 集成 WebSocket
功不唐捐，玉汝于成
04-21 6158
SpringBoot 整合 websocket、websocket 的通信应用
SpringBoot集成WebSocket
pursue.dreams的博客
05-23 537
【代码】SpringBoot集成WebSocket。
SpringBoot集成websocket
usa_washington的博客
03-05 1472
websocket
springboot集成Websocket
w_t_y_y的博客
07-29 559
一、集成 二、demo
SpringBoot 集成WebSocket详解
热门推荐
Charge8的博客
05-30 3万+
SpringBoot 集成WebSocket详解
springboot 集成websocket
大哥一声吼
05-29 8169
springboot 和websocket 集成
Springboot集成WebSocket
weixin_57205390的博客
03-06 604
简介：WebSocket是一种在单个TCP连接上进行全双工通信的协议。WebSocket通信协议于2011年被IETF定为标准RFC 6455，并由RFC7936补充规范。WebSocket API也被W3C定为标准。WebSocket使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。在WebSocket API中，浏览器和服务器只需要完成一次握手，两者之间就直接可以创建持久性的连接，并进行双向数据传输。说明：本篇主要介绍在SpringBoot框架下，WebSocket基于注解使
springboot 集成webSocket
just_learing的博客
07-20 4865
springboot 集成webSocket
springboot集成websocket的简单例子
03-02
首先，为了集成WebSocket，我们需要引入相关的依赖。在Spring Boot项目中，我们通常通过添加`spring-boot-starter-websocket`依赖来启用WebSocket功能。在`pom.xml`或`build.gradle`文件中添加如下依赖： ```xml <!...
Springboot集成websocket+protobuf基本Demo，可实现后端与前端数据实时发送与接收.zip
01-04
WebSocket是一种在客户端和服务器之间建立长连接的协议，它允许双方进行全双工通信，即...这个示例项目"Springboot集成websocket+protobuf基本Demo"提供了一个基础的实现，可以帮助开发者快速理解和实践这一技术组合。
springboot集成websocket实现简单聊天
03-29
在本项目中，我们将探讨如何利用Spring Boot集成WebSocket，以实现一个简单的聊天应用。 首先，我们需要在Spring Boot项目中引入WebSocket的相关依赖。Spring Boot本身并不直接支持WebSocket，但可以通过Spring ...
Spring Boot课程支持：智能答疑系统
2402_85762143的博客
10-11 1059
在概念模式的设计中，E-R模型法是最常见的设计方法。同时，一个大型的计算机网站系统，必须有一个正确的设计指导思想，通过合理选择数据结构、网络结构、操作系统以及开发环境，构成一个完善的网络体系结构，才能充分发挥计算机信息管理的优势。随着计算机技术的发展以及计算机网络的逐渐普及，互联网成为人们查找信息的重要场所，二十一世纪是信息的时代，所以信息的交换和信息流通显得特别重要。2.高可靠性：一个实用的网站同时必须是可靠的，本设计通过合理而先进的网络设计以及软、硬件的优化选型，可保证网站的可靠性与容错性。
在Spring Boot中具有多个实现的接口正确注入的六种方式
2301_76419561的博客
10-12 957
以上六种方法各有优缺点，选择哪种方法取决于你的具体需求和偏好。在大多数情况下，使用@Autowired和@Qualifier注解是最直接和灵活的方式。然而，在某些情况下，使用@Primary注解、构造方法注入或Java配置类可能更合适。最后，将接口的所有实现注入到List或Map中提供了一种处理多个实现的强大方式。
春日技术辅导：Spring Boot课程答疑平台
2401_85702623的博客
10-11 970
在整个系统测试中，根据需求文档和设计文档，逐一对功能进行检测并写好测试用例，有效避免残片缺陷，因为产品出现缺陷不仅影响功能，而且可以导致数据的不准确，导致产品质量的降低，经过测试，才能使得产品的稳定性和成熟度得到极大的提升，产品质量也才有保证。近来，软件工程界趋向于一种新的观点，即认为软件生命周期每一阶段中都应包含测试，从而检验本阶段的成果是否接近预期的目标，尽可能早的发现错误并加以修正，如果不在早期阶段进行测试，错误的延时扩散常常会导致最后成品测试的巨大困难。至此，在功能的测试上也已经比较圆满的完成了。
确保Spring Boot定时任务只执行一次方案
最新发布
2301_76419561的博客
10-14 415
确保Spring Boot定时任务只执行一次有多种方法，你可以根据实际需求选择最适合的方法。如果你需要更复杂的任务调度或周期性执行，@Scheduled注解和接口是更合适的选择。而对于一次性的初始化任务或应用程序启动任务，注解和实现接口则更为简洁明了。
springboot集成 websocket
05-27
SpringBoot集成WebSocket可以使用Spring框架提供的WebSocket API来实现。在SpringBoot中，使用WebSocket需要进行以下几个步骤： 1. 添加依赖：在pom.xml文件中添加spring-boot-starter-websocket依赖。 2. 创建...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值