netty实现webSocket协议

最新推荐文章于 2024-07-17 08:18:10 发布
最新推荐文章于 2024-07-17 08:18:10 发布
阅读量836 收藏
点赞数
分类专栏： netty学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxh87/article/details/73185290
版权

    1、http协议现状

         一直以来http协议一直都是请求/响应的模式，如果服务器有新的数据变化要推送给客户单，此时需要客户端发送一个请求由服务器进行响应。要想实现服务端立即推送到客户端，可以使用轮训的机制或Comet，但这里有一个共同的问题是：由于http协议的开销，导致他们不适用于低延迟。
         http协议弊端如下：
         http为半双工模式，不能同时在2个方向上进行传输，某一个时刻只能在一个方向上进行传输。
         http消息冗长繁琐。http消息包含消息头、消息体、换行符等。

    2、webSocket协议

        为了解决这些问题，WebSocket就产生了,是html5的协议规范。WebSocket的将网络套接字引入到了客户端和服务端，浏览器和服务端之间可以通过套接字建立持久的连接，双方随时都可以互发数据，而不是http的控制请求--应答模式。其特点如下：
       单一的tcp连接，采用全双工模式通信；
       无头部信息、Cookie和身份验证；
       通过 “ping/pong”帧保持链路激活；
       服务器可以主动传递消息给客户端，不用客户端轮训。
      在本例子中进行抓包，websocket协议如下：

Host: localhost:8080

Connection: Upgrade

Pragma: no-cache

Cache-Control: no-cache

Upgrade: websocket

Origin: file://

Sec-WebSocket-Version: 13

User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.96 Safari/537.36

Accept-Encoding: gzip, deflate, sdch, br

Accept-Language: zh-CN,zh;q=0.8

Sec-WebSocket-Key: JF9jXfxS2FBxTXpR8KksBg==

Sec-WebSocket-Extensions: permessage-deflate; client_max_window_bits

服务端返回信息如下：

15:35:22.339956 IP6 (flowlabel 0x06a10, hlim 64, next-header TCP (6) payload length: 161) ::1.8080 > ::1.58558: Flags [P.], cksum 0x00a9 (incorrect -> 0x779f), seq 1705481743:1705481872, ack 1497439652, win 12728, options [nop,nop,TS val 1949078939 ecr 1949078834], length 129: HTTP, length: 129

HTTP/1.1 101 Switching Protocols

Upgrade: websocket

Connection: Upgrade

Sec-WebSocket-Accept: D4W/u92AQ1egKtfmiBvX9OXodyg=

