Netty应用WebSocket协议

最新推荐文章于 2025-07-09 17:44:40 发布
原创 最新推荐文章于 2025-07-09 17:44:40 发布 · 636 阅读 · 1 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#网络 #websocket #socket #http #netty
本文介绍了WebSocket作为全双工通信技术对比HTTP的优势，并详细阐述了WebSocket连接的建立与关闭过程。通过Netty构建WebSocket服务端示例，展示如何处理WebSocket连接及消息。最后，展示了客户端HTML页面与服务端交互的运行效果。

WebSocket是HTML5开始提供的一种浏览器与服务器之间进行全双工通信的网络技术。

在WebSocketAPI中，浏览器和服务器只需要做一个握手的动作，然后，浏览器和服务器之间就形成了一条快速通道，两者就可以直接互相传送数据了。WebSocket基于TCP双向全双工进行消息传递，在同一时刻，既可以发送消息，也可以接收消息，相比于HTTP的半双工协议，性能得到很大提升。

与WebSocket相比，HTTP协议的弊端：
（1）HTTP协议为半双工协议。半双工协议指数据可以在客户端和服务端两个方向上传输，但是不能同时传输。它意味着在同一时刻，只有一个方向上的数据传送。
（2）HTTP消息冗长而繁琐。HTTP包含消息头、消息体、换行符等，通常情况下采用文本方式传输，相比于其他的二进制通信协议，冗长而繁琐。
（3）想要实现服务器推送只能使用长轮询。

WebSocket连接建立

建立WebSocket连接时，需要通过客户端或者浏览器发出握手请求，请求消息如下：

在这里插入图片描述

为了建立一个WebSocket连接，客户端浏览器首先要向服务器发起一个HTTP请求，这个请求和通常的HTTP请求不同，其中附加头信息“Upgrade：websocket”表明这是一个申请协议升级的HTTP请求。

服务端解析这些请求附加的头消息，然后生成应答消息返回客户端，客户端和服务端的WebSocket连接就建立起来了，双方可以通过这个连接自由地传递信息，并且这个连接会一直存在知道客户端或者服务端的任意一方主动关闭连接。
在这里插入图片描述

请求消息中的“Sec-WebSocket-Key”是随机的，服务器端会用这些数据来构造出一个SHA-1的信息摘要，把“Sec-WebSocket-Key”加上一个字符串“258EAFA5-E914-47DA-95CA-C5AB0DC85B11”，使用SHA-1加密，然后进行BASE-64编码，将结果作为“Sec-WebSocket-Accept”头的值，返回客户端。

WebSocket连接关闭

为了关闭WebSocket连接，客户端和服务端需要安全的关闭底层TCP连接以及TLS会话。
底层的TCP连接，在正常情况下，应该首先由服务器关闭。在异常情况下（例如在一个合理的时间周期后没有接收到服务器的TCPClose),客户端可以发起TCP Close。因此，当服务器被指示关闭WebSocket连接时，它应该立即发起一个TCPClose操作；客户端应该等待服务器的TCPClose。

WebSocket的握手关闭消息带有一个状态码和一个可选的关闭原因，它必须按照协议要求发送一个Close控制帧，当对端接收到关闭控制帧指令时，需要主动关闭WebSocket连接。

Netty构建WebSocket服务端示例

启动类WebSocketServer：

package com.netty.websocket.server;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
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.stream.ChunkedWriteHandler;

public class WebSocketServer {

	public void run(int port) throws Exception {
		EventLoopGroup bossGroup = new NioEventLoopGroup();
		EventLoopGroup workerGroup = new NioEventLoopGroup();
		try {
			ServerBootstrap b = new ServerBootstrap();
			b.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class)
					.childHandler(new ChannelInitializer<SocketChannel>() {

						@Override
						protected void initChannel(SocketChannel ch) throws Exception {
							// 创建一个管道，每一个通道都有一个管道
							ChannelPipeline pipeline = ch.pipeline();
							// 添加http-codec处理程序，它包含http-encoder和http-decoder
							pipeline.addLast("http-codec", new HttpServerCodec());
							// 添加构建一个指定maxContentLength大小的HttpObjectAggregator
							// 其将HttpMessage及其后续的HttpContent汇总为单个FullHttpRequest或FullHttpResponse
							pipeline.addLast("aggregator", new HttpObjectAggregator(65536));
							// 添加一个支持异步写入大数据流的handler
							ch.pipeline().addLast("http-chunked", new ChunkedWriteHandler());
							// 添加自定义的websocket处理程序
							pipeline.addLast("handler", new WebSocketServerHandler());
						}

					});
			// b.bind(port)将绑定端口port，并返回一个ChannelFuture对象
			// 调用sync()方法将会等待这个ChannelFuture运行，直到完成
			// 调用channel()方法将返回此ChannelFuture关联的Channel
			Channel ch = b.bind(port).sync().channel();
			System.out.println("Web socket server started at port " + port + ".");
			System.out.println("Open your browser and navigate to http://localhost:" + port + "/");
			ch.closeFuture().sync();
		} finally {
			bossGroup.shutdownGracefully();
			workerGroup.shutdownGracefully();
		}

	}

	public static void main(String[] args) throws Exception {
		int port = 8080;
		new WebSocketServer().run(port);
	}

}

