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

最新推荐文章于 2024-03-10 16:49:43 发布
最新推荐文章于 2024-03-10 16:49:43 发布
阅读量3.7k 收藏 28
点赞数 5
分类专栏： 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();
    }

}
七濑武
关注
  • 5
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring websocket获取httpsession
12-18
spring4+ websocket获取httpsession
SpringBoot项目整合WebSocket+netty实现前后端双向通信（同时支持前端webSocket和socket协议哦）
小米吃辣椒的博客
07-03 6875
最近做了一个硬件设备通信项目，需求是这样，前端使用webSocket向后端进行tcp协议的通信，后端netty服务端收到数据后，将数据发往socket客户端，客户端收到数据之后需要进行响应数据显示到前端页面供用户进行实时监控。
SpringBoot集成netty实现websocket通信
usa_washington的博客
03-10 875
netty实现websocket通信
基于SpringBoot与Netty的WebSocket弹幕系统设计源码
最新发布
04-14
本源码是一个基于SpringBoot、Netty、Redis和Protocol Buffer协议的高并发弹幕系统设计。后端使用SpringBoot 2.4.3进行开发，利用Netty实现WebSocket通信，同时结合Redis进行数据存储和处理。前端采用Vue框架，通过WebSocket与后端进行实时数据通信。系统还采用DFA算法模型对敏感词进行过滤，确保内容的安全性。整个项目包含62个Java文件、12个PNG图像文件等，共92个文件，为用户提供了一个高效、安全的弹幕互动体验。
springboot+netty+webSocket实现在线聊天.zip
07-08
netty+webSocket实现在线聊天
基于Java+SpringBoot+Netty+WebSocket+Uniapp轻松搭建准实时聊天问答程序
08-12
绍如何搭建一个准实时聊天问答程序，包括微信小程序和H5网页版。 该项目服务端主要使用了Java + Spring Boot + Netty + WebSocket等技术栈，聊天客户端使用的是UniApp来轻松搭建微信小程序和H5网页端。
netty-websocket 鉴权token及统一请求和响应头（鉴权控制器）
weixin_43861630的博客
03-09 4445
netty websocket自定义鉴权控制器(握手前) ，自定义协议头 Sec-WebSocket-Protocol 增加Sec-WebSocket-Protocol总是连接不上
SpringBoot 整合 Netty + Websocket
Mistra的博客
09-07 5245
最近项目中需要用到长连接服务，特地整合Netty+Websocket。我们系统需要给用户主动推送订单消息，还有强制用户下线的功能也需要长连接来推送消息 一、准备工作 Netty的介绍就看这里：https://www.jianshu.com/p/b9f3f6a16911 必须要理解到一些基础概念，什么是BIO，NIO，AIO，什么是多路复用，什么是Channel(相当于一个连接)，什么是管道等等概...
SpringBoot2+Netty+WebSocket(netty实现websocket）
A初夏1的博客
06-30 5242
##### 一、SpringBoot2+Netty+WebSocket(netty实现websocket，支持URL参数) 原文链接: https://zhengkai.blog.csdn.net/article/details/91552993 思路： 用netty实现 后台的 websocket 相当于前端利用websocket协议 后端用netty实现复杂的业务逻辑 <dependency> <groupId>io.netty</groupId> &lt
netty+websocket模式下token身份验证遇到的问题
alwaysRise的博客
10-27 2276
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 1364
自定义处理类,处理http请求。
springboot+netty+websocket+redis
03-08
springboot+netty+websocket+redis 分布式聊天，实现简单的聊天功能
springboot-netty-websocket
08-31
springboot-netty-websocket
springBoot + netty搭建高性能 websocket 服务 & 性能测试（包含python 测试脚本）
卷心菜投手
09-13 4657
springBoot netty websocket 性能测试
整合 Spring Boot 和 Netty 实现 WebSocket
weixin_53438263的博客
12-08 988
首先，我们先来了解一下 WenSocketWebSocket：本质上是一个基于 TCP 的协议，双向通讯协议，实现浏览器和客户端的实时通讯，接收端和发送端相互通讯，是有状态的网络上的两个程序通过一个双向链路进行通信，这个双向链路的一端称为一个 Socket，一个 Socker 对应一个 IP 地址和端口号，应用程序通常通过 Socket 向网络发出或应答网络请求socket 不是协议，是对 TCP/IP 协议层抽象出来的 API。
Springboot中使用netty 实现 WebSocket 服务
蒯厅博客
11-06 2950
Springboot中使用netty 实现 WebSocket 服务
SpringBoot中使用Netty开发WebSocket服务-netty-websocket-spring-boot-starter开源项目使用与改造多线程群发消息
BADAO_LIUMANG_QIZHI的博客
07-12 2785
在上面的基础上，使用websocket仍有不足，比如可能出现如下问题另外如果业务场景中需要高频定时任务通过websocket给多个客户端发动消息，则短时间内需要使用多线程/自定义线程池实现群发消息功能。
## springboot 集成基于netty的websocket 详解##
ew15988的博客
11-11 812
1、WebSocket简介WebSocket协议是基于TCP的一种新的网络协议。它实现了浏览器与服务器全双工(full-duplex)通信——允许服务器主动发送信息给客户端。双全工通信：全双工通信又称为双向同时通信，即通信的双方可以同时发送和接收信息的信息交互方式。半双工通信：数据传输指数据可以在一个信号载体的两个方向上传输，但是不能同时传输。
springboot项目中使用netty+websocket 实现消息推送（带校验用户是否登陆功能）
yymagicer的博客
08-12 6637
maven引入包： <!-- websocket --> <dependency> <groupId>io.netty</groupId> <artifactId>netty-all</artifactId> <version>4.1.36.Final</versio...
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、付费专栏及课程。

余额充值