第十一章 Netty 小应用

最新推荐文章于 2023-01-03 14:57:22 发布
最新推荐文章于 2023-01-03 14:57:22 发布
阅读量533 收藏 3
点赞数
分类专栏： netty 文章标签： java websocket netty socket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Byd_Liang/article/details/115742009
版权
本文介绍了使用Netty实现群聊系统，包括服务器端和客户端代码，实现了用户上线、离线及消息转发功能。接着展示了心跳检测机制，当服务器超过特定时间无读写操作时，触发相应提示。最后，通过WebSocket搭建了全双工的长连接服务器，客户端可以实时接收和发送消息。
摘要由CSDN通过智能技术生成

目录

一、群聊

服务端代码

客户端代码

测试结果

二、心跳检测

代码

结果

三、通过WebSocket实现长连接

服务端代码

客户端代码

结果

一、群聊

需求

  1. 编写一个 Netty 群聊系统，实现服务器端和客户端之间的数据简单通讯（非阻塞）
  2. 实现多人群聊
  3. 服务器端：可以监测用户上线，离线，并实现消息转发功能
  4. 客户端：通过channel 可以无阻塞发送消息给其它所有用户，同时可以接受其它用户发送的消息(由服务器转发得到)
  5. 目的：进一步理解Netty非阻塞网络编程机制

服务端代码

ChatGroupServerHandler.java

public class ChatGroupServerHandler extends SimpleChannelInboundHandler<String> {

    /**
     * 定义一个 channelGroup ，管理所有的channel
     * GlobalEventExecutor.INSTANCE 是全局的事件执行器，是一个单例
     */
    private static ChannelGroup channelGroup = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);

    /**
     * 表示Channel 处于活动状态，提示 XX 上线
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println(ctx.channel().remoteAddress() + "-上线了~");
    }

    /**
     * 表示Channel 处于不活动状态，提示 XX 离线
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        System.out.println(ctx.channel().remoteAddress() + "-离线了~");
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        // 关闭通道
        ctx.close();
    }

    /**
     * 表示连接建立，一旦建立连接，第一个执行该方法
     * 并且将当前 channel 加入到channelGroup
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
        Channel channel = ctx.channel();
        // 将该客户端加入聊天的信息，发送给其他客户端
        /**
         * 该方法将会 循环遍历ChannelGroup中所有的Channel，并发送消息，我们不需要自己遍历
         */
        channelGroup.writeAndFlush(DateTimeFormatter.ofPattern("yyyy年MM月dd日HH:mm:ss")
                .format(LocalDateTime.now()) + ": 【" + channel.remoteAddress() + "】-加入聊天");
        channelGroup.add(channel);
    }

    // 断开连接，将XX客户端离开的消息推送给当前在线的客户端
    @Override
    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
        Channel channel = ctx.channel();
        channelGroup.writeAndFlush(DateTimeFormatter.ofPattern("yyyy年MM月dd日HH:mm:ss")
                .format(LocalDateTime.now()) + ": 【" + channel.remoteAddress() + "】-离开聊天");
        System.out.println("GroupChannel-Size:" + channelGroup.size());
    }

    // 读取数据
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {

        // 读取道当前的Channel
        Channel channel = ctx.channel();
        // 这时我们遍历ChannelGroup，根据不同的情况，回送不同的消息
        channelGroup.forEach(ch -> {
            if (channel != ch) {
                // 不是自己
                ch.writeAndFlush("【" + channel.remoteAddress() + "】发送消息：" + msg + "\n");
            } else {
                // 回显
                ch.writeAndFlush("【自己】：" + msg + "\n");
            }
        });

    }
}

ChatGroupServer.java

/**
 * 群聊服务端
 */
public class ChatGroupServer {
    private final int PORT;

    public ChatGroupServer(int PORT) {
        this.PORT = PORT;
    }

    public void run() {
        // 创建两个线程组
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workGroup = new NioEventLoopGroup();

        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup, workGroup)
                    .channel(NioServerSocketChannel.class)
                    .option(ChannelOption.SO_BACKLOG, 128)
                    .childOption(ChannelOption.SO_KEEPALIVE, true)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            // 获取到pipeline
                            ChannelPipeline pipeline = ch.pipeline();
                            // 向pipeline 加入解码器
                            pipeline.addLast("decoder", new StringDecoder());
                            // 向pipeline 加入编码器
                            pipeline.addLast("encoder", new StringEncoder());
                            // 加入自己的业务处理的handler
                            pipeline.addLast(new ChatGroupServerHandler());
                        }
                    });
            System.out.println("群聊服务器启动~~~");

            ChannelFuture channelFuture = serverBootstrap.bind(PORT).sync();
            // 监听关闭
            channelFuture.channel().closeFuture().sync();

        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            bossGroup.shutdownGracefully();
            workGroup.shutdownGracefully();
        }

    }

    public static void main(String[] args) {
        new ChatGroupServer(7000).run();
    }
}

