websocket介绍
特点: 1.可以在浏览器里使用 2.支持双向通信 3.使用简单 全双工异步通信,tcp协议服用http握手通道 优点: 1.双向通信,实时性更强。 2.更好的二进制支持 3.较少的控制开销。连接创建后,ws客户端、服务端进行数据交换时,协议控制的数据包头部较小。在不包含头部的情况下,服务端到客户端的包头只有2~10字节(取决于数据包长度),客户端到服务端的的话,需要加上额外的4字节的掩码。而HTTP协议每次通信都需要携带完整的头部。 了解知识点: a.建立连接 b.交换数据 c.数据帧格式 d.如何维持连接
1 2 3 | 支持方式: 1 .java端作为服务端 2 .另起前端作为服务端 |
1 | java作为服务端时: |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | /** * 初始化器: */ public class NettyServerInitializer extends ChannelInitializer<SocketChannel> { @Override protected void initChannel(SocketChannel socketChannel) throws Exception { ChannelPipeline pipeline= socketChannel.pipeline(); //以下三个是Http的支持 //http解码器 pipeline.addLast( new HttpServerCodec()); //支持写大数据流 pipeline.addLast( new ChunkedWriteHandler()); //http聚合器 pipeline.addLast( new HttpObjectAggregator( 1024 * 62 )); //websocket支持,设置路由 pipeline.addLast( new WebSocketServerProtocolHandler( "/ws" )); //添加自定义的助手类 pipeline.addLast( new NettyHandler()); } } |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 | package com.example.demo.netty.nettyprogram; import com.alibaba.fastjson.JSON; import io.netty.channel.Channel; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.SimpleChannelInboundHandler; import io.netty.channel.group.ChannelGroup; import io.netty.channel.group.DefaultChannelGroup; import io.netty.handler.codec.http.websocketx.TextWebSocketFrame; import io.netty.util.concurrent.GlobalEventExecutor; /** * 自定义助手类: * 这个类就是业务的核心,客户端的请求会在这里处理。 * 比如客户端连接、客户端发送消息、给客户端发送消息等等。 * 自定义助手类需要重写的方法可以根据自己的需求重写, * 这里就不把每个方法都重写一遍了,完整的大家可以去找找文档看看。 */ public class NettyHandler extends SimpleChannelInboundHandler<TextWebSocketFrame> { //TextWebSocketFrame是netty用于处理websocket发来的文本对象 //所有正在连接的channel都会存在这里面,所以也可以间接代表在线的客户端 public static ChannelGroup channelGroup = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE); //在线人数 public static int online; //接收到客户都发送的消息 @Override public void channelRead0(ChannelHandlerContext ctx, TextWebSocketFrame msg) throws Exception { final String text = msg.text(); //客户端发送的文本信息,可以根据需要转换成send_message Send_Message send_message= new Send_Message(); SendAllMessages(ctx,send_message); //send_message是我的自定义类型,前后端分离往往需要统一数据格式,可以先把对象转成json字符串再发送给客户端 } //客户端建立连接 @Override public void handlerAdded(ChannelHandlerContext ctx) throws Exception { channelGroup.add(ctx.channel()); online=channelGroup.size(); System.out.println(ctx.channel().remoteAddress()+ "上线了!" ); } //关闭连接 @Override public void handlerRemoved(ChannelHandlerContext ctx) throws Exception { channelGroup.remove(ctx.channel()); online=channelGroup.size(); System.out.println(ctx.channel().remoteAddress()+ "断开连接" ); } //出现异常 @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception { cause.printStackTrace(); } //给某个人发送消息 private void SendMessage(ChannelHandlerContext ctx, Send_Message msg) { ctx.channel().writeAndFlush( new TextWebSocketFrame(JSON.toJSONString(msg))); } //给每个人发送消息,除发消息人外 private void SendAllMessages(ChannelHandlerContext ctx,Send_Message msg) { for (Channel channel:channelGroup){ if (!channel.id().asLongText().equals(ctx.channel().id().asLongText())){ channel.writeAndFlush( new TextWebSocketFrame(JSON.toJSONString(msg))); } } } } |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | public class NettyServer { private static int port; public NettyServer( int port) { this .port = port; } public static void start() throws InterruptedException { //在main方法里调用这个方法,并用构造函数设置端口号 //创建主线程组,接收请求 EventLoopGroup bossGroup = new NioEventLoopGroup(); //创建从线程组,处理主线程组分配下来的io操作 EventLoopGroup workerGroup = new NioEventLoopGroup(); //创建netty服务器 try { ServerBootstrap serverBootstrap = new ServerBootstrap(); serverBootstrap.group(bossGroup, workerGroup) //设置主从线程组 .channel(NioServerSocketChannel. class ) //设置通道 .childHandler( new NettyServerInitializer()); //子处理器,用于处理workerGroup中的操作 //启动server ChannelFuture channelFuture = serverBootstrap.bind(port).sync(); //监听关闭channel channelFuture.channel().closeFuture().sync(); } finally { bossGroup.shutdownGracefully(); //关闭主线程 workerGroup.shutdownGracefully(); //关闭从线程 } } } |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | 另起的前端作为服务端:WebSocket服务端 服务端用了ws这个库。相比大家熟悉的socket.io,ws实现更轻量 var app = require( 'express' )(); var server = require( 'http' ).Server(app); var WebSocket = require( 'ws' ); var wss = new WebSocket.Server({ port: 8080 }); wss.on( 'connection' , function connection(ws) { console.log( 'server: receive connection.' ); ws.on( 'message' , function incoming(message) { console.log( 'server: received: %s' , message); }); ws.send( 'world' ); }); app.get( '/' , function (req, res) { res.sendfile(__dirname + '/index.html' ); }); app.listen( 3000 ); |
1 2 3 4 5 6 7 8 9 10 11 12 | 客户端:向 8080 端口发起WebSocket连接。连接建立后,打印日志,同时向服务端发送消息。接收到来自服务端的消息后 <script> var ws = new WebSocket( 'ws://localhost:8080' ); ws.onopen = function () { console.log( 'ws onopen' ); ws.send( 'from client: hello' ); }; ws.onmessage = function (e) { console.log( 'ws onmessage' ); console.log( 'from server: ' + e.data); }; </script> |
1 | 建立连接: |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 | 前面提到,WebSocket复用了HTTP的握手通道。具体指的是,客户端通过HTTP请求与WebSocket服务端协商升级协议。协议升级完成后,后续的数据交换则遵照WebSocket的协议。 1 、客户端:申请协议升级 首先,客户端发起协议升级请求。可以看到,采用的是标准的HTTP报文格式,且只支持GET方法。 GET / HTTP/ 1.1 Host: localhost: 8080 Origin: http: //127.0.0.1:3000 Connection: Upgrade Upgrade: websocket Sec-WebSocket-Version: 13 Sec-WebSocket-Key: w4v7O6xFTi36lq3RNcgctw== 重点请求首部意义如下: Connection: Upgrade:表示要升级协议 Upgrade: websocket:表示要升级到websocket协议。 Sec-WebSocket-Version: 13 :表示websocket的版本。如果服务端不支持该版本,需要返回一个Sec-WebSocket-Versionheader,里面包含服务端支持的版本号。 Sec-WebSocket-Key:与后面服务端响应首部的Sec-WebSocket-Accept是配套的,提供基本的防护,比如恶意的连接,或者无意的连接。 注意,上面请求省略了部分非重点请求首部。由于是标准的HTTP请求,类似Host、Origin、Cookie等请求首部会照常发送。在握手阶段,可以通过相关请求首部进行 安全限制、权限校验等。 2 、服务端:响应协议升级 服务端返回内容如下,状态代码 101 表示协议切换。到此完成协议升级,后续的数据交互都按照新的协议来。 HTTP/ 1.1 101 Switching Protocols Connection:Upgrade Upgrade: websocket Sec-WebSocket-Accept: Oy4NRAQ13jhfONC7bP8dTKb4PTU= 备注:每个header都以\r\n结尾,并且最后一行加上一个额外的空行\r\n。此外,服务端回应的HTTP状态码只能在握手阶段使用。过了握手阶段后,就只能采用特定的错误码。 3 、Sec-WebSocket-Accept的计算 Sec-WebSocket-Accept根据客户端请求首部的Sec-WebSocket-Key计算出来。 计算公式为: 将Sec-WebSocket-Key跟258EAFA5-E914-47DA-95CA-C5AB0DC85B11拼接。 通过SHA1计算出摘要,并转成base64字符串。 伪代码如下: >toBase64( sha1( Sec-WebSocket-Key + 258EAFA5-E914-47DA-95CA-C5AB0DC85B11 ) ) 验证下前面的返回结果: const crypto = require( 'crypto' ); const magic = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11' ; const secWebSocketKey = 'w4v7O6xFTi36lq3RNcgctw==' ; let secWebSocketAccept = crypto.createHash( 'sha1' ) .update(secWebSocketKey + magic) .digest( 'base64' ); console.log(secWebSocketAccept); // Oy4NRAQ13jhfONC7bP8dTKb4PTU= |
1 | 数据帧格式: |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 | 客户端、服务端数据的交换,离不开数据帧格式的定义。因此,在实际讲解数据交换之前,我们先来看下WebSocket的数据帧格式。 WebSocket客户端、服务端通信的最小单位是帧(frame),由 1 个或多个帧组成一条完整的消息(message)。 发送端:将消息切割成多个帧,并发送给服务端; 接收端:接收消息帧,并将关联的帧重新组装成完整的消息; 本节的重点,就是讲解数据帧的格式。详细定义可参考 RFC6455 5.2 节 。 1 、数据帧格式概览 下面给出了WebSocket数据帧的统一格式。熟悉TCP/IP协议的同学对这样的图应该不陌生。 从左到右,单位是比特。比如FIN、RSV1各占据 1 比特,opcode占据 4 比特。 内容包括了标识、操作代码、掩码、数据、数据长度等。 0 1 2 3 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +-+-+-+-+-------+-+-------------+-------------------------------+ |F|R|R|R| opcode|M| Payload len | Extended payload length | |I|S|S|S| ( 4 ) |A| ( 7 ) | ( 16 / 64 ) | |N|V|V|V| |S| | ( if payload len== 126 / 127 ) | | | 1 | 2 | 3 | |K| | | +-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - + | Extended payload length continued, if payload len == 127 | + - - - - - - - - - - - - - - - +-------------------------------+ | |Masking-key, if MASK set to 1 | +-------------------------------+-------------------------------+ | Masking-key (continued) | Payload Data | +-------------------------------- - - - - - - - - - - - - - - - + : Payload Data continued ... : + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + | Payload Data continued ... | +---------------------------------------------------------------+ |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 | 数据帧格式详解 针对前面的格式概览图,这里逐个字段进行讲解。 FIN: 1 个比特。 如果是 1 ,表示这是消息(message)的最后一个分片(fragment),如果是 0 ,表示不是是消息(message)的最后一个分片(fragment)。 RSV1, RSV2, RSV3:各占 1 个比特。 一般情况下全为 0 。当客户端、服务端协商采用WebSocket扩展时,这三个标志位可以非 0 ,且值的含义由扩展进行定义。如果出现非零的值,且并没有采用WebSocket扩展,连接出错。 Opcode: 4 个比特。 操作代码,Opcode的值决定了应该如何解析后续的数据载荷(data payload)。如果操作代码是不认识的,那么接收端应该断开连接(fail the connection)。可选的操作代码如下: %x0:表示一个延续帧。当Opcode为 0 时,表示本次数据传输采用了数据分片,当前收到的数据帧为其中一个数据分片。 %x1:表示这是一个文本帧(frame) %x2:表示这是一个二进制帧(frame) %x3- 7 :保留的操作代码,用于后续定义的非控制帧。 %x8:表示连接断开。 %x9:表示这是一个ping操作。 %xA:表示这是一个pong操作。 %xB-F:保留的操作代码,用于后续定义的控制帧。 Mask: 1 个比特。 表示是否要对数据载荷进行掩码操作。从客户端向服务端发送数据时,需要对数据进行掩码操作;从服务端向客户端发送数据时,不需要对数据进行掩码操作。 如果服务端接收到的数据没有进行过掩码操作,服务端需要断开连接。 如果Mask是 1 ,那么在Masking-key中会定义一个掩码键(masking key),并用这个掩码键来对数据载荷进行反掩码。所有客户端发送到服务端的数据帧,Mask都是 1 。 掩码的算法、用途在下一小节讲解。 Payload length:数据载荷的长度,单位是字节。为 7 位,或 7 + 16 位,或 1 + 64 位。 假设数Payload length === x,如果 x为 0 ~ 126 :数据的长度为x字节。 x为 126 :后续 2 个字节代表一个 16 位的无符号整数,该无符号整数的值为数据的长度。 x为 127 :后续 8 个字节代表一个 64 位的无符号整数(最高位为 0 ),该无符号整数的值为数据的长度。 此外,如果payload length占用了多个字节的话,payload length的二进制表达采用网络序(big endian,重要的位在前)。 Masking-key: 0 或 4 字节( 32 位) 所有从客户端传送到服务端的数据帧,数据载荷都进行了掩码操作,Mask为 1 ,且携带了 4 字节的Masking-key。如果Mask为 0 ,则没有Masking-key。 备注:载荷数据的长度,不包括mask key的长度。 Payload data:(x+y) 字节 载荷数据:包括了扩展数据、应用数据。其中,扩展数据x字节,应用数据y字节。 扩展数据:如果没有协商使用扩展的话,扩展数据数据为 0 字节。所有的扩展都必须声明扩展数据的长度,或者可以如何计算出扩展数据的长度。此外,扩展如何使用必须在握手阶段就协商好。如果扩展数据存在,那么载荷数据长度必须将扩展数据的长度包含在内。 应用数据:任意的应用数据,在扩展数据之后(如果存在扩展数据),占据了数据帧剩余的位置。载荷数据长度 减去 扩展数据长度,就得到应用数据的长度。 3 、掩码算法 掩码键(Masking-key)是由客户端挑选出来的 32 位的随机数。掩码操作不会影响数据载荷的长度。掩码、反掩码操作都采用如下算法: 首先,假设: original-octet-i:为原始数据的第i字节。 transformed-octet-i:为转换后的数据的第i字节。 j:为i mod 4 的结果。 masking-key-octet-j:为mask key第j字节。 算法描述为: original-octet-i 与 masking-key-octet-j 异或后,得到 transformed-octet-i。 j = i MOD 4 transformed-octet-i = original-octet-i XOR masking-key-octet-j |
1 | 数据传递: |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 | 一旦WebSocket客户端、服务端建立连接后,后续的操作都是基于数据帧的传递。 WebSocket根据opcode来区分操作的类型。比如 0x8 表示断开连接, 0x0 - 0x2 表示数据交互。 1 、数据分片 WebSocket的每条消息可能被切分成多个数据帧。当WebSocket的接收方收到一个数据帧时,会根据FIN的值来判断,是否已经收到消息的最后一个数据帧。 FIN= 1 表示当前数据帧为消息的最后一个数据帧,此时接收方已经收到完整的消息,可以对消息进行处理。FIN= 0 ,则接收方还需要继续监听接收其余的数据帧。 此外,opcode在数据交换的场景下,表示的是数据的类型。 0x01 表示文本, 0x02 表示二进制。而 0x00 比较特殊,表示延续帧(continuation frame),顾名思义,就是完整消息对应的数据帧还没接收完。 2 、数据分片例子 直接看例子更形象些。下面例子来自MDN,可以很好地演示数据的分片。客户端向服务端两次发送消息,服务端收到消息后回应客户端,这里主要看客户端往服务端发送的消息。 第一条消息 FIN= 1 , 表示是当前消息的最后一个数据帧。服务端收到当前数据帧后,可以处理消息。opcode= 0x1 ,表示客户端发送的是文本类型。 第二条消息 FIN= 0 ,opcode= 0x1 ,表示发送的是文本类型,且消息还没发送完成,还有后续的数据帧。 FIN= 0 ,opcode= 0x0 ,表示消息还没发送完成,还有后续的数据帧,当前的数据帧需要接在上一条数据帧之后。 FIN= 1 ,opcode= 0x0 ,表示消息已经发送完成,没有后续的数据帧,当前的数据帧需要接在上一条数据帧之后。服务端可以将关联的数据帧组装成完整的消息。 Client: FIN= 1 , opcode= 0x1 , msg= "hello" Server: (process complete message immediately) Hi. Client: FIN= 0 , opcode= 0x1 , msg= "and a" Server: (listening, new message containing text started) Client: FIN= 0 , opcode= 0x0 , msg= "happy new" Server: (listening, payload concatenated to previous message) Client: FIN= 1 , opcode= 0x0 , msg= "year!" Server: (process complete message) Happy new year to you too! |
1 | 连接保持+心跳: |
1 2 3 4 5 6 7 8 9 10 11 | WebSocket为了保持客户端、服务端的实时双向通信,需要确保客户端、服务端之间的TCP通道保持连接没有断开。然而,对于长时间没有数据往来的连接,如果依旧长时间保持着,可能会浪费包括的连接资源。 但不排除有些场景,客户端、服务端虽然长时间没有数据往来,但仍需要保持连接。这个时候,可以采用心跳来实现。 发送方->接收方:ping 接收方->发送方:pong ping、pong的操作,对应的是WebSocket的两个控制帧,opcode分别是 0x9 、 0xA 。 举例,WebSocket服务端向客户端发送ping,只需要如下代码(采用ws模块) ws.ping( '' , false , true ); |
1 | Sec-WebSocket-Key/Accept的作用: |
1 2 3 4 5 6 7 8 9 10 | 前面提到了,Sec-WebSocket-Key/Sec-WebSocket-Accept在主要作用在于提供基础的防护,减少恶意连接、意外连接。 作用大致归纳如下: 避免服务端收到非法的websocket连接(比如http客户端不小心请求连接websocket服务,此时服务端可以直接拒绝连接) 确保服务端理解websocket连接。因为ws握手阶段采用的是http协议,因此可能ws连接是被一个http服务器处理并返回的,此时客户端可以通过Sec-WebSocket-Key来确保服务端认识ws协议。(并非百分百保险,比如总是存在那么些无聊的http服务器,光处理Sec-WebSocket-Key,但并没有实现ws协议。。。) 用浏览器里发起ajax请求,设置header时,Sec-WebSocket-Key以及其他相关的header是被禁止的。这样可以避免客户端发送ajax请求时,意外请求协议升级(websocket upgrade) 可以防止反向代理(不理解ws协议)返回错误的数据。比如反向代理前后收到两次ws连接的升级请求,反向代理把第一次请求的返回给cache住,然后第二次请求到来时直接把cache住的请求给返回(无意义的返回)。 Sec-WebSocket-Key主要目的并不是确保数据的安全性,因为Sec-WebSocket-Key、Sec-WebSocket-Accept的转换计算公式是公开的,而且非常简单,最主要的作用是预防一些常见的意外情况(非故意的)。 强调:Sec-WebSocket-Key/Sec-WebSocket-Accept 的换算,只能带来基本的保障,但连接是否安全、数据是否安全、客户端/服务端是否合法的 ws客户端、ws服务端,其实并没有实际性的保证。 |
本文来自博客园,作者:余生请多指教ANT,转载请注明原文链接:https://www.cnblogs.com/wangbiaohistory/p/17367145.html
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】凌霞软件回馈社区,博客园 & 1Panel & Halo 联合会员上线
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】博客园社区专享云产品让利特惠,阿里云新客6.5折上折
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步
· DeepSeek “源神”启动!「GitHub 热点速览」
· 微软正式发布.NET 10 Preview 1:开启下一代开发框架新篇章
· C# 集成 DeepSeek 模型实现 AI 私有化(本地部署与 API 调用教程)
· DeepSeek R1 简明指南:架构、训练、本地部署及硬件要求
· NetPad:一个.NET开源、跨平台的C#编辑器
2021-05-01 java的stream的使用