netty笔记-:Channel与ChannelHandlerContext执行write方法的区别
在netty中有我们一般有两种发送数据的方式，即使用ChannelHandlerContext或者Channel的write方法，这两种方法都能发送数据，那么其有什么区别呢。这儿引用netty文档中的解释如下。
这个通俗一点的解释呢可以说ChannelHandlerContext执行写入方法时只会执行当前handler之前的OutboundHandler。而Channel则会执行所有的OutboundHandler。下面我们可以通过例子来理解
1.建立一个netty服务端
public class Server { public static void main(String[] args) throws InterruptedException { ServerBootstrap serverBootstrap = new ServerBootstrap(); ChannelFuture channelFuture = serverBootstrap.group(new NioEventLoopGroup(1) , new NioEventLoopGroup(10)) .channel(NioServerSocketChannel.class) .handler(new LoggingHandler()) .childHandler(new InitialierHandler()) //即步骤2中的类 .bind(8080) .sync(); channelFuture.channel().closeFuture().sync(); } }
2.创建ChannelInitializer
在这个类中我们添加了四个处理器 这儿注意顺序 (具体类在步骤3)
public class InitialierHandler extends ChannelInitializer<SocketChannel> { @Override protected void initChannel(SocketChannel socketChannel) throws Exception { socketChannel.pipeline().addLast(new RequestChannelHandler1()); socketChannel.pipeline().addLast(new ResponseChannelHandler1()); socketChannel.pipeline().addLast(new RequestChannelHandler2()); socketChannel.pipeline().addLast(new ResponseChannelHandler2()); } }
顺序分别为 in1 →out1→ in2 →out2 这儿用图来增加理解 (netty会自动区分in或是out类型)
3. 分别创建2个 int Handler 2个out handler
RequestChannelHandler1(注意后面业务会修改方法具体内容)
public class RequestChannelHandler1 extends ChannelInboundHandlerAdapter { @Override public void channelRead(ChannelHandlerContext ctx , Object msg) throws Exception { System.out.println("请求处理器1"); super.channelRead(ctx,msg); } }
RequestChannelHandler2(注意后面业务会修改方法具体内容)
public class RequestChannelHandler2 extends ChannelInboundHandlerAdapter { @Override public void channelRead(ChannelHandlerContext ctx , Object msg) throws Exception { System.out.println("请求处理器2");super.channelRead(ctx,msg); } }
ResponseChannelHandler1
public class ResponseChannelHandler1 extends ChannelOutboundHandlerAdapter { @Override public void write(ChannelHandlerContext ctx , Object msg , ChannelPromise promise) throws Exception { System.out.println("响应处理器1"); ByteBuf byteMsg = (ByteBuf) msg; byteMsg.writeBytes("增加请求1的内容".getBytes(Charset.forName("gb2312"))); super.write(ctx,msg,promise); } }
ResponseChannelHandler2
public class ResponseChannelHandler2 extends ChannelOutboundHandlerAdapter { @Override public void write(ChannelHandlerContext ctx , Object msg , ChannelPromise promise) throws Exception { System.out.println("响应处理器2"); ByteBuf byteMsg = (ByteBuf) msg; byteMsg.writeBytes("增加请求2的内容".getBytes(Charset.forName("gb2312"))); super.write(ctx,msg,promise); } }
4.检验
可以使用调试器来调试请求，例如网络调试助手
我们一共创建了四个Handler 且类型以及顺序为 in1 → out1 →in2 →out2 ，按照netty的定义。可实验如下
4.1 in1中调用ChannelHandlerContext(只会调用其之前的handler)的方法则out1，out2都不会调用，in1中调用Channel(所有都会调用)的方法则会out1,out2都调用
我们将in1 read方法内容改为如下
@Override public void channelRead(ChannelHandlerContext ctx , Object msg) throws Exception { System.out.println("请求处理器1"); ctx.writeAndFlush(Unpooled.copiedBuffer("hello word1" , Charset.forName("gb2312"))); super.channelRead(ctx,msg); }
in2 read方法改为如下
public void channelRead(ChannelHandlerContext ctx , Object msg) throws Exception { System.out.println("请求处理器2"); super.channelRead(ctx,msg); }
使用网络调试后发现控制台打印如下 并没有经过out1和out2
而网络调试控制台打印如下 ，我们只接收到了hello word原始内容
然后将in1中的ChannelHandlerContext改为Channel后则控制台和网络调试控制台打印分别如下
public void channelRead(ChannelHandlerContext ctx , Object msg) throws Exception { System.out.println("请求处理器1"); ctx.channel().writeAndFlush(Unpooled.copiedBuffer("hello word1" , Charset.forName("gb2312"))); super.channelRead(ctx,msg); }
控制台中两次响应的处理已经打印，并且返回内容已经被分别加上out处理器中的信息
4.2 in2中调用ChannelHandlerContext(只会调用其之前的handler)的方法则out1会调用，out2不会调用，in2中调用Channel(所有都会调用)的方法则会out1,out2都调用
这儿我们将in1 与in2稍作修改
in1 read方法改为如下
public void channelRead(ChannelHandlerContext ctx , Object msg) throws Exception { System.out.println("请求处理器1"); super.channelRead(ctx,msg); }
in2 read方法改为如下
public void channelRead(ChannelHandlerContext ctx , Object msg) throws Exception { System.out.println("请求处理器2"); ctx.writeAndFlush(Unpooled.copiedBuffer("hello word2" , Charset.forName("gb2312"))); super.channelRead(ctx,msg); }
使用网络调试工具访问后控制台和网络调试控制台分别打印如下
可以发现idea控制台只打印了out1 网络调试控制台也只增加了请求1的内容。
至于将ChannelHandlerContext则和4.1中效果一致，out1和out2都会执行，这儿就不在写了
5.源码简略分析
通过上面的案例应该就很明确这两者的差别了，我们这儿可以简要看下源码步骤。
5.1 pipeline.addLast()
上面我们通过socketChannel.pipeline().addLast 添加了我们的Handler，顾名思义就是将我们的处理器添加到末尾(netty内部使用一个链表存储)。我们可以看下其源码
public final ChannelPipeline addLast(EventExecutorGroup executor, ChannelHandler... handlers) { ObjectUtil.checkNotNull(handlers, "handlers"); for (ChannelHandler h: handlers) { if (h == null) { break; } addLast(executor, null, h); } return this; }
上面循环是可能传入多个，根据这个可以得知，我们传入多个的时候也是根据参数顺序来的。我们可以接着看addLast(executor,null,h)方法。
public final ChannelPipeline addLast(EventExecutorGroup group, String name, ChannelHandler handler) { final AbstractChannelHandlerContext newCtx; synchronized (this) { checkMultiplicity(handler); newCtx = newContext(group, filterName(name, handler), handler); addLast0(newCtx); .... } callHandlerAdded0(newCtx); return this; }
这儿就是将我们传入的handler包装了成了一个AbstractChannelHandlerContext (数据类型是一个双向链表)，然后执行了addLast0方法。
private void addLast0(AbstractChannelHandlerContext newCtx) { AbstractChannelHandlerContext prev = tail.prev; newCtx.prev = prev; newCtx.next = tail; prev.next = newCtx; tail.prev = newCtx; }
这儿的代码就比较简单，就是将当前的handler插入到tail节点与倒数第二个节点之间。这样当前的handler就成为了倒数第二个节点，以后每加一个handler都会成为新的倒数第2个节点。这儿注意tail节点由一个专门的TailContext维护。
既然处理器已经添加，我们就可以看下其如何工作的吧
5.2 ChannelHandlerContext.writeAndFlush方法
private void write(Object msg, boolean flush, ChannelPromise promise) { //注意flush为true ........ final AbstractChannelHandlerContext next = findContextOutbound(flush ? (MASK_WRITE | MASK_FLUSH) : MASK_WRITE); final Object m = pipeline.touch(msg, next); EventExecutor executor = next.executor(); if (executor.inEventLoop()) { if (flush) { next.invokeWriteAndFlush(m, promise); } else { next.invokeWrite(m, promise); } } else { ....... } }
这里面的逻辑可以发现主要分为两步，第一步找到下一个执行的handler，第二部执行这个handler的write方法。我们主要看下查找next的方法，即这个findContextOutbound()方法，点进去看下
private AbstractChannelHandlerContext findContextOutbound(int mask) { AbstractChannelHandlerContext ctx = this; do { ctx = ctx.prev; } while ((ctx.executionMask & mask) == 0); return ctx; }
可以看到 这里面会不断的查找当前handlerContext的前一个满足写操作的handler。找到满足的后就会返回。
比如我们现在有个handler链是这样的head→in1→out1→in2→out2→in3→out3→tail 。我们在in3中写入，那in3的pre就是out2，如果满足条件就会将out2返回，不满足就会→in2→out1→in1这样不断往前查找
5.3Channel.writeAndFlush方法
这个方法根据上面的结论会从handler链的tail开始调用，其实这个也很好理解，上面的ChannelHanderContext本身就是链表结构，所以支持查找当前的节点的前后节点。而这个Channel并不是链表结构，所以只能从tail开始一个一个找了。
@Override public final ChannelFuture writeAndFlush(Object msg) { return tail.writeAndFlush(msg); }
这里面调用的tail的write方法，我们看下tail
final AbstractChannelHandlerContext tail;
这就是5.2中我们说的tail节点，那最终会调用的也就是5.2中的write方法，只是这个this从当前的channelContextHandler变为了tail
