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

“编程式 WebSocket” 实现简易 online QQ在线聊天项目_nestjs 使用websockt 实现聊天

作者：Cpp五条 | 2024-05-21 06:21:26

赞

踩

nestjs 使用websockt 实现聊天

目录

一、需求分析与演示

1.1、需求分析

1.2、效果演示

二、客户端、服务器开发

2.1、客户端开发

2.2、服务器开发

一、需求分析与演示

1.1、需求分析

需求：实现一个 online QQ在线聊天项目，当用户登录上自己的账号后，将会显示在线，并可以向自己的好友进行在线聊天，退出登录后，将会把当前用户下线的消息推送给该用户的所有好友，并标识“下线”。

分析：以上需求中，当用户上线后，将玩家上线消息推送给他所有的好友，以及在聊天时，将消息及时的推送给好友，最核心的就是基于 WebSocket 的消息推送机制，接下里我们就来看看如何使用 WebSocket + Spring Boot 实现在线聊天功能~

1.2、效果演示

二、客户端、服务器开发

2.1、客户端开发

js 代码编写：创建 WebSocket 实例，重写以下四个方法：

  • onopen：websocket 连接建立成功触发该方法.
  • onmessage（重点实现）：接收到服务器 websocket 响应后触发该请求.
  • onerror：websocket 连接异常时触发该方法.
  • onclose：websocket 连接断开时触发该方法.

另外，我们可以再加一个方法，用来监听页面关闭（刷新、跳转）事件，进行手动关闭 websocket，为了方便处理用户下线 如下：

  1.         //监听页面关闭事件，页面关闭之前手动操作 websocket 
  2.         window.onbeforeunload = function() {
  3.             websocket.close();
  4.         }

a）首先用户点击对应的聊天对象，开启聊天框（使用字符串拼接，最后使用 jQuery 的 html 方法填充即可），并使用 sessionStorage 通过对方的 id 获取聊天信息（这里我们约定以用户 id 为键，聊天信息为值进行存储）。

Ps：sessionStotage 类似于 服务器开发中的 HttpSession ，以键值对的方式通过 setItem 方法存储当前用户，通过 getItem 方法获取会话信息。

  1.         //点击用户卡片，开启聊天框
  2.         function startChat(nickname, photo, id) {
  3.             //修改全局对方头像和 id
  4.             otherPhoto = photo;
  5.             otherId = id;
  6.             var containerRight = "";
  7.             containerRight += '<div class="userInfo">';
  8.             containerRight += '<span>'+nickname+'</span>';
  9.             containerRight += '</div>';
  10.             containerRight += '<div class="chatList">';
  11.             containerRight += '</div>';
  12.             containerRight += '<div class="editor">';
  13.             containerRight += '<textarea id="messageText" autofocus="autofocus" maxlength="500" placeholder="请在这里输入您想发送的消息~"></textarea>';
  14.             containerRight += '<div class="sendMsg">';
  15.             containerRight += '<button id="sendButton" onclick="sendMsg()">发送</button>';
  16.             containerRight += '</div>';
  17.             containerRight += '</div>';
  18.             //拼接
  19.             jQuery(".container-right").html(containerRight);
  20.             //清空聊天框
  21.             
  22.             //使用 sessionStorage 获取对话信息
  23.             var chatData = sessionStorage.getItem(otherId);
  24.             if(chatData != null) {
  25.                 //说明之前有聊天
  26.                 jQuery(".chatList").html(chatData);
  27.             }
  28.         }

为了方便获取当前用户，和对方信息，创建以下三个全局变量：

  1.         //自己的头像
  2.         var selfPhoto = "";
  3.         //对方的头像和id
  4.         var otherPhoto = "";
  5.         var otherId = -1;

当前用户信息通过 ajax 获取即可，如下：

  1.         //获取当前登录用户信息
  2.         function getCurUserInfo() {
  3.             jQuery.ajax({
  4.                 type: "POST",
  5.                 url: "/user/info",
  6.                 data: {},
  7.                 async: false,
  8.                 success: function(result) {
  9.                     if(result != null && result.code == 200) {
  10.                         //获取成功，展示信息
  11.                         jQuery(".mycard > .photo").attr("src", result.data.photo);
  12.                         jQuery(".mycard > .username").text(result.data.nickname+"(自己)");
  13.                         //修改全局头像(selfPhoto)
  14.                         selfPhoto = result.data.photo;
  15.                     } else {
  16.                         alert("当前登录用户信息获取失败!");
  17.                     }
  18.                 }
  19.             });
  20.         }
  21.         getCurUserInfo();

