netty实现私信聊天
websocket的介绍：
WebSocket是一种在网络通信中的协议，它是独立于HTTP协议的。该协议基于TCP/IP协议，可以提供双向通讯并保有状态。这意味着客户端和服务器可以进行实时响应，并且这种响应是双向的。WebSocket协议端口通常是80，443。
WebSocket的出现使得浏览器具备了实时双向通信的能力。与HTTP这种非持久单向响应应答的协议相比，WebSocket是一个持久化的协议。举例来说，即使在关闭网页或者浏览器后，WebSocket的连接仍然保持，用户也可以继续接收到服务器的消息。
此外，要建立WebSocket连接，需要浏览器和服务器握手进行建立连接。一旦连接建立，WebSocket可以在浏览器和服务器之间双向发送或接受信息。总的来说，WebSocket提供了一个高效、实时的双向通信方案。
package com.litblue.im.config.properties; import com.alibaba.fastjson2.JSONObject; import com.litblue.starter.pojo.im.properties.MsgContentProperties; import java.util.HashMap; import java.util.Map; public class RequestUriUtils { /** * 将路径参数转换成Map对象，如果路径参数出现重复参数名，将以最后的参数值为准 * * @param uri 传入的携带参数的路径 * @return */ public static Map<String, String> getParams(String uri) { Map<String, String> params = new HashMap<>(10); int idx = uri.indexOf("?"); if (idx != -1) { String[] paramsArr = uri.substring(idx + 1).split("&"); for (String param : paramsArr) { idx = param.indexOf("="); params.put(param.substring(0, idx), param.substring(idx + 1)); } } return params; } /** * 获取URI中参数以外部分路径 * * @param uri * @return */ public static String getBasePath(String uri) { if (uri == null || uri.isEmpty()) return null; int idx = uri.indexOf("?"); if (idx == -1) return uri; return uri.substring(0, idx); } /** * 解析消息内容 * * @return */ public static MsgContentProperties handleMessageInvoke(String params) { MsgContentProperties msgContentProperties = JSONObject.parseObject(params, MsgContentProperties.class); return msgContentProperties; } }
web配置类
package com.litblue.im.config.properties; import lombok.Data; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.stereotype.Component; @Data @Component @ConfigurationProperties(prefix = "chat.websocket") public class WebSocketProperties { private Integer port = 10001; // 监听端口 private String path = "/ws"; // 请求路径 private Integer boss = 2; // bossGroup线程数 private Integer work = 2; // workGroup线程数 }
package com.litblue.im.config.netty; import com.litblue.im.config.properties.WebSocketProperties; import io.netty.channel.ChannelInitializer; import io.netty.channel.socket.SocketChannel; import io.netty.handler.codec.http.HttpObjectAggregator; import io.netty.handler.codec.http.HttpServerCodec; import io.netty.handler.codec.http.websocketx.WebSocketServerProtocolHandler; import io.netty.handler.stream.ChunkedWriteHandler; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; @Component public class NioWebSocketChannelInitializer extends ChannelInitializer<SocketChannel> { @Autowired private WebSocketProperties webSocketProperties; @Autowired private NioWebSocketHandler nioWebSocketHandler; @Override protected void initChannel(SocketChannel socketChannel) { socketChannel.pipeline() .addLast(new HttpServerCodec()) .addLast(new ChunkedWriteHandler()) .addLast(new HttpObjectAggregator(8192)) .addLast(nioWebSocketHandler) .addLast(new WebSocketServerProtocolHandler(webSocketProperties.getPath(), null, true, 65536)); } }
package com.litblue.im.config.netty; import io.netty.channel.Channel; import io.netty.channel.group.ChannelGroup; import io.netty.channel.group.DefaultChannelGroup; import io.netty.util.concurrent.GlobalEventExecutor; import lombok.extern.slf4j.Slf4j; import org.springframework.stereotype.Component; @Slf4j @Component public class NioWebSocketChannelPool { private final ChannelGroup channels = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE); /** * 新增一个客户端通道 * * @param channel */ public void addChannel(Channel channel) { channels.add(channel); } /** * 移除一个客户端连接通道 * * @param channel */ public void removeChannel(Channel channel) { channels.remove(channel); } /** * 获取所有连接信息 * @return */ public ChannelGroup getAllChannelGroup() { return channels; } }
package com.litblue.im.config.netty; import com.litblue.im.config.properties.WebSocketProperties; import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelOption; import io.netty.channel.EventLoopGroup; import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.socket.nio.NioServerSocketChannel; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.DisposableBean; import org.springframework.beans.factory.InitializingBean; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; @Slf4j @Component public class NioWebSocketServer implements InitializingBean, DisposableBean { @Autowired private WebSocketProperties webSocketProperties; @Autowired private NioWebSocketChannelInitializer webSocketChannelInitializer; private EventLoopGroup bossGroup; private EventLoopGroup workGroup; private ChannelFuture channelFuture; @Override public void afterPropertiesSet() throws Exception { try { bossGroup = new NioEventLoopGroup(webSocketProperties.getBoss()); workGroup = new NioEventLoopGroup(webSocketProperties.getWork()); ServerBootstrap serverBootstrap = new ServerBootstrap(); serverBootstrap.option(ChannelOption.SO_BACKLOG, 1024) .group(bossGroup, workGroup) .channel(NioServerSocketChannel.class) .localAddress(webSocketProperties.getPort()) .childHandler(webSocketChannelInitializer); channelFuture = serverBootstrap.bind().sync(); } finally { if (channelFuture != null && channelFuture.isSuccess()) { log.info("Netty server startup on port: {} (websocket) with context path '{}'", webSocketProperties.getPort(), webSocketProperties.getPath()); } else { log.error("Netty server startup failed."); if (bossGroup != null) bossGroup.shutdownGracefully().sync(); if (workGroup != null) workGroup.shutdownGracefully().sync(); } } } @Override public void destroy() throws Exception { log.info("Shutting down Netty server..."); if (bossGroup != null) bossGroup.shutdownGracefully().sync(); if (workGroup != null) workGroup.shutdownGracefully().sync(); if (channelFuture != null) channelFuture.channel().closeFuture().syncUninterruptibly(); log.info("Netty server shutdown."); } }
package com.litblue.im.config.netty; import cn.hutool.core.bean.BeanUtil; import cn.hutool.extra.spring.SpringUtil; import com.alibaba.fastjson2.JSON; import com.alibaba.fastjson2.JSONObject; import com.litblue.api.client.GetUserInfoClient; import com.litblue.common.exception.UnauthorizedException; import com.litblue.common.utils.CollUtils; import com.litblue.im.config.properties.RequestUriUtils; import com.litblue.im.config.properties.WebSocketProperties; import com.litblue.im.service.IMsgContentService; import com.litblue.starter.cache.redis.RedisCache; import com.litblue.starter.cache.redis.RedisKeys; import com.litblue.starter.pojo.im.domain.MsgContent; import com.litblue.starter.pojo.im.properties.MsgContentProperties; import com.litblue.starter.pojo.user.domian.LitUserInfo; import io.netty.channel.Channel; import io.netty.channel.ChannelHandler; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.SimpleChannelInboundHandler; import io.netty.channel.group.ChannelGroup; import io.netty.handler.codec.http.FullHttpRequest; import io.netty.handler.codec.http.websocketx.*; import io.netty.util.AttributeKey; import lombok.Data; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.cloud.openfeign.FeignClient; import org.springframework.stereotype.Component; import org.springframework.util.CollectionUtils; import java.time.Duration; import java.time.Instant; import java.util.*; import java.util.concurrent.atomic.AtomicReference; import java.util.stream.Collectors; /** * 通讯处理核心类,主要作用处理wss消息 */ @Slf4j @ChannelHandler.Sharable @Component public class NioWebSocketHandler extends SimpleChannelInboundHandler<WebSocketFrame> { @Autowired private NioWebSocketChannelPool webSocketChannelPool; @Autowired private WebSocketProperties webSocketProperties; @Autowired private RedisCache redisCache; @Autowired private IMsgContentService msgContentService; /** * 建立连接 * * @param ctx * @throws Exception */ @Override public void channelActive(ChannelHandlerContext ctx) throws Exception { log.debug("客户端连接：{}", ctx.channel().id()); webSocketChannelPool.addChannel(ctx.channel()); super.channelActive(ctx); } @Override public void channelInactive(ChannelHandlerContext ctx) throws Exception { log.debug("客户端断开连接：{}", ctx.channel().id()); webSocketChannelPool.removeChannel(ctx.channel()); super.channelInactive(ctx); } @Override public void channelReadComplete(ChannelHandlerContext ctx) { ctx.channel().flush(); } /** * 收到消息进行处理 * * @param ctx * @param frame */ @Override protected void channelRead0(ChannelHandlerContext ctx, WebSocketFrame frame) { // 根据请求数据类型进行分发处理 if (frame instanceof PingWebSocketFrame) { pingWebSocketFrameHandler(ctx, (PingWebSocketFrame) frame); } else if (frame instanceof TextWebSocketFrame) { textWebSocketFrameHandler(ctx, (TextWebSocketFrame) frame); } else if (frame instanceof CloseWebSocketFrame) { closeWebSocketFrameHandler(ctx, (CloseWebSocketFrame) frame); } } @Override public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { log.info("客户端请求数据类型：{}", msg.getClass()); if (msg instanceof FullHttpRequest) { fullHttpRequestHandler(ctx, (FullHttpRequest) msg); } super.channelRead(ctx, msg); } /** * 处理连接请求，客户端WebSocket发送握手包时会执行这一次请求 * * @param ctx * @param request */ private void fullHttpRequestHandler(ChannelHandlerContext ctx, FullHttpRequest request) { String uri = request.uri(); Map<String, String> params = RequestUriUtils.getParams(uri); log.debug("客户端请求参数：{}", params); String token = params.get("token").toString(); log.info("token:{}", token); Long userId = redisCache.getCacheObject(RedisKeys.DEFINE_TOKEN + token); if (userId == null) { throw new UnauthorizedException("尚未完成登录"); } log.info("userId==>,{}", userId); String route = params.get("route").toString(); if (params.containsKey("ack") && "true".equals(params.get("ack").toString())) { // 消息已读确认 String targetId = params.get("targetId").toString(); route += targetId; msgContentService.handleFinishMessageReading(userId.toString(), targetId); } //绑定连接用户 AttributeKey<String> userKey = AttributeKey.valueOf("user"); ctx.channel().attr(userKey).set(userId.toString()); //绑定连接的路由 AttributeKey<String> routeKey = AttributeKey.valueOf("route"); ctx.channel().attr(routeKey).set(route); // 判断请求路径是否跟配置中的一致 if (webSocketProperties.getPath().equals(RequestUriUtils.getBasePath(uri))) // 因为有可能携带了参数，导致客户端一直无法返回握手包，因此在校验通过后，重置请求路径 request.setUri(webSocketProperties.getPath()); else ctx.close(); } /** * 客户端发送断开请求处理 * * @param ctx * @param frame */ private void closeWebSocketFrameHandler(ChannelHandlerContext ctx, CloseWebSocketFrame frame) { webSocketChannelPool.removeChannel(ctx.channel()); try { channelInactive(ctx); ctx.close(); } catch (Exception e) { throw new RuntimeException(e); } } /** * 创建连接之后，客户端发送的消息都会在这里处理 * * @param ctx * @param frame */ private void textWebSocketFrameHandler(ChannelHandlerContext ctx, TextWebSocketFrame frame) { String userId = ctx.channel().attr(AttributeKey.valueOf("user")).get().toString(); log.info("当前登录的用户是：{}", userId); String text = frame.text(); MsgContentProperties msgContentProperties = JSON.parseObject(text, MsgContentProperties.class); //设置发送时间 msgContentProperties.setSendTime(new Date()); //聊天对话分享 if ("0".equals(msgContentProperties.getMsgType()) || "2".equals(msgContentProperties.getMsgType())) { handleWebCommonMessage(ctx, msgContentProperties); } else if ("1".equals(msgContentProperties.getMsgType())) { //文件分享 handleWebFileMessage(ctx, msgContentProperties); } else if ("3".equals(msgContentProperties.getMsgType())) { //图片分享 handleFileImageMessage(ctx,msgContentProperties); } else if ("4".equals(msgContentProperties.getMsgType())) { //视频通话邀约 handleInviteVideoCallMessage(ctx, msgContentProperties); } else if ("5".equals(msgContentProperties.getMsgType())) { //同意接收视频对话,通知加入ice handleAgreeVideoCallMessage(msgContentProperties); } else if ("6".equals(msgContentProperties.getMsgType())) { //通话开始，交换信令,offer,answer,candidate handleVideoCallMessage(msgContentProperties); } else { } } /** * 发送图片资源 * @param ctx * @param msgContentProperties */ private void handleFileImageMessage(ChannelHandlerContext ctx, MsgContentProperties msgContentProperties) { this.handleWebFileMessage(ctx,msgContentProperties); } /** * 处理文件分享 * * @param ctx * @param msgContentProperties */ private void handleWebFileMessage(ChannelHandlerContext ctx, MsgContentProperties msgContentProperties) { List<String> acceptUserId = msgContentProperties.getAcceptUserId(); List<Channel> channelList = findChannelByUserId(acceptUserId); AtomicReference<Boolean> isLook = new AtomicReference<>(false); channelList.stream().forEach(channel -> { this.updateMessageReadStatus(channel, msgContentProperties, isLook); }); // 处理消息心跳并返回给自己 handleAndSendHeartbeat(ctx, msgContentProperties, isLook.get()); //保存聊天记录 saveChatRecords(acceptUserId, msgContentProperties); } /** * 同意通话 * * @param msgContentProperties */ private void handleAgreeVideoCallMessage(MsgContentProperties msgContentProperties) { List<String> acceptUserId = msgContentProperties.getAcceptUserId(); List<Channel> channelList = findChannelByUserId(acceptUserId); Channel channel = channelList.get(0); channel.writeAndFlush(new TextWebSocketFrame(JSONObject.toJSONString(msgContentProperties))); } /** * 通话邀约 * * @param ctx * @param msgContentProperties */ private void handleInviteVideoCallMessage(ChannelHandlerContext ctx, MsgContentProperties msgContentProperties) { List<String> acceptUserId = msgContentProperties.getAcceptUserId(); Map<String, Object> messageMap = msgContentProperties.getMessageMap(); //设置来电铃声 messageMap.put("callMusic", "http://101.43.99.167:9000/blue-oss/r8nx5-0hhz7.mp3"); // 计算来电过期时间，当前时间加一分钟 Instant now = Instant.now(); Instant overdueTime = now.plus(Duration.ofMinutes(1)); messageMap.put("overdueTime", overdueTime.toString()); // 转换为字符串表示 List<Channel> channelList = findChannelByUserId(acceptUserId); if (CollectionUtils.isEmpty(channelList)) { //对方不在线 msgContentProperties.setIsRead(false); msgContentProperties.setReadName("未读"); msgContentProperties.setMsgContent("未接来电"); } else { Channel channel = channelList.get(0); channel.writeAndFlush(new TextWebSocketFrame(JSONObject.toJSONString(msgContentProperties))); } saveChatRecords(acceptUserId, msgContentProperties); } /** * 处理普通对话消息 * * @param ctx * @param msgContentProperties */ private void handleWebCommonMessage(ChannelHandlerContext ctx, MsgContentProperties msgContentProperties) { // 接收人id List<String> acceptUserId = msgContentProperties.getAcceptUserId(); AtomicReference<Boolean> isLook = new AtomicReference<>(false); List<Channel> channelList = findChannelByUserId(acceptUserId); //对方离线 if (CollectionUtils.isEmpty(channelList)) { //消息未读或者不在对话路由下面 msgContentProperties.setIsRead(false); msgContentProperties.setReadName("未读"); } channelList.stream().forEach(channel -> { this.updateMessageReadStatus(channel, msgContentProperties, isLook); }); // 处理消息心跳并返回给自己 handleAndSendHeartbeat(ctx, msgContentProperties, isLook.get()); //保存聊天记录 saveChatRecords(acceptUserId, msgContentProperties); } /** * 处理并返回消息心跳 * * @param ctx ChannelHandlerContext 上下文 * @param msgContentProperties 消息内容属性 * @param isLook 是否已读的状态 */ private void handleAndSendHeartbeat(ChannelHandlerContext ctx, MsgContentProperties msgContentProperties, boolean isLook) { // 创建新的消息属性对象并设置读取状态 MsgContentProperties properties = BeanUtil.copyProperties(msgContentProperties, MsgContentProperties.class); properties.setIsRead(isLook); properties.setReadName(isLook ? "已读" : "未读"); // 返回给自己心跳消息 ctx.channel().writeAndFlush(new TextWebSocketFrame(JSONObject.toJSONString(properties))); } /** * 更新消息的已读/未读状态 * * @param channel 当前处理的Channel * @param msgContentProperties 消息内容属性 * @param isLook 是否已读的原子引用 */ private void updateMessageReadStatus(Channel channel, MsgContentProperties msgContentProperties, AtomicReference<Boolean> isLook) { String route = channel.attr(AttributeKey.valueOf("route")).get().toString(); String chatRoute = "chat" + msgContentProperties.getSendUserId(); if (chatRoute.equals(route)) { msgContentProperties.setIsRead(true); msgContentProperties.setReadName("已读"); isLook.set(true); channel.writeAndFlush(new TextWebSocketFrame(JSONObject.toJSONString(msgContentProperties))); } else { msgContentProperties.setIsRead(false); msgContentProperties.setReadName("未读"); isLook.set(false); } } /** * 处理rtc视频通讯 * * @param msgContentProperties */ private void handleVideoCallMessage(MsgContentProperties msgContentProperties) { String message = JSONObject.toJSONString(msgContentProperties); sendToUser(msgContentProperties.getAcceptUserId(), message); String sendUserId = msgContentProperties.getSendUserId(); List<String> sendUserIdList = Collections.singletonList(sendUserId); sendToUser(sendUserIdList, message); } private void sendToUser(List<String> userId, String message) { // 找到目标用户的 Channel 并发送消息 List<Channel> targetChannel = findChannelByUserId(userId); if (!CollectionUtils.isEmpty(targetChannel)) { targetChannel.stream().forEach(channel -> { /* String route = channel.attr(AttributeKey.valueOf("route")).get().toString(); if ("rtc".equals(route)) { channel.writeAndFlush(new TextWebSocketFrame(message)); }*/ channel.writeAndFlush(new TextWebSocketFrame(message)); }); } else { log.warn("用户 {} 的 Channel 未找到", userId); } } /** * 查找连接池对应Channel * * @param userId * @return */ public List<Channel> findChannelByUserId(List<String> userId) { ChannelGroup channels = webSocketChannelPool.getAllChannelGroup(); if (CollectionUtils.isEmpty(channels)) { return CollUtils.emptyList(); } List<Channel> channelList = channels.stream().filter(item -> { return userId.contains(item.attr(AttributeKey.valueOf("user")).get().toString()); }).collect(Collectors.toList()); return channelList; } /** * 处理客户端心跳包 * * @param ctx * @param frame */ private void pingWebSocketFrameHandler(ChannelHandlerContext ctx, PingWebSocketFrame frame) { ctx.channel().writeAndFlush(new PongWebSocketFrame(frame.content().retain())); } /** * 保存聊天记录 * * @param acceptUserId * @param msgContentProperties */ private void saveChatRecords(List<String> acceptUserId, MsgContentProperties msgContentProperties) { List<MsgContent> msgContents = acceptUserId.stream() .map(userId -> { MsgContent msgContent = BeanUtil.copyProperties(msgContentProperties, MsgContent.class); String messageMap = JSONObject.toJSONString(msgContentProperties.getMessageMap()); msgContent.setMessageMap(messageMap); msgContent.setSendUserIsRemove(false); msgContent.setAcceptUserIsRemove(false); msgContent.setAcceptUserId(String.valueOf(userId)); // Assuming acceptUserId is a String in MsgContent return msgContent; }) .collect(Collectors.toList()); this.msgContentService.saveMsgContents(msgContents); // Ensure this method saves a list of MsgContent objects } }
聊天记录持久化到mongodb
/** * 保存聊天记录 * * @param acceptUserId * @param msgContentProperties */ private void saveChatRecords(List<String> acceptUserId, MsgContentProperties msgContentProperties) { List<MsgContent> msgContents = acceptUserId.stream() .map(userId -> { MsgContent msgContent = BeanUtil.copyProperties(msgContentProperties, MsgContent.class); String messageMap = JSONObject.toJSONString(msgContentProperties.getMessageMap()); msgContent.setMessageMap(messageMap); msgContent.setSendUserIsRemove(false); msgContent.setAcceptUserIsRemove(false); msgContent.setAcceptUserId(String.valueOf(userId)); // Assuming acceptUserId is a String in MsgContent return msgContent; }) .collect(Collectors.toList()); this.msgContentService.saveMsgContents(msgContents); // Ensure this method saves a list of MsgContent objects }
package com.litblue.starter.pojo.im.properties; import com.litblue.starter.pojo.artwork.domain.LitArtworkInfo; import com.litblue.starter.pojo.artwork.vo.LitArtworkInfoVo; import lombok.Data; import java.util.Date; import java.util.HashMap; import java.util.List; import java.util.Map; /** * 消息内容 */ @Data public class MsgContentProperties { /** * 发送类型 (0 群发 1 单发) */ private String sendType; /** * 消息类型 (0 文本对话 * 1 文件 * 2 作品分享 * 3 发送图片 * 4 发起视频对话请求 * 5 接收视频对话 * 6 拒绝视频对话) */ private String msgType; /** * 其他业务消息结构体 */ private Map<String,Object> messageMap = new HashMap<>(); /** * 消息内容 */ private String msgContent; /** * 发送人id */ private String sendUserId; /** * 接收人id(在两人对话聊天，或者分享的时候携带) */ private List<String> acceptUserId; /** * 群组id(在群发的时候携带) */ private String groupId; /** * 发送时间 */ private Date sendTime; /** * 消息是否已读(0已读 1未读) */ private Boolean isRead; /** * 消息状态名称 */ private String readName; }
@Override public void saveMsgContents(List<MsgContent> msgContents) { msgContentRepository.saveAll(msgContents); }
