C# WebSocket Servers -- Fleck、SuperSocket、TouchSocke

于 2024-09-28 02:46:50 发布
阅读量94 收藏
点赞数
文章标签： c# websocket 开发语言 网络协议 网络

最近在维护老项目，感觉内存一直都有问题，定位到问题是WebSocketServer的问题，了解了 Fleck、SuperSocket、TouchSocke 等开源项目 ，这里记录一下。可能今后都不会用些轮子了，.net5、.net6、.net7、.net8 项目已经集成了WebSocket，只要  app.UseWebSockets() 代码就可以了，详情见 WebSockets support in ASP.NET Core | Microsoft Learn。

0. net自带的WebSocket，基于 Kestrel。（职业选手不允许参赛）

代码：https://gitee.com/Karl_Albright/csharp-web-socket-server

复制代码 
internal class Program
{
    static void Main(string[] args)
    {
        WebSockSvr server = new WebSockSvr();
        server.Start();
        server.SendDatas();
        Console.ReadLine();
    }
}
复制代码
复制代码 
public class WebSockSvr
{
    public ConcurrentDictionary<string, WebSocket> ClinetList { get; set; } = new();
    WebApplication server;
    public WebSockSvr()
    {
        var builder = WebApplication.CreateBuilder();
        builder.WebHost.UseKestrel(opts => 
        {
            opts.ListenAnyIP(4040);
        });
        server = builder.Build();
        server.UseWebSockets(new WebSocketOptions
        {
            KeepAliveInterval = TimeSpan.FromSeconds(60),
        });
        server.Use(async (context, next) =>
        {
            if (!context.WebSockets.IsWebSocketRequest) 
            {
                await next.Invoke(context);
                return;
            }
            var id = Guid.NewGuid().ToString("N");
            try
            {
                var socket = await context.WebSockets.AcceptWebSocketAsync();

                var buffer = ArrayPool<byte>.Shared.Rent(1024);
                ClinetList.TryAdd(id, socket);
                while (socket.State == WebSocketState.Open)
                {
                    var result = await socket.ReceiveAsync(buffer, CancellationToken.None);
                    if (result.MessageType == WebSocketMessageType.Close)
                    {
                        throw new WebSocketException(WebSocketError.ConnectionClosedPrematurely, result.CloseStatusDescription);
                    }
                    var text = Encoding.UTF8.GetString(buffer.AsSpan(0, result.Count));
                    var sendStr = Encoding.UTF8.GetBytes($"Echo: {text}");
                    await socket.SendAsync(sendStr, WebSocketMessageType.Text, true, CancellationToken.None);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"WebSocket has exception, {ex.Message}\r\n{ex.StackTrace}");
            }
            finally 
            {
                ClinetList.Remove(id, out _);
            }
        });
    }

    public void Start()
    {
        server.Start();
    }

    public void SendDatas()
    {
        for (int i = 0; i < 200; i++)
        {
            Task.Run(async () =>
            {
                while (true)
                {
                    try
                    {
                        foreach (var (id, sock) in ClinetList) 
                        {
                            if (sock.State == WebSocketState.Open)
                            {
                                var sendStr = Encoding.UTF8.GetBytes($"Dev[{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff")}, 12.34, 34.56, 56.78, \"77705683\"]");
                                await sock.SendAsync(sendStr, WebSocketMessageType.Text, true, CancellationToken.None);
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine($"SendDatas has exception,{ex.Message}\r\n{ex.StackTrace}");
                    }
                    finally
                    {
                        await Task.Delay(10);
                    }
                }
            });
        }
    }
}
复制代码

 

1. Fleck 

兼容 .NetFramework V4.0、.NetFramework V4.5、.NetCoreApp V2.0、.NetStandard V2.0

dotnet add package Fleck --version 1.2.0 
复制代码 
using Fleck;