业务消息处理类WebSocketServerHandler：

package com.netty.websocket.server;

import java.util.logging.Level;
import java.util.logging.Logger;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
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.HttpResponseStatus;
import io.netty.handler.codec.http.HttpUtil;
import io.netty.handler.codec.http.HttpVersion;
import io.netty.handler.codec.http.websocketx.CloseWebSocketFrame;
import io.netty.handler.codec.http.websocketx.PingWebSocketFrame;
import io.netty.handler.codec.http.websocketx.PongWebSocketFrame;
import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;
import io.netty.handler.codec.http.websocketx.WebSocketFrame;
import io.netty.handler.codec.http.websocketx.WebSocketServerHandshaker;
import io.netty.handler.codec.http.websocketx.WebSocketServerHandshakerFactory;
import io.netty.util.CharsetUtil;

public class WebSocketServerHandler extends SimpleChannelInboundHandler<Object> {
	
	private static final Logger logger = Logger.getLogger(WebSocketServerHandler.class.getName());
	private WebSocketServerHandshaker handshaker;
	
	@Override
	protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {
		// 传统的HTTP接入
		if (msg instanceof FullHttpRequest) {
			handleHttpRequest(ctx, (FullHttpRequest) msg);
		}
		// WebSocket接入
		else if (msg instanceof WebSocketFrame) {
		    handleWebSocketFrame(ctx, (WebSocketFrame) msg);
		}
	}
	
	public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
		ctx.flush();
	}

	
	private void handleHttpRequest(ChannelHandlerContext ctx, FullHttpRequest req) throws Exception {
		// 如果HTTP解码异常，返回HTTP异常
		if (!req.decoderResult().isSuccess() || (!"websocket".equals(req.headers().get("Upgrade")))) {
			sendHttpResponse(ctx, req, new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.BAD_REQUEST));
			return;
		}
		
		// 构造握手响应返回，本机测试
		WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory(
			"ws://localhost:8080/websocket", null, false);
		handshaker = wsFactory.newHandshaker(req);
		if (handshaker == null) {
		    WebSocketServerHandshakerFactory
			    .sendUnsupportedVersionResponse(ctx.channel());
		} else {
		    handshaker.handshake(ctx.channel(), req);
		}
	}
	
	private void handleWebSocketFrame(ChannelHandlerContext ctx,
		    WebSocketFrame frame) {

		// 判断是否是关闭链路的指令
		if (frame instanceof CloseWebSocketFrame) {
		    handshaker.close(ctx.channel(),
			    (CloseWebSocketFrame) frame.retain());
		    return;
		}
		// 判断是否是Ping消息
		if (frame instanceof PingWebSocketFrame) {
		    ctx.channel().write(
			    new PongWebSocketFrame(frame.content().retain()));
		    return;
		}
		// 本例程仅支持文本消息，不支持二进制消息
		if (!(frame instanceof TextWebSocketFrame)) {
		    throw new UnsupportedOperationException(String.format(
			    "%s frame types not supported", frame.getClass().getName()));
		}

		// 返回应答消息
		String request = ((TextWebSocketFrame) frame).text();
		if (logger.isLoggable(Level.FINE)) {
		    logger.fine(String.format("%s received %s", ctx.channel(), request));
		}
		ctx.channel().write(
			new TextWebSocketFrame(request
				+ " , 欢迎使用Netty WebSocket服务，现在时刻："
				+ new java.util.Date().toString()));
	    }
	
	private static void sendHttpResponse(ChannelHandlerContext ctx, FullHttpRequest req, FullHttpResponse res) {
		// 返回应答给客户端
		if (res.status().code() != 200) {
			ByteBuf buf = Unpooled.copiedBuffer(res.status().toString(), CharsetUtil.UTF_8);
			res.content().writeBytes(buf);
			buf.release();
			HttpUtil.setContentLength(res, res.content().readableBytes());
		}
		
		// 如果是非Keep-Alive，关闭连接
		ChannelFuture f = ctx.channel().writeAndFlush(res);
		if (!HttpUtil.isKeepAlive(req) || res.status().code() != 200) {
		    f.addListener(ChannelFutureListener.CLOSE);
		}
	}
	
	public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
		cause.printStackTrace();
		ctx.close();
	}
	
}

