java Netty WebSocketServer

最新推荐文章于 2024-06-10 22:10:39 发布
最新推荐文章于 2024-06-10 22:10:39 发布
阅读量512 收藏 2
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40683787/article/details/104860021
版权

下载官方示例
netty官方 github
官方WebSocket相关演示文档路径：
在这里插入图片描述

看了下几乎和DotNetty的一模一样。（好歹DotNetty是大部分是照着仿写的）

在此基础上修改使用：
NettyWebSocketServer
两个事件循环组，bossGroup和workerGroup，绑定后增加日志handler，为通道Channel指定处理handler（WebSocketServerInitializer）
和官方示例比，图省事，把ssl给删掉了，参数直接给了个Null

package com.SocketLayer.WebSocketServer;

import java.util.HashMap;

import com.Global.LogManager;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.Channel;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;

public class NettyWebSocketServer {

	public static void StartListening(int PORT) {
		EventLoopGroup bossGroup = new NioEventLoopGroup(1);
		EventLoopGroup workerGroup = new NioEventLoopGroup();
		try {
			ServerBootstrap b = new ServerBootstrap();
			b.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class)
					.handler(new LoggingHandler(LogLevel.INFO)).childHandler(new WebSocketServerInitializer(null));

			Channel ch = b.bind(PORT).sync().channel();
			ch.closeFuture().sync();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			LogManager.writeError(e);
		} finally {
			bossGroup.shutdownGracefully();
			workerGroup.shutdownGracefully();
		}
	}

	private static HashMap<String, Channel> ClientMap = new HashMap<>();

	public static void ClientRegist(Channel c) {
		ClientMap.put(c.remoteAddress().toString(), c);
	}

	public static void ClientUnRegist(Channel c) {
		ClientMap.remove(c.remoteAddress().toString());
	}
}

WebSocketServerInitializer
初始化及在管道队列中添加对应的Handler（绑定）
HttpServerCodec：
Creates a new instance with the default decoder options (maxInitialLineLength (4096}, maxHeaderSize (8192), and maxChunkSize (8192)).
默认的decoder（编码器）
HttpObjectAggregator:
指定单次消息的最大长度
WebSocketServerCompressionHandler：
Constructor with default configuration.
（默认配置）
WebSocketServerProtocolHandler：
WebSocketServer协议处理
WebSocketIndexPageHandler:
握手请求处理（名字忘了改，直接用了官方示例的名字）
WebSocketFrameHandler：
WebSocket帧处理

package com.SocketLayer.WebSocketServer;

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
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.codec.http.websocketx.extensions.compression.WebSocketServerCompressionHandler;
import io.netty.handler.ssl.SslContext;

/**
 */
public class WebSocketServerInitializer extends ChannelInitializer<SocketChannel> {

	private static final String WEBSOCKET_PATH = "/websocket";

	private final SslContext sslCtx;

	public WebSocketServerInitializer(SslContext sslCtx) {
		this.sslCtx = sslCtx;
	}

	@Override
	public void initChannel(SocketChannel ch) throws Exception {
		ChannelPipeline pipeline = ch.pipeline();
		if (sslCtx != null) {
			pipeline.addLast(sslCtx.newHandler(ch.alloc()));
		}
		pipeline.addLast(new HttpServerCodec());
		pipeline.addLast(new HttpObjectAggregator(65536));
		pipeline.addLast(new WebSocketServerCompressionHandler());
		pipeline.addLast(new WebSocketServerProtocolHandler(WEBSOCKET_PATH, null, true));
		pipeline.addLast(new WebSocketIndexPageHandler(WEBSOCKET_PATH));
		pipeline.addLast(new WebSocketFrameHandler());
	}
}

WebSocketIndexPageHandler

package com.SocketLayer.WebSocketServer;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufUtil;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.codec.http.DefaultFullHttpResponse;
import io.netty.handler.codec.http.FullHttpRequest;
import io.netty.handler.codec.http.FullHttpResponse;
import io.netty.handler.codec.http.HttpHeaderNames;
import io.netty.handler.codec.http.HttpRequest;
import io.netty.handler.codec.http.HttpResponseStatus;
import io.netty.handler.codec.http.HttpUtil;
import io.netty.handler.ssl.SslHandler;
import io.netty.util.CharsetUtil;

import static io.netty.handler.codec.http.HttpHeaderNames.*;
import static io.netty.handler.codec.http.HttpMethod.*;
import static io.netty.handler.codec.http.HttpResponseStatus.*;