namespace FleckDemo
{
    public class WebSockSvr
    {
        public List<IWebSocketConnection> ClinetList = new();
        private WebSocketServer service;
        public WebSockSvr() 
        {
            service = new WebSocketServer("ws://0.0.0.0:4040");
        }
        public void Start() 
        {
            service.Start(socket =>
            {
                socket.OnOpen = () =>
                {
                    Console.WriteLine("Open!");
                    ClinetList.Add(socket);
                };
                socket.OnClose = () =>
                {
                    Console.WriteLine("Close!");
                    ClinetList.Remove(socket);
                };
                socket.OnMessage = message =>
                {
                    Console.WriteLine(message);
                    ClinetList.ToList().ForEach(s => s.Send("Echo: " + message));
                };
            });
        }
        public void SendDatas()
        {
            for (int i = 0; i < 200; i++)
            {
                Task.Run(async () =>
                {
                    while (true)
                    {
                        try
                        {
                            for (int j = 0; j < ClinetList.Count; j++)
                            {
                                var sock = ClinetList[j];
                                if (sock.IsAvailable)
                                {
                                    await sock.Send($"Dev[{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff")}, 12.34, 34.56, 56.78, \"77705683\"]");
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine("出现异常：" + ex.Message + "\r\n" + ex.StackTrace);
                        }
                        finally
                        {
                            await Task.Delay(1000);
                        }
                    }
                });
            }
        }
    }
}
复制代码

 

2. SuperSocket1.6 

截止到现在 superSocket 2.0版本还没正式发布，有beta.26版本，和1.6相比改动挺大的。

兼容 .NetFramework V4.6.1、.NetFramework V4.6.2、.NetFramework V4.7、.NetFramework V4.7.1、.NetFramework V4.7.2、.NetFramework V4.8、.NetFramework V4.8.1

dotnet add package SuperSocket --version 1.6.6.1
dotnet add package SuperSocket.Engine --version 1.6.6.1
dotnet add package SuperSocket.WebSocket --version 1.6.6.1
复制代码 
using SuperSocket.SocketBase;
using SuperSocket.WebSocket;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace SuperSocketDemo
{
    public class WebSockSvr
    {
        public List<WebSocketSession> ClinetList { get; set; } = new List<WebSocketSession>();
        private WebSocketServer server;
        public WebSockSvr()
        {
            server = new WebSocketServer();
            server.NewMessageReceived += Ws_NewMessageReceived;//当有信息传入时
            server.NewSessionConnected += Ws_NewSessionConnected;//当有用户连入时
            server.SessionClosed += Ws_SessionClosed;//当有用户退出时
            server.NewDataReceived += Ws_NewDataReceived;//当有数据传入时
        }

        public void Start()
        {
            if (server.Setup(4040))//绑定端口
                server.Start();//启动服务  
        }

        //public void SendDatas()
        //{
        //    //对当前已连接的所有会话进行广播
        //    foreach (var session in server.GetAllSessions())
        //    {
        //        session.Send($"Dev[{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff")}, 12.34, 34.56, 56.78, \"77705683\"]");
        //        Thread.Sleep(1000);
        //    }
        //}
        public void SendDatas()
        {
            for (int i = 0; i < 200; i++)
            {
                Task.Run(async () =>
                {
                    while (true)
                    {
                        try
                        {
                            for (int j = 0; j < ClinetList.Count; j++)
                            {
                                var sock = ClinetList[j];
                                if (sock.Connected)
                                {
                                    sock.TrySend($"Dev[{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff")}, 12.34, 34.56, 56.78, \"77705683\"]");
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine("出现异常：" + ex.Message + "\r\n" + ex.StackTrace);
                        }
                        finally
                        {
                            await Task.Delay(10);
                        }
                    }
                });
            }

        }

        private void Ws_NewSessionConnected(WebSocketSession session)
        {
            ClinetList.Add(session);
        }

        private void Ws_NewMessageReceived(WebSocketSession session, string value)
        {

        }

        private void Ws_SessionClosed(WebSocketSession session, CloseReason value)
        {
            ClinetList.Remove(session);
        }

        private void Ws_NewDataReceived(WebSocketSession session, byte[] value)
        {

        }
    }
}
复制代码

 

3. SuperSocket2.0.0-beta.26

兼容 .NetStandard V2.1、.Net5、.Net6、.Net7、.Net8

dotnet add package SuperSocket.WebSocket.Server --version 2.0.0-beta.26
复制代码 
using Microsoft.Extensions.Hosting;
using SuperSocket.Server;
using SuperSocket.Server.Abstractions;
using SuperSocket.Server.Host;
using SuperSocket.WebSocket.Server;