因为要建立WebSocket连接需要先通过HTTP请求，所以需要在ChannelPipeline中添加HTTP协议所需的Handler。

在这里插入图片描述

在请求处理中需要先处理HTTP请求，主要是建立WebSocket连接。当WebSocket连接建立之后，后续的通信都是通过WebSocket来进行的。

在这里插入图片描述

客户端HTML页面代码：

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
Netty WebSocket 时间服务器
</head>
<br>
<body>
<br>
<script type="text/javascript">
var socket;
if (!window.WebSocket) 
{
	window.WebSocket = window.MozWebSocket;
}
if (window.WebSocket) {
	socket = new WebSocket("ws://localhost:8080/websocket");
	socket.onmessage = function(event) {
		var ta = document.getElementById('responseText');
		ta.value="";
		ta.value = event.data
	};
	socket.onopen = function(event) {
		var ta = document.getElementById('responseText');
		ta.value = "打开WebSocket服务正常，浏览器支持WebSocket!";
	};
	socket.onclose = function(event) {
		var ta = document.getElementById('responseText');
		ta.value = "";
		ta.value = "WebSocket 关闭!"; 
	};
}
else
	{
	alert("抱歉，您的浏览器不支持WebSocket协议!");
	}

function send(message) {
	if (!window.WebSocket) { return; }
	if (socket.readyState == WebSocket.OPEN) {
		socket.send(message);
	}
	else
		{
		  alert("WebSocket连接没有建立成功!");
		}
}
</script>
<form onsubmit="return false;">
<input type="text" name="message" value="Netty最佳实践"/>
<br><br>
<input type="button" value="发送WebSocket请求消息" onclick="send(this.form.message.value)"/>
<hr color="blue"/>
<h3>服务端返回的应答消息</h3>
<textarea id="responseText" style="width:500px;height:300px;"></textarea>
</form>
</body>
</html>

在HTML中用JavaScript代码构建WebSocket，首先要判断浏览器是否支持WebSocket协议，随后新建WebSocket与服务端进行通信。

运行结果

先运行服务端程序：

在这里插入图片描述

再用火狐浏览器打开HTML页面，浏览器支持WebSocket协议：
在这里插入图片描述

点击“发送WebSocket请求消息”则会想服务端发送WebSocket请求，服务端根据请求消息返回相应内容。

在这里插入图片描述

当服务端关闭，客户端页面将会实时收到关闭通知

在这里插入图片描述

