拿来主义——WebSocket多人聊天室和聊天列表实现

已于 2024-08-09 09:50:48 修改
阅读量377 收藏 3
点赞数 3
文章标签： websocket 网络协议 网络
于 2024-08-06 16:09:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_56772904/article/details/140954497
版权

最近领导让做一个多人聊天功能，小编抠脑壳硬是半天没写出来个所以然，于是网上找了个多人聊天室Demo改出来一款基于SpringBoot实现的实用性较强的聊天室功能（也适用于单人聊天）。

思想：总共用两个连接，一个用于聊天室消息监听，一个用于监听聊天室列表未读消息。
调用顺序：先连接聊天室列表，再连接聊天室。
当有用户在聊天室发送消息时，消息正常推送，同步调用聊天室列表推送消息，通过所有房间在线人数和用户所属聊天室关系过滤，找出对应聊天室需要推送未读消息的在线用户。然后推送未读消息。逻辑大概是这样。

下面看实现：

pom引入的依赖

<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-websocket</artifactId>
		</dependency>
		<dependency>
			<groupId>jakarta.websocket</groupId>
			<artifactId>jakarta.websocket-api</artifactId>
			<version>1.1.2</version>
			<scope>compile</scope>
		</dependency>

WebSocket配置


import org.springframework.beans.factory.annotation.Autowired;
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的注册,用于扫描带有@ServerEndpoint的注解成为websocket,如果你使用外置的tomcat就不需要该配置文件
     */
    @Bean
    public ServerEndpointExporter serverEndpointExporter() {
        return new ServerEndpointExporter();
    }

	/**
	 * 注入service
	 * @param complainService
	 */
	@Autowired
	public void setChatRoomMessageService(ChatRoomMessageService chatRoomMessageService){
		WebSocketUtil.chatRoomMessageService = chatRoomMessageService;
	}
}

聊天传参

import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;

/**
 * @author ywb
 * @date 2024/7/29 16:14
 */
@Data
public class SocketMsg {

	@Schema(description = "聊天类型 0 全局广播 1 单聊 2 群聊")
	private int type;

	@Schema(description = "发送者id")
	private Long userId;

	@Schema(description = "发送者")
	private String userName;

	@Schema(description = "接收者")
	private String receiveUser;

	@Schema(description = "房间id")
	private Long roomId;

	@Schema(description = "消息")
	private String content;

	@Schema(description = "消息类型(IMAGE-照片,VIDEO-视频,VOICEMAIL-语音,TITLE-文字)")
	private ChatRoomMessageTypeEnum messageType;
}

聊天列表和详情公用的参数

import lombok.Data;

import javax.websocket.Session;
import java.util.HashMap;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @author ywb
 * @date 2024/8/2 9:07
 */
@Data
public abstract class WebSocketShareParam {

	/**
	 * 存放Session集合，方便推送消息 （jakarta.websocket）
	 */
	public static ConcurrentHashMap<String, Session> sessionMap = new ConcurrentHashMap<>();

	/**
	 * 存放房间用户集合，方便推送消息 （jakarta.websocket）
	 */
	public static HashMap<Long, List<Long>> groupSessionMap = new HashMap<>();

	public static ChatRoomMessageService chatRoomMessageService;

}

聊天室连接

import cn.hutool.core.util.ObjectUtil;
import cn.hutool.json.JSON;
import cn.hutool.json.JSONUtil;

import javax.annotation.Resource;
import javax.websocket.*;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;

import com.google.gson.Gson;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;

/**
 * @author ywb
 * @date 2024/7/29
 * @description WebSocket工具类
 */
@Slf4j
@Component
@ServerEndpoint("/websocket/{userId}/{roomId}")
public class WebSocketUtil extends WebSocketShareParam{

	private Long userId;
	private Session session;
	private Long roomId;

