netty-03-Handler-Pipeline-ByteBuf相关

最新推荐文章于 2026-06-04 12:37:11 发布
原创 最新推荐文章于 2026-06-04 12:37:11 发布 · 214 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#java
本文介绍了Netty框架中的ChannelHandler与ByteBuf的基本概念和使用方式。ChannelHandler包括入站和出站处理器，分别用于处理客户端数据和服务端响应。ByteBuf提供了高效的缓冲区管理和池化机制，减少了内存溢出风险并提升了性能。

1-ChannelHandler和Pipeline

ChannelHandler 用来处理 Channel 上的各种事件，分为入站、出站两种。所有 ChannelHandler 被连成一串，就是 Pipeline

- 入站处理器通常是 ChannelInboundHandlerAdapter 的子类，主要用来读取客户端数据，写回结果

- 出站处理器通常是 ChannelOutboundHandlerAdapter 的子类，主要对写回结果进行加工；

类比：每个 Channel 是一个产品的加工车间，Pipeline 是车间中的流水线，ChannelHandler 就是流水线上的各道工序，而后面要讲的 ByteBuf 是原材料，经过很多工序的加工：先经过一道道入站工序，再经过一道道出站工序最终变成产品

场景：模拟客户端向服务端发送hello, server；服务端向客户端回应：hello,client...

import io.netty.bootstrap.ServerBootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOutboundHandlerAdapter;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.ChannelPromise;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import lombok.extern.slf4j.Slf4j;

import java.nio.charset.Charset;

@Slf4j
public class HandlerServer {
    public static void main(String[] args) {
        NioEventLoopGroup bossGroup = new NioEventLoopGroup(1);
        NioEventLoopGroup workGroup = new NioEventLoopGroup(2);
        new ServerBootstrap()
                .group(bossGroup, workGroup)
                .channel(NioServerSocketChannel.class)
                .childHandler(new ChannelInitializer<NioSocketChannel>() {
                    @Override
                    protected void initChannel(NioSocketChannel ch) throws Exception {
                        // 1. 通过 channel 拿到 pipeline
                        ChannelPipeline pipeline = ch.pipeline();
                        // 2. 添加处理器 head ->  h1 -> h2 ->  h3 -> h4 -> h5 -> h6 -> tail
                        pipeline.addLast("h1", new ChannelInboundHandlerAdapter(){
                            @Override
                            public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
                                ByteBuf msg1=(ByteBuf)msg;
                                String msgNew = msg1.toString(Charset.defaultCharset());
                                log.debug("1-msgNew={}",msgNew);
                                super.channelRead(ctx, msg);
                            }
                        });
                        pipeline.addLast("h2", new ChannelInboundHandlerAdapter(){
                            @Override
                            public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
                                ByteBuf msg1=(ByteBuf)msg;
                                String msgNew = msg1.toString(Charset.defaultCharset());
                                log.debug("2-msgNew={}",msgNew);
                                super.channelRead(ctx, msg); // 将数据传递给下个 handler，如果不调用，调用链会断开 或者调用 ctx.fireChannelRead(msg);
                            }
                        });

                        pipeline.addLast("h3", new ChannelInboundHandlerAdapter(){
                            @Override
                            public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
                                ByteBuf msg1=(ByteBuf)msg;
                                String msgNew = msg1.toString(Charset.defaultCharset());
                                log.debug("3-msgNew={}",msgNew);
//ctx.channel().writeAndFlush(msg) 会 从尾部开始触发 后续出站处理器的执行
                                ctx.channel().writeAndFlush(ctx.alloc().buffer().writeBytes("hello,client...".getBytes()));
                            }
                        });
                        pipeline.addLast("h4", new ChannelOutboundHandlerAdapter(){
                            @Override
                            public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
                                ByteBuf msg1=(ByteBuf)msg;、、
                                String msgNew = msg1.toString(Charset.defaultCharset());
                                log.debug("4-msgNew={}",msgNew);
                                super.write(ctx, msg, promise);
                            }
                        });
                        pipeline.addLast("h5", new ChannelOutboundHandlerAdapter(){
                            @Override
                            public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
                                ByteBuf msg1=(ByteBuf)msg; 

                                String msgNew = msg1.toString(Charset.defaultCharset());
                                log.debug("5-msgNew={}",msgNew);
                                super.write(ctx, msg, promise);
                            }
                        });
                        pipeline.addLast("h6", new ChannelOutboundHandlerAdapter(){
                            @Override
                            public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
                                ByteBuf msg1=(ByteBuf)msg;
                                String msgNew = msg1.toString(Charset.defaultCharset());
                                log.debug("6-msgNew={}",msgNew);
                                super.write(ctx, msg, promise);
                            }
                        });
                    }
                })
                .bind(8080);
    }
}