基于 Netty 搭建 WebSocket 集群实现服务器消息推送
公众号：Java后端
09-13 8866
本文内容是构建高性能、高可用消息推送的经典案例，在微服务 Spring Cloud 环境下基于 Netty 搭建 websocket 集群实现的。目录为：1、背景2、websocket3、...
netty整合websocket（完美教程）
nanshaws的博客
11-20 1万+
WebSocket是一种在网络通信中的协议，它是独立于HTTP协议的。该协议基于TCP/IP协议，可以提供双向通讯并保有状态。这意味着客户端和服务器可以进行实时响应，并且这种响应是双向的。WebSocket协议端口通常是80，443。WebSocket的出现使得浏览器具备了实时双向通信的能力。与HTTP这种非持久单向响应应答的协议相比，WebSocket是一个持久化的协议。举例来说，即使在关闭网页或者浏览器后，WebSocket的连接仍然保持，用户也可以继续接收到服务器的消息。
Netty——WebSocket开发
吴声子夜歌的博客
07-29 3156
WebSocket是HTML5开始提供的一种浏览器与服务器间进行全双工通信的网络技术，WebSocket通信协议于2011年被IETF定为RFC6455，WebSockeet API被W3C定为标准。在WebSocket API中，浏览器和服务器只需要做一个握手动作，然后浏览器和服务器之间就行程了一条快速通道，两者就可以直接相互传送数据了。WebSocket基于TCP双向全双工进行消息传递，在同一时刻，既可以发送消息，，也可以接收消息，相比HTTP的半双工协议，性能得到很大提升。
Netty网络编程（六）：搭建websocket服务器
Java+GO+JS全栈工程师-鹤冲天的博客：编程辅导~商务合作~技术交流
01-17 1万+
websocket是一个优秀的协议，它是建立在TCP基础之上的，兼容HTTP的网络协议。通过Websocket我们可以实现客户端和服务器端的即时通讯，免除了客户端多次轮循带来的性能损耗。既然websocket这么优秀，那么怎么在netty中使用websocket呢？
太厉害了！阿里P8推荐的Netty学习方案，让你轻松吊打面试官
weixin_47066028的博客
11-03 599
前言 想要学好一门技术，最起码要对他有一定的了解，起码听说过相应的底层原理的东西吧，最起码你要有一点能和别人交流的内容吧，下面是我精简的一点内容，希望对于大家了解netty能有一点帮助 Netty是建立在NIO基础之上，Netty在NIO之上又提供了更高层次的抽象。 在Netty里面，Accept连接可以使用单独的线程池去处理，读写操作又是另外的线程池来处理。 Accept连接和读写操作也可以使用同一个线程池来进行处理。而请求处理逻辑既可以使用单独的线程池进行处理，也可以跟放在读写线程一块处理。线程池中的每
netty websocket 心跳_Netty之WebSocket协议应用开发
weixin_39843738的博客
11-25 995
上一篇聊了一下使用Netty进行HTTP协议的应用开发，今儿就来说一下HTTP协议的弊端以及WebSocket协议的开发使用。1、HTTP协议的弊端(1)半双工模式：同一时刻，只能有一个方向的数据传输，不能同时传输。(2)消息冗长复杂：包括了一大堆的消息头、消息体等，相比于其它二进制通信传输，冗长而繁琐。2、WebSocket协议WebSocket提供了一种浏览器与服务器间进行全双工通信...
websocket 发送ping_Netty之WebSocket协议应用开发
weixin_39911056的博客
12-30 1804
上一篇聊了一下使用Netty进行HTTP协议的应用开发，今儿就来说一下HTTP协议的弊端以及WebSocket协议的开发使用。1、HTTP协议的弊端(1)半双工模式：同一时刻，只能有一个方向的数据传输，不能同时传输。(2)消息冗长复杂：包括了一大堆的消息头、消息体等，相比于其它二进制通信传输，冗长而繁琐。2、WebSocket协议WebSocket提供了一种浏览器与服务器间进行全双工通信...
《Netty权威指南 第2版》学习笔记（7）--- WebSocket协议开发应用
自律使我自由
03-08 263
前言 WebSocket是一种在单个TCP连接上进行全双工的通信协议，WebSocket使得客户端和服务器之间的数据交换变的更加简单，允许服务器主动向客户端推送数据，浏览器和服务器只需要完成一次握手，两者之间就直接可以创建持久性的连接，并进行双向数据传输。 HTTP协议的弊端 很多网站为了实现推送技术，所用的技术都是轮询，轮询是在特定的时间间隔，由浏览器对服务器发送HTTP请求，然后由服务器返回最新的数据给客户端的浏览器，这种方式的主要弊端如下。 （1）HTTP协议为半双工协议，半双工协议指数据可以在客户端
netty和websocket的区别
程序员诚哥
09-06 4014
Netty是一个底层网络框架，提供了灵活、异步的网络通信能力，可以支持多种协议，包括 WebSocket。WebSocket是一个应用层协议，专注于在浏览器与服务器之间提供低延迟、全双工的通信。
netty系列之:使用netty搭建websocket服务器
热门推荐
程序那些事
09-27 1万+
文章目录简介netty中的websocketwebsocket的版本FrameDecoder和FrameEncoderWebSocketServerHandshakerWebSocketFramenetty中使用websocket总结 简介 websocket是一个优秀的协议，它是建立在TCP基础之上的，兼容HTTP的网络协议。通过Websocket我们可以实现客户端和服务器端的即时通讯，免除了客户端多次轮循带来的性能损耗。 既然websocket这么优秀，那么怎么在netty中使用websocket呢？
netty与websocket
暮霭层层楚天阔的博客
12-01 1万+
BIO和NIO的区别： 作用都一样都是处理输入输出的类，可以文件IO也可以网络IO BIO 是流的概念，基于字节流字符流进行操作，读写一般需要byte数组做缓冲区，其stream是单向的，inputstream只能读，outstream只能写， NIO(new io) 是基于channel(通道)和buffer(缓冲区)的操作，提供了非阻塞式的高伸缩网络，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。Selector(选择区)用于监听多个通 道的事件（比如：连接请求，数据到达等），因此使用单个线程
netty系列之:使用netty搭建websocket客户端
程序那些事
10-08 1万+
文章目录简介浏览器客户端netty对websocket客户端的支持WebSocketClientHandshakerWebSocketClientCompressionHandlernetty客户端的处理流程创建handshakerwebsocket消息的处理总结 简介 在网速快速提升的时代，浏览器已经成为我们访问各种服务的入口，很难想象如果离开了浏览器，我们的网络世界应该如何运作。现在恨不得把操作系统都搬上浏览器。但是并不是所有的应用都需要浏览器来执行，比如服务器和服务器之间的通信，就需要使用到自建客户端
使用 netty实现 websocket
weixin_45318638的博客
12-11 2951
WebSocket是一种计算机通信协议，用于在客户端和服务器之间建立持久性的全双工通信连接。它提供了一种在单个TCP连接上进行双向通信的方式，允许服务器主动向客户端发送数据，而不需要客户端首先发送请求。这与传统的HTTP请求-响应模型不同，后者需要客户端发送请求并等待服务器响应。双向通信：WebSocket允许服务器主动向客户端发送数据，而不仅仅是响应客户端的请求。这使得实时应用程序（如聊天应用程序、多人游戏等）的开发更加容易，因为服务器可以即时地将更新推送给客户端。
9.基于netty实现WebSocket服务器
PacosonSWJTU的博客
09-04 4537
1.本文总结自B站《netty-尚硅谷》，很不错；2.本文示例代码基于netty实现 WebSocket服务器功能；
SpringBoot集成netty实现websocket通信
usa_washington的博客
03-10 2284
netty实现websocket通信
【Netty+WebSocket详解】WebSocket全双工通信与Netty的高效结合与实战
最新发布
2302_79380280的博客
07-09 1841
本文详细对比了Netty+WebSocket与Spring WebSocket的技术方案，从协议支持、性能表现到开发效率进行全方位分析。重点演示了基于Netty构建WebSocket实时通信系统的完整实现，包含服务端初始化、心跳检测、消息广播等核心模块，并配套Vue2前端连接示例。通过性能数据对比和典型场景说明，指出Netty方案更适合高并发、低延迟场景（如IM、游戏服务器），而Spring WebSocket更适用于需要快速开发的企业应用。文章提供可直接运行的代码片段，涵盖从协议握手到业务处理的完整链路，
基于Netty的websocket的简单介绍
static_coder的博客
05-06 1856
WebSocket」是一种在单个TCP连接上进行全双工通信的协议。「WebSocket」使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。在「WebSocket API」中，浏览器和服务器只需要完成一次握手，两者之间就直接可以创建持久性的连接，并进行双向数据传输。TCP连接是一种可靠的、面向连接的网络通信协议。它通过三次握手建立连接，然后通过数据包的传输和确认来保证数据的可靠性和顺序性。
用Netty作为服务端的WebSocket通信
索隆有几把刀的博客
12-17 1万+
用Netty作为服务端的WebSocket通信的研究报告 1 WebSocket 1.1为什么要选择WebSocket? http 是无状态协议，为标识用户，通常客户端要带上session。但是它无法解决服务端主动想客户端发送消息的需求。面对并发量高的场景，由于http信息携带的数据大，而对服务器造成较大的负担，所以面对这种场景，WebSocket就上线了。 1.2什么是WebSocket？ WebSocket是一种基于tcp的新的网络协议，它实现了服务器与浏览器之间的全双工，即浏览器和服务器可以互不影响
netty对websocket协议的实现
mahao25的博客
10-20 9173
websocket协议简单介绍与netty对websocket协议的内部实现逻辑
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值