	/**
	 * 群聊：向指定房间ID推送消息
	 */
	public synchronized static void groupMessage(SocketMsg socketMsg) {
		// 存储房间号和用户信息
		Long roomId = socketMsg.getRoomId();
		// 判断是否有这个房间
		List<Long> strings = groupSessionMap.get(roomId);
		if (ObjectUtils.isEmpty(strings)) {
			List<Long> users = new ArrayList<>();
			users.add(socketMsg.getUserId());
			groupSessionMap.put(roomId, users);
		} else {
			// 这里应该写接口，先添加房间ID，简易写法直接传过来
			List<Long> users = groupSessionMap.get(roomId);
			Long sendOutUser = socketMsg.getUserId();
			boolean contains = users.contains(sendOutUser);
			if (!contains) {
				users.add(sendOutUser);
			}
		}

		// 发送给接收者
		if (roomId != null) {
			//保存历史消息
			Long messageId = chatRoomMessageService.sendMessage(socketMsg);
			ChatRoomMessageDTO dto = chatRoomMessageService.getNewMessages(messageId);
			JSON json = JSONUtil.parse(dto);
			// 发送给接收者
			log.info("发送消息对象："+json.toString());
			// 此时要判断房间有哪些人，把这些消息定向发给处于此房间的用户
			List<Long> roomUser = groupSessionMap.get(roomId);

			for (Long userId : roomUser) {
				// 接收消息的用户
				Session receiveUser = sessionMap.get(roomId + "_" + userId);
				receiveUser.getAsyncRemote().sendObject(json.toString());
			}
			WebSocketListUtil.countUnreadMessage(roomId);
		} else {
			// 发送消息的用户
			log.info(socketMsg.getUserName() + " 私聊的用户 " + socketMsg.getReceiveUser() + " 不在线或者输入的用户名不对");
			Session sendOutUser = sessionMap.get(roomId + "_"  + socketMsg.getUserName());
			// 将系统提示推送给发送者
			sendOutUser.getAsyncRemote().sendObject("系统消息：对方不在线或者您输入的用户名不对");
		}
	}

	/**
	 * 私聊：向指定客户端推送消息
	 */
	public synchronized static void privateMessage(SocketMsg socketMsg) {
		Long roomId = socketMsg.getRoomId();
		// 接收消息的用户
		Session receiveUser = sessionMap.get(roomId + "_" + socketMsg.getReceiveUser());
		// 发送给接收者
		if (receiveUser != null) {
			// 发送给接收者
			log.info(socketMsg.getUserName() + " 向 " + socketMsg.getReceiveUser() + " 发送了一条消息：" + socketMsg.getContent());
			receiveUser.getAsyncRemote().sendObject(socketMsg.getUserName() + "：" + socketMsg.getContent());
		} else {
			// 发送消息的用户
			log.info(socketMsg.getUserName() + " 私聊的用户 " + socketMsg.getReceiveUser() + " 不在线或者输入的用户名不对");
			Session sendOutUser = sessionMap.get(roomId + "_" + socketMsg.getUserName());
			// 将系统提示推送给发送者
			sendOutUser.getAsyncRemote().sendObject("系统消息：对方不在线或者您输入的用户名不对");
		}
	}

	/**
	 * 聊天室里面推送消息
	 */
	public synchronized static void roomMessage(String room,List<Long> orDefault,String message) {
		for (Long userId : orDefault){
			Session session = sessionMap.get(room + userId);
			ChatRoomMessageDTO dto = new ChatRoomMessageDTO();
			dto.setType(ChatRoomMessageTypeEnum.SYSTEM);
			dto.setContent(message);
			session.getAsyncRemote().sendObject( JSONUtil.parse(dto).toString());
		}
		log.info("系统接收了一条消息：" + message);
	}

	/**
	 * 聊天室监听：连接成功
	 *
	 * @param session
	 * @param userId 连接的用户id
	 */
	@OnOpen
	public void onOpen(Session session, @PathParam("userId") Long userId, @PathParam("roomId") Long roomId) {
		this.userId = userId;
		this.session = session;
		this.roomId = roomId;
		String room = roomId +"_";
		String name = room + userId;
		List<Long> orDefault = groupSessionMap.getOrDefault(roomId, new ArrayList<>());
		if (!orDefault.contains(userId)){
			orDefault.add(userId);
			groupSessionMap.put(roomId, orDefault);
		}
		if (!sessionMap.containsKey(name)) {
			sessionMap.put(name, session);
			// 在线数加1
			String tips = userId + " 加入聊天室。当前聊天室人数为" + orDefault.size();
			log.info(tips);
			roomMessage(room,orDefault,tips);
		}
	}

	/**
	 * 聊天室监听: 连接关闭
	 */
	@OnClose
	public void onClose() {
		String room = roomId +"_";
		String name = room + userId;
		List<Long> list = groupSessionMap.get(roomId);
		list.remove(userId);
		// 连接关闭后，将此websocket从set中删除
		sessionMap.remove(name);
		String tips = userId + " 退出聊天室。当前聊天室人数为" + list.size();
		log.info(tips);
		roomMessage(room,list,tips);
	}

