netty5+websocket练习

最新推荐文章于 2023-03-29 09:37:09 发布
最新推荐文章于 2023-03-29 09:37:09 发布
阅读量178 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/az44yao/article/details/103025919
版权

1. 了解WebSocket知识
　　略
2. websocket实现系统简单反馈时间

　　WebSocketServerHandler.java

package com.jieli.nettytest.websocketserver;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
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){
        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 {
                    //HttpServerCodec将请求和应答消息编码或解码为HTTP消息
                    //通常接收到的http是一个片段，如果想要完整接受一次请求所有数据，我们需要绑定HttpObjectAggregator
                    //然后就可以收到一个FullHttpRequest完整的请求信息了
                    //ChunkedWriteHandler 向客户端发送HTML5文件，主要用于支持浏览器和服务器进行WebSocket通信
                    //WebSocketServerHandler自定义Handler
                    ch.pipeline().addLast("http-codec", new HttpServerCodec())
                                 .addLast("aggregator", new HttpObjectAggregator(65536)) //定义缓冲大小
                                 .addLast("http-chunked", new ChunkedWriteHandler())
                                 .addLast("handler", new WebSocketServerHandler());
                }
            });
            
            ChannelFuture f = b.bind(port).sync();
            System.out.println("start...");
            f.channel().closeFuture().sync();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }
    
    public static void main(String[] args) {
        new WebSocketServer().run(7777);
    }
}

WebSocketServerHandler.java