/**
 * Outputs index page content.
 */
public class WebSocketIndexPageHandler extends SimpleChannelInboundHandler<FullHttpRequest> {

	private final String websocketPath;

	public WebSocketIndexPageHandler(String websocketPath) {
		this.websocketPath = websocketPath;
	}

	@Override
	protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest req) throws Exception {
		// Handle a bad request.
		if (!req.decoderResult().isSuccess()) {
			sendHttpResponse(ctx, req,
					new DefaultFullHttpResponse(req.protocolVersion(), BAD_REQUEST, ctx.alloc().buffer(0)));
			return;
		}

		// Allow only GET methods.
		if (!GET.equals(req.method())) {
			sendHttpResponse(ctx, req,
					new DefaultFullHttpResponse(req.protocolVersion(), FORBIDDEN, ctx.alloc().buffer(0)));
			return;
		}

		// Send the index page
		if ("/".equals(req.uri()) || "/index.html".equals(req.uri())) {
			String webSocketLocation = getWebSocketLocation(ctx.pipeline(), req, websocketPath);
			ByteBuf content = Unpooled.copiedBuffer(webSocketLocation + ": welcome", CharsetUtil.US_ASCII);
			FullHttpResponse res = new DefaultFullHttpResponse(req.protocolVersion(), OK, content);

			res.headers().set(CONTENT_TYPE, "text/html; charset=UTF-8");
			HttpUtil.setContentLength(res, 0);

			sendHttpResponse(ctx, req, res);
		} else {
			sendHttpResponse(ctx, req,
					new DefaultFullHttpResponse(req.protocolVersion(), NOT_FOUND, ctx.alloc().buffer(0)));
		}
	}

	@Override
	public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
		cause.printStackTrace();
		ctx.close();
	}

	private static void sendHttpResponse(ChannelHandlerContext ctx, FullHttpRequest req, FullHttpResponse res) {
		// Generate an error page if response getStatus code is not OK (200).
		HttpResponseStatus responseStatus = res.status();
		if (responseStatus.code() != 200) {
			ByteBufUtil.writeUtf8(res.content(), responseStatus.toString());
			HttpUtil.setContentLength(res, res.content().readableBytes());
		}
		// Send the response and close the connection if necessary.
		boolean keepAlive = HttpUtil.isKeepAlive(req) && responseStatus.code() == 200;
		HttpUtil.setKeepAlive(res, keepAlive);
		ChannelFuture future = ctx.writeAndFlush(res);
		if (!keepAlive) {
			future.addListener(ChannelFutureListener.CLOSE);
		}
	}

	private static String getWebSocketLocation(ChannelPipeline cp, HttpRequest req, String path) {
		String protocol = "ws";
		if (cp.get(SslHandler.class) != null) {
			// SSL in use so use Secure WebSockets
			protocol = "wss";
		}
		return protocol + "://" + req.headers().get(HttpHeaderNames.HOST) + path;
	}
}

WebSocketFrameHandler

package com.SocketLayer.WebSocketServer;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;
import io.netty.handler.codec.http.websocketx.WebSocketFrame;

import java.util.Locale;

import com.Model.ExpressionPack.ExpressionCMD;
import com.TVSensoranalyzerj.RegulationPackManager;
import com.alibaba.fastjson.JSON;

/**
 * Echoes uppercase content of text frames.
 */
public class WebSocketFrameHandler extends SimpleChannelInboundHandler<WebSocketFrame> {

	@Override
	protected void channelRead0(ChannelHandlerContext ctx, WebSocketFrame frame) throws Exception {
		// ping and pong frames already handled

		if (frame instanceof TextWebSocketFrame) {
			// Send the uppercase string back.
			String request = ((TextWebSocketFrame) frame).text();
			try {
				ExpressionCMD cmd = JSON.parseObject(request, ExpressionCMD.class);
				switch (cmd.getMsgType().toLowerCase()) {
				case "loadrootstr":
					var rootStr = RegulationPackManager.getRootStr();
					ctx.channel().writeAndFlush(new TextWebSocketFrame(rootStr));
					break;
				case "updateexpression":
				case "deleteexpression":
				case "updatedeviced":
				case "deletedeviced":
					if (RegulationPackManager.getMode() != 0) {
						cmd.setContext("Error: Invalid Operate during Mode" + RegulationPackManager.getMode());
						ctx.channel().writeAndFlush(new TextWebSocketFrame(JSON.toJSONString(cmd)));
						break;
					}
					cmd.setMsgType(cmd.getMsgType() + "_ACK");
					if (RegulationPackManager.HandleCmd(cmd))
						ctx.channel().writeAndFlush(new TextWebSocketFrame(RegulationPackManager.getRootStr()));
					else
						ctx.channel().writeAndFlush(new TextWebSocketFrame("error"));
					break;

				}
			} catch (Exception e) {
				// TODO: handle exception
				ctx.channel().writeAndFlush(new TextWebSocketFrame("InValid CMD"));
			}

			ctx.channel().writeAndFlush(new TextWebSocketFrame(request.toUpperCase(Locale.US)));
		} else {
			String message = "unsupported frame type: " + frame.getClass().getName();
			throw new UnsupportedOperationException(message);
		}
	}