	/**
	 * 监听：收到客户端发送的消息
	 * @param message 发送的信息（json格式，里面是 SocketMsg 的信息）
	 */
	@OnMessage
	public void onMessage(String message) {
		if (JSONUtil.isTypeJSONObject(message)) {
			SocketMsg socketMsg = JSONUtil.toBean(message, SocketMsg.class);
			if (socketMsg.getType() == 2) {
				// 群聊，需要找到发送者和房间ID
				groupMessage(socketMsg);
			} else if (socketMsg.getType() == 1) {
				// 单聊，需要找到发送者和接受者
				privateMessage(socketMsg);
			} else {
				// 全局广播群发消息
//				publicMessage(socketMsg.getContent());
				// 聊天室广播群发消息
				List<Long> list = groupSessionMap.get(roomId);
				roomMessage(roomId +"_",list,socketMsg.getContent());
			}
		}
	}

	/**
	 * 监听：发生异常
	 * @param error
	 */
	@OnError
	public void onError(Throwable error) {
		log.info("userName为：" + userId + "，发生错误：" + error.getMessage());
		error.printStackTrace();
	}
}

聊天室列表未读消息连接

import cn.hutool.json.JSONUtil;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import javax.websocket.*;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;

/**
 * @author ywb
 * @date 2024/8/2 9:04
 */
@Slf4j
@Component
@ServerEndpoint("/websocket/list/{userId}")
public class WebSocketListUtil extends WebSocketShareParam{

	private Long userId;
	private Session session;

	/**
	 * 存放聊天室列表Session集合，推送消息
	 */
	public static ConcurrentHashMap<String, Session> roomListsessionMap = new ConcurrentHashMap<>();

	//用户所有的房间信息
	private static Map<Long, List<Long>> roomIdMap = new HashMap<>();

	/**
	 * 固定前缀
	 */
	private static final String ROOM_PREFIX = "ROOM_";

	/**
	 * 聊天室监听：连接成功
	 *
	 * @param session
	 * @param userId 连接的用户id
	 */
	@OnOpen
	public void onOpen(Session session, @PathParam("userId") Long userId) {
		this.userId = userId;
		this.session = session;

		List<Long> roomIds = chatRoomMessageService.selectRoomIds(userId);

		roomIdMap.put(userId, roomIds);

		String name = ROOM_PREFIX + userId;
		if (!roomListsessionMap.containsKey(name)) {
			roomListsessionMap.put(name, session);
			// 在线数加1
			String tips = userId + " 进入聊天室列表。当前聊天室列表人数为" + roomIdMap.size();
			log.info(tips);
			roomListMessage(tips);
		}
	}

	/**
	 * 聊天室监听: 连接关闭
	 */
	@OnClose
	public void onClose() {
		String name = ROOM_PREFIX + userId;
		roomIdMap.remove(userId);
		// 连接关闭后，将此websocket从set中删除
		roomListsessionMap.remove(name);
		String tips = userId + " 退出聊天室列表。当前聊天室列表人数为" + roomListsessionMap.size();
		log.info(tips);
		roomListMessage(tips);
	}

	/**
	 * 监听：收到客户端发送的消息
	 *
	 * @param param 房间id
	 */
	@OnMessage
	public void onMessage(String param) {
		if (JSONUtil.isTypeJSONObject(param)) {
			Long roomId = JSONUtil.parse(param).getByPath("roomId", Long.class);
//			groupMessage(roomId);
			countUnreadMessage(roomId);
		}
	}

	/**
	 * 统计在线用户roomId的未读消息总数
	 */
	public synchronized static void countUnreadMessage(Long roomId) {
	//聊天室列表在线用户,至少有1个（消息发送者）
		Enumeration<String> enumeration = roomListsessionMap.keys();
		List<Long> userIds = new ArrayList<>();
		while(enumeration.hasMoreElements()) {
			Long userId = Long.parseLong(enumeration.nextElement().replace(ROOM_PREFIX, ""));
			userIds.add(userId);
		}
		//统计房间对应在线用户的未读消息
		List<ChatRoomListDTO> unreadMessage = chatRoomMessageService.countUnreadMessageCount(userIds,roomId);

		for (ChatRoomListDTO dto : unreadMessage){
			Long userId = dto.getUserId();
			Session receiveUser = roomListsessionMap.get(ROOM_PREFIX + userId);
			if (receiveUser != null){
				receiveUser.getAsyncRemote().sendObject(JSONUtil.parse(dto).toString());
			}
		}		
	}