import io.netty.bootstrap.Bootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.string.StringEncoder;
import lombok.extern.slf4j.Slf4j;
import java.net.InetSocketAddress;
import java.nio.charset.Charset;

@Slf4j
public class HandlerClient {
    public static void main(String[] args) throws InterruptedException {
        ChannelFuture channelFuture = new Bootstrap()
                .group(new NioEventLoopGroup())
                .channel(NioSocketChannel.class)
                .handler(new ChannelInitializer<NioSocketChannel>() {
                    @Override // 在连接建立后被调用
                    protected void initChannel(NioSocketChannel ch) throws Exception {
                        ch.pipeline().addLast(new StringEncoder());
                        ch.pipeline().addLast(new ChannelInboundHandlerAdapter(){
                            @Override
                            public void channelRead(ChannelHandlerContext ctx, Object msg) {
                                if(msg instanceof ByteBuf){
                                    ByteBuf msg1=(ByteBuf)msg;
                                    String msgNew = msg1.toString(Charset.defaultCharset());
                                    log.debug("in-1-client,msgNew={}",msgNew);
                                }else{
                                    log.debug("in-1-client,000");
                                }
                            }
                        });
                    }
                })
                .connect(new InetSocketAddress("localhost", 8080));
        channelFuture.sync();
        channelFuture.channel().writeAndFlush("hello, server");
    }
}

服务器端日志输出：

14:39:01 [DEBUG] [nioEventLoopGroup-3-1] c.n.d.d.HandlerServer - 1-msgNew=hello, server

14:39:01 [DEBUG] [nioEventLoopGroup-3-1] c.n.d.d.HandlerServer - 2-msgNew=hello, server

14:39:01 [DEBUG] [nioEventLoopGroup-3-1] c.n.d.d.HandlerServer - 3-msgNew=hello, server

14:39:01 [DEBUG] [nioEventLoopGroup-3-1] c.n.d.d.HandlerServer - 6-msgNew=hello,client...

14:39:01 [DEBUG] [nioEventLoopGroup-3-1] c.n.d.d.HandlerServer - 5-msgNew=hello,client...

14:39:01 [DEBUG] [nioEventLoopGroup-3-1] c.n.d.d.HandlerServer - 4-msgNew=hello,client...

客户端日志输出：

14:39:01 [DEBUG] [nioEventLoopGroup-2-1] c.n.d.d.HandlerClient - in-1-client,msgNew=hello,client...

可以看到，ChannelInboundHandlerAdapter 是按照 addLast 的顺序执行的，而 ChannelOutboundHandlerAdapter 是按照 addLast 的逆序执行的。ChannelPipeline 的实现是一个 ChannelHandlerContext（包装了 ChannelHandler） 组成的双向链表；

注意：

Handler3处的，如果调用ctx.writeAndFlush(ctx.alloc().buffer().writeBytes("hello,client...".getBytes()));

客户端会收到消息，但是服务端的4，5，6不会输出在控制台；

ctx.channel().writeAndFlush(ctx.alloc().buffer().writeBytes("hello,client...".getBytes()));

客户端会收到消息，但是服务端的4，5，6会输出在控制台；

2-ByteBuf

优点：

  • 池化 - 可以重用池中 ByteBuf 实例，更节约内存，减少内存溢出的可能

  • 读写指针分离，不需要像 ByteBuffer 一样切换读写模式

  • 可以自动扩容

  • 支持链式调用，使用更流畅

  • 很多地方体现零拷贝，例如 slice、duplicate、CompositeByteBuf

2.1-直接内存 vs 堆内存

//创建池化基于堆的 ByteBuf
ByteBuf buffer = ByteBufAllocator.DEFAULT.heapBuffer(10);

//创建池化基于直接内存的 ByteBuf
ByteBuf buffer = ByteBufAllocator.DEFAULT.directBuffer(10);

//直接内存创建和销毁的代价昂贵，但读写性能高（少一次内存复制），适合配合池化功能一起用
//直接内存对 GC 压力小，因为这部分内存不受 JVM 垃圾回收的管理，但也要注意及时主动释放

2.2-池化 vs 非池化

池化的最大意义在于可以重用 ByteBuf，优点有

  • 没有池化，则每次都得创建新的 ByteBuf 实例，这个操作对直接内存代价昂贵，就算是堆内存，也会增加 GC 压力

  • 有了池化，则可以重用池中 ByteBuf 实例，并且采用了与 jemalloc 类似的内存分配算法提升分配效率

  • 高并发时，池化功能更节约内存，减少内存溢出的可能

Unpooled 是一个工具类，类如其名，提供了非池化的 ByteBuf 创建、组合、复制等操作；

