在深入分析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<SocketChannel>(){ //为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();
}
}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();
}
});
}
}
代码首先创建了一个ByteBuf，然后再将aaa写入到buffer里面，然后再发送buf，那是因为NioSocketChannel是基于byte的，因此它的unsafe对象也是基于byte的。。。。
先看看pipeline的write方法：（defaultchannelpipeline）
//从尾handler的context的write方法
public ChannelFuture write(Object message) {
return tail.write(message);
}好了，接下来看context的write方法：（defaultchannelhandlercontext）
//调用write方法，并将创建的promise返回
public ChannelFuture write(Object message) {
return write(message, newPromise());
} @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;
}//将数据写入到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);
} //将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();
}
}
好了，那么接下来我们来看看headhandler的flush方法，由于NioSocketChannel是基于byte的，所以我们也看基于byte的headhandler的flush方法吧：
@Override
public void flush(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {
int discardedMessages = 0;
MessageBuf<Object> in = msgSink;
for (;;) {
//这里也是存在一定的可能性将要发送的数据写到了msgbuf中去
Object m = in.poll();
if (m == null) {
break;
}
if (m instanceof ByteBuf) {
ByteBuf src = (ByteBuf) m;
//将数据提取出来，并写到bytebuf中去
byteSink.writeBytes(src, src.readerIndex(), src.readableBytes());
} else {
logger.debug(
"Discarded outbound message {} that reached at the head of the pipeline. " +
"Please check your pipeline configuration.", m);
discardedMessages ++;
}
BufUtil.release(m);
}
if (discardedMessages != 0) {
logger.warn(
"Discarded {} outbound message(s) that reached at the head of the pipeline. " +
"Please check your pipeline configuration.", discardedMessages);
}
//其实最终还是调用usafe的flush来写数据
unsafe.flush(promise);
}
} @Override
//具体的将缓冲区的数据flush
public void flush(final ChannelPromise promise) {
if (eventLoop().inEventLoop()) {
//如果已经有需要flush的任务了，那么将flush的任务挂起就好了
FlushTask task = flushTaskInProgress;
if (task != null) {
// loop over the tasks to find the last one
for (;;) {
FlushTask t = task.next;
if (t == null) {
break;
}
task = t.next;
}
task.next = new FlushTask(null, promise);
return;
}
//here
//调用这个方法
flushNotifierAndFlush(promise);
} else {
eventLoop().execute(new Runnable() {
@Override
public void run() {
flush(promise);
}
});
}
} private void flushNotifierAndFlush(ChannelPromise promise) {
flushNotifier(promise);
//调用flush0方法来将数据发送数据
flush0();
} private void flush0() {
if (!inFlushNow) { // Avoid re-entrance
try {
// Flush immediately only when there's no pending flush.
// If there's a pending flush operation, event loop will call flushNow() later,
// and thus there's no need to call it now.
if (!isFlushPending()) {
//调用flushnow方法将数据flush出去
flushNow();
}
} catch (Throwable t) {
flushFutureNotifier.notifyFlushFutures(t);
if (t instanceof IOException) {
close(voidFuture());
}
}
} else {
//执行flush的任务队列
if (!flushNowPending) {
flushNowPending = true;
eventLoop().execute(flushLaterTask);
}
}
} @Override
public final void flushNow() {
if (inFlushNow || flushTaskInProgress != null) {
return;
}
inFlushNow = true;
//here
//获取headhandler的context，也就是pipeline里面自定义的那个，是outboundhandler，从他那里来获取outbuf，也就是要发送的数据
ChannelHandlerContext ctx = headContext();
Throwable cause = null;
try {
if (metadata().bufferType() == BufType.BYTE) {
ByteBuf out = ctx.outboundByteBuffer();
int oldSize = out.readableBytes(); //本身需要发送的数据量
try {
//这个方法延后到了子类中显示
doFlushByteBuffer(out);
} catch (Throwable t) {
cause = t;
} finally {
int delta = oldSize - out.readableBytes(); //这里就相当于是已经发送了的数据量
out.discardSomeReadBytes();
flushFutureNotifier.increaseWriteCounter(delta);
}
} else {
MessageBuf<Object> out = ctx.outboundMessageBuffer();
int oldSize = out.size();
try {
doFlushMessageBuffer(out);
} catch (Throwable t) {
cause = t;
} finally {
flushFutureNotifier.increaseWriteCounter(oldSize - out.size());
}
}
if (cause == null) {
flushFutureNotifier.notifyFlushFutures();
} else {
flushFutureNotifier.notifyFlushFutures(cause);
if (cause instanceof IOException) {
close(voidFuture());
}
}
} finally {
inFlushNow = false;
}
} //用于向channel中写数据
protected void doFlushByteBuffer(ByteBuf buf) throws Exception {
for (int i = config().getWriteSpinCount() - 1; i >= 0; i --) {
//其实是调用doWriteBytes来写数据，这个方法延后到了后来的类中
int localFlushedAmount = doWriteBytes(buf, i == 0);
if (localFlushedAmount > 0) {
break;
}
if (!buf.isReadable()) {
// Reset reader/writerIndex to 0 if the buffer is empty.
buf.clear();
break;
}
}
}//写数据到channel里面，将buf里面的数据发送出去
protected int doWriteBytes(ByteBuf buf, boolean lastSpin) throws Exception {
final int expectedWrittenBytes = buf.readableBytes(); //相当于是需要发送的数据
final int writtenBytes = buf.readBytes(javaChannel(), expectedWrittenBytes); //这里就是真正的发送数据
final SelectionKey key = selectionKey(); //获取selectionkey
final int interestOps = key.interestOps(); //获取当前channel挂起的事件
if (writtenBytes >= expectedWrittenBytes) {
//如果想要发送的数据都已经发送完了，那么可以更新感兴趣的事件了，将write事件去除
// Wrote the outbound buffer completely - clear OP_WRITE.
if ((interestOps & SelectionKey.OP_WRITE) != 0) {
key.interestOps(interestOps & ~SelectionKey.OP_WRITE);
}
} else {
// Wrote something or nothing.
// a) If wrote something, the caller will not retry.
// - Set OP_WRITE so that the event loop calls flushForcibly() later.
// b) If wrote nothing:
// 1) If 'lastSpin' is false, the caller will call this method again real soon.
// - Do not update OP_WRITE.
// 2) If 'lastSpin' is true, the caller will not retry.
// - Set OP_WRITE so that the event loop calls flushForcibly() later.
//如果没有发送完数据，那么需要挂起写事件
if (writtenBytes > 0 || lastSpin) {
if ((interestOps & SelectionKey.OP_WRITE) == 0) {
key.interestOps(interestOps | SelectionKey.OP_WRITE);
}
}
}
return writtenBytes;
}好了，上面的代码还是很简单额，基本一看就能看明白，那么这个发送的流程也就走完了。。。
够长的。。感觉写的也不够仔细。。就这样吧。。
接下来可以看serverbootstrap的流程了。。。。
扫一扫
296
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
