SpringBoot 集成 Netty 使用WebSocket功能，并实现token校验

最新推荐文章于 2024-09-16 15:21:15 发布
最新推荐文章于 2024-09-16 15:21:15 发布
阅读量4.2k 收藏 33
点赞数 6
分类专栏： netty java 文章标签： spring boot websocket 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xw_725/article/details/125655257
版权

SpringBoot 集成 Netty 使用Socket功能，并实现token校验

  1. 引入Netty的jar包
<dependency>
    <groupId>io.netty</groupId>
    <artifactId>netty-all</artifactId>
    <version>4.1.77.Final</version>
</dependency>
  1. 与Springboot集成
package com.netty;

import cn.hutool.core.util.ObjectUtil;
import com.netty.config.MyWebSocketServerProtocolHandler;
import com.netty.config.NettyWebSocketHandler;
import com.netty.config.NettyWebSocketParamHandler;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
import io.netty.handler.stream.ChunkedWriteHandler;
import io.netty.handler.timeout.IdleStateHandler;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

/**
 * NettyBooter
 *
 * @author 七濑武【Nanase Takeshi】
 * @date 2022/06/23 10:14
 */
@Slf4j
@Component
public class NettyBooster {

    private final NettyWebSocketParamHandler nettyWebSocketParamHandler;

    private final NettyWebSocketHandler nettyWebSocketHandler;

    private EventLoopGroup bossGroup;

    private EventLoopGroup workerGroup;

    public NettyBooster(NettyWebSocketParamHandler nettyWebSocketParamHandler, NettyWebSocketHandler nettyWebSocketHandler) {
        this.nettyWebSocketParamHandler = nettyWebSocketParamHandler;
        this.nettyWebSocketHandler = nettyWebSocketHandler;
    }

    @PostConstruct
    public void start() throws InterruptedException {
        //创建BossGroup，这里指定线程数1就够了，bossGroup 就相当于领导，workerGroup 就相当于员工，领导有一个差不多了
        bossGroup = new NioEventLoopGroup(1);
        //创建WorkerGroup
        workerGroup = new NioEventLoopGroup();
        //创建服务器端的启动对象，配置参数
        ServerBootstrap serverBootstrap =
                new ServerBootstrap()
                        .group(bossGroup, workerGroup)
                        //使用NioServerSocketChannel作为服务器的通道实现
                        .channel(NioServerSocketChannel.class)
                        //设置日志处理器
                        .handler(new LoggingHandler(LogLevel.INFO))
                        //设置线程队列得到的连接个数
                        .option(ChannelOption.SO_BACKLOG, 128)
                        //设置保持活动连接的状态
                        .childOption(ChannelOption.SO_KEEPALIVE, true)
                        //给我们的workerGroup的EventLoop对应的管道设置处理器
                        .childHandler(new ChannelInitializer<SocketChannel>() {
                            /**
                             * 创建一个通道测试对象（匿名对象）
                             * 给pipeline设置处理器
                             */
                            @Override
                            protected void initChannel(SocketChannel socketChannel) throws Exception {
                                socketChannel.pipeline().addLast(
                                        // 解码器
                                        new HttpServerCodec(),
                                        // http 消息聚合器  512*1024为接收的最大content-length
                                        new HttpObjectAggregator(8192),
                                        // 支持异步发送大的码流(大的文件传输),但不占用过多的内存，防止java内存溢出
                                        new ChunkedWriteHandler(),
                                        //设置一个空闲状态处理程序（心跳机制），读空闲，写空闲，读写空闲
                                        new IdleStateHandler(20, 0, 0),
                                        // 自定义参数处理器，必须放在 new WebSocketServerProtocolHandler() 处理器之前
                                        nettyWebSocketParamHandler,
                                        // websocket支持，前端通过访问IP:端口/web-socket连接,设置路由（这里使用了自己继承WebSocketServerProtocolHandler重写了decode方法的类，目的是为了获取到客户端传递的自定义Close Code）
                                        new MyWebSocketServerProtocolHandler("/web-socket"),
                                        //自定义处理程序
                                        nettyWebSocketHandler
                                );
                            }
                        });
        serverBootstrap.bind(10000).sync();
        log.info("NettyBooster.start --> Netty 启动成功");
    }