b）接下来就是当前用户发送消息给对方了，这时就需要用到我们的 websocket 消息推送机制，具体的，创建 websocket 实例，实现以下四大方法：

  1.         //创建 WebSocket 实例
  2.         //TODO: 上传云服务器的时候需要进行修改路径
  3.         var host = window.location.host;
  4.         var websocket = new WebSocket("ws://"+host+"/chat");
  5.  
  6.         websocket.onopen = function() {
  7.             console.log("连接成功");
  8.         }
  9.  
  10.         websocket.onclose = function() {
  11.             console.log("连接关闭");
  12.         }
  13.  
  14.         websocket.onerror = function() {
  15.             console.log("连接异常");
  16.         }
  17.  
  18.         //监听页面关闭事件，页面关闭之前手动操作 websocket 
  19.         window.onbeforeunload = function() {
  20.             websocket.close();
  21.         }
  22.  
  23.         //处理服务器返回的响应(一会重点实现)
  24.         websocket.onmessage = function(e) {
  25.             //获取服务器推送过来的消息
  26.  
  27.         }

接着创建一个 sendMsg() 方法，用来发送聊天信息，首先还是一如既往的非空校验（发送的聊聊天消息不能为空），接着还需要校验消息推送的工具 websocket 是否连接正常（websocket.readState == websocket.OPEN 成立表示连接正常），连接正常后，首先将用户发送的消息在客户端界面上进行展示，再将发送的消息使用 JSON 格式（JSON.stringify）进行封装，这是 websocket 的 send 方法发送消息约定的格式，包装后使用 websocket.send 发送数据，接着不要忘记使用 sessionStorage 存储当前用户发送的消息，最后清除输入框内容，如下 js 代码：

  1.         //发送信息
  2.         function sendMsg() {
  3.             //非空校验           
  4.             var message = jQuery("#messageText");
  5.             if(message.val() == "") {
  6.                 alert("发送信息不能为空!");
  7.                 return;
  8.             }
  9.             //触发 websocket 请求前，先检验 websocket 连接是否正常(readyState == OPEN 表示连接正常)
  10.             if (websocket.readyState == websocket.OPEN) {
  11.                 //客户端展示
  12.                 var chatDiv = "";   
  13.                 chatDiv += '<div class="self">';
  14.                 chatDiv += '<div class="msg">'+message.val()+'</div>';
  15.                 chatDiv += '<img src="'+selfPhoto+'" class="photo" alt="">';
  16.                 chatDiv += '</div>';
  17.                 jQuery(".chatList").append(chatDiv);
  18.                 //消息发送给服务器
  19.                 var json = {
  20.                     "code": otherId,
  21.                     "msg": message.val()
  22.                 };
  23.                 websocket.send(JSON.stringify(json));
  24.                 //使用 sessionStorage 存储对话信息
  25.                 var chatData = sessionStorage.getItem(otherId);
  26.                 if(chatData != null) {
  27.                     chatDiv = chatData + chatDiv;
  28.                 }
  29.                 sessionStorage.setItem(otherId, chatDiv);
  30.                 //清除输入框内容
  31.                 message.val("");
  32.             } else {
  33.                 alert("当前您的连接已经断开，请重新登录!");
  34.                 location.assign("/login.html");
  35.             }
  36.         }

Ps：textarea 控件 必须要具有 name 值，才能使用 jQuery 通过 id 获取到，并使用 val() 方法获取到相应的值！！！

c）我们该如何接收对方推送过来的消息呢？这时候我们就需要来重点实现 websocket 的 onmessage 方法了~ onmessage 方法中有一个参数，这个参数便是响应信息，通过 .data 获取这个参数的 JSON 数据，这个 JSON 格式数据需要通过 JSON.parse 方法转化成 js 对象，这样就拿到了我们需要的约定的数据（约定的数据是前后端交互时同一的数据格式）~ 