2.3-堆外内存回收

由于 Netty 中有堆外内存的 ByteBuf 实现，堆外内存最好是手动来释放，而不是等 GC 垃圾回收。

  • UnpooledHeapByteBuf 使用的是 JVM 内存，只需等 GC 回收内存即可

  • UnpooledDirectByteBuf 使用的就是直接内存了，需要特殊的方法来回收内存

  • PooledByteBuf 和它的子类使用了池化机制，需要更复杂的规则来回收内存

基本规则是，谁是最后使用者，谁负责 release，详细分析如下：

  • 起点，对于 NIO 实现来讲，在 io.netty.channel.nio.AbstractNioByteChannel.NioByteUnsafe#read 方法中首次创建 ByteBuf 放入 pipeline（line 163 pipeline.fireChannelRead(byteBuf)）

  • 入站 ByteBuf 处理原则

  • 对原始 ByteBuf 不做处理，调用 ctx.fireChannelRead(msg) 向后传递，这时无须 release

  • 将原始 ByteBuf 转换为其它类型的 Java 对象，这时 ByteBuf 就没用了，必须 release

  • 如果不调用 ctx.fireChannelRead(msg) 向后传递，那么也必须 release

  • 注意各种异常，如果 ByteBuf 没有成功传递到下一个 ChannelHandler，必须 release

  • 假设消息一直向后传，那么 TailContext 会负责释放未处理消息（原始的 ByteBuf）

  • 出站 ByteBuf 处理原则

  • 出站消息最终都会转为 ByteBuf 输出，一直向前传，由 HeadContext flush 后 release

  • 异常处理原则

  • 有时候不清楚 ByteBuf 被引用了多少次，但又必须彻底释放，可以循环调用 release 直到返回 true