	/**
	 * 统计在线用户roomId的未读消息+1
	 * 群聊：向指定用户列表添加未读消息（过滤了当前在聊天室的用户，如果不过来这部分用户，可以省略判断，直接发送消息）
	 */
	public synchronized static void groupMessage(Long roomId) {
		//聊天室列表在线用户,至少有1个（消息发送者）
		Enumeration<String> enumeration = roomListsessionMap.keys();

		//聊天室内在线用户
		List<Long> orDefault = groupSessionMap.get(roomId);

		//过滤出所有不在该房间的在线用户未读消息+1
		while(enumeration.hasMoreElements()) {
			Long userId = Long.getLong(enumeration.nextElement().replace(ROOM_PREFIX, ""));
			if (orDefault.contains(userId)){
				continue;
			}
			//用户所有的聊天室
			List<Long> roomIds = roomIdMap.get(userId);
			if (roomIds.contains(roomId)){
				// 接收消息的用户
				Session receiveUser = null;
				for (Long room : roomIds){
					if (sessionMap.get(room + "_" + userId) != null){
						receiveUser = roomListsessionMap.get(ROOM_PREFIX + userId);
						break;
					}
				}
				if (receiveUser == null) continue;
				receiveUser.getAsyncRemote().sendText(userId + " 的房间 【 " + roomId + " 】 新增了一条未读消息。" );
			}
		}
	}

	public synchronized static void roomListMessage( String message) {
		for (Long userId : roomIdMap.keySet()){
			Session session = roomListsessionMap.get(ROOM_PREFIX + userId);
			session.getAsyncRemote().sendText( message);
			log.info("聊天室列表收了一条消息：" + message);
		}
	}

	/**
	 * 监听：发生异常
	 *
	 * @param error
	 */
	@OnError
	public void onError(Throwable error) {
		log.info("userName为：" + userId + "，发生错误：" + error.getMessage());
		error.printStackTrace();
	}
}

这里 —> 参考链接
前端对接可以参考链接实现，小编前端是个菜鸟，就不班门弄斧了。

最后我们来说一下连接测试

小编使用的是Apifox进行的后端测试（没有的自行百度下载）

注意：Apifox 版本号需 ≥ 2.2.32 才能管理 WebSocket 接口

在这里插入图片描述
如图点击新建WebSocket接口进入后输入：ws://localhost:8080/websocket/{userId}/{roomId}
进行连接测试。

注意参数修改：
port -> 修改自己的端口号为项目端口号
userId -> 用户id 可以使用userName测试更直观，但是可能存在重名情况
roomId -> 聊天室id
在这里插入图片描述

至此，功能实现。

