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

SpringBoot（java）实现websocket实现实时通信_java springboot websocket

作者：weixin_40725706 | 2024-05-15 20:28:56

赞

踩

java springboot websocket

一、认识WebSocket

WebSockets是一种在Web应用程序中实现实时通信的技术。它允许客户端和服务器之间建立持久的、双向的通信通道，从而使得服务器可以实时向客户端推送数据，而不需要客户端不断地向服务器发起请求。这种实时通信的能力对于需要即时更新数据的应用程序非常有用，比如在线聊天应用、实时游戏、股票市场更新等。

在使用WebSockets时，通常需要以下步骤：

  1. 建立连接：客户端向服务器发起WebSocket连接请求，服务器接受连接请求后，双方建立WebSocket连接。

  2. 通信：一旦建立了连接，客户端和服务器就可以通过该连接进行双向通信，可以发送和接收数据。

  3. 处理消息：客户端和服务器需要处理接收到的消息，并根据需要进行相应的操作。消息的格式和内容可以根据应用程序的需求来定义。

  4. 关闭连接：当通信结束时，可以通过发送关闭消息来关闭WebSocket连接，释放资源。

在实际开发中，可以使用各种现代Web框架和库来简化WebSocket的使用，例如：

  • 在前端，可以使用现代JavaScript框架如Vue.js、React.js或Angular来处理WebSocket连接和消息传递。
  • 在后端，常见的Web框架如Spring Boot（Java）、Express.js（Node.js）、Django（Python）等都提供了对WebSocket的支持。

要实现实时通信，你需要在客户端和服务器端分别实现WebSocket连接的建立和消息的处理逻辑。具体的实现方式会根据你选择的编程语言、框架和库而有所不同。

二、使用WebSocket（参照若依后端SpringBoot，前端Vue.js）

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

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

2、配置匿名访问

.antMatchers("/websocket/**").permitAll()

3、若依的websocket实现实时通信代码

（1）SemaphoreUtils.java

  1. package com.ruoyi.framework.websocket;
  2.  
  3. import java.util.concurrent.Semaphore;
  4. import org.slf4j.Logger;
  5. import org.slf4j.LoggerFactory;
  6.  
  7. /**
  8.  * 信号量相关处理
  9.  * 
  10.  * @author ruoyi
  11.  */
  12. public class SemaphoreUtils
  13. {
  14.     /**
  15.      * SemaphoreUtils 日志控制器
  16.      */
  17.     private static final Logger LOGGER = LoggerFactory.getLogger(SemaphoreUtils.class);
  18.  
  19.     /**
  20.      * 获取信号量
  21.      * 
  22.      * @param semaphore
  23.      * @return
  24.      */
  25.     public static boolean tryAcquire(Semaphore semaphore)
  26.     {
  27.         boolean flag = false;
  28.  
  29.         try
  30.         {
  31.             flag = semaphore.tryAcquire();
  32.         }
  33.         catch (Exception e)
  34.         {
  35.             LOGGER.error("获取信号量异常", e);
  36.         }
  37.  
  38.         return flag;
  39.     }
  40.  
  41.     /**
  42.      * 释放信号量
  43.      * 
  44.      * @param semaphore
  45.      */
  46.     public static void release(Semaphore semaphore)
  47.     {
  48.  
  49.         try
  50.         {
  51.             semaphore.release();
  52.         }
  53.         catch (Exception e)
  54.         {
  55.             LOGGER.error("释放信号量异常", e);
  56.         }
  57.     }
  58. }

（2）WebSocketConfig.java

  1. package com.ruoyi.framework.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.  * 
  10.  * @author ruoyi
  11.  */
  12. @Configuration
  13. public class WebSocketConfig
  14. {
  15.     @Bean
  16.     public ServerEndpointExporter serverEndpointExporter()
  17.     {
  18.         return new ServerEndpointExporter();
  19.     }
  20. }