`.j....@....................................e...YA....1........

t,..t,.2HTTP/1.1 101 Switching Protocols

Upgrade: websocket

Connection: Upgrade

Sec-WebSocket-Accept: D4W/u92AQ1egKtfmiBvX9OXodyg=


      

   3、Netty实现webSocket协议

     websocketServer代码如下：
      
package zou;

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();
					pipeline.addLast("http-codec", new HttpServerCodec());
					pipeline.addLast("aggregator", new HttpObjectAggregator(65536));
					pipeline.addLast("http-chunked", new ChunkedWriteHandler());
					pipeline.addLast("handler", new WebSocketServerHandler());
				}
			});
			Channel ch = b.bind(port).sync().channel();
			System.out.println("web socket server started at  port " + port);
			System.out.println("open you browser and navigate to  http://localhost:" + port + "/");
			ch.closeFuture().sync();

		} catch (Exception e) {

		} finally {
			bossGroup.shutdownGracefully();
			workerGroup.shutdownGracefully();
		}

	}

	public static void main(String[] args) throws Exception {
		int port = 8080;
		if (args != null && args.length > 0) {
			try {
				port = Integer.parseInt(args[0]);
			} catch (Exception e) {

			}
		}
		new WebSocketServer().run(port);
	}

}
     这里添加HttpServerCodec，将请求和应答消息编码或者解码为http消息。HttpObjectAggregator的作用是将http消息的多个部分组合成一条完整的http消息；ChunkedWriteHandler来向客户端发送html5文件，它主要用于浏览器和服务端进行websocket通信；最后增加WebSocket服务端的handler。
      handler代码如下： 
package zou;

import static io.netty.handler.codec.http.HttpHeaders.isKeepAlive;
import static io.netty.handler.codec.http.HttpHeaders.setContentLength;
import static io.netty.handler.codec.http.HttpResponseStatus.BAD_REQUEST;
import static io.netty.handler.codec.http.HttpVersion.HTTP_1_1;
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.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;

import java.util.logging.Logger;

public class WebSocketServerHandler extends SimpleChannelInboundHandler<Object> {

	private static final Logger logger = Logger.getLogger(WebSocketServerHandler.class.getName());

	private WebSocketServerHandshaker handshaker;

	@Override
	protected void messageReceived(ChannelHandlerContext ctx, Object msg) throws Exception {
		// 传统的http接入
		if (msg instanceof FullHttpRequest) {
			handleHttpRequest(ctx, (FullHttpRequest) msg);
		}
		// websocket接入
		else if (msg instanceof WebSocketFrame) {
			handleWebSockerFrame(ctx, (WebSocketFrame) msg);
		}

	}

	@Override
	public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
		ctx.flush();
	}

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

	private void handleHttpRequest(ChannelHandlerContext ctx, FullHttpRequest req) throws Exception {
		//http码返回失败
		if (!req.getDecoderResult().isSuccess() || (!"websocket".equals(req.headers().get("Upgrade")))) {
			sendHttpResponse(ctx, req, new DefaultFullHttpResponse(HTTP_1_1, BAD_REQUEST));
			return;
		}
		WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory("ws://localhost:8080", null, false);
		handshaker = wsFactory.newHandshaker(req);
		if (handshaker == null) {
			WebSocketServerHandshakerFactory.sendUnsupportedWebSocketVersionResponse(ctx.channel());
		} else {
			handshaker.handshake(ctx.channel(), req);
		}
	}

	private void handleWebSockerFrame(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();
		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.getStatus().code() != 200) {
			ByteBuf buf = Unpooled.copiedBuffer(res.getStatus().toString(), CharsetUtil.UTF_8);
			res.content().writeBytes(buf);
			buf.release();
			setContentLength(res, res.content().readableBytes());
		}

		ChannelFuture f = ctx.channel().writeAndFlush(res);
		//如果是非keep-Alive，关闭连接
		if (!isKeepAlive(req) || res.getStatus().code() != 200) {
			f.addListener(ChannelFutureListener.CLOSE);
		}
	}
}

 页面代码如下： 
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
	<title>Netty WebSocket时间服务器</title>
</head>
<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 οnsubmit="return false;">
	<input type="text" name="message" value="Netty 最佳实践"/>
	 <br>
	<input type="button" value="发送 websocket请求消息" οnclick="send(this.form.message.value)">
	<hr color="blue" />
	<h3>服务端返回的应答消息</h3>
	<textarea id="responseText" style="width: 500px;height: 300px"></textarea>
</form>

</body>
</html>


     

zxh87
关注
专栏目录
Netty - WebSocket协议
tamu123的博客
08-31 231
前言 websockt是需要依赖http1.1 然后返回其响应码101 再开始由http协议转为 webSocket 1、MyServer /** * @author wzcstart * @date 2021/6/30 - 1:49 */ public class MyServer { public static void main(String[] args) throws Exception{ EventLoopGroup bossGroup = new Ni
netty-实现websocket
AmbroseLe
07-08 1704
netty介绍 netty是一个高性能、事件驱动、异步非阻塞的 IO java 开源框架，由Jboss提供，建立tcp等底层连接。基于netty可以建立高性能的http服务器，快速开发，高性能高可靠的网络服务器和客户端程序，支持http、websocket、tcp、udp等。很多高性能的项目，把他作为socket底层的通信基础。 netty是基于nio的客户服务端、服务端编程框架。使用netty可以快速的开发出简单的一个网络应用，netty相当简化的和流线化了网络应用的开发过程 稳定性和伸缩性 使用
netty实现WebSocket协议
刘本龙的专栏
02-11 2637
文章目录WebSocket协议服务端开发客户端运行测试全双工 WebSocket协议 一般web应用都是使用的HTTP协议。HTTP协议有以下特点： 支持客户端-服务端模式 使用简单：只需要知道服务端URL，携带参数发送请求即可 支持多种传输数据类型，由消息头中content-type标识 无状态，使得HTTP服务轻量级 HTTP协议也存在一些缺点： 半双工通信：同一时刻，数据只能往同一方向...
Netty Websocket
最新发布
王小工小工历程
07-17 1382
Netty 是一个高性能、异步事件驱动的网络应用程序框架，支持快速开发可维护的高性能协议服务器和客户端。它基于 Java NIO（非阻塞 I/O）进行封装，提供了更简单易用的 API，并解决了 NIO 编程中常见的复杂性和错误。
Netty 实现 websocket
weixin_30416871的博客
05-11 78
现在网上网站为了实现推送基本都采用轮询的方式，比较新的轮询技术是comet，采用ajax，但是还是得发送请求，为了解决html效率低下的问题，html5定义了websocket协议。 服务端代码： import java.util.concurrent.TimeUnit; import org.apache.activemq.util.TimeUtils; import io....
Netty实现websocket
qq_41797857的博客
08-05 747
Netty实现websocket 项目中有一个需求，就是能够让服务端主动向客户端发送通知信息，大致过程如下 门柜设备开门成功 -》返回开门成功信息给服务端 -》服务端返回ACK确认 -》服务端同时通知小程序用户开锁成功信息… 由于需要服务端主动向客户端发送信息，这里可以使用websocket来实现，下面就来实现一个基于websocket的服务器的基本建立过程（这里使用的时Netty，其基于NIO，...
Netty实现websocket协议源码
01-15
在本文中，我们将深入探讨如何使用 Netty 实现 WebSocket 协议，并理解其背后的源码机制。 WebSocket 是一种在浏览器和服务器之间建立持久连接的协议，它允许双向通信，即服务器和客户端可以同时发送数据。...
netty-websocket-demo:一个简单的netty实现的websocket
05-18
在本文中，我们将深入探讨如何使用 Netty 实现 WebSocket 协议，这是一个基于 TCP 的低延迟、全双工通信协议，广泛应用于实时数据传输，如在线聊天、股票行情更新等场景。 首先，我们需要理解 WebSocket 协议的基本...
netty+websocket实现心跳和断线重连
03-06
在本文中，我们将深入探讨如何利用 Netty 和 WebSocket 实现心跳检测和断线重连机制。 首先，我们需要理解 WebSocket 协议。WebSocket 是一种在单个 TCP 连接上进行全双工通信的协议，它为客户端和服务器提供了低...
Spring+Netty+WebSocket实例
12-06
Netty提供了对WebSocket协议的全面支持，允许开发者直接在Netty服务器上处理WebSocket连接，提高了性能和灵活性。 在实际项目中，Spring与Netty的结合可以发挥各自的优势。Spring负责业务逻辑和路由控制，而Netty...
Spring Boot 整合 Netty + WebSocket 实时消息推送
03-14
8. **错误处理和异常捕获**：在WebSocket和Netty的实现中，需要妥善处理各种可能出现的错误和异常，例如网络中断、消息解析错误等，以保证系统的稳定性和健壮性。 综上所述，Spring Boot与Netty的结合使用，能够...
netty之websocket协议开发
10-25
我们要编写一个webSocket服务器，支持WebSocket的浏览器通过webSocket协议发送请求给我们编写的webSocket服务器，服务器对请求消息进行判断，如果是合法的webSocket请求，则获取请求消息体，并在后面追加字符串：“欢迎使用Netty WebSocket 服务，现在时刻：系统时间”。
netty做服务端支持ssl协议实现websocket的wss协议（java）
05-16
在网上查的资料，整理了一下 实现了wss协议的连接 和websocket的心跳,,在网上查的资料，整理了一下 实现了wss协议的连接 和websocket的心跳
用Netty实现Websocket（包含服务器代码和客户端网页）
05-06
用Netty实现Websocket（包含服务器代码和客户端网页）
Netty 实现 WebSocket 协议
m0_69146489的博客
04-03 1066
System.out.println(NettyServer.class + " 启动正在监听： " + cf.channel().localAddress());.channel(NioServerSocketChannel.class) // 指定使用的channel。log.info("客户端断开: 租户xx:{}", ctx.channel().id().asLongText());//以块的方式来写的处理器。
Netty四、websocket 协议
qq_37813031的博客
09-28 550
List item 1. Websocket协议 ​ WebSocket是HTML5开始提供的一种浏览器与服务器间进行全双工通信的网络技术，浏览器和服务器只需要做一个握手的动作，然后，浏览器和服务器之间就形成了一条快速通道，两者就可以直接互相传送数据了。WebSocket基于TCP 双向全双工进行消息传递，在同一时刻，既可以发送消息，也可以接收消息，相比HTTP 的半双工协议，性能得到很大提升。其特点是 单一的TCP连接，采用全双工模式通信： 对代理、防火墙和路由器透明； 对代理、防火墙和路由器.
基于Netty实现WebSocket客户端
u013771019的专栏
05-25 1977
握手事件是在自定义的Handler中实现的，这里为了方便使用CountDownLatch，使用了匿名内部类SimpleChannelInboundHandler的方式。这里我们不手动进行握手，由Netty通过WebSocketClientProtocolHandler进行握手，但是我们要知道何时握手完成了。测试的时候，我们可以看到，当客户端发送ping的时候，服务端会自动回pong，这个是有Netty实现的服务端自带的心跳机制。】，测试用的WebSocket服务端也是用Netty实现的，参考【
netty之WebSocket
spring_live_in的博客
09-12 257
WebSocket协议是基于TCP的一种新的网络协议。它实现了浏览器与服务器全双工(full-duplex)通信--允许服务器主动发送信息给客户端. 今天我们来看一些netty的一种长连接的通信方式-WebSocket通信 首先我们的服务器代码为： package netty.Demo04WebSocket; import io.netty.bootstrap.ServerBootstr...
netty实现websocket
07-27
Netty是一个基于Java的网络编程框架，它提供了一种简单且高性能的方式来实现WebSocket协议。 要使用Netty实现WebSocket，可以按照以下步骤进行操作： 1. 创建一个新的Netty项目，并添加Netty的依赖。 2. 创建一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值