Springboot+netty+websocket 实现单聊群聊及用户鉴权

最新推荐文章于 2024-09-02 16:34:31 发布
最新推荐文章于 2024-09-02 16:34:31 发布
阅读量2.9k 收藏 17
点赞数
分类专栏： Netty spring 文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cocoxzq000/article/details/123967759
版权

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

前言

技术栈： SpringBoot+netty+websocket+mybatis-plus

一、配置

Maven

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.5</version>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.7.22</version>
        </dependency>
        <dependency>
            <groupId>com.sun.mail</groupId>
            <artifactId>javax.mail</artifactId>
            <version>1.6.2</version>
        </dependency>


        <dependency>
            <groupId>com.graphql-java-kickstart</groupId>
            <artifactId>graphql-spring-boot-starter</artifactId>
            <version>12.0.0</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
        </dependency>
        <dependency>
            <groupId>io.netty</groupId>
            <artifactId>netty-all</artifactId>
            <version>4.1.75.Final</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.80</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.1</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.7.22</version>
        </dependency>

spring配置

server:
  port: 10086
netty:
  host: 127.0.0.1
  port: 10010
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/test_one?useUnicode=true&useSSL=false
    username: xzq
    password: root
mybatis-plus:
  mapper-locations: classpath*:/mapper/**/*.xml
  type-aliases-package: com.xzq.netty.websocket.entity
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

二、Netty服务

1. WsServer构建

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelOption;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
@Slf4j
public class WsServer {
    @Value("${netty.host}")
    public String host;
    @Value("${netty.port}")
    public Integer port;
    @Autowired
    private WsChannelInitializer channelInitializer;

    private NioEventLoopGroup bossGroup = new NioEventLoopGroup();
    private NioEventLoopGroup workerGroup = new NioEventLoopGroup();

    public void listener() {
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap()
                    .group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    //指定服务端连接队列长度，也就是服务端处理线程全部繁忙，并且队列长度已达到1024个，后续请求将会拒绝
                    .option(ChannelOption.SO_BACKLOG, 1024)
                    .childHandler(channelInitializer);

            log.info("Netty start successful " + host + ":" + port);
            ChannelFuture f = serverBootstrap.bind(host, port).sync();
            f.channel().closeFuture().sync();
        } catch (Exception e) {
            log.info("Ws服务启动失败：" + e);
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }

    public void destroy() {
        log.info("JVM close，WsServer close");
        workerGroup.shutdownGracefully();
        bossGroup.shutdownGracefully();
    }

}

2. ChannelInitializer构建

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 WsChannelInitializer extends ChannelInitializer<SocketChannel> {

    @Autowired
    private AuthHandler authHandler;

    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        //http 协议编解码器
        ch.pipeline().addLast("http-codec", new HttpServerCodec());
        //http请求聚合处理，多个HTTP请求或响应聚合为一个FullHtppRequest或FullHttpResponse
        ch.pipeline().addLast("aggregator", new HttpObjectAggregator(65536));
        //鉴权处理器
        ch.pipeline().addLast("auth", authHandler);
        //大数据的分区传输
        ch.pipeline().addLast("http-chunked", new ChunkedWriteHandler());
        //websocket协议处理器
        ch.pipeline().addLast("websocket", new WebSocketServerProtocolHandler("/im"));
        //自定义消息处理器
        ch.pipeline().addLast("my-handler", new WsChannelHandler());
    }
}

3. 自定义消息处理器

import com.alibaba.fastjson.JSONException;
import com.alibaba.fastjson.JSONObject;
import com.xzq.netty.websocket.message.ClientMessage;
import com.xzq.netty.websocket.util.MsgUtil;
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;
import lombok.extern.slf4j.Slf4j;

