java netty之一个write跟踪（数据发送）

在深入分析ServerBootstrap之前，先来跟踪一个write的过程吧，也就是数据发送的过程。。。。

先来看看这个例子的代码吧，server部分的初始化：

public class NettyServer {
	public void run() throws Exception {
		EventLoopGroup bossGroup = new NioEventLoopGroup();
		EventLoopGroup workerGroup = new NioEventLoopGroup();
		try {
			ServerBootstrap b = new ServerBootstrap();
			b.group(bossGroup, workerGroup);   //前者用来处理accept事件，后者用于处理已经建立的连接的io
			b.channel(NioServerSocketChannel.class);   //用它来建立新accept的连接，用于构造serversocketchannel的工厂类
			b.childHandler(new ChannelInitializer(){      //为accept的pipeline预添加的inboundhandler
				@Override     //当新连接accept的时候，这个方法会调用
				protected void initChannel(SocketChannel ch) throws Exception {
					// TODO Auto-generated method stub
					ch.pipeline().addLast(new MyChannelHandler());
				}
				
			});
			ChannelFuture f = b.bind(80).sync();    //在所有的网卡上监听这个端口
			f.channel().closeFuture().sync();
		} finally {
			bossGroup.shutdownGracefully();
			workerGroup.shutdownGracefully();
		}
	}
	
	public static void main(String args[]) throws Exception {
		new NettyServer().run();
	}
}

接下来是handler部分的代码：

public class MyChannelHandler extends ChannelInboundByteHandlerAdapter {

	@Override
	protected void inboundBufferUpdated(ChannelHandlerContext ctx, ByteBuf in)
			throws Exception {
		// TODO Auto-generated method stub
		//while (in.isReadable()) {
			//System.out.print((char)in.readByte());
		//}
		ByteBuf b = ctx.alloc().buffer();
		b.writeBytes("aaa".getBytes());
		ctx.pipeline().write(b);
		ctx.pipeline().flush().addListener(new ChannelFutureListener(){

			@Override
			public void operationComplete(ChannelFuture future)
					throws Exception {
				// TODO Auto-generated method stub
				future.channel().close().sync();
			}
		});	
	}
}

这个要实现的功能还是很简单的，当建立了连接并收到数据之后，向客户端发送aaa。。。好了，接下来我们来跟踪一下整个过程。。。。

代码首先创建了一个ByteBuf，然后再将aaa写入到buffer里面，然后再发送buf，那是因为NioSocketChannel是基于byte的，因此它的unsafe对象也是基于byte的。。。。

先看看pipeline的write方法：（defaultchannelpipeline）

    //从尾handler的context的write方法
    public ChannelFuture write(Object message) {
        return tail.write(message);
    }

这里调用的是tailhander的context的write方法，而tailhandler是一个inboundhandler，因此会向前寻找到第一个oubounhander来处理，在前面的文章也有提到过对于读取的数据，pipeline上面的处理流程是从head到tail，而对于发送出去的数据，则是从tail到head。

好了，接下来看context的write方法：（defaultchannelhandlercontext）

    //调用write方法，并将创建的promise返回
    public ChannelFuture write(Object message) {
        return write(message, newPromise());
    }

额，接着再来看这里调用的write方法吧：

    @Override
    public ChannelFuture write(final Object message, final ChannelPromise promise) {
        if (message instanceof FileRegion) {
        	//如果是fileregion的话，
            return sendFile((FileRegion) message, promise);
        }

        if (message == null) {
            throw new NullPointerException("message");
        }
        validateFuture(promise);

        DefaultChannelHandlerContext ctx = prev;
        EventExecutor executor;
        final boolean msgBuf;
//向上寻找到第一个有buf的outboundhandler
        if (message instanceof ByteBuf) {
        	//如果是bytebuf的类型，那么向上找到第一个有outbytebuffer的outboundhandler
            for (;;) {
                if (ctx.hasOutboundByteBuffer()) {
                	
                    msgBuf = false;   //表示不是msg，是byte
                    executor = ctx.executor();
                    break;
                }
//message的类型，基于byte的handler和基于message的handler都行，因为最终到了head都会处理，成为基于byte的
                if (ctx.hasOutboundMessageBuffer()) {
                	
                    msgBuf = true;  //
                    executor = ctx.executor();
                    break;
                }

                ctx = ctx.prev;
            }
        } else {
            msgBuf = true;
            for (;;) {
                if (ctx.hasOutboundMessageBuffer()) {
                    executor = ctx.executor();
                    break;
                }

                ctx = ctx.prev;
            }
        }
//调用刚刚找到的那个有outbuf的handler的context的write0方法
        if (executor.inEventLoop()) {
            ctx.write0(message, promise, msgBuf);
            return promise;
        }

        final DefaultChannelHandlerContext ctx0 = ctx;
        executor.execute(new Runnable() {
            @Override
            public void run() {
                ctx0.write0(message, promise, msgBuf);
            }
        });

        return promise;
    }