namespace SuperSocket2Demo
{
    public class WebSockSvr
    {
        public List<WebSocketSession> ClinetList { get; set; } = new();
        private IServer server;
        public WebSockSvr()
        {
            server = WebSocketHostBuilder.Create()
                .ConfigureSuperSocket(opts =>
                {
                    opts.AddListener(new ListenOptions
                    {
                        Ip = "127.0.0.1",
                        Port = 4040
                    });
                })
                .UseSessionHandler((session) =>
                {
                    var sess = (WebSocketSession)session;
                    ClinetList.Add(sess);
                    return ValueTask.CompletedTask;
                }, (session, reason) =>
                {
                    var sess = (WebSocketSession)session;
                    ClinetList.Remove(sess);
                    return ValueTask.CompletedTask;
                })
                .UseWebSocketMessageHandler(async (session, message) =>
                {
                })
                .BuildAsServer();
        }
        public Task Start()
        {
            return server.StartAsync();
        }
        public void SendDatas()
        {
            for (int i = 0; i < 200; i++)
            {
                Task.Run(async () =>
                {
                    while (true)
                    {
                        try
                        {
                            for (int j = 0; j < ClinetList.Count; j++)
                            {
                                var sock = ClinetList[j];
                                if (sock.State == SessionState.Connected)
                                {
                                    await sock.SendAsync($"Dev[{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff")}, 12.34, 34.56, 56.78, \"77705683\"]");
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine("出现异常：" + ex.Message + "\r\n" + ex.StackTrace);
                        }
                        finally
                        {
                            await Task.Delay(10);
                        }
                    }
                });
            }
        }
    }
}
复制代码

 

4. TouchSocket

目前兼容 .NetFramework V4.5、.NetFramework V4.6.2、.NetFramework V4.7.2、.NetFramework V4.8.1、.NetStandard V2.0、.NetStandard V2.1、.Net6、.Net7、.Net8

dotnet add package TouchSocket --version 2.1.5
dotnet add package TouchSocket.Http --version 2.1.5
dotnet add package TouchSocket.WebApi --version 2.1.5
复制代码 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using TouchSocket.Core;
using TouchSocket.Http;
using TouchSocket.Http.WebSockets;
using TouchSocket.Rpc;
using TouchSocket.Sockets;
using TouchSocket.WebApi;

namespace TouchSocketDemo.Core
{
    public class WebSockSvr
    {
        public List<IHttpSession> ClinetList { get; set; } = new List<IHttpSession>();
        private HttpService service;
        public WebSockSvr() 
        {
            service = new HttpService();
        }
        public async Task Start() 
        {
            await service.SetupAsync(new TouchSocketConfig()//加载配置
                 .SetListenIPHosts(4040)
                 .ConfigureContainer(a =>
                 {
                     a.AddConsoleLogger();
                 })
                 .ConfigurePlugins(a =>
                 {
                     a.UseWebSocket().SetWSUrl(null).UseAutoPong();
                     //a.Add<MyWebSocketPlugin>();
                     a.Add(typeof(IWebSocketHandshakedPlugin), async (IWebSocket client, HttpContextEventArgs e) =>
                     {
                         ClinetList.Add(client.Client);
                         await e.InvokeNext();
                     });
                     a.Add(typeof(IWebSocketClosingPlugin), async (IWebSocket client, ClosedEventArgs e) =>
                     {
                         ClinetList.Remove(client.Client);
                         await e.InvokeNext();
                     });

                     a.Add(typeof(IWebSocketReceivedPlugin), async (IWebSocket client, WSDataFrameEventArgs e) =>
                     {
                         switch (e.DataFrame.Opcode)
                         {
                             case WSDataType.Close:
                                 {
                                     await client.CloseAsync("断开");
                                 }
                                 return;
                             case WSDataType.Ping:
                                 await client.PongAsync();//收到ping时，一般需要响应pong
                                 break;
                             case WSDataType.Pong:
                                 break;
                             default:
                                 break;
                         }

                         await e.InvokeNext();
                     });

                     a.UseWebSocketReconnection();//a.Add<MyWebSocketPlugin>();
                 }));
            await service.StartAsync();
        }