客户端代码

ChatGroupClientHandler.java

public class ChatGroupClientHandler extends SimpleChannelInboundHandler<String> {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
        System.out.println(msg.trim());
    }
}

ChatGroupClient.java

public class ChatGroupClient {

    private final int PORT;
    private final String HOST;

    public ChatGroupClient(String host, int port) {
        PORT = port;
        HOST = host;
    }

    private void run() {
        NioEventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group)
                    .channel(NioSocketChannel.class)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            // 获取到pipeline
                            ChannelPipeline pipeline = ch.pipeline();
                            // 向pipeline 加入解码器
                            pipeline.addLast("decoder", new StringDecoder());
                            // 向pipeline 加入编码器
                            pipeline.addLast("encoder", new StringEncoder());
                            // 加入自己的业务处理的handler
                            pipeline.addLast(new ChatGroupClientHandler());
                        }
                    });
            ChannelFuture channelFuture = bootstrap.connect(HOST, PORT).sync();
            // 得到Channel
            Channel channel = channelFuture.channel();
            System.out.println("-----" + channel.localAddress() + "-----");
            // 客户端需要输入信息，
            Scanner scanner = new Scanner(System.in);
            while (scanner.hasNextLine()) {
                String msg = scanner.nextLine();
                // 通过channel 发送到服务端
                channel.writeAndFlush(msg + "\r\n");
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            group.shutdownGracefully();
        }
    }

    public static void main(String[] args) {
        new ChatGroupClient("127.0.0.1", 7000).run();
    }
}

测试结果

  image.png                  image.png  

                 服务端                                                                    客户端1 

 image.png      image.png

                客户端2                                                                    客户端3                                                                               

二、心跳检测

需求:  

  1. 编写一个 Netty心跳检测机制案例, 当服务器超过3秒没有读时，就提示读空闲
  2. 当服务器超过5秒没有写操作时，就提示写空闲
  3. 实现当服务器超过7秒没有读或者写操作时，就提示读写空闲

代码

HeartBeatHandler.java

public class HeartBeatHandler extends ChannelInboundHandlerAdapter {

    /**
     * @param ctx 上下文
     * @param evt 事件
     * @throws Exception
     */
    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        // 将evt 向下转型，
        IdleStateEvent event = (IdleStateEvent) evt;
        switch (event.state()) {
            case READER_IDLE:
                System.out.println(System.currentTimeMillis()+":读空闲");
                break;
            case WRITER_IDLE:
                System.out.println(System.currentTimeMillis()+":写空闲");
                break;
            case ALL_IDLE:
                System.out.println(System.currentTimeMillis()+":读写空闲");
                break;
        }

        // 关闭通道
//        ctx.close();
    }
}

HeartBeatServer.java

public class HeartBeatServer {

    public static void main(String[] args) {

        NioEventLoopGroup bossGroup = new NioEventLoopGroup(1);
        NioEventLoopGroup workGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup, workGroup)
                    .channel(NioServerSocketChannel.class)
                    .handler(new LoggingHandler(LogLevel.INFO))
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();
                            /**
                             * 加入一个netty提供的IdleStateHandler
                             * 说明：
                             * 1. IdleStateHandler 是 netty 提供的处理空闲状态的处理器
                             * 2. long readerIdleTime: 表示经过多长时间没有读，就会发送一个心跳检测包进行连接检查
                             * 3. long writerIdleTime: 表示经过多长时间没有写，就会发送一个心跳检测包进行连接检查
                             * 4. long allIdleTime: 表示经过多长时间没有读写，就会发送一个心跳检测包进行连接检查
                             * 官方解释：
                             * Triggers an IdleStateEvent when a Channel has not performed read, write, or both operation for a while.
                             * 5. 当 IdleStateEvent 触发后，就会传递给管道的下一个handler去处理，
                             *   通过调用下一个Handler的 userEventTiggered，在该方法中处理IdleStateEvent(读空闲，写空闲，读写空闲)
                             */
                            pipeline.addLast(new IdleStateHandler(7, 10, 5, TimeUnit.SECONDS));
                            pipeline.addLast(new HeartBeatHandler());
                        }
                    });
            System.out.println(System.currentTimeMillis()+"服务器启动");
            ChannelFuture channelFuture = serverBootstrap.bind(7000).sync();
            channelFuture.channel().closeFuture().sync();

        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            bossGroup.shutdownGracefully();
            workGroup.shutdownGracefully();
        }

    }
}