    /**
     * Springboot关闭时关闭Netty
     */
    @PreDestroy
    private void destroy() throws InterruptedException {
        log.info("NettyBooster.destroy --> : 关闭 Netty...");
        if (ObjectUtil.isNotNull(bossGroup)) {
            bossGroup.shutdownGracefully().sync();
        }
        if (ObjectUtil.isNotNull(workerGroup)) {
            workerGroup.shutdownGracefully().sync();
        }
        log.info("NettyBooster.destroy --> : Netty 线程已全部关闭...");
    }

}
  1. 编写URL参数处理程序
package com.netty;

import cn.hutool.core.net.url.UrlBuilder;
import cn.hutool.core.util.URLUtil;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.codec.http.FullHttpRequest;
import io.netty.util.AttributeKey;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import java.util.Map;


/**
 * URL参数处理程序，这时候连接还是个http请求，没有升级成webSocket协议，此处SimpleChannelInboundHandler泛型使用FullHttpRequest
 *
 * @author Nanase Takeshi
 * @date 2022/5/7 15:07
 */
@Slf4j
@Component
@ChannelHandler.Sharable
public class NettyWebSocketParamHandler extends SimpleChannelInboundHandler<FullHttpRequest> {

    /**
     * 此处进行url参数提取，重定向URL，访问webSocket的url不支持带参数的，带参数会抛异常，这里先提取参数，将参数放入通道中传递下去，重新设置一个不带参数的url
     *
     * @param ctx     the {@link ChannelHandlerContext} which this {@link SimpleChannelInboundHandler}
     *                belongs to
     * @param request the message to handle
     * @throws Exception
     */
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest request) throws Exception {
        String uri = request.uri();
        log.info("NettyWebSocketParamHandler.channelRead0 --> : 格式化URL... {}", uri);
        Map<CharSequence, CharSequence> queryMap = UrlBuilder.ofHttp(uri).getQuery().getQueryMap();
        //将参数放入通道中传递下去
        AttributeKey<String> attributeKey = AttributeKey.valueOf("token");
        ctx.channel().attr(attributeKey).setIfAbsent(queryMap.get("token").toString());
        request.setUri(URLUtil.getPath(uri));
        ctx.fireChannelRead(request.retain());
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        log.error("NettyWebSocketParamHandler.exceptionCaught --> cause: ", cause);
        ctx.close();
    }

}
  1. 对客户端传递的数据进行拦截提取自定义code，放入通道中传递下去
package com.ljky.ambl.config;

import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.http.websocketx.CloseWebSocketFrame;
import io.netty.handler.codec.http.websocketx.WebSocketFrame;
import io.netty.handler.codec.http.websocketx.WebSocketServerProtocolHandler;

import java.util.List;

/**
 * 继承WebSocketServerProtocolHandler，自定义处理下客户端发送的自定义关闭消息
 *
 * @author Nanase Takeshi
 * @date 2022/6/2 11:40
 */
public class MyWebSocketServerProtocolHandler extends WebSocketServerProtocolHandler {

    public MyWebSocketServerProtocolHandler(String websocketPath) {
        super(websocketPath);
    }

    @Override
    protected void decode(ChannelHandlerContext ctx, WebSocketFrame frame, List<Object> out) throws Exception {
    	//对客户端消息解码时如果消息是关闭通道类型，则获取Close Code
        if (frame instanceof CloseWebSocketFrame) {
            CloseWebSocketFrame closeWebSocketFrame = (CloseWebSocketFrame) frame;
            //传递CloseWebSocketFrame的statusCode
            AttributeKey<Integer> attributeKey = AttributeKey.valueOf("closeCode");
            ctx.channel().attr(attributeKey).setIfAbsent(closeWebSocketFrame.statusCode());
        }
        super.decode(ctx, frame, out);
    }

}
  1. 自定义WebSocket处理程序
package com.netty;

import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.codec.http.websocketx.CloseWebSocketFrame;
import io.netty.handler.codec.http.websocketx.WebSocketFrame;
import io.netty.handler.codec.http.websocketx.WebSocketServerProtocolHandler;
import io.netty.handler.timeout.IdleState;
import io.netty.handler.timeout.IdleStateEvent;
import io.netty.util.Attribute;
import io.netty.util.AttributeKey;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

/**
 * 自定义WebSocket处理程序
 * SimpleChannelInboundHandler的泛型需要传递WebSocketFrame
 *
 * @author Nanase Takeshi
 * @date 2022/5/7 15:07
 */