        public void SendDatas()
        {
            for (int i = 0; i < 200; i++)
            {
                Task.Run(async () =>
                {
                    while (true)
                    {
                        try
                        {
                            var clientList = ClinetList.ToList();
                            for (int j = 0; j < clientList.Count; j++)
                            {
                                var sock = (HttpSessionClient)clientList[j];
                                if (sock.Online)
                                {
                                    await sock.WebSocket.SendAsync($"Dev[{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff")}, 12.34, 34.56, 56.78, \"77705683\"]");
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine("出现异常：" + ex.Message + "\r\n" + ex.StackTrace);
                        }
                        finally
                        {
                            await Task.Delay(10);
                        }
                    }
                });
            }
        }
        public class MyWebSocketPlugin : PluginBase, IWebSocketHandshakingPlugin, IWebSocketHandshakedPlugin, IWebSocketReceivedPlugin
        {
            public MyWebSocketPlugin(ILog logger)
            {
                this.m_logger = logger;
            }

            public async Task OnWebSocketHandshaking(IWebSocket client, HttpContextEventArgs e)
            {
                if (client.Client is IHttpSessionClient socketClient)
                {
                    //服务端
                    var id = socketClient.Id;
                }
                else if (client.Client is IHttpClient httpClient)
                {
                    //客户端
                }
                this.m_logger.Info("WebSocket正在连接");
                await e.InvokeNext();
            }

            public async Task OnWebSocketHandshaked(IWebSocket client, HttpContextEventArgs e)
            {
                this.m_logger.Info("WebSocket成功连接");
                await e.InvokeNext();
            }

            private readonly ILog m_logger;

            public async Task OnWebSocketReceived(IWebSocket client, WSDataFrameEventArgs e)
            {
                switch (e.DataFrame.Opcode)
                {
                    case WSDataType.Close:
                        {await client.CloseAsync("断开");
                        }
                        return;
                    case WSDataType.Ping:await client.PongAsync();//收到ping时，一般需要响应pong
                        break;
                    case WSDataType.Pong:
                        this.m_logger.Info("Pong");
                        break;
                    default:
                        {
                            //其他报文，需要考虑中继包的情况。所以需要手动合并 WSDataType.Cont类型的包。
                            //或者使用消息合并器
                            //获取消息组合器
                            var messageCombinator = client.GetMessageCombinator();
                            try
                            {
                                //尝试组合
                                if (messageCombinator.TryCombine(e.DataFrame, out var webSocketMessage))
                                {
                                    //组合成功，必须using释放模式
                                    using (webSocketMessage)
                                    {
                                        //合并后的消息
                                        var dataType = webSocketMessage.Opcode;

                                        //合并后的完整消息
                                        var data = webSocketMessage.PayloadData;

                                        if (dataType == WSDataType.Text)
                                        {
                                            //按文本处理
                                        }
                                        else if (dataType == WSDataType.Binary)
                                        {
                                            //按字节处理
                                        }
                                        else
                                        {
                                            //可能是其他自定义协议
                                        }
                                    }
                                }
                            }
                            catch (Exception ex)
                            {
                                this.m_logger.Exception(ex);
                                messageCombinator.Clear();//当组合发生异常时，应该清空组合器数据
                            }
                        }
                        break;
                }
                await e.InvokeNext();
            }
        }
    }
}
复制代码

 

