Netty学习笔记（五）--- ChannelHandler的执行顺序

最新推荐文章于 2024-07-28 18:10:46 发布
最新推荐文章于 2024-07-28 18:10:46 发布
阅读量2k 收藏 6
点赞数 3
分类专栏： Netty
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lincain/article/details/90484917
版权

在上一篇文章中，我们已经对ChannelHandler的执行顺序进行了介绍，一个I/O事件可以通过ChannelHandlerContext中的事件传播方法（如 ChannelHandlerContext.fireChannelRead(Object) 和ChannelHandlerContext.write(Object)）传递到下一个类型相同的ChannelHandler上。

下图取自Netty源码的注释，它描述了通常情况下，ChannelPipeline中的ChannleHandler是以何种顺序处理I/O事件的。
1558572050858

下面通过案例来对ChannelHandler的执行顺序进行验证。该案例模拟了服务端和客户端的通讯，服务端注册了两个ChannelInboundHandler和两个ChannelOutboundHandler。当客户端连接到服务端后，会向其发送一条信息，然后服务端经过多个ChannelHandler的处理，向客户端反馈一条信息。

ChannelHandler代码
FirstInServerHandler
package com.netty.handler;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;

public class FirstInServerHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf in = (ByteBuf) msg;
        System.out.println("Server console: " + in.toString(CharsetUtil.UTF_8));
        ctx.fireChannelRead(Unpooled.copiedBuffer("FirstInServerHandler -> ",
                CharsetUtil.UTF_8));
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        super.channelReadComplete(ctx);
    }
}
SecondInServerHandler
package com.netty.handler;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;
import io.netty.util.ReferenceCountUtil;

public class SecondInServerHandler extends ChannelInboundHandlerAdapter{
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf in = (ByteBuf) msg;
        System.out.println("Server console: " + in.toString(CharsetUtil.UTF_8));
        ctx.write(Unpooled.copiedBuffer(in,
                Unpooled.copiedBuffer("SecondInServerHandler -> ", CharsetUtil.UTF_8)));
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ctx.flush();
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}
FirstOutServerHandler
package com.netty.handler;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelOutboundHandlerAdapter;
import io.netty.channel.ChannelPromise;
import io.netty.util.CharsetUtil;

public class FirstOutServerHandler extends ChannelOutboundHandlerAdapter{
    @Override
    public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
        ByteBuf in = (ByteBuf) msg;
        System.out.println("Server console: " + in.toString(CharsetUtil.UTF_8));
        ctx.writeAndFlush(Unpooled.copiedBuffer(in,
                Unpooled.copiedBuffer("FirstOutServerHandler", CharsetUtil.UTF_8)))
                .addListener(ChannelFutureListener.CLOSE);
    }
    
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}
SecondOutServerHandler
package com.netty.handler;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelOutboundHandlerAdapter;
import io.netty.channel.ChannelPromise;
import io.netty.util.CharsetUtil;

public class SecondOutServerHandler extends ChannelOutboundHandlerAdapter{
    @Override
    public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
        ByteBuf in = (ByteBuf) msg;
        System.out.println("Server console: " + in.toString(CharsetUtil.UTF_8));
        ctx.writeAndFlush(Unpooled.copiedBuffer(in,
                Unpooled.copiedBuffer("SecondOutServerHandler -> ", CharsetUtil.UTF_8)));
    }
}
ClientInHandler
package com.netty.handler;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.util.CharsetUtil;

public class ClientInHandler extends SimpleChannelInboundHandler<ByteBuf>{
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) throws Exception {
        System.out.println("Client Console: " + msg.toString(CharsetUtil.UTF_8));
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        ctx.writeAndFlush(Unpooled.copiedBuffer("ClientInHandler -> ", CharsetUtil.UTF_8));
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}
ClientOutHandler
package com.netty.handler;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelOutboundHandlerAdapter;
import io.netty.channel.ChannelPromise;
import io.netty.util.CharsetUtil;

public class ClientOutHandler extends ChannelOutboundHandlerAdapter{
    @Override
    public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
        ByteBuf in = (ByteBuf) msg;
        ctx.writeAndFlush(Unpooled.copiedBuffer(in,
                Unpooled.copiedBuffer("ClientOutHandler", CharsetUtil.UTF_8)));
    }
    
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}
Server代码
HelloServerDemo
package com.netty;

import com.netty.handler.FirstInServerHandler;
import com.netty.handler.FirstOutServerHandler;
import com.netty.handler.SecondInServerHandler;
import com.netty.handler.SecondOutServerHandler;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;