结果

image.png

三、通过WebSocket实现长连接

要求:  实现基于webSocket的长连接的全双工的交互

  1. Http协议是无状态的, 浏览器和服务器间的请求响应一次，下一次会重新创建连接.
  2. 需要改变Http协议多次请求的约束，实现长连接， 服务器可以发送消息给浏览器
  3. 客户端浏览器和服务器端会相互感知，比如服务器关闭了，浏览器会感知，同样浏览器关闭了，服务器会感知

 

服务端代码

  • WebSocketServerHandler.java
/**
 * TextWebSocketFrame 表示一个文本帧
 */
public class WebSocketServerHandler extends SimpleChannelInboundHandler<TextWebSocketFrame> {


    @Override
    protected void channelRead0(ChannelHandlerContext ctx, TextWebSocketFrame msg) throws Exception {
        System.out.println("服务端收到消息："+msg.text());
        // 回复消息
        ctx.writeAndFlush(new TextWebSocketFrame("当前时间："+ LocalDateTime.now()+"--"+msg.text()));

    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        System.out.println("异常发生：" + cause.getMessage());
        ctx.close();
    }

    /**
     * 当 web 客户端连接后，触发该方法
     * @param ctx
     * @throws Exception
     */
    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
        // id 是唯一值，short 不唯一，Long 是唯一的
        System.out.println("handlerAdded:"+ctx.channel().id().asShortText());
        System.out.println("handlerAdded:"+ctx.channel().id().asLongText());
    }

    @Override
    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
        System.out.println("handlerRemoved:"+ctx.channel().id().asLongText());
    }
}
  • WebSocketServer.java
/**
 * websocket 服务端
 */
public class WebSocketServer {

    public static void main(String[] args) {
        NioEventLoopGroup bossGroup = new NioEventLoopGroup(1);
        NioEventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .handler(new LoggingHandler(LogLevel.ERROR)) // 打印 netty 日志
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();
                            // 因为基于Http协议，所以使用http的编解码器
                            pipeline.addLast(new HttpServerCodec());
                            // 以块方式写，添加 ChunkedWriteHandler 处理器
                            pipeline.addLast(new ChunkedWriteHandler());
                            /**
                             * 说明
                             * 1. Http再传输过程中是分段，HttpObjectAggregator 就是可以将多个段聚合，
                             * 2. 这就是为什么，当浏览器发送大数据时，会发生多次 http 请求
                             */
                            pipeline.addLast(new HttpObjectAggregator(8192));
                            /**
                             * 说明：
                             * 1. websocket 协议,数据是以帧（frame）形式传递
                             * 2. WebSocketFrame 下面有6个子类
                             * 3. 浏览器请求时：ws:127.0.0.1/7998/hello 表示请求的uri
                             * 4. WebSocketServerProtocolHandler 核心功能是将http协议升级为ws协议，保持长连接，状态码101
                             */
                            pipeline.addLast(new WebSocketServerProtocolHandler("/hello"));
                            // 自定义的handler，处理业务逻辑
                            pipeline.addLast(new WebSocketServerHandler());
                        }
                    });
            ChannelFuture channelFuture = serverBootstrap.bind(7998).sync();
            System.out.println("~~~websocket 服务器已经启动~~~");
            channelFuture.channel().closeFuture().sync();
        } catch (Exception exception){
            exception.printStackTrace();
        }
        finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }

    }
}

客户端代码

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>netty-websocket-client</title>
</head>
<body>

<script>
    let socket;
    // 判断当前浏览器是否支持websocket
    if (window.WebSocket) {
        socket = new WebSocket("ws://localhost:7998/hello");

        // 相当于 channelRead0，读取消息
        socket.onmessage = function (ev) {
            const showText = document.getElementById('responseText');
            showText.value += ev.data + "\r\n";
        }

        // 连接开启
        socket.onopen = function (ev) {
            const showText = document.getElementById('responseText');
            showText.value = "已建立连接"+"\r\n";
        }

        // 连接关闭
        socket.onclose = function (ev) {
            const showText = document.getElementById('responseText');
            showText.value += "已关闭连接" + "\r\n";
        }

        // 发送消息到服务器
        function send(msg) {
            // 先判断socket是否创建好
            if (!socket) {
                return;
            }
            if (socket.readyState === socket.OPEN) { // 判断websocket是否以建立连接
                socket.send(msg);
                const sendBox = document.getElementById('sendBox');
                sendBox.value = '';
            } else {
                alert("未开启连接")
            }

        }

    } else {
        alert("当前浏览器不支持websocket！！！");
    }