（3）WebSocketServer.java

  1. package com.ruoyi.framework.websocket;
  2.  
  3. import java.util.concurrent.Semaphore;
  4. import javax.websocket.OnClose;
  5. import javax.websocket.OnError;
  6. import javax.websocket.OnMessage;
  7. import javax.websocket.OnOpen;
  8. import javax.websocket.Session;
  9. import javax.websocket.server.ServerEndpoint;
  10. import org.slf4j.Logger;
  11. import org.slf4j.LoggerFactory;
  12. import org.springframework.stereotype.Component;
  13.  
  14. /**
  15.  * websocket 消息处理
  16.  * 
  17.  * @author ruoyi
  18.  */
  19. @Component
  20. @ServerEndpoint("/websocket/message")
  21. public class WebSocketServer
  22. {
  23.     /**
  24.      * WebSocketServer 日志控制器
  25.      */
  26.     private static final Logger LOGGER = LoggerFactory.getLogger(WebSocketServer.class);
  27.  
  28.     /**
  29.      * 默认最多允许同时在线人数100
  30.      */
  31.     public static int socketMaxOnlineCount = 100;
  32.  
  33.     private static Semaphore socketSemaphore = new Semaphore(socketMaxOnlineCount);
  34.  
  35.     /**
  36.      * 连接建立成功调用的方法
  37.      */
  38.     @OnOpen
  39.     public void onOpen(Session session) throws Exception
  40.     {
  41.         boolean semaphoreFlag = false;
  42.         // 尝试获取信号量
  43.         semaphoreFlag = SemaphoreUtils.tryAcquire(socketSemaphore);
  44.         if (!semaphoreFlag)
  45.         {
  46.             // 未获取到信号量
  47.             LOGGER.error("\n 当前在线人数超过限制数- {}", socketMaxOnlineCount);
  48.             WebSocketUsers.sendMessageToUserByText(session, "当前在线人数超过限制数：" + socketMaxOnlineCount);
  49.             session.close();
  50.         }
  51.         else
  52.         {
  53.             // 添加用户
  54.             WebSocketUsers.put(session.getId(), session);
  55.             LOGGER.info("\n 建立连接 - {}", session);
  56.             LOGGER.info("\n 当前人数 - {}", WebSocketUsers.getUsers().size());
  57.             WebSocketUsers.sendMessageToUserByText(session, "连接成功");
  58.         }
  59.     }
  60.  
  61.     /**
  62.      * 连接关闭时处理
  63.      */
  64.     @OnClose
  65.     public void onClose(Session session)
  66.     {
  67.         LOGGER.info("\n 关闭连接 - {}", session);
  68.         // 移除用户
  69.         WebSocketUsers.remove(session.getId());
  70.         // 获取到信号量则需释放
  71.         SemaphoreUtils.release(socketSemaphore);
  72.     }
  73.  
  74.     /**
  75.      * 抛出异常时处理
  76.      */
  77.     @OnError
  78.     public void onError(Session session, Throwable exception) throws Exception
  79.     {
  80.         if (session.isOpen())
  81.         {
  82.             // 关闭连接
  83.             session.close();
  84.         }
  85.         String sessionId = session.getId();
  86.         LOGGER.info("\n 连接异常 - {}", sessionId);
  87.         LOGGER.info("\n 异常信息 - {}", exception);
  88.         // 移出用户
  89.         WebSocketUsers.remove(sessionId);
  90.         // 获取到信号量则需释放
  91.         SemaphoreUtils.release(socketSemaphore);
  92.     }
  93.  
  94.     /**
  95.      * 服务器接收到客户端消息时调用的方法
  96.      */
  97.     @OnMessage
  98.     public void onMessage(String message, Session session)
  99.     {
  100.         String msg = message.replace("你", "我").replace("吗", "");
  101.         WebSocketUsers.sendMessageToUserByText(session, msg);
  102.     }
  103. }