public class HelloServerDemo {
    public static void main(String[] args) {
        HelloServerDemo server = new HelloServerDemo();
        server.start(20000);
    }
    public void start(int port){
        NioEventLoopGroup bossGroup = new NioEventLoopGroup(1);
        NioEventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(bossGroup,workerGroup);
            bootstrap.channel(NioServerSocketChannel.class);
            bootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    ChannelPipeline pipeline = ch.pipeline();
                    pipeline.addLast(new FirstOutServerHandler());
                    pipeline.addLast(new SecondOutServerHandler());
                    pipeline.addLast(new FirstInServerHandler());
                    pipeline.addLast(new SecondInServerHandler());
                }
            });
            ChannelFuture future = bootstrap.bind(port).sync();
            future.channel().closeFuture().sync();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}
Client代码
HellClientDemo
package com.netty;

import com.netty.handler.ClientInHandler;
import com.netty.handler.ClientOutHandler;
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;

public class HelloClientDemo {
    public static void main(String[] args) {
        HelloClientDemo client = new HelloClientDemo();
        client.start("localhost", 20000);
    }

    public void start(String ip, int port) {
        NioEventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(workerGroup);
            bootstrap.channel(NioSocketChannel.class);
            bootstrap.handler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    ChannelPipeline pipeline = ch.pipeline();
                    pipeline.addLast(new ClientOutHandler());
                    pipeline.addLast(new ClientInHandler());

                }
            });
            ChannelFuture future = bootstrap.connect(ip, port).sync();
            future.channel().closeFuture().sync();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            workerGroup.shutdownGracefully();
        }
    }
}
运行代码

首先启动服务端代码，然后启动客户端代码，控制台的输出结果如下：

HelloClientDemo console：
Server console: ClientInHandler -> ClientOutHandler
Server console: FirstInServerHandler -> 
Server console: FirstInServerHandler -> SecondInServerHandler -> 
Server console: FirstInServerHandler -> SecondInServerHandler -> SecondOutServerHandler ->
HelloClientDemo console：
Client Console: FirstInServerHandler -> SecondInServerHandler -> SecondOutServerHandler -> FirstOutServerHandler

从结果可以看出，执行顺序和我们注册ChannelHandler的顺序有一定关联，其中inbound处理器是顺序执行，而outbound处理器是逆序执行，这也验证了源码中的执行顺序。

注意事项

到这里，关于ChannelHandler的执行顺序问题，已经弄清楚了，接下来介绍一下这个过程中需要注意的细节。

下图代表注册了四个ChannelHandler后，每个通道的ChannelPipeline的handler分布。
1558589122812
上面的案例是按照如下方式注册：

bootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();
        pipeline.addLast(new FirstOutServerHandler());	// ①
        pipeline.addLast(new SecondOutServerHandler());	// ②
        pipeline.addLast(new FirstInServerHandler());	// ③
        pipeline.addLast(new SecondInServerHandler());	// ④
    }
});

如果改变ChannelHandler的注册顺序（inbound处理器的相对位置不变），客户端控制台的显示效果也会随之变化，我们预期是四个handler类名称的都会出现在控制台上，只是顺序有所变化。但在有些情况下，四个handler类名称只会显示三个，甚至两个。多次测试发现，当outbound处理器位于ChannelPipeline的末端时，就会出现handler名称缺失。

下面我们来复现该问题，按照如下的顺序注册ChannelHandler对象。

bootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();
        pipeline.addLast(new FirstOutServerHandler());  // ①
        pipeline.addLast(new FirstInServerHandler());   // ②
        pipeline.addLast(new SecondInServerHandler());	// ③
        pipeline.addLast(new SecondOutServerHandler());	// ④
    }
});

执行代码，控制台的结果为（这里只展示客户端的控制台）：

Client Console: FirstInServerHandler -> SecondInServerHandler -> FirstOutServerHandler

这是为什么呢？通过追踪源码发现，当我们调用ChannelContext.write(msg)时，会调用findContextOutbound()方法查找下一个出站处理器，该方法的源码如下：

private AbstractChannelHandlerContext findContextOutbound() {
    AbstractChannelHandlerContext ctx = this;
    do {
        ctx = ctx.prev;
    } while (!ctx.outbound);
    return ctx;
}

这里的逻辑很简单，它会以自身为起点，反向查找下一个outbound处理器，从上面的handler分布图可知，如果将第二个outbound处理器放置在ChannnelPipeline的尾端时，由于handler的反向查找，就会将该outbound处理器跳过，导致SecondOutServerHandler没有打印出来。要解决这个问题，就需要在进站转换为出站时，从tail节点进行查找，这怎么实现呢？