【Netty学习】八、ByteBuf的自动释放
kangbin825的专栏
02-04 3131
在入站处理时，Netty是何时自动创建入站的ByteBuf的呢？查看Netty源代码，我们可以看到，Netty的Reactor反应器线程会在底层的Java NIO通道读数据时，也就是AbstractNioByteChannel.NioByteUnsafe.read()处，调用ByteBufAllocator方法，创建ByteBuf实例，从操作系统缓冲区把数据读取到Bytebuf实例中，然后调用pipeline.fireChannelRead(byteBuf)方法将读取到的数据包送入到入站处理流水线中。
Netty源码解析 -- ChannelPipeline机制与读写过程
binecy
11-07 446
本文继续阅读Netty源码，解析ChannelPipeline事件传播原理，以及Netty读写过程。 源码分析基于Netty 4.1 ChannelPipeline Netty中的ChannelPipeline可以理解为拦截器链，维护了一个ChannelHandler链表，ChannelHandler即具体拦截器，可以在读写过程中，对数据进行处理。 ChannelHandler也可以分为两类。 ChannelInboundHandler，监控Channel状态变化，如channelActive，channe
关于socket flush（）目标端接收不到数据，close（）可以接收到数据的问题
热门推荐
琉璃糖的博客
12-09 1万+
最近在写一个简单的socket示例时遇到一个问题，使用write.flush（）目标端read接收不到数据，调用close（）后数据可正常接收。这让我很是费解，记得当初学习flush方法时，都说明这个方法是强制将缓存区内容刷新到输出流中。难道是socket输出流有不一样。看到网上很多人在问这个问题，解释的也是五花八门的。后来我终于找到了原因，有这样疑惑的同胞们可以参考下，出问题的不是输出的逻辑，而是
netty源码调试过程中遇到的小问题总结
weixin_44652738的博客
07-27 1035
windows环境下netty客户端数据发送不了问题
netty开发遇到的问题
KnowledgeAndWistom的博客
03-19 666
netty开发遇到的问题背景原因服务器端客户端 背景 今天进行netty代码测试，所有开发完成后，出现客户端与服务器端通信失败，并且卡住。 原因 两边编码不一致导致 服务器端 服务器端编码配置 @Override protected void initChannel(SocketChannel socketChannel) throws Exception { //添加编解码 socketChannel.pipeline().addLast("decoder"
Netty源码—5.Pipeline和Handler
weixin_33242795的博客
04-28 98
ChannelPipeline中保存了Channel的引用，ChannelPipeline中每个结点都是一个ChannelHandlerContext对象，每个ChannelHandlerContext结点都包裹着一个ChannelHandler执行器，每个ChannelHandlerContext结点都保存了它包裹的执行器ChannelHandler执行操作时所需要的上下文ChannelPipeline。NioByteUnsafe中的写有两个方法，一个是write()方法，一个是flush()方法。
你知道 netty的ChannelInBoundHandler生命周期以及Pipeline入站处理流程吗？
唐欢
07-24 591
当对端数据入站到Netty通道时，Netty将触发流水线Pipeline上开启入站操作处理，触发入站处理器ChannelInboundHandler多对应的入站API。入站处理器有两个接口，一个是超级接口ChannelHander，另一个是ChannelInboundHandler，ChannelInboundHandler接口继承了超级接口ChannelHandler，如下图所示：ChannelInboundHandler的常用方法如下图所示：/**
Netty5 Write和Flush事件处理过程_源码讲解
weixin_34168700的博客
05-29 259
2019独角兽企业重金招聘Python工程师标准>>> ...
【Netty专题】Netty UDP模式 下发指令时收不到上报数据
Coinker的博客
03-26 2526
今天调试项目程序，涉及 6000 台表单线程进行抄读，平均每个表抄读要5秒钟，每天想抄读多次。 算下来 6000 * 5 = 30000 s = 500 min ≈ 8.3 hour 这样是绝对不行的，于是我想做成多线程抄表，通过netty的 ctx.executor().schedule（）方法启动定时任务。 可是调试的时候发现下发抄表指令时，上报数据上不来，我和项目经理还有团队大佬研究了半天，还是没有解决。 后来经过调试我才发现，是因为我在ctx.executor().schedule（）启动定.
Netty服务器接收客户端消息延迟分析
YuChen
10-12 3742
Netty服务器接收客户端消息延迟分析
Netty channelHandler注意事項——super.channelRead(ctx, msg)
冷月的编程学习
03-09 1106
通过nioSocketChannel.pipeline()的addLast添加入站处理器，如果有多个必须显示的唤醒下一个入站处理器，否则执行链中间会断掉。//这里未调用唤醒下一个处理器。//找到下一个ｈａｎｄｌｅｒ并执行。//新启动一个线程，执行新的处理器。
Netty中的Channel之数据冲刷与线程安全（writeAndFlush）
weixin_30908707的博客
04-25 399
本文首发于本博客，如需转载，请申明出处. GitHub项目地址 InChat 一个轻量级、高效率的支持多端（应用与硬件Iot）的异步网络应用通讯框架 前言 本文预设读者已经了解了一定的Netty基础知识，并能够自己构建一个Netty的通信服务（包括客户端与服务端）。那么你一定使用到了Channel，这是Netty对传统JavaIO、NIO的链接封装实例。 那么接下来...
【Netty Websocket】使用writeAndFlush方法后客户端无法收到消息的解决办法
持续分享有趣的技术干货
09-09 1804
在使用 Netty 进行 WebSocket 开发的过程中，有时候会遇到使用方法发送消息后，客户端却无法收到消息的情况。本文将深入探讨这个问题的可能原因及解决办法。
bytebuf池_Netty默认的Bytebuf是堆内还是堆外？池化or非池化？
tianyaleixiaowu的专栏
02-23 1559
开篇 Netty的ByteBuf有从不同角度有如下2个分类，4种组合！ 堆外内存和堆内内存 池化和非池化 我们在利用Netty做底层通信框架的时候，会默认给我们的到底是哪一种组合了？ 分析 池化分析 Netty的Boostrap启动类按照标准模板，通常会添加这个配置option(ChannelOption.ALLOCATOR, ByteBufAllocator.DEFAULT) val serverBootstrap = ServerBootstrap().group(bossGroup,
Netty 中细说数据容器-ByteBuf
weixin_42030357的博客
11-26 1421
文章目录1. 简介2. 运作方式与使用模式2.1 运作方式2.2 使用模式2.2.1 堆缓冲区2.2.2 直接缓冲区2.2.3 复合缓冲区3. 支持的操作3.1 随机访问索引3.2 顺序访问索引3.2.1 可丢弃的字节3.2.2 可读字节3.2.3 可写字节3.2.4 例子3.3 索引管理3.4 查找操作3.5 派生缓冲区3.6 读/写操作4. ByteBufHolder5. ByteBuf分配5.1 使用ByteBufAllocator接口分配5.2 使用Unpooled缓冲区分配5.3 使用ByteBu
手把手调试：在Ubuntu 22.04上为Radeon RX 6000系列显卡编译并加载自定义DRM驱动模块
最新发布
weixin_30908941的博客
06-04 697
本文详细介绍了在Ubuntu 22.04上为AMD Radeon RX 6000系列显卡编译并加载自定义DRM驱动模块的完整流程。从环境准备、内核源码获取到驱动代码修改、编译加载，再到常见问题排查与性能调优，手把手教你深入Linux图形栈底层开发。特别针对Radeon显卡的电源管理和调试技巧提供了实用建议，帮助开发者高效完成GPU驱动定制。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值