这里的响应有以下 4 种可能，我们通过约定数据格式中的 msg 字段进行区分：

  1. 初始化好友列表(init)
  2. 推送上线消息(online)
  3. 下线(offline)
  4. 聊天消息(msg)

前三个响应都很好处理，这里主要讲一下第四个：“拿到聊天消息后，首先进行检验，只有对方的 id 和我们发送给对方消息时携带的对方 id 相同时，才将消息进行展示，最后使用 sessionStorage 存储对象信息”，如下代码：

  1.         //处理服务器返回的响应
  2.         websocket.onmessage = function(e) {
  3.             //获取服务器推送过来的消息
  4.             var jsonInfo = e.data;
  5.             //这里获取到的 jsonInfo 是 JSON 格式的数据，我们需要将他转化成 js 对象
  6.             var result = JSON.parse(jsonInfo);
  7.             if(result != null) {
  8.                 //这里的响应有四种可能：1.初始化好友列表(init) 2.推送上线消息(online) 3.下线(offline) 4.聊天消息(msg)
  9.                 if(result.msg == "init") {
  10.                     //1.初始化好友列表
  11.                     var friendListDiv = "";
  12.                     for(var i = 0; i < result.data.length; i++) {
  13.                         //获取每一个好友信息
  14.                         var friendInfo = result.data[i];
  15.                         friendListDiv += '<div class="friend-card" id="'+friendInfo.id+'" onclick="javascript:startChat(\''+friendInfo.nickname+'\', \''+friendInfo.photo+'\','+friendInfo.id+')">';
  16.                         friendListDiv += '<img src="'+friendInfo.photo+'" class="photo"  alt="">';
  17.                         friendListDiv += '<span class="username">'+friendInfo.nickname+'</span>';
  18.                         //判断是否在线
  19.                         if(friendInfo.online == "在线") {
  20.                             friendListDiv += '<span class="state" id="state-yes">'+friendInfo.online+'</span>';
  21.                         } else {
  22.                             friendListDiv += '<span class="state" id="state-no">'+friendInfo.online+'</span>';
  23.                         }
  24.                         friendListDiv += '</div>';
  25.                     }
  26.                     //拼接
  27.                     jQuery("#friends").html(friendListDiv);
  28.                 } else if(result.msg == "online") {
  29.                     //2.推送上线消息
  30.                     var state = jQuery("#"+result.data+" > .state");
  31.                     state.text("在线");
  32.                     state.attr("id", "state-yes");
  33.                 } else if(result.msg == "offline"){
  34.                     //3.推送下线消息
  35.                     var state = jQuery("#"+result.data+" > .state");
  36.                     state.text("离线");
  37.                     state.attr("id", "state-no");
  38.                 } else if(result.msg == "msg"){
  39.                     //4.聊天消息
  40.                     var chatDiv = "";
  41.                     chatDiv += '<div class="other">';
  42.                     chatDiv += '<img src="'+otherPhoto+'" class="photo" alt="">';
  43.                     chatDiv += '<div class="msg">'+result.data+'</div>';
  44.                     chatDiv += '</div>';
  45.                     //只有和我聊天的人的 id 和我们发送的对象 id 一致时，才将消息进行拼接
  46.                     if(otherId == result.code) {
  47.                         jQuery(".chatList").append(chatDiv);
  48.                     } 
  49.                     //使用 sessionStorage 存储对话信息
  50.                     var chatData = sessionStorage.getItem(result.code);
  51.                     if(chatData != null) {
  52.                         chatDiv = chatData + chatDiv;
  53.                     }
  54.                     sessionStorage.setItem(result.code, chatDiv);
  55.  
  56.                 } else {
  57.                     //5.错误情况
  58.                     alert(result.msg);
  59.                 }
  60.             } else {
  61.                 alert("消息推送错误!");
  62.             }
  63.         }

这样客户端开发就完成了~（这里的 html 和 css 代码就不展示了，大家可以自己下来设计一下）

2.2、服务器开发

a）首先需要引入 websocket 依赖，如下：

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

b）创建一下两个类：

1. WebSocketAPI：继承 TextWebSocketHandler ，重写那四大方法，实现相应逻辑。