原创作者: KarlAlbright 转载于: https://www.cnblogs.com/KarlAlbright/p/18433768
DarwinYue
关注
Android中使用WebSocket
Huang兄
10-28 2万+
背景：后端逻辑框架调整，将原来的推送和轮询方式改成了使用`WebSocket`通信。原来的请求方式是由app发起请求，appServer对请求进行分发，中转中继服务器将具体请求下发到对应的物联网服务器，物联网服务器将指令下发到指定的设备。整个流程涉及到很多层http请求，并且每个服务的回调接口还不一致，只能在app发情请求之后，接着去轮询服务器，服务器端去查询设备状态、是否对指令有响应。 改版后涉及到对物联网的请求全部改成`WebSocket`,不在轮询，而是被动等待。 后端使用的是`Spring`实现的`
让ie6也支持websocket采用flash封装实现
12-01
1. **Flash封装WebSocket**：代码中定义了一个名为`websocket4ie`的类，该类继承自`Sprite`。这个类的主要目标是模拟WebSocket的行为，使用Flash的`Socket`类来实现网络连接。 2. **参数处理**：类的构造函数中，从...
websocket指南
M_Edison的博客
03-20 276
1.websocket上车指南 首先需要搞清楚的是websocket到底是什么，它有什么作用。 websocket是一种服务器主动给客户端发送消息的技术。 WebSocket是一种通信协议，可在单个TCP连接上进行全双工通信。WebSocket使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。在WebSocket API中，浏览器和服务器只需要完成一次握手，两者之间就可以建立持久性的连接，并进行双向数据传输。 websocket是一种通信协议。区别与HTTP协议，HTTP协议
WebSocket学习笔记
Fire_Sky_Ho的博客
10-18 1042
举个例子，HTTP协议就是，小明要去超市买薯片，老板说没有，过了一会小明又跑来超市买薯片，老板还是说没有，这样反反复复过了很多次，超市进货的薯片终于到了，小明也拿到薯片了。这样是不是就更省时更省事呢？WbeSocket 是 Html5 开始提供的一种浏览器与服务器之间进行全双工通信的协议（websocket协议本质上是一个基于tcp的协议），它实现了浏览器与服务器全双工通信，能更好的节省服务器资源和带宽并达到实时通讯的目的，属于应用层，基于TCP协议，并且复用HTTP握手通道，是一个持久化的协议。
Websocket兼容IE8问题
曾某人的博客
10-20 1557
问题描述 近期需要在IE8进行websocket通信，出现了兼容性问题，网上找了很多帖子，发现了swfobject.js，web_socket.js，WebSocketMain.swf这三个文件，进行demo测试发现并不能成功运行。 问题定位 发现Flash Player版本对此产生了异常影响，这个路子本身走的就是Flash，遂进行版本升级，websocket测试通过。 新版Flash 下载链接 ...
WebSocket 实战
woaiwym的博客
06-12 385
WebSocket 前世今生众所周知，Web 应用的交互过程通常是客户端通过浏览器发出一个请求，服务器端接收请求后进行处理并返回结果给客户端，客户端浏览器将信息呈现，这种机制对于信息变化不是特别频繁的应用尚可，但对于实时要求高、海量并发的应用来说显得捉襟见肘，尤其在当前业界移动互联网蓬勃发展的趋势下，高并发与用户实时响应是 Web 应用经常面临的问题，比如金融证券的实时信息，Web 导航应用中的地...
SpringMvc集成WebSocket 利用flash兼容IE Redis订阅发布解决多实例问题
weixin_40349541的博客
11-30 422
SpringMvc集成WebSocket 利用flash兼容IE Redis订阅发布解决多实例问题）WebSocket协议是什么1.WebSocket是应用层协议WebSocket与Http的区别 WebSocket协议是什么 1.WebSocket是应用层协议 WebSocket是基于TCP的应用层协议，用于在C/S架构的应用中实现双向通信. 需要特别注意的是：虽然WebSocket协议在建立连接时会使用HTTP协议，但这并意味着WebSocket协议是基于HTTP协议实现的。 WebSocket与Ht
WebSocket技术分享
Luther Li的博客
07-24 509
在正式介绍WebSocket之前先跟大家科普一下以及讨论一下过去是如何实现Web双向通信的 科普一下通讯传输模式 单工：只支持数据在一个方向上传输；例如：BP机 半双工：允许数据在两个方向上传输，但是某一时刻只允许数据在一个方向上传输；例如：对讲机, 电报机 全双工：同时在两个方向上传输，是两个单工通信的结合，要求发送设备和接收设备同时具有独立的接收和发送能力。 例如：手机 历史回顾 H...
WebSocket详解
Erica_1230的专栏
04-29 1313
WebSocket 前世今生 众所周知，Web 应用的交互过程通常是客户端通过浏览器发出一个请求，服务器端接收请求后进行处理并返回结果给客户端，客户端浏览器将信息呈现，这种机制对于信息变化不是特别频繁的应用尚可，但对于实时要求高、海量并发的应用来说显得捉襟见肘，尤其在当前业界移动互联网蓬勃发展的趋势下，高并发与用户实时响应是 Web 应用经常面临的问题，比如金融证券的实时信息，Web 导
websocket
qq_30359197的博客
03-26 214
WebSocket HTML5定义了WebSocket协议，能更好的节省服务器资源和带宽，并且能够更实时地进行通讯。 在2008年诞生，2011年成为国际标准。 现在基本所有浏览器都已经支持了。 WebSocket是一种在单个TCP连接上进行全双工通信的协议。在WebSocket API中，浏览器和服务器只需要完成一次握手（不是指建立TCP连接的那个三次握手，是指在建立TCP连接后传输...
as3.0 websocket
04-26
在AS3（ActionScript 3.0）中实现WebSocket客户端库，意味着开发者可以在Flash环境中利用WebSocket技术，实现低延迟、高效率的网络通信。 标题中的"as3.0 websocket"指的是在AS3.0环境下实现的WebSocket客户端库。...
websocket-mse-demo:使用Websocket和w3媒体源扩展将H264流传输到浏览器
05-13
视频以封装在MP4中的H264格式流式传输。 在流到浏览器管道中不会进行任何代码转换。 不需要浏览器端Flash或纯JavaScript解码器。 使用W3 Media Source Extensions在浏览器中对视频进行解码和呈现，目前所有主流...
C#——switch案例讲解
m0_65520060的博客
09-27 229
当输入的数据不在判断语句内的时候，默认执行其中某一条；以下是当房间号不存在的时候默认进入101房间。案例：根据输入的内容判断执行哪一条输出语句。
C# 中yield 的使用详解
鲤籽鲲的博客
09-23 1334
C# 中yield 的使用详解
C# CS1612 尝试修改集合中值类型的情况
Morris-w的专栏
09-24 251
可知，尝试修改某一值类型，但是该值类型作为中间表达式的结果生成但不存储在变量中，会发生报错。正确做法是将其赋值给局部变量，然后再将变量赋回集合中的项。在C#中，发现尝试直接修改集合中值类型的中的值发生报错。提示“它不是变量”，通过官方索引的。
C# winforms DataGridView 隐藏行 解决“与货币管理器的位置关联的行不能设置为不可见”
编程之道在明明德在亲民在止于至善
09-24 550
C# winforms DataGridView 隐藏行 解决“与货币管理器的位置关联的行不能设置为不可见”
初识C#（四）- 函数或方法
最新发布
qq_45310624的博客
09-27 375
本篇笔记重点描述C#中如何使用函数。
C#_继承详解
从易到难，从入门到精通
09-23 681
继承是面向对象程序设计中最重要的概念之一。继承允许我们根据一个类来定义另一个类，这使得创建和维护应用程序变得更容易。同时也有利于重用代码和节省开发时间。当创建一个类时，程序员不需要完全重新编写新的数据成员和成员函数，只需要设计一个新的类，继承了已有的类的成员即可。这个已有的类被称为的，这个新的类被称为。继承的思想实现了关系。例如，哺乳动物动物，狗哺乳动物，因此狗动物。
netty websocket sec-websocket-protocol
09-09
Netty是一个基于Java的异步事件驱动的网络应用框架，它提供了一系列易于使用的API，用于创建高性能、可扩展的网络服务器和客户端应用程序。 WebSocket是一种在单个TCP连接上进行全双工通信的协议，它允许服务器主动向客户端推送数据，而不需要客户端先发起请求。在Java中，Netty提供了对WebSocket的支持，可以通过Netty来实现WebSocket服务器和客户端。 当使用Netty实现WebSocket时，Sec-WebSocket-Protocol是WebSocket握手过程中的一个HTTP头部字段，它用于指定客户端和服务器之间通信所使用的子协议。子协议是在WebSocket连接建立后，用于在双方之间传输数据的协议。 在Netty中，可以通过设置`WebSocketServerProtocolHandler`的`subprotocols`属性来指定支持的子协议。例如，可以使用以下代码来设置子协议为"chat"： ```java ChannelPipeline pipeline = channel.pipeline(); pipeline.addLast(new HttpServerCodec()); pipeline.addLast(new HttpObjectAggregator(65536)); pipeline.addLast(new WebSocketServerCompressionHandler()); pipeline.addLast(new WebSocketServerProtocolHandler("/websocket", "chat")); pipeline.addLast(new MyWebSocketHandler()); ``` 在上面的代码中，`WebSocketServerProtocolHandler`的第二个参数就是Sec-WebSocket-Protocol的值，这里设置为"chat"。这样，当客户端与服务器进行握手时，可以指定"chat"作为子协议，在连接建立后双方就可以使用该子协议来进行通信。 希望这个回答对你有帮助！如果你还有其他问题，请继续提问。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值