package com.jieli.nettytest.websocketserver;

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.HttpHeaderUtil;
import io.netty.handler.codec.http.HttpResponseStatus;
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());
    /**
     * 全局websocket
     */
    private WebSocketServerHandshaker handshaker;
    
    @Override
    protected void messageReceived(ChannelHandlerContext ctx, Object msg)
            throws Exception {
        //普通HTTP接入
        if(msg instanceof FullHttpRequest){
            handleHttpRequest(ctx, (FullHttpRequest) msg);
        }else if(msg instanceof WebSocketFrame){ //websocket帧类型 已连接
            //BinaryWebSocketFrame CloseWebSocketFrame ContinuationWebSocketFrame 
            //PingWebSocketFrame PongWebSocketFrame TextWebScoketFrame
            handleWebSocketFrame(ctx, (WebSocketFrame) msg);
        }
    }
    
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ctx.flush();
    }
    
    private void handleHttpRequest(ChannelHandlerContext ctx, FullHttpRequest request){
        //如果http解码失败 则返回http异常 并且判断消息头有没有包含Upgrade字段(协议升级)
        if(!request.decoderResult().isSuccess() 
                || (!"websocket".equals( request.headers().get("Upgrade")))    ){
            sendHttpResponse(ctx, request, new DefaultFullHttpResponse(
                    HttpVersion.HTTP_1_1, HttpResponseStatus.BAD_REQUEST));
            return ;
        }
        //构造握手响应返回
        WebSocketServerHandshakerFactory ws = new WebSocketServerHandshakerFactory("", null, false);
        handshaker = ws.newHandshaker(request);
        if(handshaker == null){
            //版本不支持
            WebSocketServerHandshakerFactory.sendUnsupportedVersionResponse(ctx.channel());
        }else{
            handshaker.handshake(ctx.channel(), request);
        }
    }
    /**
     * websocket帧
     * @param ctx
     * @param frame
     */
    private void handleWebSocketFrame(ChannelHandlerContext ctx, WebSocketFrame frame){
        //判断是否关闭链路指令
        if(frame instanceof CloseWebSocketFrame){
            handshaker.close(ctx.channel(), (CloseWebSocketFrame) frame.retain());
            return ;
        }
        //判断是否Ping消息 -- ping/pong心跳包
        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()));
        }
        
        //返回应答消息 text文本帧
        String request = ((TextWebSocketFrame) frame).text();
        //打印日志
        if(logger.isLoggable(Level.FINE)){
            logger.fine(String.format("%s received %s", ctx.channel(), request));
        }
        //发送到客户端websocket
        ctx.channel().write(new TextWebSocketFrame(request 
                + ", 欢迎使用Netty WebSocket服务， 现在时刻:" 
                + new java.util.Date().toString()));
    }
    
    /**
     * response
     * @param ctx
     * @param request
     * @param response
     */
    private static void sendHttpResponse(ChannelHandlerContext ctx, 
            FullHttpRequest request, FullHttpResponse response){
        //返回给客户端
        if(response.status().code() != HttpResponseStatus.OK.code()){
            ByteBuf buf = Unpooled.copiedBuffer(response.status().toString(), CharsetUtil.UTF_8);
            response.content().writeBytes(buf);
            buf.release();
            HttpHeaderUtil.setContentLength(response, response.content().readableBytes());
        }
        //如果不是keepalive那么就关闭连接
        ChannelFuture f = ctx.channel().writeAndFlush(response);
        if(!HttpHeaderUtil.isKeepAlive(response) 
                || response.status().code() != HttpResponseStatus.OK.code()){
            f.addListener(ChannelFutureListener.CLOSE);
        }
    }
    
    /**
     * 异常 出错
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
            throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

WebSocketServer.html (这个随便放都可以，到时候双击打开这个即可，不由服务器提供)

<html>
    <head>
        <meta charset="utf-8">
        <title>Netty websocket 时间服务器</title>
    </head>
    <body>
        <form action="" onsubmit="return false;">
            <input type="text" name="message" value="..."/>
            <br>
            <input type="button" value="send" value="发送websocket请求消息" onclick="send(this.form.message.value);" /> 
            <hr color="blue">
            <h3>服务器返回信息</h3>
            <textarea id="responseText" rows="10" cols=""></textarea>
        </form>
    </body>
    
    <script type="text/javascript">
        var socket;
        if(!window.WebSocket){
            window.WebSocket = window.MozWebSocket;
        }
        if(window.WebSocket){
            socket = new WebSocket("ws://localhost:7777/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服务正常";
            }
            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>
</html>

运行结果

3. websocket实现简单聊天室

　　WebSocketChatServer.java

package com.jieli.nettytest.websocket;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;

public class WebsocketChatServer {
    
    private int port;
    
    public WebsocketChatServer(int port){
        this.port = port;
    }
    
    public void run() throws Exception{
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup)
             .channel(NioServerSocketChannel.class)
             .childHandler(new WebsocketChatServerInitializer())
             .option(ChannelOption.SO_BACKLOG, 128)
             .childOption(ChannelOption.SO_KEEPALIVE, true);
            
            System.out.println("websocket start..");

            ChannelFuture f = b.bind(port).sync();
            
            f.channel().closeFuture().sync();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
            System.out.println("websocket close.");
        }
    }
    
    public static void main(String[] args) throws Exception{
        new WebsocketChatServer(8080).run();
    }
}

 WebsocketChatServerInitializer.java

package com.jieli.nettytest.websocket;

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.stream.ChunkedWriteHandler;

public class WebsocketChatServerInitializer extends ChannelInitializer<SocketChannel>{

    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();
        pipeline.addLast(new HttpServerCodec())
                .addLast(new HttpObjectAggregator(64*1024))
                .addLast(new ChunkedWriteHandler())
                .addLast(new HttpRequestHandler("/ws")) //如果访问的是RUI"/ws"，处理WebSocket升级
                .addLast(new WebSocketServerProtocolHandler("/ws"))
                .addLast(new TextWebSocketFrameHandler());
    }
    
}

HttpRequestHandler.java

package com.jieli.nettytest.websocket;

import java.io.File;
import java.io.RandomAccessFile;
import java.net.URL;

import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.DefaultFileRegion;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.codec.http.DefaultHttpResponse;
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.HttpHeaderUtil;
import io.netty.handler.codec.http.HttpHeaderValues;
import io.netty.handler.codec.http.HttpResponse;
import io.netty.handler.codec.http.HttpResponseStatus;
import io.netty.handler.codec.http.HttpVersion;
import io.netty.handler.codec.http.LastHttpContent;
import io.netty.handler.ssl.SslHandler;
import io.netty.handler.stream.ChunkedNioFile;

public class HttpRequestHandler extends SimpleChannelInboundHandler<FullHttpRequest>{
    //扩展SimpleChannelInboundHandler用于处理FullHttpRequest信息
    private final String wsuri;
//    private static final File index;
//    
//    static {
//        URL location = HttpRequestHandler.class
//                .getProtectionDomain().getCodeSource().getLocation();
//        try {
//            String path = location.toURI() + "html/index.html";
//            path = !path.contains("file:") ? path : path.substring(5);
//            index = new File(path);
//        } catch (Exception e) {
//            e.printStackTrace();
//            throw new IllegalStateException("can't find index.html");
//        }
//    }
    
    public HttpRequestHandler(String wsuri){
        this.wsuri = wsuri;
    }
    
    @Override
    protected void messageReceived(ChannelHandlerContext ctx,
            FullHttpRequest request) throws Exception {
        if(wsuri.equalsIgnoreCase(request.uri())){
            //如果请求的是WebSocket升级，将其传递给在ChannelPipeline中的下一个ChannelInboundHandler处理
            //这里跟第一个例子的websocket协议升级判断方式是不同的 因为只只是判断uri路径而已
            //对应的js请求路径 socket = new WebSocket("ws://localhost:8080/ws");
            ctx.fireChannelRead(request.retain());
        }else{
            //处理100continue
            if(HttpHeaderUtil.is100ContinueExpected(request)){
                send100Continue(ctx);
            }
            //读取默认页
            RandomAccessFile file = new RandomAccessFile("C:\\html\\index.html", "r");
            
            HttpResponse response = new DefaultHttpResponse(
                    request.protocolVersion(), HttpResponseStatus.OK);
            response.headers().set(HttpHeaderNames.CONTENT_TYPE, 
                    "text/html; charset=UTF-8");
            
            boolean keepAlive = HttpHeaderUtil.isKeepAlive(request);
            if(keepAlive){
                response.headers().setInt(HttpHeaderNames.CONTENT_LENGTH, (int) file.length());
                response.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.KEEP_ALIVE);
            }
            ctx.write(response);
            
            if(ctx.pipeline().get(SslHandler.class) == null){
                //如果不是https安全连接的话 要达到最大效率的话，可以通过把index.html直接存储在DefaultFileRegion中
                //实现零拷贝传输 就是不拷贝到内存，直接读取文件通过文件输出流进行处理
                ctx.write(new DefaultFileRegion(file.getChannel(), 0, file.length()));
            }else{
                //否则要读取全部文件，然后处理加密，在发送，只不过这一切都有netty内部处理
                //A ChunkedInput that fetches data from a file chunk by chunk using NIO FileChannel.
                //If your operating system supports zero-copy file transfer such as sendfile(), 
                //you might want to use FileRegion instead.
                ctx.write(new ChunkedNioFile(file.getChannel()));
            }
            ChannelFuture future = ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT);
            
            if(!keepAlive){
                future.addListener(ChannelFutureListener.CLOSE);
            }
            file.close();
        }
    }

    private static void send100Continue(ChannelHandlerContext ctx){
        FullHttpResponse response = (FullHttpResponse) new DefaultHttpResponse(
                HttpVersion.HTTP_1_1, HttpResponseStatus.CONTINUE);
        ctx.writeAndFlush(response);
    }
    
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
            throws Exception {
        Channel incoming = ctx.channel();
        System.out.println("Client:"+incoming.remoteAddress()+"exception.");
        cause.printStackTrace();
        ctx.close();
    }
}

html/index.html

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>WebSocket Chat</title>
</head>
<body>
    <script type="text/javascript">
        var socket;
        if (!window.WebSocket) {
            window.WebSocket = window.MozWebSocket;
        }
        if (window.WebSocket) {
            socket = new WebSocket("ws://localhost:8080/ws");
            socket.onmessage = function(event) {
                var ta = document.getElementById('responseText');
                ta.value = ta.value + '\n' + event.data
            };
            socket.onopen = function(event) {
                var ta = document.getElementById('responseText');
                ta.value = "连接开启!";
            };
            socket.onclose = function(event) {
                var ta = document.getElementById('responseText');
                ta.value = ta.value + "连接被关闭";
            };
        } else {
            alert("你的浏览器不支持 WebSocket！");
        }

        function send(message) {
            if (!window.WebSocket) {
                return;
            }
            if (socket.readyState == WebSocket.OPEN) {
                socket.send(message);
            } else {
                alert("连接没有开启.");
            }
        }
    </script>
    <form onsubmit="return false;">
        <h3>WebSocket 聊天室：</h3>
        <textarea id="responseText" style="width: 500px; height: 300px;"></textarea>
        <br> 
        <input type="text" name="message"  style="width: 300px" value="Welcome to localhost">
        <input type="button" value="发送消息" onclick="send(this.form.message.value)">
        <input type="button" onclick="javascript:document.getElementById('responseText').value=''" value="清空聊天记录">
    </form>
    <br>
        Netty SEO 优化 
        Netty 是什么
        Netty 怎么样
        Netty4 Netty5 区别
        Netty 效率
        Netty 版本区别
        Netty 和 Mina
        Netty 网络编程
        Netty Java 网络编程
        Netty Java Socket NIO
        NIO 编程
        Netty NIO 开发
        Netty3 Netty4 Netty5
        Netty 好处
        Netty 一般注意什么
        Netty 例子程序
        Netty Hello World
        Netty 聊天程序
        Netty Web HTML HTTP FTP SSL 
        Netty UDP TCP WebSocket 练习
        Netty 连接数
        Netty 源码
    <br>
</body>
</html>

运行结果，依次运行1，2，3

　　服务器打印结果

Netty实现简单WebSocket服务器
https://www.cnblogs.com/lanqie/p/8250302.html

一款基于Netty开发的WebSocket服务器
https://www.cnblogs.com/demodashi/p/9443544.html


Netty实现WebSocket通信
https://blog.csdn.net/naruto_Mr/article/details/81452640

轻量级、高性能的WebSocket框架
netty-websocket-spring-boot-starter
https://gitee.com/Yeauty/netty-websocket-spring-boot-starter

Netty+WebSocket简单实现网页聊天
https://www.cnblogs.com/ggwow/p/7921136.html


一款基于Netty开发的WebSocket服务器
https://www.cnblogs.com/demodashi/p/9443544.html


Netty实现WebSocket通信案例
https://blog.csdn.net/Java_Mrsun/article/details/81911214

netty学习----Netty对WebSocket的整合
https://blog.csdn.net/qq_29807745/article/details/82558599


Netty入门（一）环境搭建及使用
https://www.cnblogs.com/coderJiebao/p/Netty01.html

Netty框架入门
https://www.cnblogs.com/baronzhao/p/netty_1.html


《跟闪电侠学Netty》开篇：Netty是什么？
https://www.jianshu.com/p/a4e03835921a

Netty处理WebSocket，Nginx配置
http://liweidan.cn/java/frame/netty/2019/08/04/346/

参考资料:
　　《Netty 权威指南》
　　https://zh.wikipedia.org/wiki/WebSocket
　　https://www.zhihu.com/question/20215561
　　http://waylau.com/netty-websocket-chat/

原文地址:http://www.cnblogs.com/wunaozai/p/5240006.html

az44yao
关注
springboot+netty+websocket+redis
03-08
**SpringBoot+Netty+WebSocket+Redis：构建分布式实时聊天应用** 在当今的互联网世界中，实时通信和数据共享是许多应用程序的核心需求。Spring Boot作为一款流行的Java框架，因其简洁的配置和快速开发特性而备受...
Netty(五)——WebSocket之事
学会改变自己——才能突破
10-30 555
        在说WebSocket以前，我们再来看看HTTP协议，HTTP1.0，HTTP1.1，HTTP2.0每个版本的更新带来更高效的更丰富的功能：短连接、长连接、缓存处理的丰富、断点续传、错误通知的丰富、多路复用、请求优先级、header压缩……更多的我们来看这篇文章：HTTP1.0、HTTP1.1和HTTP2.0的区别 （https://www.cnblogs.com/zhangyfr...
SuperSocket在.Net5中使用——WebSocket Server篇
四点的博客
01-15 2864
背景：SuperSocket支持WebSocket应用层协议，记录一下怎样使用 一.首先引用相关Nuget包 二、创建WebSocketHostBuilder var host = WebSocketHostBuilder.Create().UseWebSocketMessageHandler( async (session, message) => { await session.Se
C# .net5 SuperWebSocket 应用示例
zxb11c的博客
03-29 1119
可以使用任何支持WebSocket协议的客户端来连接到服务器，例如JavaScript的WebSocket API或者C#的WebSocketClient类。可以使用NuGet包管理器来安装SuperWebSocket库。这个例子演示了如何创建WebSocket服务器并在客户端连接、收到消息和断开连接时进行响应。1,安装SuperWebSocket库。3编写WebSocket客户端。添加WebSocket服务器。
Netty之——基于Netty5.0高级案例NettyWebsocket
海子@幸福人
05-11 350
转载请注明出处：http://blog.csdn.net/l1028386804/article/details/55026558一、前言介绍    本案例主要介绍如何使用Netty开发websocket。二、环境需求    1、jdk1.7    2、Eclipse    3、Netty5.0    4、支持websocket的浏览器[火狐]三、工程截图四、代码部分1、服务端Global.jav...
基于Netty5.0高级案例一之NettyWebsocket
热门推荐
攻城狮Luke
05-16 1万+
基于Netty5.0高级案例一之NettyWebsocket 2015-1-1 付政委 Netty5.0 高级篇 前言介绍：     本案例主要介绍如何使用Netty开发websocket。 环境需求：     1、jdk1.7     2、Eclipse     3、Netty5.0     4、支持websocket的浏览器[火狐] 工程截
Spring+Netty+WebSocket实例
12-06
5. **客户端支持**：在前端，使用JavaScript的WebSocket API或者基于Stomp的库（如`sockjs-client`和`stompjs`）与Spring的WebSocket服务器通信。 6. **测试与调试**：使用WebSocket客户端工具或自定义的测试页面，...
Spring Boot 整合 Netty + WebSocket 实时消息推送
03-14
5. **安全性和认证**：在实际项目中，我们需要考虑WebSocket的认证和授权。Spring Security可以与WebSocket整合，提供基于JWT或OAuth的认证机制，确保只有经过验证的用户才能访问WebSocket端点。 6. **前端实现**：...
netty+websocket实现心跳和断线重连
03-06
在本文中，我们将深入探讨如何利用 Netty 和 WebSocket 实现心跳检测和断线重连机制。 首先，我们需要理解 WebSocket 协议。WebSocket 是一种在单个 TCP 连接上进行全双工通信的协议，它为客户端和服务器提供了低...
基于Netty+SpringBoot+WebSocket+MUI+HTML5+制作的仿微信聊天APP.zip
最新发布
02-12
html5开发
netty5实现的websocket服务器
12-10
实现了websocket服务端，提供给android和IOS的APP实现长链接功能，以提升APP的响应及时度。效果很好。
netty5_兼容tcp、websocket小例子 实现信息广播
07-22
netty5_兼容tcp、websocket小例子 实现信息广播,socket客户端连接后会受到getid此时socket客户端发送个六位数进行验证
netty之websocket协议开发
10-25
我们要编写一个webSocket服务器，支持WebSocket的浏览器通过webSocket协议发送请求给我们编写的webSocket服务器，服务器对请求消息进行判断，如果是合法的webSocket请求，则获取请求消息体，并在后面追加字符串：“欢迎使用Netty WebSocket 服务，现在时刻：系统时间”。
.Net 5 下使用 Tool.Net 框架 搭建 WebSocket 服务器
逆-血
11-18 1558
在当前最新版本中，已经增加了关于WebSocket 长连接部分的类，提供大家直接使用，用法简单，开发高效，废话不多说，上代码： using Tool.Sockets.WebTcp; static void Main(string[] args) { WebServer webServer = new WebServer();//创建服务实例 webServer.StartAsync("0.0.0.0",866, false);//指
websocket在.net4.5中实现的简单demo
书写人生
07-19 1万+
以下代码环境要求：win8或win10, .net4.5+IIS8 win7上是IIS7，win7上.net本身不直接支持websocket, win7可以用superwebsocket, 或自己根据协议用TCPListener实现   handler代码： using System; using System.Net.WebSockets; using System.Text; u...
NET WebSocket
n_niankong_k的博客
09-12 776
NET WebSocket2019年9月12日范文一范文二 2019年9月12日 WebSocket是什么我就不多说了，去百度百科，搜索一下，他会比我写的更全面，更细致 这几天需要socket，踩了不少坑，所以把代码直接拿出来，让大家看看，话说net socket这方面的代码挺少的，一搜索都是java的，（疯狂暗示微软）话不多说，直接上代码 范文一 需要引用程序包SuperWebSocket;和...
.net5 WebAPI中搭建WebSocket服务端
四点的博客
08-26 3072
背景：需要开发一个WebSocket服务端，用来向h5客户端推送消息；以前的做法是直接做一个windows服务，专门开一个端口来进行WebSocket连接，现在可以在.net5 WebAPI中直接支持WebSocket，且不用单开端口 使用步骤： 1.在Startup.cs的Configure中启用WebSocket中间件 app.UseWebSockets(); 2.在控制器中添加Action，来接收WebSocket客户端的连接和处理接收、发送消息，关闭连接； [HttpG.
Netty5+Websocket
HGJacky的博客
03-23 971
根据官方文档和自己实际操作整理，方便自己以后使用。为了方便，用maven做的例子。 pom.xml <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.ap...
netty +websocket优点
04-20
Netty WebSocket 的优点包括： 1. 支持双向通信，实时性好。 2. 基于 HTTP 协议，可以通过80和443端口进行通信。 3. 连接可以保持长久开启状态，减少连接的创建和关闭带来的性能问题。 4. 提供灵活的消息格式，可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值