（4）WebSocketUsers.java

  1. package com.ruoyi.framework.websocket;
  2.  
  3. import java.io.IOException;
  4. import java.util.Collection;
  5. import java.util.Map;
  6. import java.util.Set;
  7. import java.util.concurrent.ConcurrentHashMap;
  8. import javax.websocket.Session;
  9. import org.slf4j.Logger;
  10. import org.slf4j.LoggerFactory;
  11.  
  12. /**
  13.  * websocket 客户端用户集
  14.  * 
  15.  * @author ruoyi
  16.  */
  17. public class WebSocketUsers
  18. {
  19.     /**
  20.      * WebSocketUsers 日志控制器
  21.      */
  22.     private static final Logger LOGGER = LoggerFactory.getLogger(WebSocketUsers.class);
  23.  
  24.     /**
  25.      * 用户集
  26.      */
  27.     private static Map<String, Session> USERS = new ConcurrentHashMap<String, Session>();
  28.  
  29.     /**
  30.      * 存储用户
  31.      *
  32.      * @param key 唯一键
  33.      * @param session 用户信息
  34.      */
  35.     public static void put(String key, Session session)
  36.     {
  37.         USERS.put(key, session);
  38.     }
  39.  
  40.     /**
  41.      * 移除用户
  42.      *
  43.      * @param session 用户信息
  44.      *
  45.      * @return 移除结果
  46.      */
  47.     public static boolean remove(Session session)
  48.     {
  49.         String key = null;
  50.         boolean flag = USERS.containsValue(session);
  51.         if (flag)
  52.         {
  53.             Set<Map.Entry<String, Session>> entries = USERS.entrySet();
  54.             for (Map.Entry<String, Session> entry : entries)
  55.             {
  56.                 Session value = entry.getValue();
  57.                 if (value.equals(session))
  58.                 {
  59.                     key = entry.getKey();
  60.                     break;
  61.                 }
  62.             }
  63.         }
  64.         else
  65.         {
  66.             return true;
  67.         }
  68.         return remove(key);
  69.     }
  70.  
  71.     /**
  72.      * 移出用户
  73.      *
  74.      * @param key 键
  75.      */
  76.     public static boolean remove(String key)
  77.     {
  78.         LOGGER.info("\n 正在移出用户 - {}", key);
  79.         Session remove = USERS.remove(key);
  80.         if (remove != null)
  81.         {
  82.             boolean containsValue = USERS.containsValue(remove);
  83.             LOGGER.info("\n 移出结果 - {}", containsValue ? "失败" : "成功");
  84.             return containsValue;
  85.         }
  86.         else
  87.         {
  88.             return true;
  89.         }
  90.     }
  91.  
  92.     /**
  93.      * 获取在线用户列表
  94.      *
  95.      * @return 返回用户集合
  96.      */
  97.     public static Map<String, Session> getUsers()
  98.     {
  99.         return USERS;
  100.     }
  101.  
  102.     /**
  103.      * 群发消息文本消息
  104.      *
  105.      * @param message 消息内容
  106.      */
  107.     public static void sendMessageToUsersByText(String message)
  108.     {
  109.         Collection<Session> values = USERS.values();
  110.         for (Session value : values)
  111.         {
  112.             sendMessageToUserByText(value, message);
  113.         }
  114.     }
  115.  
  116.     /**
  117.      * 发送文本消息
  118.      *
  119.      * @param userName 自己的用户名
  120.      * @param message 消息内容
  121.      */
  122.     public static void sendMessageToUserByText(Session session, String message)
  123.     {
  124.         if (session != null)
  125.         {
  126.             try
  127.             {
  128.                 session.getBasicRemote().sendText(message);
  129.             }
  130.             catch (IOException e)
  131.             {
  132.                 LOGGER.error("\n[发送消息异常]", e);
  133.             }
  134.         }
  135.         else
  136.         {
  137.             LOGGER.info("\n[你已离线]");
  138.         }
  139.     }
  140. }