</script>

<form onsubmit="return false">
    <textarea id = 'sendBox' name="message" style="width: 150px;height: 200px"></textarea>
    <input type="button" value="发送消息" onclick="send(this.form.message.value)">
    <textarea id="responseText" style="width: 150px;height: 200px"></textarea>
    <input type="button" value="清空内容" onclick="document.getElementById('responseText').value = ''">
</form>

</body>
</html>

结果

image.png           image.png

 

幺零二肆
关注
专栏目录
Spark | 记录下Spark作业执行时常见的参数属性配置
俗人
06-08 968
Spark Core Spark Streaming Spark SQL
spark中的动态executor分配
热门推荐
隔壁老杨的专栏
02-03 1万+
spark源代码分析,spark中动态executor的配置项,spark动态executor的分配源代码分析
Netty学习笔记
guomei的专栏
03-11 948
1.新建NettyTest工程 工程结构如图所示: 2.各个类：   ClientPipelineFactory.java   public class ClientPipelineFactory implements ChannelPipelineFactory {       @Override     public Cha
8、Netty应用实例-群聊系统
m0_45364328的博客
05-20 276
服务器： package com.atguigu.bio.nio.group; import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelInitializer; import io.netty.channel.ChannelOption; import io.netty.channel.ChannelPipeline; import i.
Spark的Worker/Instance /Executor之间的
走向程序的康庄大道
04-21 2805
FAQSpark配置中，可以配置 SPARK_WORKER_INSTANCES 实现每台机器启动多个Worker Instance，在什么情况下需要这么做呢？如果使用Mesos或Yarn作为Spark应用的资源管理器，每个Worker默认就可以启动多个Executor。但是如果使用Standalone模式，则每个Worker只能启动一个Executor，所以如果每台机器想启动多个Executor则...
第四章 Netty应用下学习笔记
hankin的博客
07-14 333
一、解决粘包/半包问题 回顾我们的的Hello,Netty，参见com.chj.nettybasic.splicing.demo下的代码 1、什么是TCP粘包半包？ 假设客户端分别发送了两个数据包D1和D2给服务端，由于服务端一次读取到的字节数是不确定的，故可能存在以下4种情况。 1）务端分两次读取到了两个独立的数据包，分别是D1和D2，没有粘包和拆包； 2）服务端一次接收到了两个数...
netty权威指南第2版
12-27
第11章 WebSocket协议开发 第12章 私有协议栈开发 第13章 服务端创建 第14章 客户端创建 第15章 ByteBuf 和相关辅助类 第16章 Channel 和Unsafe 第17章 ChannelPipeline 和ChannelHandler 第18章 EvenLoop 和...
netty技术文档，socket技术第十二章
06-13
这个技术文档，即"socket技术第十二章"，很可能是对Netty如何在Socket编程中实现高效长连接的深入探讨。 Socket编程是网络编程的基础，它提供了进程间通信（IPC）的能力，使得运行在不同机器上的程序可以通过网络...
Netty权威指南（三）Netty入门应用
DreamsArchitects的博客
04-05 449
Netty入门应用回顾NIO开发步骤一、依赖二、Netty TimeServer三、Netty TimeServerHandler四、Netty TimeClient五、Netty TimeClientHandler 回顾NIO开发步骤 创建ServerSocketChannel，配置为非阻塞模式。 绑定监听，配置TCP参数，例如backlog大小。 创建一个独立的I/O线程，用于轮询多路复用器Selector。 创建Selector，将之前创建的ServerSocketChannel注册到Selecto
Netty学习之Netty模型的模块组件
weixin_43896829的博客
03-09 267
前言 上一篇博客介绍了Netty模型是如何一步步演化的，以及该模型由哪些模块组件所构成，而这篇博客则详细讲述下，该模型中各个模块组件的具体功能。 Netty的模块组件 首先来回顾下Netty的模型图： 模块组件： 1.【NioEventLoop】： NioEventLoop 中维护了一个线程和任务队列，支持异步提交执行任务，线程启动时会调用 NioEventLoop 的 run 方法，执行 I/O 任务和非 I/O 任务。 I/O 任务，即 selectionKey 中 ready 的事件，如 accep
Netty 中的心跳机制详解
yygr的博客
04-21 5542
https://blog.csdn.net/youanyyou/article/details/117757273 我们知道在TCP长连接或者WebSocket长连接中一般我们都会使用心跳机制–即发送特殊的数据包来通告对方自己的业务还没有办完，不要关闭链接。 那么心跳机制可以用来做什么呢？ 我们知道网络的传输是不可靠的，当我们发起一个链接请求的过程之中会发生什么事情谁都无法预料，或者断电，服务器重启，断网线之类。 如果有这种情况的发生对方也无法判断你是否还在线。所以这时候我们引入心跳机制，在长链
Netty优雅退出机制shutdownGracefully源码分析
xu_Melon的博客
02-01 1万+
使用Netty开发的小伙伴肯定对下面这两句代码非常熟悉了 bossGroup.shutdownGracefully(); workerGroup.shutdownGracefully();那就是Netty中大名鼎鼎的优雅退出，顾名思义它的作用就是使线程池退出，用我们都用过，那么它到底是如何工作的呢？ 由于Netty处理的是线程池，线程池的关闭要求其中的每一个线程关闭。而线程的实现实在Si
12、Netty-源码-shutdownGracefully[进行中]
爱欧米
05-08 812
关闭应用分为两种方式，一种方式强杀用户进程，导致应用没有机会保证正在处理工作的完整性，具体表现在丢失数据、数据损坏、数据重复等问题。那么我们关闭应用就应该采用稳定靠谱的方式关闭应用，等待应用完全处理完毕当前的任务并无新任务进来在关闭应用，这种方式叫优雅关机。 下面我们从JVM优雅关机慢慢过渡到Netty的优雅关机。 一、导致JVM关闭的原因 分析JVM关闭前，我们需要了解什么情况下JVM会关闭。 JVM强制关闭：系统关机[系统会通知JVM关闭，如果JVM关闭超时会强制关闭]、kill -9、Runti
Netty 实现 一个端口同时接收 socket 和 webSocket 连接
NRGAGA的专栏
06-22 6622
项目是在 Springboot 集成 Netty 的基础上开发。 参考文章： 1、SpringBoot 整合 Netty 实现Socket：https://www.cnblogs.com/guoyuchuan/p/9581283.html 2、Netty 实现 webSocket：https://www.cnblogs.com/miller-zou/p/7002070.html 3、同时实现...
Java基础之《netty（18）—群聊系统》
最新发布
csj50的专栏
01-03 874
4、客户端：通过channel可以无阻塞发送消息给其他所有用户，同时可以接受其他用户发送的消息（由服务器转发得到）1、编写一个netty群聊系统，实现服务器端和客户端之间的数据简单通讯（非阻塞）3、服务器端：可以检测用户上线，离线，并实现消息转发功能。5、目的：进一步理解netty非阻塞网络编程机制。
netty入门介绍及应用实例
懵齐的博客
03-10 1063
Netty介绍及使用 1. Netty介绍 1.1 简介 Netty是由JBOSS提供的一个java开源框架，现为Github上的独立项目。Netty是一个异步的、基于事件驱动的网络应用框架，用以快速开发高性能、高可靠的网络IO程序。Netty主要针对在TCP协议下，面向Clients端的高并发应用，或Peer-to-Peer场景下的大量数据持续传输的应用。Netty本质是NIO框架，适用于服务器通讯相关的多种应用场景。 要透彻理解Netty，先学习NIO java NIO介绍及入门案例 NIO的类库和AP
基于Netty实现群聊功能
收破烂的小熊猫
03-11 685
有你的日子你就是一切，没你的日子一切都是你 又是一天新的开始，让我来带领你打开任督二脉。。。 前言： 在前面有了对NIO、BIO知识的学习，以及对netty结构组的基本了解，接下来将学习一下如何使用netty去实现一个群聊功能，读者可自行去对比基于NIO、BIO、Netty实现群聊功能的不同方式，以更深刻的理解IO网络编程。 学习内容： 整体思路： 1） 编写一个Netty群聊系统，实现服务器端和客户端之间的数据简单通讯（非阻塞） 2） 实现多人聊天 3） 服务器端：可以监测用户上线，离线，并实现消息.
Netty源码分析-ChannelFuture的注意事项
大新博客
10-04 699
在Netty当中所有的IO操作全部是异步的，也就是说调用任何方法都会立即返回，而不能保证所请求的I / O操作在调用结束时已完成，想下面的方法，像对端发送一个消息，方法会立即返回，但是消息是异步发送的，你不知道消息最后的具体发送是成功了还是失败了。 ctx.channel().writeAndFlusf(); 该方法返回一个ChannelFuture实力，通过它设置回调函数来接收操作的执行情...
精通Netty：构建高性能网络应用
- 第11章列出了Netty提供的预置ChannelHandlers和编解码器。 3. 网络协议： - 第12章专门探讨WebSocket协议。 - 第13章介绍了利用UDP广播事件。 4. 案例研究： - 第14章和第15章提供了实际案例分析，分为两...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值