ChannelHandlerContext 有很多的方法，其中一些方法也存在于 Channel 和 ChannelPipeline 本身上，但是有一点重要的不同。如果调用 Channel 或者 ChannelPipeline 上的这些方法，它们将沿着整个 ChannelPipeline 进行传播。

public class SecondInServerHandler extends ChannelInboundHandlerAdapter{
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf in = (ByteBuf) msg;
        System.out.println("Server console: " + in.toString(CharsetUtil.UTF_8));
        ctx.pipeline().write(Unpooled.copiedBuffer(in,
                Unpooled.copiedBuffer("SecondInServerHandler -> ", CharsetUtil.UTF_8)));
//        ctx.channel().write(Unpooled.copiedBuffer(in,
//               Unpooled.copiedBuffer("SecondInServerHandler -> ", CharsetUtil.UTF_8)));
    }
}

按照上面两种方法之一，即可解决该问题，实现和案例相同的效果。因此我们在注册ChannelHandler时，最好将outbound处理器放在最后一个inbound处理器之前，然后调用ChannelHandlerContext的相应方法，这样会产生更短的事件流，使你的应用程序获得更好的性能。

Lincain
关注
专栏目录
netty-spring-boot-starter:Netty与Spring Boot集成
03-19
netty-spring-boot-starter 基于Netty的Spring Boot Starter工程。 介绍 支持TCP长连接消息转发到Spring容器 支持自定义消息枚举类（ CommandController ， CommandMapping ） 支持自定义通信协议解析（ ...
Netty中Pipeline的ChannelHandler执行顺序案例详解
小单的博客专栏
11-10 301
1、InboundHandler是通过fire事件决定是否要执行下一个InboundHandler，如果哪个InboundHandler没有调用fire事件，那么往后的Pipeline就断掉了。2、InboundHandler是按照Pipleline的加载顺序，顺序执行。3、OutboundHandler是按照Pipeline的加载顺序，逆序执行。4、有效的InboundHandler是指通过fire事件能触达到的最后一个InboundHander。
一文搞懂Netty中Handler的执行顺序
zhengchao1991的博客
12-17 7720
看了很多讲解Netty中InboundHandler、OutboundHandler执行顺序的文章，很少有一篇能完全讲的全的、对的、没有歧义的，在此根据所学、亲自验证得出的结论给大家举例：netty服务端是这个添加顺序 链表中的顺序为head->in1->in2->out1->out2->tail1、如果在InboundHandler2中执行的是ctx.channel().writeAndFlush，执行顺序是： 结果证明：执行完InboundHandler1、InboundHandler2之后，由
Netty技术全解析：ChannelOutboundHandlerAdapter：简化出站事件处理的适配器
最新发布
码到三十五
07-28 1047
ChannelOutboundHandlerAdapter是Netty框架中处理出站事件的重要适配器类。它提供了ChannelOutboundHandler接口中所有方法的默认实现，使得用户只需要重写感兴趣的方法来处理特定的出站事件。通过使用ChannelOutboundHandlerAdapter，用户可以更加高效地开发网络应用程序，并灵活地处理各种出站事件
nio学习之netty入门（2）---netty中handler的执行顺序
tianjun2012的专栏
12-21 9804
1、简介Handler在netty中，无疑占据着非常重要的地位。Handler与Servlet中的filter很像，通过Handler可以完成通讯报文的解码编码、拦截指定的报文、统一对日志错误进行处理、统一对请求进行计数、控制Handler执行与否。一句话，没有它做不到的只有你想不到的。Netty中的所有handler都实现自ChannelHandler接口。按照输出输出来分，分为ChannelIn
Netty4.0学习笔记系列之二：Handler的执行顺序
BruceOuyang 的专栏
01-18 1222
Handler在netty中，无疑占据着非常重要的地位。Handler与Servlet中的filter很像，通过Handler可以完成通讯报文的解码编码、拦截指定的报文、统一对日志错误进行处理、统一对请求进行计数、控制Handler执行与否。一句话，没有它做不到的只有你想不到的。 Netty中的所有handler都实现自ChannelHandler接口。按照输出输出来分，分为ChannelI
关于使用Netty过程中多ChannelHandler的顺序
不爱运动的跑者
06-10 1412
addLast()`是用于向ChannelPipeline添加ChannelHandler的方法。ChannelPipeline是Netty中处理请求和响应的事件处理机制，ChannelHandler负责处理这些事件。当定义一个Server时，可以使用`addLast()`方法将一个或多个ChannelHandler添加到ChannelPipeline的尾部。这样，当请求到达时，它们将按照添加的顺序被依次调用。@Override// 添加自定义的ChannelHandler});
netty-all-4.1.17.Final.jar
01-20
netty-all-4.1.17.Final.jar的依赖包
netty-socketio-1.7.7 jar包下载
10-19
netty-socketio-1.7.7 依赖jar包下载 下载不了的同学自取
netty-4.1.17.Final.jar
09-21
这个"Netty-4.1.17.Final.jar"是Netty框架的一个发行版本，它适用于Java 8及以上版本，这意味着它可以充分利用Java 8的新特性，如lambda表达式和流API，来提升性能和代码可读性。 Netty的核心设计理念是基于通道...
netty-all-4.1.28.Final.jar
08-29
netty-all-4.1.28.Final.jar是Netty的基本包，提供了非阻塞式网络通信的基本功能。
Java方法
m0_45825648的博客
09-25 240
何为方法 例如System.out.println() System为一个类 out为对象 println()为一个方法 定义：方法是语句的集合，用来执行功能 方法的定义及调用 方法重载 命令行传参 可变参数 递归
Netty学习九：编解码之writeAndFlush
weixin_41402069的博客
07-12 4084
Netty学习系列
netty中Pipeline的ChannelHandler执行顺序案例详解
songfei_dream的专栏
10-25 3300
一、netty的Pipeline模型 netty的Pipeline模型用的是责任链 设计模式，当boss线程监控到绑定端口上有accept事件，此时会为该socket连接实例化Pipeline，并将InboundHandler和OutboundHandler按序加载到Pipeline中，然后将该socket连接（也就是Channel对象）挂载到selector上。一个selector对应一个线程，...
netty中ChannelHandler执行顺序案例详解
入门菜鸟程序员的成长
07-13 1571
一、netty的Pipeline模型 netty的Pipeline模型用的是责任链设计模式，当boss线程监控到绑定端口上有accept事件，此时会为该socket连接实例化Pipeline，并将InboundHandler和OutboundHandler按序加载到Pipeline中，然后将该socket连接（也就是Channel对象）挂载到selector上。一个selector对应一个线程，该线程会轮询所有挂载在他身上的socket连接有没有read或write事件，然后通过线程池去执行Pipelin
【Netty专题】Netty 中channelRead 和 channelRead0 有什么区别？
热门推荐
Coinker的博客
04-07 1万+
最近做项目发现Netty中的channel有channelRead 方法也有channelRead0 方法， 然后思考下这两个有什么区别呢？ 我们来直接看源码 channelRead @Override public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { boolean release = true; try { if (acce.
Netty回调与Channel执行流程分析
joeyin
03-06 825
Chanel的生命周期： 状态 描述 ChannelUnregistered Channel已被创建，但未注册到EventLoop ChannelRegisterd Channel注册到EventLoop ChannelActive Channel处于活动状态 ChannelInactive Channel没有连接到远程节点 Channel的状态发生改变是，会生成相应的事件，这些事件将会转发给ChannelPipline中的Chan..
初步了解Netty核心组件：Channel、ChannelHandler和ChannelPipeline
APlus
06-02 1733
1、Channel 这里的Channel与JDK中的Channel有所区别，Netty的Channel在JDK的基础上进行了封装并赋予了更多的功能，用户可以使用Channel进行一下操作： 查询Channel状态和配置Channel的参数 进行IO操作(read\write\connect\bind) Channel接口大大降低了直接使用Socket类的复杂性，Chann...
netty源码分析_带你搞懂ChannelHandler事件传播顺序
wb_snail的博客
06-08 1899
明确关键点： 要搞懂事件在多个ChannelHandler间的传播顺序，有两个关键点需要明确 1.pipeline初始化时，会创建两个哨兵Handler，即HeadContext、TailContext，我们添加的Handler处于这两个哨兵Handler之间，HeadContext可以是入站事件传播的起点，一定是出站事件传播的终点 TailContext可以是出站事件传播的起点(为啥分为"可以是"与"一定是"，下文会有说明) 2.事件的传播起点、方向、目标： 入站事件的起点为当前Handler
netty reactor3 reactor-netty
11-05
Netty是一个基于Java NIO的客户端/服务器框架，可以快速开发可维护的高性能协议服务器和客户端。Reactor3是Netty框架中的一种设计模式，它是一种基于事件驱动的反应式编程模型，可以实现高效的I/O操作。Reactor-...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值