Netty原理-新连接接入

新连接检测

BossGroup的 NioEventLoop 线程在启动后，会不停地去循环处理网络 IO 事件、普通任务和定时任务。在处理网络 IO 事件时，当轮询到 IO 事件类型为 OP_ACCEPT 时(如下代码所示)，就表示有新客户端来连接服务端了，也就是检测到了新连接。这个时候，服务端 channel 就会进行新连接的读取。

if ((readyOps & (SelectionKey.OP_READ | SelectionKey.OP_ACCEPT)) != 0 || readyOps == 0) {
    unsafe.read();
}

NioSocketChannel的创建

在NioMessageUnsafe类的doReadMessages进行消息的读取，服务端 channel 在监听到 OP_ACCEPT 事件后，会为新连接创建一个客户端 channel，后面数据的读写均是通过这个客户端 channel 来进行的，把它放到buf的list中

protected int doReadMessages(List<Object> buf) throws Exception {
    SocketChannel ch = SocketUtils.accept(javaChannel());

    try {
        if (ch != null) {
            buf.add(new NioSocketChannel(this, ch));
            return 1;
        }
    } 

通过责任链调用Handler，读数据

int size = readBuf.size();
for (int i = 0; i < size; i ++) {
    readPending = false;
    pipeline.fireChannelRead(readBuf.get(i));
}

新连接NioEventLoop和Selector注册

在ServerBootstrapAcceptor 中负责新连接的接入，在channelRead方法中，处理客户端的连接，

1. 设置客户端的Options属性

setChannelOptions(child, childOptions, logger);
setAttributes(child, childAttrs);

2. channel和客户端handler进行绑定

child.pipeline().addLast(childHandler);

3. 将客户端channel注册到工作线程池，即从workerGroup中选择出一个NioEventloop，再将客户端channel绑定到NioEventLoop上

childGroup.register(child).addListener(new ChannelFutureListener() {
    @Override
    public void operationComplete(ChannelFuture future) throws Exception {
        if (!future.isSuccess()) {
            forceClose(child, future.cause());
        }
    }
});

public void channelRead(ChannelHandlerContext ctx, Object msg) {
    final Channel child = (Channel) msg;

    child.pipeline().addLast(childHandler);

    setChannelOptions(child, childOptions, logger);
    setAttributes(child, childAttrs);

    try {
        childGroup.register(child).addListener(new ChannelFutureListener() {
            @Override
            public void operationComplete(ChannelFuture future) throws Exception {
                if (!future.isSuccess()) {
                    forceClose(child, future.cause());
                }
            }
        });
    } catch (Throwable t) {
        forceClose(child, t);
    }
}

将客户端 channel 与一个 NioEventLoop 进行了绑定，然后进行注册

AbstractChannel.this.eventLoop = eventLoop;

if (eventLoop.inEventLoop()) {
    register0(promise);
}

1. 执行注册

2. 调用handlerAdded方法

3. 如果是首次接入会调用channelActive方法

4. 设置可读状态为可读

5. 设置可读状态后再客户端的NioEventLoop的run方法中就可对消息进行读取

private void register0(ChannelPromise promise) {
    try {
        // check if the channel is still open as it could be closed in the mean time when the register
        // call was outside of the eventLoop
        if (!promise.setUncancellable() || !ensureOpen(promise)) {
            return;
        }
        boolean firstRegistration = neverRegistered;
        doRegister();
        neverRegistered = false;
        registered = true;

        // Ensure we call handlerAdded(...) before we actually notify the promise. This is needed as the
        // user may already fire events through the pipeline in the ChannelFutureListener.
        pipeline.invokeHandlerAddedIfNeeded();

        safeSetSuccess(promise);
        pipeline.fireChannelRegistered();
        // Only fire a channelActive if the channel has never been registered. This prevents firing
        // multiple channel actives if the channel is deregistered and re-registered.
        if (isActive()) {
            if (firstRegistration) {
                pipeline.fireChannelActive();
            } else if (config().isAutoRead()) {
                // This channel was registered before and autoRead() is set. This means we need to begin read
                // again so that we process inbound data.
                //
                // See https://github.com/netty/netty/issues/4805
                beginRead();
            }
        }
    } catch (Throwable t) {
        // Close the channel directly to avoid FD leak.
        closeForcibly();
        closeFuture.setClosed();
        safeSetFailure(promise, t);
    }
}