	@Override
	public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
		// TODO Auto-generated method stub
		super.channelRead(ctx, msg);
	}

	@Override
	public void channelActive(ChannelHandlerContext ctx) throws Exception {
		// TODO Auto-generated method stub
		super.channelActive(ctx);
		NettyWebSocketServer.ClientRegist(ctx.channel());
	}

	@Override
	public void channelInactive(ChannelHandlerContext ctx) throws Exception {
		// TODO Auto-generated method stub
		super.channelInactive(ctx);
		NettyWebSocketServer.ClientUnRegist(ctx.channel());
	}
}

效果：
在这里插入图片描述在这里插入图片描述感觉都不想费过多口舌了，发现官方上的github里啥都有，很详细，然后还有example，很适合懒人。。

Silen_p
关注
专栏目录
netty实现websocket server
09-02
1. **WebSocketServer.java**：这是 Netty WebSocket 服务器的核心类。首先，我们需要导入相关的 Netty 和 WebSocket 库。然后，创建一个 `ServerBootstrap` 对象，配置服务器的参数，如线程池、管道工厂等。接着，...
在Java中使用WebSocket
热门推荐
小易
07-18 1万+
WebSocket是一种协议，用于在Web应用程序和服务器之间建立实时、双向的通信连接。它通过一个单一的TCP连接提供了持久化连接，这使得Web应用程序可以更加实时地传递数据。WebSocket协议最初由W3C开发，并于2011年成为标准。
websocket在java中的使用教程
weixin_42684368的博客
03-05 3481
本文从websocket服务端和客户端两个方面简单介绍下websocket在java中的使用
java后端实现Websocket服务，供前端建立连接
qq_40083897的博客
03-11 1万+
一、搭建一个简单的springBoot项目，导入以下jar包 <dependency> <groupId>javax</groupId> <artifactId>javaee-api</artifactId> <version>7.0</version> <scope>provided</scope> </depen
Java netty 实现websocket搭建
freetts的专栏
09-02 2736
websocket协议是属于服务端和客户端之间建立起长连接的协议，通常在im即时消息等对信息的实时性要求比较高，请求较频繁的操作上使用。本案例的代码将会提交到码云上可以查看，文章后附地址。这里举得案例是wss协议的，属于安全协议的，证书是自签的，如果不会生成自签证书，可以看我往常的一个博客，里面有介绍，这里wss用的证书是jks的，你们如果是ws协议就能满足系统需要，就不需要用这个证书和去掉sslHandler的处理即可。至此，服务端的代码就完成了，剩下的就是前端js和后端服务进行连接了，
Java集成WebSocket服务
ITKidKid的博客
04-20 4088
WebSocket实现长连接
spring boot + netty websocket
10-23
接着，我们需要创建一个Netty的WebSocketServer。在Netty中，我们需要定义一个`ChannelInitializer`来设置管道（Pipeline）中的处理器，这些处理器负责解析WebSocket帧并处理数据。此外，还需要定义一个`...
netty+websocket实现心跳和断线重连
03-06
Netty 提供了 WebSocket Server 和 WebSocket Client 的实现，使得构建基于 WebSocket 的系统变得更加容易。 1. **建立 WebSocket 连接** 创建 WebSocket 服务器端，我们需要实现 `ServerBootstrap` 类，配置 `...
netty websocket源码
01-20
Netty提供了WebSocketServer端和WebSocketClient端的实现，方便开发者快速搭建WebSocket服务。 构建WebSocket服务器的核心步骤如下： 1. **配置Bootstrap**：初始化一个Bootstrap对象，这是Netty的启动类，用于...
nettyWebSocket
06-19
标题"NettyWebSocket"指的是使用Netty框架实现的WebSocket协议通信。Netty是一个高性能、异步事件驱动的网络应用框架，常用于开发高效的服务器和客户端应用程序。而WebSocket是一种在客户端和服务器之间建立长时间...
（java）websocket服务的两种实现方式
qq_62646841的博客
05-12 5402
用java注解来监听连接@ServerEndpoint、连接成功@OnOpen、连接失败@OnClose、收到消息等状态@OnMessage。把spring中的ServerEndpointExporter对象注入进来。
学习笔记：用java编写WebSocket服务端
最新发布
Yuziqizzk的博客
06-10 2125
使用Java编写websocket服务端实现全双工通信。 首先，我们需要明白，WebSocket的本质是基于TCP的端到端双工通信协议，它是区别于Http的一种协议。所以接到客户端发来的websocket连接请求时，需要进行验证，保证双方都支持websocket协议。
Netty网络编程（六）：搭建websocket服务器
Java+GO+JS全栈工程师-鹤冲天的博客：编程辅导~商务合作~技术交流
01-17 9747
websocket是一个优秀的协议，它是建立在TCP基础之上的，兼容HTTP的网络协议。通过Websocket我们可以实现客户端和服务器端的即时通讯，免除了客户端多次轮循带来的性能损耗。既然websocket这么优秀，那么怎么在netty中使用websocket呢？
9.基于netty实现WebSocket服务器
PacosonSWJTU的博客
09-04 3944
1.本文总结自B站《netty-尚硅谷》，很不错；2.本文示例代码基于netty实现 WebSocket服务器功能；
websocket基于java实现
weixin_37750248的博客
06-06 3163
随着互联网的发展，传统的HTTP协议已经很难满足Web应用日益复杂的需求了。近年来，随着HTML5的诞生，WebSocket协议被提出，。我们知道，传统的HTTP协议是无状态的，每次请求（request）都要由客户端（如 浏览器）主动发起，服务端进行处理后返回response结果，而；这种客户端是主动方，服务端是被动方的传统Web模式 对于信息变化不频繁的Web应用来说造成的麻烦较小，而对于涉及实时信息的Web应用却带来了很大的不便，如带有即时通信、实时数据、订阅推送等功能的应 用。。
【网络编程】Netty 通过 WebSocket 编程实现服务器和客户端长连接
tangxz的博客
10-31 436
MyServer package com.atguigu.netty.websocket; import com.atguigu.netty.heartbeat.MyServerHandler; import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelInitializer; import io.netty.channel.Channel
java-websocket连接多个websocket server 自定义springboot
qq_34168515的博客
06-29 6018
websocket作为java后端与web端长链接的工具，一般来说java后端是作为server端存在的。像一些简易版的聊天室，都是通过java后端作为server端进行转发的。但是有时候，java后端也可以作为客户端进行存在的。本文采用 java-websocket 这个工具类，讲述了如何使用 java后端搭建 springboot版本的websocket客户端。实现如下机制： ...
WebSocket服务端消息推送
m0_67391121的博客
06-18 3072
**前言：**移动互联网蓬勃发展的今天，大部分手机 APP和网站都提供了消息推送功能，如新闻客户端的热点新闻推荐，IM 工具的聊天消息提醒，电商产品促销信息，企业应用的通知和审批流程等等。推送对于提高产品活跃度、提高功能模块使用率、提升用户粘性、提升用户留存率起到了重要作用，作为 APP 和网站运营中一个关键的渠道，对消息推送的合理运用能有效促进目标的实现。股票曲线实时变化，在线IM聊天等等，Web系统里总是能见到消息推送的应用。消息推送用好了能增强用户体验，实现消息推送有N种解决方案。Web网站推送:当我
java实现websocket server/client
Eddie-Wang的博客
08-08 3497
最近在项目中有一个场景，在内网的应用需要接受外网应用的指令。有两种解决方案： 1.内网应用轮询外网应用，http请求指令 2.内网应用与外网应用之间建立websocket长连接 记录一下websocket server/client的java实现 一、websocket server @Configuration public class WebSocketConfig extends...
netty websocket
03-31
Netty provides a WebSocket server implementation that makes it easy to build WebSocket applications. The WebSocket server implementation is based on the WebSocket specification and supports the latest...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值