@Slf4j
public class WsChannelHandler extends SimpleChannelInboundHandler<TextWebSocketFrame> {
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        Channel channel = ctx.channel();
        log.info("有客户端建立连接");
        log.info("客户端address: " + channel.remoteAddress().toString());
        log.info("客户端channel Id:" + channel.id().toString());
    }

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, TextWebSocketFrame msg) throws Exception {
        String body = msg.text();
        ClientMessage clientMessage = JSONObject.parseObject(body, ClientMessage.class);
        if (clientMessage.getType() == 1) {
            WsChannelGroup.userChannelGroup.get(clientMessage.getTo()).writeAndFlush(MsgUtil.buildSingleMsg(ctx.channel().id().toString(), clientMessage.getMsgInfo()));
            return;
        }
        WsChannelGroup.channelGroup.writeAndFlush(MsgUtil.buildGroupMsg(ctx.channel().id().toString(),clientMessage.getMsgInfo()));
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        Channel channel = ctx.channel();
        log.info("客户端断开连接... 客户端 address: " + channel.remoteAddress());
        WsChannelGroup.channelGroup.remove(channel);
        WsChannelGroup.userChannelGroup.remove(channel.id().toString(), channel);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        if (cause instanceof JSONException) {
            ctx.channel().writeAndFlush(new TextWebSocketFrame("服务端仅支持JSON格式体消息"));
            return;
        }
        Channel channel = ctx.channel();
        log.info(channel.remoteAddress()+" 连接异常,断开连接...");
        cause.printStackTrace();
        ctx.channel().writeAndFlush(new TextWebSocketFrame("服务端500 关闭连接"));
        ctx.channel().closeFuture();
        WsChannelGroup.channelGroup.remove(channel);
        WsChannelGroup.userChannelGroup.remove(channel.id().toString(), channel);
    }
}

4. 全局用户Session管理

import io.netty.channel.Channel;
import io.netty.channel.group.ChannelGroup;
import io.netty.channel.group.DefaultChannelGroup;
import io.netty.util.concurrent.GlobalEventExecutor;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class WsChannelGroup  {
    public static ChannelGroup channelGroup = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);
    public static Map<String, Channel> userChannelGroup = new ConcurrentHashMap<>();
}

5. 客户端与服务端消息实体

@Data
public class ClientMessage implements Serializable {
    /**
     *  消息类型：  1 单聊  2,群聊
     */
    private int type;

    /**
     * 消息内容
     */
    private String msgInfo;

    /**
     *  消息发送方 （目前只在单聊中体现，【群聊暂时没有分组处理】）
     */
    private String to;

}

@Data
public class ServerMessage implements Serializable {
    /**
     * 消息发送方
     */
    private String from;
    /**
     * 消息内容
     */
    private String msgInfo;

    /**
     * 时间
     */
    private String date;

    public ServerMessage(String from, String msgInfo) {
        this.from = from;
        this.msgInfo = msgInfo;
        this.date = LocalDateTime.now().toString();
    }
}

6. 消息构建工具类

import com.alibaba.fastjson.JSONObject;
import com.xzq.netty.websocket.message.ServerMessage;
import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;


public class MsgUtil {

    public static TextWebSocketFrame buildSingleMsg(String from, String msgInfo) {
        return new TextWebSocketFrame(JSONObject.toJSONString(new ServerMessage(from, msgInfo)));
    }

    public static TextWebSocketFrame buildGroupMsg(String from,String msgInfo) {
        return new TextWebSocketFrame(JSONObject.toJSONString(new ServerMessage(from, msgInfo)));
    }
}

7. 鉴权处理器

import cn.hutool.core.util.StrUtil;
import com.xzq.netty.websocket.entity.TestUser;
import com.xzq.netty.websocket.mapper.TestUserMapper;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.handler.codec.http.DefaultFullHttpResponse;
import io.netty.handler.codec.http.FullHttpRequest;
import io.netty.handler.codec.http.HttpResponseStatus;
import io.netty.handler.codec.http.HttpVersion;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
@ChannelHandler.Sharable
public class AuthHandler extends ChannelInboundHandlerAdapter {

    @Autowired
    private TestUserMapper userMapper;

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        if (msg instanceof FullHttpRequest) {
            FullHttpRequest msg1 = (FullHttpRequest) msg;
            //根据请求头的 auth-token 进行鉴权操作
            String authToken = msg1.headers().get("auth-token");
            System.out.println(">>>>>>>>>>>>鉴权操作");
            if (StrUtil.isEmpty(authToken)) {
                refuseChannel(ctx);
                return;
            }
            //查询数据库是否存在该用户
            TestUser testUser = userMapper.selectById(authToken);
            if (testUser == null) {
                refuseChannel(ctx);
            }
            //鉴权成功，添加channel用户组
            WsChannelGroup.channelGroup.add(ctx.channel());
            WsChannelGroup.userChannelGroup.put(testUser.getName(), ctx.channel());
        }
        ctx.fireChannelRead(msg);
    }

    private void refuseChannel(ChannelHandlerContext ctx) {
        ctx.channel().writeAndFlush(new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.UNAUTHORIZED));
        ctx.channel().close();
    }
}