WebSocketConfig：用来配置 WebSocket 的类（让 Spring 框架知道程序中使用了 WebSocket），重写 registerWebSocketHandlers 方法，就是用来注册刚刚写到的 WebSocketAPI 类，将他与客户端创建的 WebSocket 对象联系起来，如下：

2. 其中  addInterceptors(new HttpSessionHandshakeInterceptor()) 就是在把 HttpSession 中的信息注册到 WebSocketSession 中，让 WebSocketSession 能拿到 HttpSession 中的信息。

如下代码：

  1. package com.example.demo.config;
  2.  
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.web.socket.config.annotation.EnableWebSocket;
  6. import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
  7. import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;
  8. import org.springframework.web.socket.server.support.HttpSessionHandshakeInterceptor;
  9.  
  10. @Configuration
  11. @EnableWebSocket //让 spring 框架知道这是一个配置 WebSocket 的类
  12. public class WebSocketConfig implements WebSocketConfigurer {
  13.  
  14.     @Autowired
  15.     private WebSocketAPI webSocketAPI;
  16.  
  17.     /**
  18.      * 注意:addInterceptors(new HttpSessionHandshakeInterceptor()) 就是在把
  19.      * HttpSession 中的信息注册到 WebSocketSession 中
  20.      * @param registry
  21.      */
  22.     @Override
  23.     public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
  24.         registry.addHandler(webSocketAPI, "/chat").
  25.                 addInterceptors(new HttpSessionHandshakeInterceptor());
  26.     }
  27.  
  28. }

