Netty（六）:NioServerSocketChannel源码解析
我们在Netty学习系列五的最后提出了一些问题还没得到回答，今天来通过学习NioServerSocketChannel的源码来帮我们找到之前问题的答案。
先看一下NioServerSocketChannel的继承结构。
AttributeMap接口及DefaultAttributeMap主要是提供了体检属性和获取属性的能力，便于我们为Channel绑定额外的属性。
AbstractChannel实现了Channel接口，实现了Channel通用的行为和方法，我们在Netty学习系列四中已经介绍过了。
AbstractNioChannel抽象类关联了Channel接口与JDK的NIOChannel，也就是让底层的通信交给Nio来实现。
简单介绍下源码：
1 public abstract class AbstractNioChannel extends AbstractChannel { 2 3 private static final InternalLogger logger = 4 InternalLoggerFactory.getInstance(AbstractNioChannel.class); 5 6 private static final ClosedChannelException DO_CLOSE_CLOSED_CHANNEL_EXCEPTION = ThrowableUtil.unknownStackTrace( 7 new ClosedChannelException(), AbstractNioChannel.class, "doClose()"); 8 9 //和Java NIO的Channel绑定 10 private final SelectableChannel ch; 11 //为SelectableChannel注册的时间 12 protected final int readInterestOp; 13 volatile SelectionKey selectionKey; 14 15 boolean readPending; 16 17 private final Runnable clearReadPendingRunnable = new Runnable() { 18 @Override 19 public void run() { 20 clearReadPending0(); 21 } 22 }; 23 24 /** 25 * The future of the current connection attempt. If not null, subsequent 26 * connection attempts will fail. 27 */ 28 private ChannelPromise connectPromise; 29 private ScheduledFuture<?> connectTimeoutFuture; 30 private SocketAddress requestedRemoteAddress; 31 32 //构造函数，参数分别为父Channel，要封装的SelectableChannel和注册的感兴趣的事件 33 protected AbstractNioChannel(Channel parent, SelectableChannel ch, int readInterestOp) { 34 super(parent); 35 this.ch = ch; 36 this.readInterestOp = readInterestOp; 37 try { 38 //将SelectableChannel设置为非阻塞 39 ch.configureBlocking(false); 40 } catch (IOException e) { 41 try { 42 ch.close(); 43 } catch (IOException e2) { 44 if (logger.isWarnEnabled()) { 45 logger.warn( 46 "Failed to close a partially initialized socket.", e2); 47 } 48 } 49 50 throw new ChannelException("Failed to enter non-blocking mode.", e); 51 } 52 } 53 54 //通道是否打开 55 @Override 56 public boolean isOpen() { 57 return ch.isOpen(); 58 } 59 60 //返回更具体的Unsafe子类 61 @Override 62 public NioUnsafe unsafe() { 63 return (NioUnsafe) super.unsafe(); 64 } 65 66 //返回内部封装的SelectableChannel 67 protected SelectableChannel javaChannel() { 68 return ch; 69 } 70 71 //返回EventLoop更具体的子类 72 @Override 73 public NioEventLoop eventLoop() { 74 return (NioEventLoop) super.eventLoop(); 75 } 76 77 //返回SelectionKey 78 protected SelectionKey selectionKey() { 79 assert selectionKey != null; 80 return selectionKey; 81 } 82 83 //已废弃方法 84 @Deprecated 85 protected boolean isReadPending() { 86 return readPending; 87 } 88 89 //已废弃方法 90 @Deprecated 91 protected void setReadPending(final boolean readPending) { 92 if (isRegistered()) { 93 EventLoop eventLoop = eventLoop(); 94 if (eventLoop.inEventLoop()) { 95 setReadPending0(readPending); 96 } else { 97 eventLoop.execute(new Runnable() { 98 @Override 99 public void run() { 100 setReadPending0(readPending); 101 } 102 }); 103 } 104 } else { 105 // Best effort if we are not registered yet clear readPending. 106 // NB: We only set the boolean field instead of calling clearReadPending0(), because the SelectionKey is 107 // not set yet so it would produce an assertion failure. 108 this.readPending = readPending; 109 } 110 } 111 112 /** 113 * Set read pending to {@code false}. 114 */ 115 protected final void clearReadPending() { 116 if (isRegistered()) { 117 EventLoop eventLoop = eventLoop(); 118 if (eventLoop.inEventLoop()) { 119 clearReadPending0(); 120 } else { 121 eventLoop.execute(clearReadPendingRunnable); 122 } 123 } else { 124 // Best effort if we are not registered yet clear readPending. This happens during channel initialization. 125 // NB: We only set the boolean field instead of calling clearReadPending0(), because the SelectionKey is 126 // not set yet so it would produce an assertion failure. 127 readPending = false; 128 } 129 } 130 131 private void setReadPending0(boolean readPending) { 132 this.readPending = readPending; 133 if (!readPending) { 134 ((AbstractNioUnsafe) unsafe()).removeReadOp(); 135 } 136 } 137 138 private void clearReadPending0() { 139 readPending = false; 140 ((AbstractNioUnsafe) unsafe()).removeReadOp(); 141 } 142 143 //Unsafe的具体子类，增加了一些和NioChannel相关的特性 144 public interface NioUnsafe extends Unsafe { 145 //返回内部的SelectableChannel 146 SelectableChannel ch(); 147 148 //连接完成 149 void finishConnect(); 150 151 //读方法 152 void read(); 153 154 //强制刷新 155 void forceFlush(); 156 } 157 158 //NioUnsafe的抽象实现 159 protected abstract class AbstractNioUnsafe extends AbstractUnsafe implements NioUnsafe { 160 161 protected final void removeReadOp() { 162 SelectionKey key = selectionKey(); 163 // Check first if the key is still valid as it may be canceled as part of the deregistration 164 // from the EventLoop 165 // See https://github.com/netty/netty/issues/2104 166 if (!key.isValid()) { 167 return; 168 } 169 int interestOps = key.interestOps(); 170 if ((interestOps & readInterestOp) != 0) { 171 // only remove readInterestOp if needed 172 key.interestOps(interestOps & ~readInterestOp); 173 } 174 } 175 176 //返回内部封装的Channel 177 @Override 178 public final SelectableChannel ch() { 179 return javaChannel(); 180 } 181 182 //connect方法，实际在使用时NioServerSocket是不支持connect的，但是NioSocket会支持 183 @Override 184 public final void connect( 185 final SocketAddress remoteAddress, final SocketAddress localAddress, final ChannelPromise promise) { 186 if (!promise.setUncancellable() || !ensureOpen(promise)) { 187 return; 188 } 189 190 try { 191 if (connectPromise != null) { 192 // Already a connect in process. 193 throw new ConnectionPendingException(); 194 } 195 196 boolean wasActive = isActive(); 197 //调用具体子类的doConnect方法 198 if (doConnect(remoteAddress, localAddress)) { 199 //连接成功设置fulfillConnectPromise 200 fulfillConnectPromise(promise, wasActive); 201 } else { 202 //连接未成功 203 connectPromise = promise; 204 requestedRemoteAddress = remoteAddress; 205 206 //根据配置的超时时间，设置超时任务，一旦到达超时时间则抛出连接失败的异常 207 int connectTimeoutMillis = config().getConnectTimeoutMillis(); 208 if (connectTimeoutMillis > 0) { 209 connectTimeoutFuture = eventLoop().schedule(new Runnable() { 210 @Override 211 public void run() { 212 ChannelPromise connectPromise = AbstractNioChannel.this.connectPromise; 213 ConnectTimeoutException cause = 214 new ConnectTimeoutException("connection timed out: " + remoteAddress); 215 if (connectPromise != null && connectPromise.tryFailure(cause)) { 216 close(voidPromise()); 217 } 218 } 219 }, connectTimeoutMillis, TimeUnit.MILLISECONDS); 220 } 221 222 //添加监听器，如果期间操作成功了，则取消掉超超时任务 223 promise.addListener(new ChannelFutureListener() { 224 @Override 225 public void operationComplete(ChannelFuture future) throws Exception { 226 if (future.isCancelled()) { 227 if (connectTimeoutFuture != null) { 228 connectTimeoutFuture.cancel(false); 229 } 230 connectPromise = null; 231 close(voidPromise()); 232 } 233 } 234 }); 235 } 236 } catch (Throwable t) { 237 //运行出现异常，则设置Promise为失败 238 promise.tryFailure(annotateConnectException(t, remoteAddress)); 239 closeIfClosed(); 240 } 241 } 242 243 private void fulfillConnectPromise(ChannelPromise promise, boolean wasActive) { 244 if (promise == null) { 245 // Closed via cancellation and the promise has been notified already. 246 return; 247 } 248 249 // Get the state as trySuccess() may trigger an ChannelFutureListener that will close the Channel. 250 // We still need to ensure we call fireChannelActive() in this case. 251 boolean active = isActive(); 252 253 // trySuccess() will return false if a user cancelled the connection attempt. 254 boolean promiseSet = promise.trySuccess(); 255 256 257 //active状态发生改变，现在已经连接成功 258 if (!wasActive && active) { 259 //pipeline产生Active事件在通道中流传 260 pipeline().fireChannelActive(); 261 } 262 263 // If a user cancelled the connection attempt, close the channel, which is followed by channelInactive(). 264 if (!promiseSet) { 265 close(voidPromise()); 266 } 267 } 268 269 private void fulfillConnectPromise(ChannelPromise promise, Throwable cause) { 270 if (promise == null) { 271 // Closed via cancellation and the promise has been notified already. 272 return; 273 } 274 275 // Use tryFailure() instead of setFailure() to avoid the race against cancel(). 276 promise.tryFailure(cause); 277 closeIfClosed(); 278 } 279 280 //连接完成，该方法会在连接成功后，由EventLoop调用 281 @Override 282 public final void finishConnect() { 283 284 assert eventLoop().inEventLoop(); 285 286 try { 287 boolean wasActive = isActive(); 288 doFinishConnect(); 289 fulfillConnectPromise(connectPromise, wasActive); 290 } catch (Throwable t) { 291 fulfillConnectPromise(connectPromise, annotateConnectException(t, requestedRemoteAddress)); 292 } finally { 293 // Check for null as the connectTimeoutFuture is only created if a connectTimeoutMillis > 0 is used 294 // See https://github.com/netty/netty/issues/1770 295 if (connectTimeoutFuture != null) { 296 connectTimeoutFuture.cancel(false); 297 } 298 connectPromise = null; 299 } 300 } 301 302 @Override 303 protected final void flush0() { 304 // Flush immediately only when there's no pending flush. 305 // If there's a pending flush operation, event loop will call forceFlush() later, 306 // and thus there's no need to call it now. 307 if (!isFlushPending()) { 308 super.flush0(); 309 } 310 } 311 312 @Override 313 public final void forceFlush() { 314 // directly call super.flush0() to force a flush now 315 super.flush0(); 316 } 317 318 private boolean isFlushPending() { 319 SelectionKey selectionKey = selectionKey(); 320 return selectionKey.isValid() && (selectionKey.interestOps() & SelectionKey.OP_WRITE) != 0; 321 } 322 } 323 324 //判断EventLoop和Channel是否匹配 325 @Override 326 protected boolean isCompatible(EventLoop loop) { 327 return loop instanceof NioEventLoop; 328 } 329 330 //注册 331 @Override 332 protected void doRegister() throws Exception { 333 boolean selected = false; 334 for (;;) { 335 try { 336 //让内部的javaChannel先注册的interestOps为0 337 selectionKey = javaChannel().register(eventLoop().unwrappedSelector(), 0, this); 338 return; 339 } catch (CancelledKeyException e) { 340 if (!selected) { 341 // Force the Selector to select now as the "canceled" SelectionKey may still be 342 // cached and not removed because no Select.select(..) operation was called yet. 343 eventLoop().selectNow(); 344 selected = true; 345 } else { 346 // We forced a select operation on the selector before but the SelectionKey is still cached 347 // for whatever reason. JDK bug ? 348 throw e; 349 } 350 } 351 } 352 } 353 354 @Override 355 protected void doDeregister() throws Exception { 356 eventLoop().cancel(selectionKey()); 357 } 358 359 //doBeginRead由read方法调用 360 @Override 361 protected void doBeginRead() throws Exception { 362 final SelectionKey selectionKey = this.selectionKey; 363 if (!selectionKey.isValid()) { 364 return; 365 } 366 367 readPending = true; 368 //重新注册感兴趣的事件 369 final int interestOps = selectionKey.interestOps(); 370 if ((interestOps & readInterestOp) == 0) { 371 selectionKey.interestOps(interestOps | readInterestOp); 372 } 373 } 374 375 /** 376 * Connect to the remote peer 377 */ 378 protected abstract boolean doConnect(SocketAddress remoteAddress, SocketAddress localAddress) throws Exception; 379 380 /** 381 * Finish the connect 382 */ 383 protected abstract void doFinishConnect() throws Exception; 384 385 //分配直接内存 386 protected final ByteBuf newDirectBuffer(ByteBuf buf) { 387 final int readableBytes = buf.readableBytes(); 388 if (readableBytes == 0) { 389 ReferenceCountUtil.safeRelease(buf); 390 return Unpooled.EMPTY_BUFFER; 391 } 392 393 final ByteBufAllocator alloc = alloc(); 394 if (alloc.isDirectBufferPooled()) { 395 ByteBuf directBuf = alloc.directBuffer(readableBytes); 396 directBuf.writeBytes(buf, buf.readerIndex(), readableBytes); 397 ReferenceCountUtil.safeRelease(buf); 398 return directBuf; 399 } 400 401 final ByteBuf directBuf = ByteBufUtil.threadLocalDirectBuffer(); 402 if (directBuf != null) { 403 directBuf.writeBytes(buf, buf.readerIndex(), readableBytes); 404 ReferenceCountUtil.safeRelease(buf); 405 return directBuf; 406 } 407 408 // Allocating and deallocating an unpooled direct buffer is very expensive; give up. 409 return buf; 410 } 411 412 //分配直接内存 413 protected final ByteBuf newDirectBuffer(ReferenceCounted holder, ByteBuf buf) { 414 final int readableBytes = buf.readableBytes(); 415 if (readableBytes == 0) { 416 ReferenceCountUtil.safeRelease(holder); 417 return Unpooled.EMPTY_BUFFER; 418 } 419 420 final ByteBufAllocator alloc = alloc(); 421 if (alloc.isDirectBufferPooled()) { 422 ByteBuf directBuf = alloc.directBuffer(readableBytes); 423 directBuf.writeBytes(buf, buf.readerIndex(), readableBytes); 424 ReferenceCountUtil.safeRelease(holder); 425 return directBuf; 426 } 427 428 final ByteBuf directBuf = ByteBufUtil.threadLocalDirectBuffer(); 429 if (directBuf != null) { 430 directBuf.writeBytes(buf, buf.readerIndex(), readableBytes); 431 ReferenceCountUtil.safeRelease(holder); 432 return directBuf; 433 } 434 435 // Allocating and deallocating an unpooled direct buffer is very expensive; give up. 436 if (holder != buf) { 437 // Ensure to call holder.release() to give the holder a chance to release other resources than its content. 438 buf.retain(); 439 ReferenceCountUtil.safeRelease(holder); 440 } 441 442 return buf; 443 } 444 445 //关闭方法 446 @Override 447 protected void doClose() throws Exception { 448 ChannelPromise promise = connectPromise; 449 if (promise != null) { 450 // Use tryFailure() instead of setFailure() to avoid the race against cancel(). 451 promise.tryFailure(DO_CLOSE_CLOSED_CHANNEL_EXCEPTION); 452 connectPromise = null; 453 } 454 455 ScheduledFuture<?> future = connectTimeoutFuture; 456 if (future != null) { 457 future.cancel(false); 458 connectTimeoutFuture = null; 459 } 460 } 461 }
AbstractNioChannel又有两个子类，分别是AbstractNioMessageChannel和AbstractNioByteChannel。两者的区别是前者的通道中封装处理的是Object，而后者的通道中封装处理的是ByteBuf（或FileRegion）。
对于NioServerSocketChannel而言，需要处理的是NioSocketChannel。因此它集成了AbstractNioMessageChannel。
AbstractNioMessageChannel源码：
1 public abstract class AbstractNioMessageChannel extends AbstractNioChannel { 2 boolean inputShutdown; 3 4 //构造函数 5 protected AbstractNioMessageChannel(Channel parent, SelectableChannel ch, int readInterestOp) { 6 //设置父Channel, 内部封装的JDKchannel和注册interestOp 7 super(parent, ch, readInterestOp); 8 } 9 10 //返回Unsafe对象 11 @Override 12 protected AbstractNioUnsafe newUnsafe() { 13 return new NioMessageUnsafe(); 14 } 15 16 //读 17 @Override 18 protected void doBeginRead() throws Exception { 19 if (inputShutdown) { 20 return; 21 } 22 super.doBeginRead(); 23 } 24 25 //AbstractNioUnsafe对象的 26 private final class NioMessageUnsafe extends AbstractNioUnsafe { 27 28 private final List<Object> readBuf = new ArrayList<Object>(); 29 30 @Override 31 public void read() { 32 assert eventLoop().inEventLoop(); 33 final ChannelConfig config = config(); 34 final ChannelPipeline pipeline = pipeline(); 35 final RecvByteBufAllocator.Handle allocHandle = unsafe().recvBufAllocHandle(); 36 allocHandle.reset(config); 37 38 boolean closed = false; 39 Throwable exception = null; 40 41 42 try { 43 try { 44 //开始读操作，主要是调用子类的doReadMessages实现，从SelectableChannel中读取数据，并封装到readBuf 45 do { 46 int localRead = doReadMessages(readBuf); 47 if (localRead == 0) { 48 break; 49 } 50 if (localRead < 0) { 51 closed = true; 52 break; 53 } 54 55 allocHandle.incMessagesRead(localRead); 56 } while (allocHandle.continueReading()); 57 } catch (Throwable t) { 58 exception = t; 59 } 60 61 //将读到的readBuf通过pipline，在通道中流通，便于被通道中的Handler处理 62 int size = readBuf.size(); 63 for (int i = 0; i < size; i ++) { 64 readPending = false; 65 pipeline.fireChannelRead(readBuf.get(i)); 66 } 67 //清空 68 readBuf.clear(); 69 //读完成，产生readCompleate事件 70 allocHandle.readComplete(); 71 pipeline.fireChannelReadComplete(); 72 73 //如果有异常，则产生异常事件 74 if (exception != null) { 75 closed = closeOnReadError(exception); 76 77 pipeline.fireExceptionCaught(exception); 78 } 79 80 //如果被关闭，则调用关闭 81 if (closed) { 82 inputShutdown = true; 83 if (isOpen()) { 84 close(voidPromise()); 85 } 86 } 87 } finally { 88 // Check if there is a readPending which was not processed yet. 89 // This could be for two reasons: 90 // * The user called Channel.read() or ChannelHandlerContext.read() in channelRead(...) method 91 // * The user called Channel.read() or ChannelHandlerContext.read() in channelReadComplete(...) method 92 // 93 // See https://github.com/netty/netty/issues/2254 94 if (!readPending && !config.isAutoRead()) { 95 removeReadOp(); 96 } 97 } 98 } 99 } 100 101 102 103 //写操作，NioServerSocketChannel不支持写 104 @Override 105 protected void doWrite(ChannelOutboundBuffer in) throws Exception { 106 final SelectionKey key = selectionKey(); 107 final int interestOps = key.interestOps(); 108 109 for (;;) { 110 Object msg = in.current(); 111 if (msg == null) { 112 //如果注册了写事件，则移除写事件 113 if ((interestOps & SelectionKey.OP_WRITE) != 0) { 114 key.interestOps(interestOps & ~SelectionKey.OP_WRITE); 115 } 116 break; 117 } 118 try { 119 boolean done = false; 120 for (int i = config().getWriteSpinCount() - 1; i >= 0; i--) { 121 //具体的写操作交给子类实现（NioServerSocketChannel不支持写操作） 122 if (doWriteMessage(msg, in)) { 123 done = true; 124 break; 125 } 126 } 127 128 if (done) { 129 in.remove(); 130 } else { 131 // Did not write all messages. 132 if ((interestOps & SelectionKey.OP_WRITE) == 0) { 133 key.interestOps(interestOps | SelectionKey.OP_WRITE); 134 } 135 break; 136 } 137 } catch (Exception e) { 138 if (continueOnWriteError()) { 139 in.remove(e); 140 } else { 141 throw e; 142 } 143 } 144 } 145 } 146 147 /** 148 * Returns {@code true} if we should continue the write loop on a write error. 149 */ 150 protected boolean continueOnWriteError() { 151 return false; 152 } 153 154 155 protected boolean closeOnReadError(Throwable cause) { 156 if (!isActive()) { 157 // If the channel is not active anymore for whatever reason we should not try to continue reading. 158 return true; 159 } 160 if (cause instanceof PortUnreachableException) { 161 return false; 162 } 163 if (cause instanceof IOException) { 164 // ServerChannel should not be closed even on IOException because it can often continue 165 // accepting incoming connections. (e.g. too many open files) 166 return !(this instanceof ServerChannel); 167 } 168 return true; 169 } 170 171 //读和写的具体操作交给子类去实现 172 protected abstract int doReadMessages(List<Object> buf) throws Exception; 173 174 protected abstract boolean doWriteMessage(Object msg, ChannelOutboundBuffer in) throws Exception; 175 }
最后来看NioServerSocketChannel源码：
1 public class NioServerSocketChannel extends AbstractNioMessageChannel 2 implements io.netty.channel.socket.ServerSocketChannel { 3 4 private static final ChannelMetadata METADATA = new ChannelMetadata(false, 16); 5 private static final SelectorProvider DEFAULT_SELECTOR_PROVIDER = SelectorProvider.provider(); 6 7 private static final InternalLogger logger = InternalLoggerFactory.getInstance(NioServerSocketChannel.class); 8 9 //产生NIOServerSocketChannel的方法 10 private static ServerSocketChannel newSocket(SelectorProvider provider) { 11 try { 12 /** 13 * Use the {@link SelectorProvider} to open {@link SocketChannel} and so remove condition in 14 * {@link SelectorProvider#provider()} which is called by each ServerSocketChannel.open() otherwise. 15 * 16 * See <a href="https://github.com/netty/netty/issues/2308">#2308</a>. 17 */ 18 return provider.openServerSocketChannel(); 19 } catch (IOException e) { 20 throw new ChannelException( 21 "Failed to open a server socket.", e); 22 } 23 } 24 25 private final ServerSocketChannelConfig config; 26 27 //默认构造函数, ReflectivaChannelFactory利用反射创建Channel时，即是调用了这个方法 28 public NioServerSocketChannel() { 29 this(newSocket(DEFAULT_SELECTOR_PROVIDER)); 30 } 31 32 /** 33 * Create a new instance using the given {@link SelectorProvider}. 34 */ 35 public NioServerSocketChannel(SelectorProvider provider) { 36 this(newSocket(provider)); 37 } 38 39 //将NIO中的ServerSocketChannel封装成Netty的NioServerSocketChannel 40 public NioServerSocketChannel(ServerSocketChannel channel) { 41 //调用父类的构造函数，注意设置了interestOps为OP_ACCEPT 42 super(null, channel, SelectionKey.OP_ACCEPT); 43 //创建配置 44 config = new NioServerSocketChannelConfig(this, javaChannel().socket()); 45 } 46 47 //返回以太网地址 48 @Override 49 public InetSocketAddress localAddress() { 50 return (InetSocketAddress) super.localAddress(); 51 } 52 53 //返回元数据信息 54 @Override 55 public ChannelMetadata metadata() { 56 return METADATA; 57 } 58 59 //返回配置 60 @Override 61 public ServerSocketChannelConfig config() { 62 return config; 63 } 64 65 //Channel是否活跃 66 @Override 67 public boolean isActive() { 68 //通过socket的bound状态来确定是否为active 69 return javaChannel().socket().isBound(); 70 } 71 72 //返回远端地址，ServerSocketChannel没有对应的远端地址 73 @Override 74 public InetSocketAddress remoteAddress() { 75 return null; 76 } 77 78 //内部封装的JDK自带的Channel 79 @Override 80 protected ServerSocketChannel javaChannel() { 81 return (ServerSocketChannel) super.javaChannel(); 82 } 83 84 @Override 85 protected SocketAddress localAddress0() { 86 return SocketUtils.localSocketAddress(javaChannel().socket()); 87 } 88 89 //通过调用内部封装的JDK中的NIO channel来绑定地址 90 @Override 91 protected void doBind(SocketAddress localAddress) throws Exception { 92 if (PlatformDependent.javaVersion() >= 7) { 93 javaChannel().bind(localAddress, config.getBacklog()); 94 } else { 95 javaChannel().socket().bind(localAddress, config.getBacklog()); 96 } 97 } 98 99 //关闭通道 100 @Override 101 protected void doClose() throws Exception { 102 javaChannel().close(); 103 } 104 105 //读消息 106 @Override 107 protected int doReadMessages(List<Object> buf) throws Exception { 108 //其实就是调用ServerSocketChannel的accept方法监听accept事件，返回SocketChannel 109 SocketChannel ch = SocketUtils.accept(javaChannel()); 110 111 try { 112 //将JDK NIO中的channel封装成Netty的NioSocketChannel对象，添加进buf中，使其在Pipeline中传递 113 if (ch != null) { 114 buf.add(new NioSocketChannel(this, ch)); 115 return 1;//返回数量 116 } 117 } catch (Throwable t) { 118 logger.warn("Failed to create a new channel from an accepted socket.", t); 119 120 try { 121 ch.close(); 122 } catch (Throwable t2) { 123 logger.warn("Failed to close a socket.", t2); 124 } 125 } 126 127 return 0; 128 } 129 130 //NIOServerSocketChannel不支持的部分操作 返回null 或者 UnsuppotedOperationException异常 131 @Override 132 protected boolean doConnect( 133 SocketAddress remoteAddress, SocketAddress localAddress) throws Exception { 134 throw new UnsupportedOperationException(); 135 } 136 137 @Override 138 protected void doFinishConnect() throws Exception { 139 throw new UnsupportedOperationException(); 140 } 141 142 @Override 143 protected SocketAddress remoteAddress0() { 144 return null; 145 } 146 147 @Override 148 protected void doDisconnect() throws Exception { 149 throw new UnsupportedOperationException(); 150 } 151 152 @Override 153 protected boolean doWriteMessage(Object msg, ChannelOutboundBuffer in) throws Exception { 154 throw new UnsupportedOperationException(); 155 } 156 157 @Override 158 protected final Object filterOutboundMessage(Object msg) throws Exception { 159 throw new UnsupportedOperationException(); 160 } 161 162 /********************************************************************/ 163 164 165 private final class NioServerSocketChannelConfig extends DefaultServerSocketChannelConfig { 166 private NioServerSocketChannelConfig(NioServerSocketChannel channel, ServerSocket javaSocket) { 167 super(channel, javaSocket); 168 } 169 170 @Override 171 protected void autoReadCleared() { 172 clearReadPending(); 173 } 174 } 175 176 // Override just to to be able to call directly via unit tests. 177 @Override 178 protected boolean closeOnReadError(Throwable cause) { 179 return super.closeOnReadError(cause); 180 } 181 }
分析完源码，再来看看上一篇文章中提出的问题：
为什么一开始register中注册的interestOps值为0，而非OP_ACCEPT？又是何时会注册OP_ACCEPT呢?
首先我们通过分析NioServerSocketChannel的源码可以看到:
channelFactory会通过发射创建NioServerSocketChannel对象。而发射调用的构造函数中设置了readInterestOps的值为OP_ACCEPT。而在AbstractNioChannel的doBeginRead方法中又会将readInterestOps注册到channel。
根据方法名我们可以猜测在开始读之前，selectableChannel的interestOps会从0被改为OP_ACCEPT。
为了证实这点，我们需要弄清楚开始时register interestOps为0的时机和调用doBeginRead的时机。
首先注册interestOps为0是在AbstractNioChannel的doRegister方法中。我们知道这个方法发生在channel的注册阶段。
再看doBeginRead的函数调用：
之前已经介绍过了注册或者绑定成功后，会调用pipeline.fireChannelActive事件。此时的DefaultChannelPipeline除了传递channelActive事件之外，还会调用readIfAutoRead()。
这个方法会根据Config配置的AutoRead属性来决定是否调用read方法。
而这个属性默认是自动读的。于是就可以调用read方法，并最终为channel注册OP_ACCEPT事件。
