Netty Review - NioServerSocketChannel源码分析

ChannelFuture channelFuture = serverBootstrap.bind(9000).sync();

/**
 * Create a new {@link Channel} and bind it.
 */
public ChannelFuture bind(int inetPort) {
    // 调用bind方法，并传入一个InetSocketAddress对象，其中端口号由参数inetPort指定
    return bind(new InetSocketAddress(inetPort));
}

    private ChannelFuture doBind(final SocketAddress localAddress) {
        final ChannelFuture regFuture = initAndRegister();
 		......
 		......      
}

这段代码是NioServerSocketChannel类中的一个私有方法，用于初始化并注册一个新的Channel。让我们逐步解释它：

```java
final ChannelFuture initAndRegister() {
    Channel channel = null;
    try {
        // 使用ChannelFactory创建一个新的Channel实例
        channel = channelFactory.newChannel();
        // 初始化Channel，包括设置Channel的配置、分配Channel的ID等
        init(channel);
    } catch (Throwable t) {
        if (channel != null) {
            // 如果Channel已经创建但是初始化过程中发生了异常，则强制关闭Channel
            channel.unsafe().closeForcibly();
            // 创建一个新的ChannelPromise并设置异常
            return new DefaultChannelPromise(channel, GlobalEventExecutor.INSTANCE).setFailure(t);
        }
        // 如果Channel还未创建就发生了异常，则创建一个FailedChannel实例，并设置异常
        return new DefaultChannelPromise(new FailedChannel(), GlobalEventExecutor.INSTANCE).setFailure(t);
    }

    // 将Channel注册到EventLoopGroup中，并获取注册结果
    ChannelFuture regFuture = config().group().register(channel);
    // 如果注册过程中出现了异常
    if (regFuture.cause() != null) {
        // 如果Channel已经注册成功，直接关闭Channel
        if (channel.isRegistered()) {
            channel.close();
        } else {
            // 如果Channel尚未注册成功，强制关闭Channel
            channel.unsafe().closeForcibly();
        }
    }

    // 返回注册结果
    return regFuture;
}

    @Override
    public T newChannel() {
        try {
            return constructor.newInstance();
        } catch (Throwable t) {
            throw new ChannelException("Unable to create Channel from class " + constructor.getDeclaringClass(), t);
        }
    }

/**
 * Create a new instance
 */
public NioServerSocketChannel() {
    // 调用另一个构造函数，传入一个新创建的Java NIO ServerSocketChannel实例
    this(newSocket(DEFAULT_SELECTOR_PROVIDER));
}

private static ServerSocketChannel newSocket(SelectorProvider provider) {
    try {
        // 使用指定的SelectorProvider打开一个新的ServerSocketChannel  (熟悉的NIO代码)
        return provider.openServerSocketChannel();
    } catch (IOException e) {
        // 如果发生异常，则抛出ChannelException异常
        throw new ChannelException("Failed to open a server socket.", e);
    }
}

 private static final SelectorProvider DEFAULT_SELECTOR_PROVIDER = SelectorProvider.provider();

/**
 * Create a new instance using the given {@link ServerSocketChannel}.
 */
public NioServerSocketChannel(ServerSocketChannel channel) {
    // 调用父类构造函数，传入null作为EventLoopGroup参数（因为NioServerSocketChannel没有父类EventLoopGroup），传入给定的ServerSocketChannel实例以及OP_ACCEPT作为感兴趣的事件
    super(null, channel, SelectionKey.OP_ACCEPT);
    // 创建一个新的NioServerSocketChannelConfig实例，用于配置NioServerSocketChannel的参数
    config = new NioServerSocketChannelConfig(this, javaChannel().socket());
}

/**
 * Create a new instance
 *
 * @param parent            the parent {@link Channel} by which this instance was created. May be {@code null}
 * @param ch                the underlying {@link SelectableChannel} on which it operates
 * @param readInterestOp    the ops to set to receive data from the {@link SelectableChannel}
 */
protected AbstractNioChannel(Channel parent, SelectableChannel ch, int readInterestOp) {
    // 调用父类构造函数，传入父Channel实例
    super(parent);
    // 初始化成员变量，保存SelectableChannel和读取操作的兴趣操作
    this.ch = ch;
    this.readInterestOp = readInterestOp;
    try {
        // 将SelectableChannel设置为非阻塞模式  （熟悉的NIO方法）
        ch.configureBlocking(false);
    } catch (IOException e) {
        try {
            // 发生异常时关闭SelectableChannel
            ch.close();
        } catch (IOException e2) {
            if (logger.isWarnEnabled()) {
                logger.warn("Failed to close a partially initialized socket.", e2);
            }
        }
        // 抛出ChannelException异常
        throw new ChannelException("Failed to enter non-blocking mode.", e);
    }
}

/**
 * Creates a new instance.
 *
 * @param parent
 *        the parent of this channel. {@code null} if there's no parent.
 */
protected AbstractChannel(Channel parent) {
    // 将父Channel赋值给成员变量parent
    this.parent = parent;
    // 生成唯一的通道ID
    id = newId();
    // 创建一个新的Unsafe实例，用于执行底层操作
    unsafe = newUnsafe();
    // 创建一个新的ChannelPipeline实例，用于存储和处理ChannelHandler
    pipeline = newChannelPipeline();
}

/**
 * Returns a new {@link DefaultChannelPipeline} instance.
 */
protected DefaultChannelPipeline newChannelPipeline() {
    // 创建一个新的DefaultChannelPipeline实例，传入当前的Channel作为参数
    return new DefaultChannelPipeline(this);
}

protected DefaultChannelPipeline(Channel channel) {
    // 将传入的Channel赋值给成员变量channel
    this.channel = ObjectUtil.checkNotNull(channel, "channel");
    // 创建一个新的SucceededChannelFuture实例，表示成功的Future
    succeededFuture = new SucceededChannelFuture(channel, null);
    // 创建一个新的VoidChannelPromise实例，表示空的Promise
    voidPromise =  new VoidChannelPromise(channel, true);

    // 创建一个新的TailContext实例，表示管道中的尾部节点
    tail = new TailContext(this);
    // 创建一个新的HeadContext实例，表示管道中的头部节点
    head = new HeadContext(this);

    // 设置头部节点的下一个节点为尾部节点，尾部节点的上一个节点为头部节点
    head.next = tail;
    tail.prev = head;
}