这里直接上代码，每段代码的意思我都十分详细的写在上面了，如果还有不懂的 -> 私信我~

  1. import com.example.demo.common.AjaxResult;
  2. import com.example.demo.common.AppVariable;
  3. import com.example.demo.common.UserSessionUtils;
  4. import com.example.demo.entity.ChatMessageInfo;
  5. import com.example.demo.entity.FollowInfo;
  6. import com.example.demo.entity.UserInfo;
  7. import com.example.demo.entity.vo.UserinfoVO;
  8. import com.example.demo.service.FollowService;
  9. import com.example.demo.service.UserService;
  10. import com.fasterxml.jackson.core.JsonProcessingException;
  11. import com.fasterxml.jackson.databind.ObjectMapper;
  12. import org.springframework.beans.BeanUtils;
  13. import org.springframework.beans.factory.annotation.Autowired;
  14. import org.springframework.stereotype.Component;
  15. import org.springframework.web.socket.CloseStatus;
  16. import org.springframework.web.socket.TextMessage;
  17. import org.springframework.web.socket.WebSocketSession;
  18. import org.springframework.web.socket.handler.TextWebSocketHandler;
  19.  
  20. import java.io.IOException;
  21. import java.util.ArrayList;
  22. import java.util.List;
  23. import java.util.concurrent.ConcurrentHashMap;
  24.  
  25. @Component
  26. public class WebSocketAPI extends TextWebSocketHandler {
  27.  
  28.     @Autowired
  29.     private UserService userService;
  30.  
  31.     @Autowired
  32.     private FollowService followService;
  33.  
  34.     private ObjectMapper objectMapper = new ObjectMapper();
  35.  
  36.     //用来存储每一个客户端对应的 websocketSession 信息
  37.     public static ConcurrentHashMap<Integer, WebSocketSession> onlineUserManager = new ConcurrentHashMap<>();
  38.  
  39.     @Override
  40.     public void afterConnectionEstablished(WebSocketSession session) throws Exception {
  41.         //用户上线，加入到 onlineUserManager，推送上线消息给所有客户端
  42.  
  43.         //1.获取当前用户信息(是谁在建立连接)
  44.         // 这里能够获取到 session 信息，依靠的是注册 websocket 的时候，
  45.         // 加上的 addInterceptors(new HttpSessionHandshakeInterceptor()) 就是把 HttpSession 中的 Attribute 都拿给了 WebSocketSession 中
  46.         //注意：此处的 userinfo 有可能为空，因为用户有可能直接通过 url 访问私信页面，此时 userinfo 就为 null，因此就需要 try catch
  47.         try {
  48.             UserInfo userInfo = (UserInfo) session.getAttributes().get(AppVariable.USER_SESSION_KEY);
  49.             //2.先判断当前用户是否正在登录，如果是就不能进行后面的逻辑
  50.             WebSocketSession socketSession = onlineUserManager.get(userInfo.getId());
  51.             if(socketSession != null) {
  52.                 //当前用户已登录,就要告诉客户端重复登录了
  53.                 session.sendMessage(new TextMessage(objectMapper.writeValueAsBytes(AjaxResult.fail(403, "当前用户正在登录，禁止多开!"))));
  54.                 session.close();
  55.                 return;
  56.             }
  57.             //3.拿到身份信息之后就可以把当前登录用户设置成在线状态了
  58.             onlineUserManager.put(userInfo.getId(), session);
  59.             System.out.println("用户:" + userInfo.getUsername() + "进入聊天室");
  60.             //4.将当前在线的用户名推送给所有的客户端
  61.             //4.1、获取当前用户的好友(相互关注)中所有在线的用户
  62.             //注意：这里的 init 表示告诉客户端这是在初始化好友列表
  63.             List<ChatMessageInfo> friends = getCurUserFriend(session);
  64.             AjaxResult ajaxResult = AjaxResult.success("init", friends);
  65.             //把好友列表消息推送给当前用户
  66.             session.sendMessage(new TextMessage(objectMapper.writeValueAsString(ajaxResult)));
  67.             //将当前用户上线消息推送给所有他的好友(通过 id)
  68.             for(ChatMessageInfo friend : friends) {
  69.                 WebSocketSession friendSession = onlineUserManager.get(friend.getId());
  70.                 if(friendSession != null) {
  71.                     friendSession.sendMessage(new TextMessage(objectMapper.writeValueAsString(AjaxResult.success("online", userInfo.getId()))));
  72.                 }
  73.             }
  74.         } catch (NullPointerException e) {
  75.             e.printStackTrace();
  76.             //说明此时的用户未登录
  77.             //先通过 ObjectMapper 包装成一个 JSON 字符串
  78.             //然后用 TextMessage 进行包装，表示是一个 文本格式的 websocket 数据包
  79.             session.sendMessage(new TextMessage(objectMapper.writeValueAsString(AjaxResult.fail(403, "您尚未登录!"))));
  80.         }
  81.     }
  82.  
  83.     /**
  84.      * 获取所有在线用户信息
  85.      * @return
  86.      */
  87.     private List<ChatMessageInfo> getCurUserFriend(WebSocketSession session) throws IOException {
  88.         //1.筛选出当前用户相互关注的用户
  89.         //1.1获取当前用户所有关注的用户列表
  90.         List<ChatMessageInfo> resUserinfoList = new ArrayList<>();
  91.         try {
  92.             UserInfo curUserInfo = (UserInfo) session.getAttributes().get(AppVariable.USER_SESSION_KEY);
  93.             List<FollowInfo> followInfos = followService.getConcernListByUid(curUserInfo.getId());
  94.             //好友列表(相互关注的用户列表)
  95.             for(FollowInfo followInfo : followInfos) {
  96.                 //1.2获取被关注的人的 id 列表，检测是否出现了关注当前用户的人
  97.                 List<FollowInfo> otherList =  followService.getConcernListByUid(followInfo.getFollow_id());
  98.                 for(FollowInfo otherInfo : otherList) {
  99.  
  100.                     //1.3检测被关注的人是否也关注了自己
  101.                     if(followInfo.getUid().equals(otherInfo.getFollow_id())) {
  102.                         //1.4相互关注的用户
  103.                         UserInfo friendInfo = userService.getUserById(otherInfo.getUid());
  104.                         ChatMessageInfo chatMessageInfo = new ChatMessageInfo();
  105.                         chatMessageInfo.setId(friendInfo.getId());
  106.                         chatMessageInfo.setNickname(friendInfo.getNickname());
  107.                         chatMessageInfo.setPhoto(friendInfo.getPhoto());
  108.                         //设置在线信息(在 onlineUserManager 中说明在线)
  109.                         if(onlineUserManager.get(friendInfo.getId()) != null) {
  110.                             chatMessageInfo.setOnline("在线");
  111.                         } else {
  112.                             chatMessageInfo.setOnline("离线");
  113.                         }
  114.                         resUserinfoList.add(chatMessageInfo);
  115.                     }
  116.                 }
  117.             }
  118.         } catch (NullPointerException e) {
  119.             e.printStackTrace();
  120.             session.sendMessage(new TextMessage(objectMapper.writeValueAsString(AjaxResult.fail(403, "您尚未登录!"))));
  121.         }
  122.         return resUserinfoList;
  123.     }
  124.  
  125.     @Override
  126.     protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
  127.         //实现处理发送消息操作
  128.         UserInfo userInfo = (UserInfo) session.getAttributes().get(AppVariable.USER_SESSION_KEY);
  129.         //获取客户端发送过来的数据(数据载荷)
  130.         String payload = message.getPayload();
  131.         //当前这个数据载荷是一个 JSON 格式的字符串，就需要解析成 Java 对象
  132.         AjaxResult request = objectMapper.readValue(payload, AjaxResult.class);
  133.         //对方的 id
  134.         Integer otherId = request.getCode();
  135.         //要发送给对方的消息
  136.         String msg = request.getMsg();
  137.         //将消息发送给对方
  138.         WebSocketSession otherSession = onlineUserManager.get(otherId);
  139.         if(otherSession == null) {
  140.             session.sendMessage(new TextMessage(objectMapper.writeValueAsString(AjaxResult.fail(403,"对方不在线!"))));
  141.             return;
  142.         }
  143.         otherSession.sendMessage(new TextMessage(objectMapper.writeValueAsString(AjaxResult.success(userInfo.getId(),"msg",  msg))));
  144.     }
  145.  
  146.     @Override
  147.     public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception {
  148.         try {
  149.             //用户下线，从 onlineUserManager 中删除
  150.             UserInfo userInfo = (UserInfo) session.getAttributes().get(AppVariable.USER_SESSION_KEY);
  151.             onlineUserManager.remove(userInfo.getId());
  152.             //通知该用户的所有好友，当前用户已下线
  153.             List<ChatMessageInfo> friends = getCurUserFriend(session);
  154.             //将当前用户下线消息推送给所有他的好友(通过 id)
  155.             for(ChatMessageInfo friend : friends) {
  156.                 WebSocketSession friendSession = onlineUserManager.get(friend.getId());
  157.                 if(friendSession != null) {
  158.                     friendSession.sendMessage(new TextMessage(objectMapper.writeValueAsString(AjaxResult.success("offline", userInfo.getId()))));
  159.                 }
  160.             }
  161.         } catch(NullPointerException e) {
  162.             e.printStackTrace();
  163.             //说明此时的用户未登录
  164.             //先通过 ObjectMapper 包装成一个 JSON 字符串
  165.             //然后用 TextMessage 进行包装，表示是一个 文本格式的 websocket 数据包
  166.             session.sendMessage(new TextMessage(objectMapper.writeValueAsString(AjaxResult.fail(403, "您尚未登录!"))));
  167.         }
  168.     }
  169.  
  170.     @Override
  171.     public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
  172.         try {
  173.             //用户下线，从 onlineUserManager 中删除
  174.             UserInfo userInfo = (UserInfo) session.getAttributes().get(AppVariable.USER_SESSION_KEY);
  175.             onlineUserManager.remove(userInfo.getId());
  176.             //通知该用户的所有好友，当前用户已下线
  177.             List<ChatMessageInfo> friends = getCurUserFriend(session);
  178.             //将当前用户下线消息推送给所有他的好友(通过 id)
  179.             for(ChatMessageInfo friend : friends) {
  180.                 WebSocketSession friendSession = onlineUserManager.get(friend.getId());
  181.                 if(friendSession != null) {
  182.                     friendSession.sendMessage(new TextMessage(objectMapper.writeValueAsString(AjaxResult.success("offline", userInfo.getId()))));
  183.                 }
  184.             }
  185.         } catch (NullPointerException e) {
  186.             e.printStackTrace();
  187.             //说明此时的用户未登录
  188.             //先通过 ObjectMapper 包装成一个 JSON 字符串
  189.             //然后用 TextMessage 进行包装，表示是一个 文本格式的 websocket 数据包
  190.             session.sendMessage(new TextMessage(objectMapper.writeValueAsString(AjaxResult.fail(403, "您尚未登录!"))));
  191.         }
  192.     }
  193.  
  194. }

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

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

  

闽ICP备14008679号