这部分代码就能很明显的看出是从tail向head方向寻找的吧。。。由于我们前期并没有定义outboundhandler，所以这里找到的将是pipeline上面默认的headhandler，好了，接下来来看write0方法吧：

//将数据写入到outbuf中，并调用flush方法
    private void write0(Object message, ChannelPromise promise, boolean msgBuf) {
        Channel channel = channel();
        //如果当前的channel并没有
        if (!channel.isRegistered() && !channel.isActive()) {
            promise.setFailure(new ClosedChannelException());
            return;
        }

        if (isOutboundFreed()) {
            promise.setFailure(new ChannelPipelineException(
                    "Unable to write as outbound buffer of next handler was freed already"));
            return;
        }
        if (msgBuf) {	    
        	//加入message
            outboundMessageBuffer().add(message);
        } else {
            ByteBuf buf = (ByteBuf) message;
            try {
            	//将要发送的数据写进outhandler
                outboundByteBuffer().writeBytes(buf, buf.readerIndex(), buf.readableBytes());
            } finally {
                buf.release();
            }
        }
        //flush操作，将缓冲区的数据发送出去
        invokeFlush0(promise);
    }

将数据写入到outbuf中去，然后最后调用invokeFlush0，好了这里来看看这个invokeFlush0f方法吧：

    //将buf里面的数据flush出去
    private void invokeFlush0(ChannelPromise promise) {
        if (isOutboundFreed()) {
            promise.setFailure(new ChannelPipelineException(
                    "Unable to flush as outbound buffer of next handler was freed already"));
            return;
        }

        Channel channel = channel();   //获取channel
        if (!channel.isActive() && !channel.isRegistered()) {
            promise.setFailure(new ClosedChannelException());
            return;
        }
//提取当前的context的handler，因为是outboundhandler，所以也是operationhandler
        ChannelOperationHandler handler = (ChannelOperationHandler) handler();
        if (handler instanceof ChannelOutboundHandler) {
        	//将bridge部分的数据flush，留在以后看
            flushOutboundBridge();
        }

        try {
        	//真实的调用poutboundhandler或者说operationhandler的flush方法，用于将数据发送出去
        	//其实是headhandler的话，其实就是调用其unsafe对象的flush方法，说白了也就是所属channel的unsafe对象的flush方法
            handler.flush(this, promise);
        } catch (Throwable t) {
            notifyHandlerException(t);
        } finally {
            if (handler instanceof ChannelOutboundByteHandler && !isOutboundFreed()) {
                try {
                    ((ChannelOutboundByteHandler) handler).discardOutboundReadBytes(this);
                } catch (Throwable t) {
                    notifyHandlerException(t);
                }
            }
            freeHandlerBuffersAfterRemoval();
        }
    }

代码还是很简单吧，说白了就是调用当前context的handler的flush方法，我们这里由于并没有定义自己的outboundhandler，所以这地调用的pipeline默认的headhandler的flush方法来将buf中的数据真正的发送出去。。

好了，那么接下来我们来看看headhandler的flush方法，由于NioSocketChannel是基于byte的，所以我们也看基于byte的headhandler的flush方法吧：

        @Override
        public void flush(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {
            int discardedMessages = 0;
            MessageBuf