（5）webSocket.js

  1. /**
  2.  * 参数说明：
  3.  *  webSocketURL：String    webSocket服务地址    eg: ws://127.0.0.1:8088/websocket (后端接口若为restful风格可以带参数)  
  4.  *  callback：为带一个参数的回调函数
  5.  *  message：String 要传递的参数值（不是一个必要的参数）
  6.  */
  7. export default{
  8.     // 初始化webSocket
  9.     webSocketInit(webSocketURL){      // ws://127.0.0.1:8088/websocket
  10.         this.webSocket = new WebSocket(webSocketURL);
  11.         this.webSocket.onopen = this.onOpenwellback;
  12.         this.webSocket.onmessage = this.onMessageCallback;
  13.         this.webSocket.onerror = this.onErrorCallback;
  14.         this.webSocket.onclose = this.onCloseCallback;
  15.     },
  16.  
  17.     // 自定义回调函数
  18.     setOpenCallback(callback){ //  与服务端连接打开回调函数
  19.         this.webSocket.onopen = callback;
  20.     },
  21.     setMessageCallback(callback){   //  与服务端发送消息回调函数
  22.         this.webSocket.onmessage = callback;
  23.     },
  24.     setErrorCallback(callback){ //  与服务端连接异常回调函数
  25.         this.webSocket.onerror = callback;
  26.     },
  27.     setCloseCallback(callback){ //  与服务端连接关闭回调函数
  28.         this.webSocket.onclose = callback;
  29.     },
  30.  
  31.     close(){    // 关闭连接
  32.         this.webSocket.close();
  33.     },
  34.     sendMessage(message){   // 发送消息函数
  35.         this.webSocket.send(message);
  36.     },
  37. }

（6）index.vue

  1. <template>
  2.     <div class="contanier" >
  3.         
  4.     </div>
  5. </template>
  6.     
  7.     
  8. <script>
  9. import webSocket from '@/utils/webSocket'
  10. import Cookie from 'js-cookie'
  11.  
  12. export default {
  13.     name: "WebSocketTest",
  14.    
  15.     data() {
  16.         return {
  17.             id: null,
  18.             infoList: {
  19.                
  20.             },
  21.            
  22.             webSocketObject: null,
  23.            
  24.         }
  25.     },
  26.     created() {
  27.         
  28.         this.createWebSocket();
  29.       
  30.     },
  31.     methods: {
  32.  
  33.         sendMessage() {
  34.             // 数据发生改变时给WebSocket发送消息，让其进行广播操作
  35.             webSocket.sendMessage("11111");
  36.         },
  37.     // 与websocket服务器创建连接
  38.         createWebSocket() {
  39.             if (typeof (webSocket) === "undefined") {
  40.                 alert("您的浏览器不支持socket")
  41.             }
  42.             const TokenKey = Cookie.get("Admin-Token");
  43.  
  44.             webSocket.webSocketInit('ws://127.0.0.1:8080/websocket/message' )	//初始化webSocket
  45.             // 按需进行绑定回调函数
  46.             webSocket.setOpenCallback(res => {
  47.                 console.log("连接建立成功", res);
  48.             })
  49.             webSocket.setMessageCallback(res => {
  50.                 if (res.data === "连接成功") {
  51.                     console.log("连接成功");
  52.                     return;
  53.                 }
  54.                 // 在此处进行数据刷新操作即可实现数据发生改变时实时更新数据
  55.                 console.log("接收到回信", res);
  56.                 console.log("接收到回信", JSON.parse(res.data));
  57.                 this.infoList = JSON.parse(res.data);
  58.              
  59.             })
  60.             webSocket.setErrorCallback(res => {
  61.                 console.log("连接异常", res);
  62.                
  63.             })
  64.             webSocket.setCloseCallback(res => {
  65.                 console.log("连接关闭", res);
  66.                
  67.             })
  68.         }
  69.     }
  70. }
  71. </script>
  72. <style scoped>
  73.  
  74. </style>

三、实现

前后端同时打开：

关闭后端：

 关闭前端：

后端向前端发送信息（群发）：

 WebSocketUsers.sendMessageToUsersByText(JSONObject.toJSONString(list));

 后端向前端发送信息（单发）：

 WebSocketUsers.sendMessageToUserByText(value,JSONObject.toJSONString(list));

参考：

插件集成 | RuoYi

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

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

  

闽ICP备14008679号