三， 整合spring

mport com.xzq.netty.websocket.server.WsServer;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("com.xzq.netty.websocket.mapper")
public class WsApplication implements CommandLineRunner {

    @Autowired
    private WsServer wsServer;


    public static void main(String[] args) {
        SpringApplication.run(WsApplication.class, args);
    }


    @Override
    public void run(String... args) throws Exception {
        wsServer.listener();
        //钩子函数,虚拟机正常关闭调用
        Runtime.getRuntime().addShutdownHook(new Thread(()->{
            wsServer.destroy();
        }));
    }
}
```

# 四，测试
开启三个websocket客户端并都建立连接
![在这里插入图片描述](https://img-blog.csdnimg.cn/045f579ec75b4cae9b358eb073cef88d.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAQ29jb3h6cTAwMA==,size_20,color_FFFFFF,t_70,g_se,x_16)
发送消息
客户端2收到消息
![在这里插入图片描述](https://img-blog.csdnimg.cn/ebc7637bc17c4f54aae9d142b2e76f5f.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAQ29jb3h6cTAwMA==,size_20,color_FFFFFF,t_70,g_se,x_16)
Cocoxzq000
关注
专栏目录
springboot和netty整合的聊天室
qq_45659777的博客
12-05 855
文章目录一.新建工程二.各部分代码三.测试四.参考链接 一.新建工程 添加依赖 二.各部分代码 NettychathatApplication： package com.example.nettychat; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.co
springboot+netty+websocket+redis
03-08
springboot+netty+websocket+redis 分布式聊天，实现简单的聊天功能
netty-websocket 鉴权token及统一请求和响应头（鉴权控制器）
weixin_43861630的博客
03-09 5573
netty websocket自定义鉴权控制器(握手前) ，自定义协议头 Sec-WebSocket-Protocol 增加Sec-WebSocket-Protocol总是连接不上
netty编程之基于websocket实现聊天功能
最新发布
wang0907的博客
09-02 1350
本文看下netty如何通过websocket实现聊天功能。类似于实现http server,netty实现websocket也很简单，同样使用对应的编码器和解码器就行了，相关的有HttpServerCodec,HttpObjectAggregator,ChunkedWriteHandler。server类： MyChannelInitializer: 其中设置了支持websocket相关的编解码器是关键。 MyServerHandler： 对解码后的websocket消息按照不同的消息类型做了不同的处理，工
175. Spring Boot WebSocket：单聊
热门推荐
悟纤学院
12-23 2万+
【视频&交流平台】 à SpringBoot视频 http://study.163.com/course/introduction.htm?courseId=1004329008 à SpringCloud视频 http://study.163.com/course/introduction.htm?courseId=1004638001 à Spring Boot源码 https:/
springcloud环境集成netty-websocket-spring-boot-starter请求头权鉴解决方案
weixin_44123956的博客
09-05 1969
最近项目中有一个站内信推送的功能需要优化，之前一直都是前端不断定时去查询新消息，造成很多不必要的资源浪费，现在想使用websocket保持长连接，有新消息的时候通过websocket发送特定的标识给前端，前端收到后再去调用查询新消息的接口。Netty 是一个开源的、异步的、事件驱动的网络应用程序框架，用于快速开发高性能的网络和分布式系统。：Netty的设计采用了组件化和可重用的原则，它提供了一系列的易于扩展和替换的组件，如编解码器、处理器、Handler等，开发人员可以根据需要组合和定制这些组件。
springboot+websockt实现简易单聊，群发消息
weixin_44315761的博客
03-15 826
使用websocket实现简易消息推送，STOMP协议来传输基于代理的消息
基于Springboot用Netty实现WebSocket及用户身份校验
linbeiwo的博客
07-21 2794
基于Springboot用Netty实现WebSocket及用户身份校验
基于springboot+netty+vue构建的类似bililbili的弹幕群聊系统，个人娱乐项目，可用于前后端开发学习研究
06-20
基于springboot+netty+vue构建的类似bililbili的弹幕群聊系统，个人娱乐项目，可用于前后端开发学习研究 基于springboot+netty+vue构建的类似bililbili的弹幕群聊系统，个人娱乐项目，可用于前后端开发学习研究 ...
SpringBoot+WebSocket+Netty实现消息推送的示例代码
08-19
在本文中，我们将深入探讨如何使用SpringBoot、WebSocket和Netty来实现消息推送功能。首先，让我们了解一下这三个组件的关键概念。 SpringBoot是一个流行的Java框架，它简化了Spring应用程序的开发，提供了快速启动...
springboot+netty实现mqtt协议的broken
11-09
标题"springboot+netty实现mqtt协议的broken"可能意味着这个项目旨在解决Spring Boot与Netty集成时可能出现的问题，或者是一个关于如何处理MQTT连接中断的教程。在实际应用中，MQTT连接可能会因为各种原因断开，例如...
springboot基础netty和websocket
07-02
基于springboot+netty+webscoket实现的及时通讯,封装netty相关接口
Springboot+netty实现的流媒体服务（可用于直播点播）
04-28
介绍：Springboot、netty实现的http-flv、websocket-flv流媒体服务（可用于直播点播），支持rtsp、h264、h265等、rtmp等多种源，h5纯js播放（不依赖flash），不需要依赖nginx等第三方，低延迟（支持识别h264、aac...
netty-websocket扩展协议及token鉴权补充_netty-socketio 鉴权
2401_84166567的博客
04-15 1319
为channel添加属性 将userid设置为属性，避免客户端特殊情况退出时获取不到userid。(img-GgUXwz7y-1713146988829)]log.info(“与客户端断开连接，通道关闭！// 从channelGroup通道组移除。log.info(“断开的用户id为”);* @param ctx 上下文。* @param msg 消息。* @param msg 消息。
springboot整合websocket实现简易版单人聊天
congge
03-12 2732
websockt在作为即时通讯类的聊天方面有较多的应用，其主要的特点就是轻量，使用方便，容易快速上手，通过webscoket整合服务端，就可以实现简单的类似聊天的功能，下面说说springboot整合socketjs实现一个简易版的点对点聊天过程， 1、pom依赖： &lt;parent&gt; &lt;groupId&gt;org.springframework.boot&lt;/group...
SpringBoot + WebSocket实现点对点在线单聊案例
weixin_41359273的博客
02-10 1241
SpringBoot + WebSocket实现点对点在线单聊案例1.pom.xml2.实体类3.WebSocket的配置4.Security的配置，配置用于登录的用户名和密码5.controller5.前端页面6.测试 1.pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XM
netty-websocket扩展协议及token鉴权补充_netty-socketio 鉴权(1)
2401_84182392的博客
04-12 621
为channel添加属性 将userid设置为属性，避免客户端特殊情况退出时获取不到userid。* 为channel添加属性 将userid设置为属性，避免客户端特殊情况退出时获取不到userid。// //http处理器 用来握手和执行进一步操作。// 从channelGroup通道组移除。log.info(“断开的用户id为”);// log.info(“有新的连接”);// //netty 自带的http解码器。//收到信息后，群发给所有channel。// //http聚合器。
springboot+netty（一）
qq_43481350的博客
03-07 974
实例 helloserver.java package com.ndd.netty.test; import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.EventLoopGroup; import io.netty.channel.nio....
springboot项目中使用netty+websocket 实现消息推送（带校验用户是否登陆功能）
yymagicer的博客
08-12 6829
maven引入包： <!-- websocket --> <dependency> <groupId>io.netty</groupId> <artifactId>netty-all</artifactId> <version>4.1.36.Final</versio...
springboot+netty+websocket实现局域网音视频通话
05-20
实现局域网音视频通话可以用Spring Boot作为后端框架，Netty作为网络通信框架，WebSocket作为实现双向通信的协议。以下是一个简单的实现过程： 1. 首先需要搭建一个Spring Boot项目，可以使用Spring Initializr来...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值