@Slf4j
@Component
@ChannelHandler.Sharable
public class NettyWebSocketHandler extends SimpleChannelInboundHandler<WebSocketFrame> {

    /**
     * 事件回调
     *
     * @param ctx
     * @param evt
     * @throws Exception
     */
    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        if (evt instanceof WebSocketServerProtocolHandler.HandshakeComplete) {
            //协议握手成功完成
            log.info("NettyWebSocketHandler.userEventTriggered --> : 协议握手成功完成");
            //检查用户token
            AttributeKey<String> attributeKey = AttributeKey.valueOf("token");
            //从通道中获取用户token
            String token = ctx.channel().attr(attributeKey).get();
            //校验token逻辑
            //......
            if(1 == 2) {
                //如果token校验不通过，发送连接关闭的消息给客户端，设置自定义code和msg用来区分下服务器是因为token不对才导致关闭
                ctx.writeAndFlush(new CloseWebSocketFrame(400, "token 无效")).addListener(ChannelFutureListener.CLOSE);
            }
        }
        //通过判断IdleStateEvent的状态来实现自己的读空闲，写空闲，读写空闲处理逻辑
        if (evt instanceof IdleStateEvent && ((IdleStateEvent) evt).state() == IdleState.READER_IDLE) {
            //读空闲，关闭通道
            log.info("NettyWebSocketHandler.userEventTriggered --> : 读空闲，关闭通道");
            ctx.close();
        }
    }

    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, WebSocketFrame textWebSocketFrame) throws Exception {
        log.info("NettyWebSocketHandler.channelRead0 --> : 发消息来了");
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        log.info("NettyWebSocketHandler.channelInactive --> : 通道关闭了");
        //获取用户关闭通道时设置的close code
        AttributeKey<Integer> attributeKey = AttributeKey.valueOf("closeCode");
        Attribute<Integer> closeCode = ctx.channel().attr(attributeKey);
        //对closeCode进行区分处理....
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        log.error("NettyWebSocketHandler.exceptionCaught --> cause: ", cause);
        ctx.close();
    }

}
七濑武
关注
专栏目录
springboot项目中使用netty+websocket 实现消息推送（带校验用户是否登陆功能）
yymagicer的博客
08-12 6833
maven引入包： <!-- websocket --> <dependency> <groupId>io.netty</groupId> <artifactId>netty-all</artifactId> <version>4.1.36.Final</versio...
Spring-boot集成Netty做websocket服务端
Lance
06-21 6358
Springboot集成netty4.1.12做为websocket服务端，
Springboot实现websocket（连接前jwt验证token）
weixin_42966151的博客
09-27 5662
二、因为springboot的websocket连接时不会显示header信息，也就无法拿到cookie中的token信息，需要在连接前处理，新建一个WebSocketConfig.class，在连接前做一个jwt的token验证，并获取用户的账号信息添加到session中。(关于jwt的token验证工具类我这里就不详细讲了)，用户连接服务器weksocket前，需经过jwt的token验证（token中包含账号信息），验证合法后，才可以于服务器正常交互。一、配置依赖（pom.xml）
Springboot整合Netty
最新发布
我的博客
09-16 993
Netty是由JBOSS提供的一个java开源框架。Netty是 一个异步事件驱动的网络应用程序框架，用于快速开发高性能、高可靠性的网络服务器和客户端程序。它提供了对TCP、UDP以及各种二进制和基于文本的传统协议的支持。它极大地简化并优化了 TCP 和 UDP 套接字服务器等网络编程，解决了断线重连、 网络闪断、心跳处理、半包读写、 网络拥塞和异常流的处理等等问题。Netty 现在都在用的是4.x，5.x版本已经封存，Netty 4.x 需要JDK 6以上版本支持。
netty-websocket 鉴权token及统一请求和响应头（鉴权控制器）
weixin_43861630的博客
03-09 5586
netty websocket自定义鉴权控制器(握手前) ，自定义协议头 Sec-WebSocket-Protocol 增加Sec-WebSocket-Protocol总是连接不上
netty+websocket模式下token身份验证遇到的问题
alwaysRise的博客
10-27 2439
netty+websocket下pipeline中handler无法传递的问题在ChannelPipeline中责任链的传递 在ChannelPipeline中责任链的传递 ChannelPipeline pipeline = socketChannel.pipeline(); //websocket协议本身是基于http协议的，所以这边也要使用http解编码器 pipeline.addLast(new HttpServerCodec()); //以块的方式来写的处理器 pipeline.addLast(
spring boot集成netty实现websocket
FSDYZx的博客
04-12 1465
自定义处理类,处理http请求。
SpringBoot整合Netty之Websocket
AnxiangLemon的博客
10-31 4193
前后端通过websocket通信进行聊天~ 核心代码整理如下： netty组件 @Component public class NettyBooter implements ApplicationListener<ContextRefreshedEvent> { @Override public void onApplicationEvent(ContextRef...
SpringBoot集成netty实现websocket通信
usa_washington的博客
03-10 1253
netty实现websocket通信
Springboot整合Netty提供WebSocket服务
wl_Honest的博客
10-09 1518
昨天重温Netty学习视频，发现Netty还能够提供WebSocket服务，刚好前段时间做了个WebSocket服务的接口，感觉做的不是很好，特地查了一下如何用Springboot整合Netty提供WebSocket服务。经过网上的搜查和昨天视频学习的现学现用，整理出此篇文章记录如何用WebSocket接口定时发送消息。
Spring boot 项目（二十三）——用 Netty+Websocket实现聊天室
weixin_45974176的博客
06-14 3092
Netty快速入门教程
SpringBoot集成Netty实现WebSocket和Http服务
u010631992的博客
06-10 2277
项目地址：https://github.com/pengyongjianpyj/netty-websocket-http-spring-boot-starter
netty-websocket扩展协议及token鉴权补充
weixin_43861630的博客
02-05 2036
postman链接成功根据日志可以看出，链接成功并且相应和请求的头是一致的。
在SpringBoot中整合使用Netty框架提供WebSocket服务
weixin_39280774的博客
08-07 1996
在SpringBoot中整合使用Netty框架 Netty是一个非常优秀的Socket框架。如果需要在SpringBoot开发的app中，提供Socket服务，那么Netty是不错的选择。 Netty与SpringBoot的整合，我想无非就是要整合几个地方 让netty跟springboot生命周期保持一致，同生共死 让netty能用上ioc中的Bean 让netty能读取到全局的配置 整合Netty，提供WebSocket服务 这里演示一个案例，在SpringBoot中使用Netty提供一个Websock
SpringBoot整合Netty搭建高性能Websocket服务器（实现聊天功能）
冯冬冬的博客
12-27 5546
之前使用Springboot整合了websocket，实现了一个后端向前端推送信息的基本小案例，这篇文章主要是增加了一个新的框架就是Netty，实现一个高性能的websocket服务器，并结合前端代码，实现一个基本的聊天功能。你可以根据自己的业务需求进行更改。 这里假设你已经了解了Netty和websocket的相关知识，仅仅是想通过Springboot来整合他们。根据之前大家的需求，代码已经上...
springboot+netty实现网络聊天
junseven164的博客
12-04 3261
如愿一、创建项目二、代码模块三、总结四、参考 一、创建项目 选择spring initialzr，点击next 改一下项目名字和所使用的Java版本，点击next 选择spring web，点击next 二、代码模块 这个不需要引入了，在pom.xml文件里添加依赖，下面是pom.xml文件，自己添加依赖 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0"
SpringBoot 整合 Netty + Websocket
Mistra的博客
09-07 6177
最近项目中需要用到长连接服务，特地整合Netty+Websocket。我们系统需要给用户主动推送订单消息，还有强制用户下线的功能也需要长连接来推送消息 一、准备工作 Netty的介绍就看这里：https://www.jianshu.com/p/b9f3f6a16911 必须要理解到一些基础概念，什么是BIO，NIO，AIO，什么是多路复用，什么是Channel(相当于一个连接)，什么是管道等等概...
SpringBoot 整合 Netty 实现 WebSocket
MR.骑士道
05-11 7208
SpringBoot 整合 Netty 实现 WebSocket
springboot集成netty实现websocket消息推送
03-11
非常感谢您的提问。关于springboot集成netty实现websocket消息推送的问题，我可以回答您。在springboot中，我们可以使用Netty-WebSocket来实现WebSocket消息推送。具体实现方法可以参考相关的文档和教程。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值