疆果
关注
WebSocket多人聊天室
不想头秃QAQ的博客
03-12 6687
项目背景   现在的年轻人，大多都有“社交恐惧症”，但其实随着通信技术的日益发展，网络聊天在当今已不算新鲜事物，聊天可以方便大家交流，帮助大家克服“社恐”。以此为契机，我仿照QQ开发了一款 WebSocket多人聊天室 ，以供同一局域网下多名小伙伴相互聊天，增进彼此感情，共同战胜“社恐”。 实现功能 本聊天室具有以下功能：   1） 简单的注册登录功能   2） 用户发送消息，所有在线用户都能收到消息   3） 不在线用户在上线后能收到历史消息（第一次注册用户不会收到历史消息）   4） 右侧动态的显示
java利用websocket实现多人聊天室（springmvc框架）
05-22
环境：eclipse+jdk1.8+tomcat8 项目启动后访问链接：http://localhost:8080/Chatroom/home/list.do
websocket实现多聊天室，聊天(附完整代码)
qq_43532386的博客
12-27 8700
聊天功能实现需求关于websocketwebsocket的方法后端1、引入依赖2、在自己的websocket上加ServerEndpoint注解3、监听的方法1、@OnOpen（连接建立时触发）2、@OnClose（关闭连接时触发）3、@OnMessage（ 收到客户端消息触发事件）4、@OnError（通信发生错误时触发）4、发送消息的方法（利用Session会话）1、在建立连接时触发@OnOpen，2、收到客户端消息时，将该消息进行转发，前端1、实例化websocket2、监听的方法1、websocke
websocket实现多人聊天
06-07
简单websocket实现在线群聊功能 1、通过登录获取每个用户的昵称，在发送消息前加“昵称说：” 2、通过websocket推送到前台页面聊天消息
websocket学习和群聊实现
weixin_34279184的博客
08-19 176
WebSocket协议可以实现前后端全双工通信，从而取代浪费资源的长轮询。在此协议的基础上，可以实现前后端数据、多端数据，真正的实时响应。在学习WebSocket的过程中，实现了一个简化版群聊，过程和代码详细记录在这篇文章中。 本篇文章来自董沅鑫的个人网站，引用、转载请指明出处。 查看更多知识，或者技术交流：请访问godbmw.com ...
实现websocket多人聊天，很简单
weixin_33751566的博客
01-29 222
go? http://localhost:8080/chats/1http://localhost:8080/chats/1 房间号相同的人能聊天 Flask Server # -*- coding: utf-8 -*- from flask import Flask, render_template from flask_socketio import SocketIO, rooms a...
注解式 WebSocket - 构建 群聊、单聊 系统
最新发布
CYK_byte的博客
04-06 1065
很久之前，咱们聊过 WebSocket 编程式的写法，但是有些过于繁琐，这次来看看更接近现代的注解式，构建 群聊、单聊 有多么便利.
基于vue和websocket的多人在线聊天室
10-15
在本文中，我们将探讨如何构建一个基于Vue.js和WebSocket的多人在线聊天室。Vue.js是一个流行的前端JavaScript框架，用于构建用户界面，而WebSocket则是一种在客户端和服务器之间提供全双工、低延迟通信的协议。结合...
Springboot+websocket 实现多人聊天室/单人聊天
10-11
这是一个简单使用websocket实现多人聊天室，单人聊天室的demo，里面使用的是最原始的websocket的方法，附有客户端界面可以直接跑起来发送消息看效果。 该项目对应刚刚接触websocket技术是比较有用的。 2019-10-11的...
spring boot整合WebSocket实现多人聊天室的实例
04-14
在本实例中，我们将探讨如何使用Spring Boot整合WebSocket和STOMP协议来实现一个多人聊天室。 首先，我们需要在Spring Boot项目中添加WebSocket的相关依赖。这通常包括`spring-websocket`和`spring-messaging`。在`...
WebSocket精简多人聊天
03-08
我是用jdk8，tomcar 9的 eclipse直接可以服务器运行就能跑了，好像tomcar7以上不用jar包，反正我里面没有，就单纯多人聊天，后面的就你们举一反三了
websocket实现群聊
12-03
基于tomcat7和jdk7下websocket实现群聊,可以参考代码学习下哦
websocket 多人聊天室 网页版
07-18
javaweb 实现的多人聊天系统，代码中相应的url改成你自己的就可以了，直接导入myeclipse就可以运行
websocket单个,多人聊天
02-05
websocket简单通信，支持指向性聊天（单对单聊天），多人群聊,界面操作简单
基于websocket的多人多聊天室服务器
04-03
任何人可开设聊天室，其他人登录相同的网址，进入相同的聊天室即可开始多人聊天。无需任何配置，没有外部数据存储依赖，只要安装openresty。
使用websocket简单实现多人聊天
qq_36414969的博客
03-20 1859
前言 这是课堂作业，在网上找到了源码（感谢嘚佬们分享），自己看懂了后打了一遍，并根据自己的需要改了一些，写这篇博客希望记录自己对websocket的理解，也希望看见的各位交流。 websocket可以简单的与Javase的socket比作一个东西，不过websocket适用于浏览器与服务器的交互。它与http的区别是，http不是一个持久性的连接，而websocket是一个持久的连接，它是基于...
使用WebSocket实现多人实时聊天
iteye_5722的博客
04-29 486
一 应用 本应用使用WebSocket实现多人实时聊天   二 代码 客户端代码 &lt;!DOCTYPE html&gt; &lt;html&gt; &lt;head&gt; &lt;meta name="author" content="Yeeku.H.Lee(CrazyIt.org)" /&gt; &lt;meta http-equiv="Content
Go语言实现WebSocket多人聊天室
在实际应用中，可能需要更复杂的逻辑，比如管理多个并发的WebSocket连接，或者实现聊天室功能。为了实现聊天室，你可以维护一个连接池，每个连接代表一个用户，当接收到新的消息时，遍历连接池并发送消息到所有活跃...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值