code-learning/netty/11-Netty 源码分析-启动（一）之服务端.md

精尽 Netty 源码分析 —— 启动（一）之服务端

1. 概述

对于所有 Netty 的新手玩家，我们最先使用的就是 Netty 的 Bootstrap 和 ServerBootstrap 组这两个“启动器”组件。它们在 transport 模块的 bootstrap 包下实现，如下图所示：

![bootstrap 包](11-Netty 源码分析-启动（一）之服务端.assets/01.png)bootstrap 包

在图中，我们可以看到三个以 Bootstrap 结尾的类，类图如下：

Bootstrap 类图

• 为什么是这样的类关系呢？因为 ServerBootstrap 和 Bootstrap 大部分的方法和职责都是相同的。

本文仅分享 ServerBootstrap 启动 Netty 服务端的过程。下一篇文章，我们再分享 Bootstrap 分享 Netty 客户端。

2. ServerBootstrap 示例

下面，我们先来看一个 ServerBootstrap 的使用示例，就是我们在 《精尽 Netty 源码分析 —— 调试环境搭建》 搭建的 EchoServer 示例。代码如下：

 1: public final class EchoServer {
 2: 
 3:     static final boolean SSL = System.getProperty("ssl") != null;
 4:     static final int PORT = Integer.parseInt(System.getProperty("port", "8007"));
 5: 
 6:     public static void main(String[] args) throws Exception {
 7:         // Configure SSL.
 8:         // 配置 SSL
 9:         final SslContext sslCtx;
10:         if (SSL) {
11:             SelfSignedCertificate ssc = new SelfSignedCertificate();
12:             sslCtx = SslContextBuilder.forServer(ssc.certificate(), ssc.privateKey()).build();
13:         } else {
14:             sslCtx = null;
15:         }
16: 
17:         // Configure the server.
18:         // 创建两个 EventLoopGroup 对象
19:         EventLoopGroup bossGroup = new NioEventLoopGroup(1); // 创建 boss 线程组 用于服务端接受客户端的连接
20:         EventLoopGroup workerGroup = new NioEventLoopGroup(); // 创建 worker 线程组 用于进行 SocketChannel 的数据读写
21:         // 创建 EchoServerHandler 对象
22:         final EchoServerHandler serverHandler = new EchoServerHandler();
23:         try {
24:             // 创建 ServerBootstrap 对象
25:             ServerBootstrap b = new ServerBootstrap();
26:             b.group(bossGroup, workerGroup) // 设置使用的 EventLoopGroup
27:              .channel(NioServerSocketChannel.class) // 设置要被实例化的为 NioServerSocketChannel 类
28:              .option(ChannelOption.SO_BACKLOG, 100) // 设置 NioServerSocketChannel 的可选项
29:              .handler(new LoggingHandler(LogLevel.INFO)) // 设置 NioServerSocketChannel 的处理器
30:              .childHandler(new ChannelInitializer<SocketChannel>() {
31:                  @Override
32:                  public void initChannel(SocketChannel ch) throws Exception { // 设置连入服务端的 Client 的 SocketChannel 的处理器
33:                      ChannelPipeline p = ch.pipeline();
34:                      if (sslCtx != null) {
35:                          p.addLast(sslCtx.newHandler(ch.alloc()));
36:                      }
37:                      //p.addLast(new LoggingHandler(LogLevel.INFO));
38:                      p.addLast(serverHandler);
39:                  }
40:              });
41: 
42:             // Start the server.
43:             // 绑定端口，并同步等待成功，即启动服务端
44:             ChannelFuture f = b.bind(PORT).sync();
45: 
46:             // Wait until the server socket is closed.
47:             // 监听服务端关闭，并阻塞等待
48:             f.channel().closeFuture().sync();
49:         } finally {
50:             // Shut down all event loops to terminate all threads.
51:             // 优雅关闭两个 EventLoopGroup 对象
52:             bossGroup.shutdownGracefully();
53:             workerGroup.shutdownGracefully();
54:         }
55:     }
56: }

• 第 7 至 15 行：配置 SSL ，暂时可以忽略。
• 第 17 至 20 行：创建两个 EventLoopGroup 对象。
  • boss 线程组：用于服务端接受客户端的连接。
  • worker 线程组：用于进行客户端的 SocketChannel 的数据读写。
  • 关于为什么是两个 EventLoopGroup 对象，我们在后续的文章，进行分享。
• 第 22 行：创建 io.netty.example.echo.EchoServerHandler 对象。
• 第 24 行：创建 ServerBootstrap 对象，用于设置服务端的启动配置。
  • 第 26 行：调用 #group(EventLoopGroup parentGroup, EventLoopGroup childGroup) 方法，设置使用的 EventLoopGroup 。
  • 第 27 行：调用 #channel(Class<? extends C> channelClass) 方法，设置要被实例化的 Channel 为 NioServerSocketChannel 类。在下文中，我们会看到该 Channel 内嵌了 java.nio.channels.ServerSocketChannel 对象。是不是很熟悉 😈 ？
  • 第 28 行：调用 #option(ChannelOption<T> option, T value) 方法，设置 NioServerSocketChannel 的可选项。在 io.netty.channel.ChannelOption 类中，枚举了相关的可选项。
  • 第 29 行：调用 #handler(ChannelHandler handler) 方法，设置 NioServerSocketChannel 的处理器。在本示例中，使用了 io.netty.handler.logging.LoggingHandler 类，用于打印服务端的每个事件。详细解析，见后续文章。
  • 第 30 至 40 行：调用 #childHandler(ChannelHandler handler) 方法，设置连入服务端的 Client 的 SocketChannel 的处理器。在本实例中，使用 ChannelInitializer 来初始化连入服务端的 Client 的 SocketChannel 的处理器。
• 第 44 行：先调用 #bind(int port) 方法，绑定端口，后调用 ChannelFuture#sync() 方法，阻塞等待成功。这个过程，就是“启动服务端”。
• 第 48 行：先调用 #closeFuture() 方法，监听服务器关闭，后调用 ChannelFuture#sync() 方法，阻塞等待成功。😈 注意，此处不是关闭服务器，而是“监听”关闭。
• 第 49 至 54 行：执行到此处，说明服务端已经关闭，所以调用 EventLoopGroup#shutdownGracefully() 方法，分别关闭两个 EventLoopGroup 对象。

老艿艿的自我吐槽：😈 貌似又啰嗦了一把？？？

3. AbstractBootstrap

我们再一起来看看 AbstractBootstrap 的代码实现。因为 ServerBootstrap 和 Bootstrap 都实现这个类，所以和 ServerBootstrap 相关度高的方法，我们会放在 「4. ServerBootstrap」 中分享，而和 Bootstrap 相关度高的方法，我们会放在下一篇 Bootstrap 的文章分享。

老艿艿：下面我会开始分享一系列的 AbstractBootstrap 的配置方法，如果比较熟悉的胖友，可以直接跳到 「3.13 bind」 开始看。

3.1 构造方法

public abstract class AbstractBootstrap<B extends AbstractBootstrap<B, C>, C extends Channel> implements Cloneable {

    /**
     * EventLoopGroup 对象
     */
    volatile EventLoopGroup group;
    /**
     * Channel 工厂，用于创建 Channel 对象。
     */
    @SuppressWarnings("deprecation")
    private volatile ChannelFactory<? extends C> channelFactory;
    /**
     * 本地地址
     */
    private volatile SocketAddress localAddress;
    /**
     * 可选项集合
     */
    private final Map<ChannelOption<?>, Object> options = new LinkedHashMap<ChannelOption<?>, Object>();
    /**
     * 属性集合
     */
    private final Map<AttributeKey<?>, Object> attrs = new LinkedHashMap<AttributeKey<?>, Object>();
    /**
     * 处理器
     */
    private volatile ChannelHandler handler;

    AbstractBootstrap() {
        // Disallow extending from a different package.
    }

    AbstractBootstrap(AbstractBootstrap<B, C> bootstrap) {
        group = bootstrap.group;
        channelFactory = bootstrap.channelFactory;
        handler = bootstrap.handler;
        localAddress = bootstrap.localAddress;
        synchronized (bootstrap.options) { // <1>
            options.putAll(bootstrap.options);
        }
        synchronized (bootstrap.attrs) { // <2>
            attrs.putAll(bootstrap.attrs);
        }
    }
    
    // ... 省略无关代码
}

• AbstractBootstrap 是个

  抽象类

  ，并且实现 Cloneable 接口。另外，它声明了

  B
  

  、

  C
  

  两个泛型：

  • B ：继承 AbstractBootstrap 类，用于表示自身的类型。
  • C ：继承 Channel 类，表示表示创建的 Channel 类型。

• 每个属性比较简单，结合下面我们要分享的每个方法，就更易懂啦。

• 在 <1> 和 <2> 两处，比较神奇的使用了 synchronized 修饰符。老艿艿也是疑惑了一下，但是这并难不倒我。因为传入的 bootstrap 参数的 options 和 attrs 属性，可能在另外的线程被修改( 例如，我们下面会看到的 #option(hannelOption<T> option, T value) 方法)，通过 synchronized 来同步，解决此问题。

3.2 self

#self() 方法，返回自己。代码如下：

private B self() {
    return (B) this;
}

• 这里就使用到了 AbstractBootstrap 声明的 B 泛型。

3.3 group

#group(EventLoopGroup group) 方法，设置 EventLoopGroup 到 group 中。代码如下：

public B group(EventLoopGroup group) {
    if (group == null) {
        throw new NullPointerException("group");
    }
    if (this.group != null) { // 不允许重复设置
        throw new IllegalStateException("group set already");
    }
    this.group = group;
    return self();
}

• 最终调用 #self() 方法，返回自己。实际上，AbstractBootstrap 整个方法的调用，基本都是“链式调用”。

3.4 channel

#channel(Class<? extends C> channelClass) 方法，设置要被实例化的 Channel 的类。代码如下：

public B channel(Class<? extends C> channelClass) {
    if (channelClass == null) {
        throw new NullPointerException("channelClass");
    }
    return channelFactory(new ReflectiveChannelFactory<C>(channelClass));
}

• 虽然传入的 channelClass 参数，但是会使用 io.netty.channel.ReflectiveChannelFactory 进行封装。

• 调用 #channelFactory(io.netty.channel.ChannelFactory<? extends C> channelFactory) 方法，设置 channelFactory 属性。代码如下：

  public B channelFactory(io.netty.channel.ChannelFactory<? extends C> channelFactory) {
      return channelFactory((ChannelFactory<C>) channelFactory);
  }
  
  @Deprecated
  public B channelFactory(io.netty.bootstrap.ChannelFactory<? extends C> channelFactory) {
      if (channelFactory == null) {
          throw new NullPointerException("channelFactory");
      }
      if (this.channelFactory != null) { // 不允许重复设置
          throw new IllegalStateException("channelFactory set already");
      }
  
      this.channelFactory = channelFactory;
      return self();
  }
  

  • 我们可以看到有两个 #channelFactory(...) 方法，并且第二个是 @Deprecated 的方法。从 ChannelFactory 使用的包名，我们就可以很容易的判断，最初 ChannelFactory 在 bootstrap 中，后重构到 channel 包中。

3.4.1 ChannelFactory

io.netty.channel.ChannelFactory ，Channel 工厂接口，用于创建 Channel 对象。代码如下：

public interface ChannelFactory<T extends Channel> extends io.netty.bootstrap.ChannelFactory<T> {

    /**
     * Creates a new channel.
     *
     * 创建 Channel 对象
     *
     */
    @Override
    T newChannel();

}

• #newChannel() 方法，用于创建 Channel 对象。

3.4.2 ReflectiveChannelFactory

io.netty.channel.ReflectiveChannelFactory ，实现 ChannelFactory 接口，反射调用默认构造方法，创建 Channel 对象的工厂实现类。代码如下：

public class ReflectiveChannelFactory<T extends Channel> implements ChannelFactory<T> {

    /**
     * Channel 对应的类
     */
    private final Class<? extends T> clazz;

    public ReflectiveChannelFactory(Class<? extends T> clazz) {
        if (clazz == null) {
            throw new NullPointerException("clazz");
        }
        this.clazz = clazz;
    }

    @Override
    public T newChannel() {
        try {
            // 反射调用默认构造方法，创建 Channel 对象
            return clazz.getConstructor().newInstance();
        } catch (Throwable t) {
            throw new ChannelException("Unable to create Channel from class " + clazz, t);
        }
    }

}

• 重点看 clazz.getConstructor().newInstance() 代码块。

3.5 localAddress

#localAddress(...) 方法，设置创建 Channel 的本地地址。有四个重载的方法，代码如下：

public B localAddress(SocketAddress localAddress) {
    this.localAddress = localAddress;
    return self();
}

public B localAddress(int inetPort) {
    return localAddress(new InetSocketAddress(inetPort));
}

public B localAddress(String inetHost, int inetPort) {
    return localAddress(SocketUtils.socketAddress(inetHost, inetPort));
}

public B localAddress(InetAddress inetHost, int inetPort) {
    return localAddress(new InetSocketAddress(inetHost, inetPort));
}

• 一般情况下，不会调用该方法进行配置，而是调用 #bind(...) 方法，例如 「2. ServerBootstrap 示例」 。

3.6 option

#option(ChannelOption<T> option, T value) 方法，设置创建 Channel 的可选项。代码如下：

public <T> B option(ChannelOption<T> option, T value) {
    if (option == null) {
        throw new NullPointerException("option");
    }
    if (value == null) { // 空，意味着移除
        synchronized (options) {
            options.remove(option);
        }
    } else { // 非空，进行修改
        synchronized (options) {
            options.put(option, value);
        }
    }
    return self();
}

3.7 attr

#attr(AttributeKey<T> key, T value) 方法，设置创建 Channel 的属性。代码如下：

public <T> B attr(AttributeKey<T> key, T value) {
    if (key == null) {
        throw new NullPointerException("key");
    }
    if (value == null) { // 空，意味着移除
        synchronized (attrs) {
            attrs.remove(key);
        }
    } else { // 非空，进行修改
        synchronized (attrs) {
            attrs.put(key, value);
        }
    }
    return self();
}

• 怎么理解 attrs 属性呢？我们可以理解成 java.nio.channels.SelectionKey 的 attachment 属性，并且类型为 Map 。

3.8 handler

#handler(ChannelHandler handler) 方法，设置创建 Channel 的处理器。代码如下：

public B handler(ChannelHandler handler) {
    if (handler == null) {
        throw new NullPointerException("handler");
    }
    this.handler = handler;
    return self();
}

3.9 validate

#validate() 方法，校验配置是否正确。代码如下：

public B validate() {
    if (group == null) {
        throw new IllegalStateException("group not set");
    }
    if (channelFactory == null) {
        throw new IllegalStateException("channel or channelFactory not set");
    }
    return self();
}

• 在 #bind(...) 方法中，绑定本地地址时，会调用该方法进行校验。

3.10 clone

#clone() 抽象方法，克隆一个 AbstractBootstrap 对象。代码如下。

/**
 * Returns a deep clone of this bootstrap which has the identical configuration.  This method is useful when making
 * multiple {@link Channel}s with similar settings.  Please note that this method does not clone the
 * {@link EventLoopGroup} deeply but shallowly, making the group a shared resource.
 */
@Override
public abstract B clone();

• 来自实现 Cloneable 接口，在子类中实现。这是

  深

  拷贝，即创建一个新对象，但不是所有的属性是

  深

  拷贝。可参见

  「3.1 构造方法」

  ：

  • 浅拷贝属性：group、channelFactory、handler、localAddress 。
  • 深拷贝属性：options、attrs 。

3.11 config

#config() 方法，返回当前 AbstractBootstrap 的配置对象。代码如下：

public abstract AbstractBootstrapConfig<B, C> config();

3.11.1 AbstractBootstrapConfig

io.netty.bootstrap.AbstractBootstrapConfig ，BootstrapConfig 抽象类。代码如下：

public abstract class AbstractBootstrapConfig<B extends AbstractBootstrap<B, C>, C extends Channel> {

    protected final B bootstrap;

    protected AbstractBootstrapConfig(B bootstrap) {
        this.bootstrap = ObjectUtil.checkNotNull(bootstrap, "bootstrap");
    }
    
    public final SocketAddress localAddress() {
        return bootstrap.localAddress();
    }
    
    public final ChannelFactory<? extends C> channelFactory() {
        return bootstrap.channelFactory();
    }

    public final ChannelHandler handler() {
        return bootstrap.handler();
    }

    public final Map<ChannelOption<?>, Object> options() {
        return bootstrap.options();
    }

    public final Map<AttributeKey<?>, Object> attrs() {
        return bootstrap.attrs();
    }

    public final EventLoopGroup group() {
        return bootstrap.group();
    }
    
}

• bootstrap 属性，对应的启动类对象。在每个方法中，我们可以看到，都是直接调用 boostrap 属性对应的方法，读取对应的配置。

---

AbstractBootstrapConfig 的整体类图如下：AbstractBootstrapConfig 类图

• 每个 Config 类，对应一个 Bootstrap 类。
• ServerBootstrapConfig 和 BootstrapConfig 的实现代码，和 AbstractBootstrapConfig 基本一致，所以胖友自己去查看噢。

3.12 setChannelOptions

#setChannelOptions(...) 静态方法，设置传入的 Channel 的多个可选项。代码如下：

static void setChannelOptions(
        Channel channel, Map<ChannelOption<?>, Object> options, InternalLogger logger) {
    for (Map.Entry<ChannelOption<?>, Object> e: options.entrySet()) {
        setChannelOption(channel, e.getKey(), e.getValue(), logger);
    }
}

static void setChannelOptions(
        Channel channel, Map.Entry<ChannelOption<?>, Object>[] options, InternalLogger logger) {
    for (Map.Entry<ChannelOption<?>, Object> e: options) {
        setChannelOption(channel, e.getKey(), e.getValue(), logger);
    }
}

• 在两个方法的内部，都调用 #setChannelOption(Channel channel, ChannelOption<?> option, Object value, InternalLogger logger) 静态方法，设置传入的 Channel 的一个可选项。代码如下：

  private static void setChannelOption(
          Channel channel, ChannelOption<?> option, Object value, InternalLogger logger) {
      try {
          if (!channel.config().setOption((ChannelOption<Object>) option, value)) {
              logger.warn("Unknown channel option '{}' for channel '{}'", option, channel);
          }
      } catch (Throwable t) {
          logger.warn("Failed to set channel option '{}' with value '{}' for channel '{}'", option, value, channel, t);
      }
  }
  

  • 不同于 「3.6 option」 方法，它是设置要创建的 Channel 的可选项。而 #setChannelOption(...) 方法，它是设置已经创建的 Channel 的可选项。

3.13 bind

老艿艿：#bind(...) 方法，也可以启动 UDP 的一端，考虑到这个系列主要分享 Netty 在 NIO 相关的源码解析，所以如下所有的分享，都不考虑 UDP 的情况。

#bind(...) 方法，绑定端口，启动服务端。代码如下：

public ChannelFuture bind() {
    // 校验服务启动需要的必要参数
    validate();
    SocketAddress localAddress = this.localAddress;
    if (localAddress == null) {
        throw new IllegalStateException("localAddress not set");
    }
    // 绑定本地地址( 包括端口 )
    return doBind(localAddress);
}

public ChannelFuture bind(int inetPort) {
    return bind(new InetSocketAddress(inetPort));
}

public ChannelFuture bind(String inetHost, int inetPort) {
    return bind(SocketUtils.socketAddress(inetHost, inetPort));
}

public ChannelFuture bind(InetAddress inetHost, int inetPort) {
    return bind(new InetSocketAddress(inetHost, inetPort));
}

public ChannelFuture bind(SocketAddress localAddress) {
    // 校验服务启动需要的必要参数
    validate();
    if (localAddress == null) {
        throw new NullPointerException("localAddress");
    }
    // 绑定本地地址( 包括端口 )
    return doBind(localAddress);
}

• 该方法返回的是 ChannelFuture 对象，也就是异步的绑定端口，启动服务端。如果需要同步，则需要调用 ChannelFuture#sync() 方法。

#bind(...) 方法，核心流程如下图：

核心流程

• 主要有 4 个步骤，下面我们来拆解代码，看看和我们在 《精尽 Netty 源码分析 —— NIO 基础（五）之示例》 的 NioServer 的代码，是怎么对应的。

3.13.1 doBind

#doBind(final SocketAddress localAddress) 方法，代码如下：

 1: private ChannelFuture doBind(final SocketAddress localAddress) {
 2:     // 初始化并注册一个 Channel 对象，因为注册是异步的过程，所以返回一个 ChannelFuture 对象。
 3:     final ChannelFuture regFuture = initAndRegister();
 4:     final Channel channel = regFuture.channel();
 5:     if (regFuture.cause() != null) { // 若发生异常，直接进行返回。
 6:         return regFuture;
 7:     }
 8: 
 9:     // 绑定 Channel 的端口，并注册 Channel 到 SelectionKey 中。
10:     if (regFuture.isDone()) { // 未
11:         // At this point we know that the registration was complete and successful.
12:         ChannelPromise promise = channel.newPromise();
13:         doBind0(regFuture, channel, localAddress, promise); // 绑定
14:         return promise;
15:     } else {
16:         // Registration future is almost always fulfilled already, but just in case it's not.
17:         final PendingRegistrationPromise promise = new PendingRegistrationPromise(channel);
18:         regFuture.addListener(new ChannelFutureListener() {
19:             @Override
20:             public void operationComplete(ChannelFuture future) throws Exception {
22:                 Throwable cause = future.cause();
23:                 if (cause != null) {
24:                     // Registration on the EventLoop failed so fail the ChannelPromise directly to not cause an
25:                     // IllegalStateException once we try to access the EventLoop of the Channel.
26:                     promise.setFailure(cause);
27:                 } else {
28:                     // Registration was successful, so set the correct executor to use.
29:                     // See https://github.com/netty/netty/issues/2586
30:                     promise.registered();
31: 
32:                     doBind0(regFuture, channel, localAddress, promise); // 绑定
33:                 }
34:             }
35:         });
36:         return promise;
37:     }
38: }

• 第 3 行：调用

  #initAndRegister()
  

  方法，初始化并注册一个 Channel 对象。因为注册是

  异步

  的过程，所以返回一个 ChannelFuture 对象。详细解析，见

  「3.14 initAndRegister」

  。

  • 第 5 至 7 行：若发生异常，直接进行返回。

• 第 9 至 37 行：因为注册是

  异步

  的过程，有可能已完成，有可能未完成。所以实现代码分成了【第 10 至 14 行】和【第 15 至 36 行】分别处理已完成和未完成的情况。

  • 核心在【第 13 行】或者【第 32 行】的代码，调用 #doBind0(final ChannelFuture regFuture, final Channel channel, final SocketAddress localAddress, final ChannelPromise promise) 方法，绑定 Channel 的端口，并注册 Channel 到 SelectionKey 中。
  • 如果异步注册对应的 ChanelFuture 未完成，则调用 ChannelFuture#addListener(ChannelFutureListener) 方法，添加监听器，在注册完成后，进行回调执行 #doBind0(...) 方法的逻辑。详细解析，见 见 「3.13.2 doBind0」 。
  • 所以总结来说，bind 的逻辑，执行在 register 的逻辑之后。
  • TODO 1001 Promise 2. PendingRegistrationPromise

3.13.2 doBind0

老艿艿：此小节的内容，胖友先看完 「3.14 initAndRegister」 的内容在回过头来看。因为 #doBind0(...) 方法的执行，在 #initAndRegister() 方法之后。

#doBind0(...) 方法，执行 Channel 的端口绑定逻辑。代码如下：

 1: private static void doBind0(
 2:         final ChannelFuture regFuture, final Channel channel,
 3:         final SocketAddress localAddress, final ChannelPromise promise) {
 4: 
 5:     // This method is invoked before channelRegistered() is triggered.  Give user handlers a chance to set up
 6:     // the pipeline in its channelRegistered() implementation.
 7:     channel.eventLoop().execute(new Runnable() {
 8:         @Override
 9:         public void run() {
11:             // 注册成功，绑定端口
12:             if (regFuture.isSuccess()) {
13:                 channel.bind(localAddress, promise).addListener(ChannelFutureListener.CLOSE_ON_FAILURE);
14:             // 注册失败，回调通知 promise 异常
15:             } else {
16:                 promise.setFailure(regFuture.cause());
17:             }
18:         }
19:     });
20: }

• 第 7 行：调用 EventLoop 执行 Channel 的端口绑定逻辑。但是，实际上当前线程已经是 EventLoop 所在的线程了，为何还要这样操作呢？答案在【第 5 至 6 行】的英语注释。感叹句，Netty 虽然代码量非常庞大且复杂，但是英文注释真的是非常齐全，包括 Github 的 issue 对代码提交的描述，也非常健全。

• 第 14 至 17 行：注册失败，回调通知 promise 异常。

• 第 11 至 13 行：注册成功，调用

  Channel#bind(SocketAddress localAddress, ChannelPromise promise)
  

  方法，执行 Channel 的端口绑定逻辑。后续的方法栈调用如下图：

  

  Channel bind 流程

  • 还是老样子，我们先省略掉 pipeline 的内部实现代码，从 AbstractUnsafe#bind(final SocketAddress localAddress, final ChannelPromise promise) 方法，继续向下分享。

AbstractUnsafe#bind(final SocketAddress localAddress, final ChannelPromise promise) 方法，Channel 的端口绑定逻辑。代码如下：

 1: @Override
 2: public final void bind(final SocketAddress localAddress, final ChannelPromise promise) {
 3:     // 判断是否在 EventLoop 的线程中。
 4:     assertEventLoop();
 5: 
 6:     if (!promise.setUncancellable() || !ensureOpen(promise)) {
 7:         return;
 8:     }
 9: 
10:     // See: https://github.com/netty/netty/issues/576
11:     if (Boolean.TRUE.equals(config().getOption(ChannelOption.SO_BROADCAST)) &&
12:         localAddress instanceof InetSocketAddress &&
13:         !((InetSocketAddress) localAddress).getAddress().isAnyLocalAddress() &&
14:         !PlatformDependent.isWindows() && !PlatformDependent.maybeSuperUser()) {
15:         // Warn a user about the fact that a non-root user can't receive a
16:         // broadcast packet on *nix if the socket is bound on non-wildcard address.
17:         logger.warn(
18:                 "A non-root user can't receive a broadcast packet if the socket " +
19:                 "is not bound to a wildcard address; binding to a non-wildcard " +
20:                 "address (" + localAddress + ") anyway as requested.");
21:     }
22: 
23:     // 记录 Channel 是否激活
24:     boolean wasActive = isActive();
25: 
26:     // 绑定 Channel 的端口
27:     try {
28:         doBind(localAddress);
29:     } catch (Throwable t) {
30:         safeSetFailure(promise, t);
31:         closeIfClosed();
32:         return;
33:     }
34: 
35:     // 若 Channel 是新激活的，触发通知 Channel 已激活的事件。
36:     if (!wasActive && isActive()) {
37:         invokeLater(new Runnable() {
38:             @Override
39:             public void run() {
40:                 pipeline.fireChannelActive();
41:             }
42:         });
43:     }
44: 
45:     // 回调通知 promise 执行成功
46:     safeSetSuccess(promise);
47: }

• 第 4 行：调用 #assertEventLoop() 方法，判断是否在 EventLoop 的线程中。即该方法，只允许在 EventLoop 的线程中执行。代码如下：

  // AbstractUnsafe.java
  private void assertEventLoop() {
      assert !registered || eventLoop.inEventLoop();
  }
  

• 第 6 至 8 行：和 #register0(...) 方法的【第 5 至 8 行】的代码，是一致的。

• 第 10 至 21 行：https://github.com/netty/netty/issues/576

• 第 24 行：调用 #isActive() 方法，获得 Channel 是否激活( active )。NioServerSocketChannel 对该方法的实现代码如下：

  // NioServerSocketChannel.java
  
  @Override
  public boolean isActive() {
      return javaChannel().socket().isBound();
  }
  

  • NioServerSocketChannel 的 #isActive() 的方法实现，判断 ServerSocketChannel 是否绑定端口。此时，一般返回的是 false 。

• 第 28 行：调用 #doBind(SocketAddress localAddress) 方法，绑定 Channel 的端口。代码如下：

  // NioServerSocketChannel.java
  
  @Override
  protected void doBind(SocketAddress localAddress) throws Exception {
      if (PlatformDependent.javaVersion() >= 7) {
          javaChannel().bind(localAddress, config.getBacklog());
      } else {
          javaChannel().socket().bind(localAddress, config.getBacklog());
      }
  }
  

  • 【重要】到了此处，服务端的 Java 原生 NIO ServerSocketChannel 终于绑定端口。😈

• 第 36 行：再次调用 #isActive() 方法，获得 Channel 是否激活。此时，一般返回的是 true 。因此，Channel 可以认为是新激活的，满足【第 36 至 43 行】代码的执行条件。

  • 第 37 行：调用 #invokeLater(Runnable task) 方法，提交任务，让【第 40 行】的代码执行，异步化。代码如下：

    // AbstractUnsafe.java
    private void invokeLater(Runnable task) {
        try {
            // This method is used by outbound operation implementations to trigger an inbound event later.
            // They do not trigger an inbound event immediately because an outbound operation might have been
            // triggered by another inbound event handler method.  If fired immediately, the call stack
            // will look like this for example:
            //
            //   handlerA.inboundBufferUpdated() - (1) an inbound handler method closes a connection.
            //   -> handlerA.ctx.close()
            //      -> channel.unsafe.close()
            //         -> handlerA.channelInactive() - (2) another inbound handler method called while in (1) yet
            //
            // which means the execution of two inbound handler methods of the same handler overlap undesirably.
            eventLoop().execute(task);
        } catch (RejectedExecutionException e) {
            logger.warn("Can't invoke task later as EventLoop rejected it", e);
        }
    }
    

    • 从实现代码可以看出，是通过提交一个新的任务到 EventLoop 的线程中。
    • 英文注释虽然有丢丢长，但是胖友耐心看完。有道在手，英文不愁啊。

  • 第 40 行：调用 DefaultChannelPipeline#fireChannelActive() 方法，触发 Channel 激活的事件。详细解析，见 「3.13.3 beginRead」 。

• 第 46 行：调用 #safeSetSuccess(ChannelPromise) 方法，回调通知 promise 执行成功。此处的通知，对应回调的是我们添加到 #bind(...) 方法返回的 ChannelFuture 的 ChannelFutureListener 的监听器。示例代码如下：

  ChannelFuture f = b.bind(PORT).addListener(new ChannelFutureListener() { // 回调的就是我！！！
      @Override
      public void operationComplete(ChannelFuture future) throws Exception {
          System.out.println("测试下被触发");
      }
  }).sync();
  

3.13.3 beginRead

老艿艿：此小节的内容，胖友先看完 「3.14 initAndRegister」 的内容在回过头来看。因为 #beginRead(...) 方法的执行，在 #doBind0(...) 方法之后。

在 #bind(final SocketAddress localAddress, final ChannelPromise promise) 方法的【第 40 行】代码，调用 Channel#bind(SocketAddress localAddress, ChannelPromise promise) 方法，触发 Channel 激活的事件。后续的方法栈调用如下图：触发 Channel 激活的事件

* 还是老样子，我们先省略掉 pipeline 的内部实现代码，从 `AbstractUnsafe#beginRead()` 方法，继续向下分享。

AbstractUnsafe#beginRead() 方法，开始读取操作。代码如下：

@Override
public final void beginRead() {
    // 判断是否在 EventLoop 的线程中。
    assertEventLoop();

    // Channel 必须激活
    if (!isActive()) {
        return;
    }

    // 执行开始读取
    try {
        doBeginRead();
    } catch (final Exception e) {
        invokeLater(new Runnable() {
            @Override
            public void run() {
                pipeline.fireExceptionCaught(e);
            }
        });
        close(voidPromise());
    }
}

• 调用 Channel#doBeginRead() 方法，执行开始读取。对于 NioServerSocketChannel 来说，该方法实现代码如下：

  // AbstractNioMessageChannel.java
  @Override
  protected void doBeginRead() throws Exception {
      if (inputShutdown) {
          return;
      }
      super.doBeginRead();
  }
  
  // AbstractNioChannel.java
  @Override
  protected void doBeginRead() throws Exception {
      // Channel.read() or ChannelHandlerContext.read() was called
      final SelectionKey selectionKey = this.selectionKey;
      if (!selectionKey.isValid()) {
          return;
      }
  
      readPending = true;
  
      final int interestOps = selectionKey.interestOps();
      if ((interestOps & readInterestOp) == 0) {
          selectionKey.interestOps(interestOps | readInterestOp);
      }
  }
  

  • 【重要】在最后几行，我们可以看到，调用 SelectionKey#interestOps(ops) 方法，将我们创建 NioServerSocketChannel 时，设置的 readInterestOp = SelectionKey.OP_ACCEPT 添加为感兴趣的事件。也就说，服务端可以开始处理客户端的连接事件。

3.14 initAndRegister

#initAndRegister() 方法，初始化并注册一个 Channel 对象，并返回一个 ChannelFuture 对象。代码如下：

  1: final ChannelFuture initAndRegister() {
 2:     Channel channel = null;
 3:     try {
 4:         // 创建 Channel 对象
 5:         channel = channelFactory.newChannel();
 6:         // 初始化 Channel 配置
 7:         init(channel);
 8:     } catch (Throwable t) {
 9:         if (channel != null) { // 已创建 Channel 对象
10:             // channel can be null if newChannel crashed (eg SocketException("too many open files"))
11:             channel.unsafe().closeForcibly(); // 强制关闭 Channel
12:             // as the Channel is not registered yet we need to force the usage of the GlobalEventExecutor
13:             return new DefaultChannelPromise(channel, GlobalEventExecutor.INSTANCE).setFailure(t);
14:         }
15:         // as the Channel is not registered yet we need to force the usage of the GlobalEventExecutor
16:         return new DefaultChannelPromise(new FailedChannel(), GlobalEventExecutor.INSTANCE).setFailure(t);
17:     }
18: 
19:     // 注册 Channel 到 EventLoopGroup 中
20:     ChannelFuture regFuture = config().group().register(channel);
21:     if (regFuture.cause() != null) {
22:         if (channel.isRegistered()) {
23:             channel.close();
24:         } else {
25:             channel.unsafe().closeForcibly(); // 强制关闭 Channel
26:         }
27:     }
28: 
29:     return regFuture;
30: }

• 第 5 行：调用

  ChannelFactory#newChannel()
  

  方法，创建 Channel 对象。在本文的示例中，会使用 ReflectiveChannelFactory 创建 NioServerSocketChannel 对象。详细解析，见

  「3.14.1 创建 Channel」

  。

  • 第 16 行：返回带异常的 DefaultChannelPromise 对象。因为创建 Channel 对象失败，所以需要创建一个 FailedChannel 对象，设置到 DefaultChannelPromise 中才可以返回。

• 第 7 行：调用

  #init(Channel)
  

  方法，初始化 Channel 配置。详细解析，见

  「3.14.1 创建 Channel」

  。

  • 第 9 至 14 行：返回带异常的 DefaultChannelPromise 对象。因为初始化 Channel 对象失败，所以需要调用 #closeForcibly() 方法，强制关闭 Channel 。

• 第 20 行：首先获得 EventLoopGroup 对象，后调用 EventLoopGroup#register(Channel) 方法，注册 Channel 到 EventLoopGroup 中。实际在方法内部，EventLoopGroup 会分配一个 EventLoop 对象，将 Channel 注册到其上。详细解析，见 「3.14.3 注册 Channel 到 EventLoopGroup」 。

  • 第 22 至 23 行：若发生异常，并且 Channel 已经注册成功，则调用 #close() 方法，正常关闭 Channel 。

  • 第 24 至 26 行：若发生异常，并且 Channel 并未注册成功，则调用 #closeForcibly() 方法，强制关闭 Channel 。也就是说，和【第 9 至 14 行】一致。为什么会有正常和强制关闭 Channel 两种不同的处理呢？我们来看下 #close() 和 #closeForcibly() 方法的注释：

    // Channel.java#Unsafe
    
    /**
     * Close the {@link Channel} of the {@link ChannelPromise} and notify the {@link ChannelPromise} once the
     * operation was complete.
     */
    void close(ChannelPromise promise);
    
    /**
     * Closes the {@link Channel} immediately without firing any events.  Probably only useful
     * when registration attempt failed.
     */
    void closeForcibly();
    

    • 调用的前提，在于 Channel 是否注册到 EventLoopGroup 成功。😈 因为注册失败，也不好触发相关的事件。

3.14.1 创建 Channel 对象

考虑到本文的内容，我们以 NioServerSocketChannel 的创建过程作为示例。流程图如下：

创建 NioServerSocketChannel 对象

• 我们可以看到，整个流程涉及到 NioServerSocketChannel 的父类们。类图如下：Channel 类图

• 可能有部分胖友对 Netty Channel 的定义不是很理解，如下是官方的英文注释：

  A nexus to a network socket or a component which is capable of I/O operations such as read, write, connect, and bind

  • 简单点来说，我们可以把 Netty Channel 和 Java 原生 Socket 对应，而 Netty NIO Channel 和 Java 原生 NIO SocketChannel 对象。

下面，我们来看看整个 NioServerSocketChannel 的创建过程的代码实现。

3.14.1.1 NioServerSocketChannel

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

private final ServerSocketChannelConfig config;

public NioServerSocketChannel() {
    this(newSocket(DEFAULT_SELECTOR_PROVIDER));
}

public NioServerSocketChannel(SelectorProvider provider) {
    this(newSocket(provider));
}

• DEFAULT_SELECTOR_PROVIDER 静态属性，默认的 SelectorProvider 实现类。

• config 属性，Channel 对应的配置对象。每种 Channel 实现类，也会对应一个 ChannelConfig 实现类。例如，NioServerSocketChannel 类，对应 ServerSocketChannelConfig 配置类。

  ChannelConfig 的官网英文描述： A set of configuration properties of a Channel.

• 在构造方法中，调用 #newSocket(SelectorProvider provider) 方法，创建 NIO 的 ServerSocketChannel 对象。代码如下：

  private static ServerSocketChannel newSocket(SelectorProvider provider) {
      try {
          return provider.openServerSocketChannel();
      } catch (IOException e) {
          throw new ChannelException("Failed to open a server socket.", e);
      }
  }
  

  • 😈 是不是很熟悉这样的代码，效果和 ServerSocketChannel#open() 方法创建 ServerSocketChannel 对象是一致。

• #NioServerSocketChannel(ServerSocketChannel channel) 构造方法，代码如下：

  public NioServerSocketChannel(ServerSocketChannel channel) {
      super(null, channel, SelectionKey.OP_ACCEPT);
      config = new NioServerSocketChannelConfig(this, javaChannel().socket());
  }
  

  • 调用父 AbstractNioMessageChannel 的构造方法。详细解析，见 「3.14.1.2 AbstractNioMessageChannel」 。注意传入的 SelectionKey 的值为 OP_ACCEPT 。
  • 初始化 config 属性，创建 NioServerSocketChannelConfig 对象。

3.14.1.2 AbstractNioMessageChannel

protected AbstractNioMessageChannel(Channel parent, SelectableChannel ch, int readInterestOp) {
    super(parent, ch, readInterestOp);
}

• 直接调用父 AbstractNioChannel 的构造方法。详细解析，见 「3.14.1.3 AbstractNioChannel」 。

3.14.1.3 AbstractNioChannel

private final SelectableChannel ch;
protected final int readInterestOp;

protected AbstractNioChannel(Channel parent, SelectableChannel ch, int readInterestOp) {
    super(parent);
    this.ch = ch;
    this.readInterestOp = readInterestOp;
    try {
        ch.configureBlocking(false);
    } catch (IOException e) {
        try {
            ch.close();
        } catch (IOException e2) {
            if (logger.isWarnEnabled()) {
                logger.warn("Failed to close a partially initialized socket.", e2);
            }
        }

        throw new ChannelException("Failed to enter non-blocking mode.", e);
    }
}

• ch 属性，Netty NIO Channel 对象，持有的 Java 原生 NIO 的 Channel 对象。

• readInterestOp
  

  属性，感兴趣的读事件的操作位值。

  • 目前笔者看了 AbstractNioMessageChannel 是 SelectionKey.OP_ACCEPT ， 而 AbstractNioByteChannel 是 SelectionKey.OP_READ 。
  • 详细的用途，我们会在 「3.13.3 beginRead」 看到。

• 调用父 AbstractNioChannel 的构造方法。详细解析，见 「3.14.1.4 AbstractChannel」 。

• 调用

  SelectableChannel#configureBlocking(false)
  

  方法，设置 NIO Channel 为

  非阻塞

  。😈 这块代码是不是非常熟悉哟。

  • 若发生异常，关闭 NIO Channel ，并抛出异常。

3.14.1.4 AbstractChannel

/**
 * 父 Channel 对象
 */
private final Channel parent;
/**
 * Channel 编号
 */
private final ChannelId id;
/**
 * Unsafe 对象
 */
private final Unsafe unsafe;
/**
 * DefaultChannelPipeline 对象
 */
private final DefaultChannelPipeline pipeline;

protected AbstractChannel(Channel parent) {
    this.parent = parent;
    // 创建 ChannelId 对象
    id = newId();
    // 创建 Unsafe 对象
    unsafe = newUnsafe();
    // 创建 DefaultChannelPipeline 对象
    pipeline = newChannelPipeline();
}

• parent 属性，父 Channel 对象。对于 NioServerSocketChannel 的 parent 为空。

• id 属性，Channel 编号对象。在构造方法中，通过调用 #newId() 方法，进行创建。本文就先不分享，感兴趣的胖友自己看。

• unsafe 属性，Unsafe 对象。在构造方法中，通过调用 #newUnsafe() 方法，进行创建。本文就先不分享，感兴趣的胖友自己看。

  • 这里的 Unsafe 并不是我们常说的 Java 自带的sun.misc.Unsafe ，而是 io.netty.channel.Channel#Unsafe。

    // Channel.java#Unsafe
    /**
    * <em>Unsafe</em> operations that should <em>never</em> be called from user-code. These methods
    * are only provided to implement the actual transport, and must be invoked from an I/O thread except for the
    * following methods:
    * <ul>
    *   <li>{@link #localAddress()}</li>
    *   <li>{@link #remoteAddress()}</li>
    *   <li>{@link #closeForcibly()}</li>
    *   <li>{@link #register(EventLoop, ChannelPromise)}</li>
    *   <li>{@link #deregister(ChannelPromise)}</li>
    *   <li>{@link #voidPromise()}</li>
    * </ul>
    */
    

    • 这就是为什么叫 Unsafe 的原因。按照上述官网类的英文注释，Unsafe 操作不允许被用户代码使用。这些函数是真正用于数据传输操作，必须被IO线程调用。
    • 实际上，Channel 真正的具体操作，通过调用对应的 Unsafe 实现。😈 下文，我们将会看到。

  • Unsafe 不是一个具体的类，而是一个定义在 Channel 接口中的接口。不同的 Channel 类对应不同的 Unsafe 实现类。整体类图如下：

    

    Unsafe 类图

    • 对于 NioServerSocketChannel ，Unsafe 的实现类为 NioMessageUnsafe 。

• pipeline 属性，DefaultChannelPipeline 对象。在构造方法中，通过调用 #newChannelPipeline() 方法，进行创建。本文就先不分享，感兴趣的胖友自己看。

  ChannelPipeline 的英文注释：A list of ChannelHandlers which handles or intercepts inbound events and outbound operations of a Channel 。

3.14.1.5 小结

看到此处，我们来对 「3.1.4.1 创建 Channel 对象」 作一个小结。

对于一个 Netty NIO Channel 对象，它会包含如下几个核心组件：

• ChannelId
• Unsafe
• Pipeline
  • ChannelHandler
• ChannelConfig
• Java 原生 NIO Channel

如果不太理解，可以撸起袖子，多调试几次。

3.14.2 初始化 Channel 配置

#init(Channel channel) 方法，初始化 Channel 配置。它是个抽象方法，由子类 ServerBootstrap 或 Bootstrap 自己实现。代码如下：

abstract void init(Channel channel) throws Exception;

• ServerBootstrap 对该方法的实现，我们在 「4. ServerBootstrap」 中，详细解析。

3.14.3 注册 Channel 到 EventLoopGroup

EventLoopGroup#register(Channel channel) 方法，注册 Channel 到 EventLoopGroup 中。整体流程如下：

register 流程

3.14.3.1 register

EventLoopGroup 和 EventLoop 不是本文的重点，所以省略 1 + 2 + 3 部分的代码，从第 4 步的 AbstractUnsafe#register(EventLoop eventLoop, final ChannelPromise promise) 方法开始，代码如下：

 1: @Override
 2: public final void register(EventLoop eventLoop, final ChannelPromise promise) {
 3:     // 校验传入的 eventLoop 非空
 4:     if (eventLoop == null) {
 5:         throw new NullPointerException("eventLoop");
 6:     }
 7:     // 校验未注册
 8:     if (isRegistered()) {
 9:         promise.setFailure(new IllegalStateException("registered to an event loop already"));
10:         return;
11:     }
12:     // 校验 Channel 和 eventLoop 匹配
13:     if (!isCompatible(eventLoop)) {
14:         promise.setFailure(new IllegalStateException("incompatible event loop type: " + eventLoop.getClass().getName()));
15:         return;
16:     }
17: 
18:     // 设置 Channel 的 eventLoop 属性
19:     AbstractChannel.this.eventLoop = eventLoop;
20: 
21:     // 在 EventLoop 中执行注册逻辑
22:     if (eventLoop.inEventLoop()) {
23:         register0(promise);
24:     } else {
25:         try {
26:             eventLoop.execute(new Runnable() {
27:                 @Override
28:                 public void run() {
31:                     register0(promise);
32:                 }
33:             });
34:         } catch (Throwable t) {
35:             logger.warn("Force-closing a channel whose registration task was not accepted by an event loop: {}", AbstractChannel.this, t);
36:             closeForcibly();
37:             closeFuture.setClosed();
38:             safeSetFailure(promise, t);
39:         }
40:     }
41: }

• 第 3 至 6 行：校验传入的 eventLoop 参数非空。

• 第 7 至 11 行：调用 #isRegistered() 方法，校验未注册。代码如下：

  // AbstractChannel.java
  
  /**
   * 是否注册
   */
  private volatile boolean registered;
  
  @Override
  public boolean isRegistered() {
      return registered;
  }
  

• 第 12 至 16 行：校验 Channel 和 eventLoop 类型是否匹配，因为它们都有多种实现类型。代码如下：

  @Override
  protected boolean isCompatible(EventLoop loop) {
      return loop instanceof NioEventLoop;
  }
  

  • 要求 eventLoop 的类型为 NioEventLoop 。

• 第 19 行：【重要】设置 Channel 的 eventLoop 属性。

• 第 21 至 40 行：在

  evnetLoop
  

  中，调用

  #register0()
  

  方法，执行注册的逻辑。详细解析，见

  「3.14.3.2 register0」

  。

  • 第 34 至 39 行：若调用

    EventLoop#execute(Runnable)
    

    方法发生异常，则进行处理：

    • 第 36 行：调用 AbstractUnsafe#closeForcibly() 方法，强制关闭 Channel 。
    • 第 37 行：调用 CloseFuture#setClosed() 方法，通知 closeFuture 已经关闭。详细解析，见 《精尽 Netty 源码解析 —— Channel（七）之 close 操作》 。
    • 第 38 行：调用 AbstractUnsafe#safeSetFailure(ChannelPromise promise, Throwable cause) 方法，回调通知 promise 发生该异常。

3.14.3.2 register0

#register0(ChannelPromise promise) 方法，注册逻辑。代码如下：

 1: private void register0(ChannelPromise promise) {
 2:     try {
 3:         // check if the channel is still open as it could be closed in the mean time when the register
 4:         // call was outside of the eventLoop
 5:         if (!promise.setUncancellable() // TODO 1001 Promise
 6:                 || !ensureOpen(promise)) { // 确保 Channel 是打开的
 7:             return;
 8:         }
 9:         // 记录是否为首次注册
10:         boolean firstRegistration = neverRegistered;
11: 
12:         // 执行注册逻辑
13:         doRegister();
14: 
15:         // 标记首次注册为 false
16:         neverRegistered = false;
17:         // 标记 Channel 为已注册
18:         registered = true;
19: 
20:         // Ensure we call handlerAdded(...) before we actually notify the promise. This is needed as the
21:         // user may already fire events through the pipeline in the ChannelFutureListener.
22:         pipeline.invokeHandlerAddedIfNeeded();
23: 
24:         // 回调通知 `promise` 执行成功
25:         safeSetSuccess(promise);
26: 
27:         // 触发通知已注册事件
28:         pipeline.fireChannelRegistered();
29: 
30:         // TODO 芋艿
31:         // Only fire a channelActive if the channel has never been registered. This prevents firing
32:         // multiple channel actives if the channel is deregistered and re-registered.
33:         if (isActive()) {
34:             if (firstRegistration) {
35:                 pipeline.fireChannelActive();
36:             } else if (config().isAutoRead()) {
37:                 // This channel was registered before and autoRead() is set. This means we need to begin read
38:                 // again so that we process inbound data.
39:                 //
40:                 // See https://github.com/netty/netty/issues/4805
41:                 beginRead();
42:             }
43:         }
44:     } catch (Throwable t) {
45:         // Close the channel directly to avoid FD leak.
46:         closeForcibly();
47:         closeFuture.setClosed();
48:         safeSetFailure(promise, t);
49:     }
50: }

• 第 5 行：// TODO 1001 Promise

• 第 6 行：调用 #ensureOpen(ChannelPromise) 方法，确保 Channel 是打开的。代码如下：

  // AbstractUnsafe.java
  protected final boolean ensureOpen(ChannelPromise promise) {
      if (isOpen()) {
          return true;
      }
  
      // 若未打开，回调通知 promise 异常
      safeSetFailure(promise, ENSURE_OPEN_CLOSED_CHANNEL_EXCEPTION);
      return false;
  }
  
  // AbstractNioChannel.java
  @Override
  public boolean isOpen() {
      return ch.isOpen();
  }
  

• 第 10 行：记录是否首次注册。neverRegistered 变量声明在 AbstractUnsafe 中，代码如下：

  /**
   * 是否重未注册过，用于标记首次注册
   *
   * true if the channel has never been registered, false otherwise
   */
  private boolean neverRegistered = true;
  

• 第 13 行：调用 #doRegister() 方法，执行注册逻辑。代码如下：

  // NioUnsafe.java
    1: @Override
    2: protected void doRegister() throws Exception {
    3:     boolean selected = false;
    4:     for (;;) {
    5:         try {
    6:             selectionKey = javaChannel().register(eventLoop().unwrappedSelector(), 0, this);
    7:             return;
    8:         } catch (CancelledKeyException e) {
    9:             // TODO TODO 1003 doRegister 异常
   10:             if (!selected) {
   11:                 // Force the Selector to select now as the "canceled" SelectionKey may still be
   12:                 // cached and not removed because no Select.select(..) operation was called yet.
   13:                 eventLoop().selectNow();
   14:                 selected = true;
   15:             } else {
   16:                 // We forced a select operation on the selector before but the SelectionKey is still cached
   17:                 // for whatever reason. JDK bug ?
   18:                 throw e;
   19:             }
   20:         }
   21:     }
   22: }
  

  • 第 6 行：调用 #unwrappedSelector() 方法，返回 Java 原生 NIO Selector 对象。代码如下：

    // NioEventLoop.java
    
    private Selector unwrappedSelector;
    
    Selector unwrappedSelector() {
        return unwrappedSelector;
    }
    

    • 每个 NioEventLoop 对象上，都独有一个 Selector 对象。

  • 第 6 行：调用 #javaChannel() 方法，获得 Java 原生 NIO 的 Channel 对象。

  • 第 6 行：【重要】调用 SelectableChannel#register(Selector sel, int ops, Object att) 方法，注册 Java 原生 NIO 的 Channel 对象到 Selector 对象上。相信胖友对这块的代码是非常熟悉的，但是为什么感兴趣的事件是为 0 呢？正常情况下，对于服务端来说，需要注册 SelectionKey.OP_ACCEPT 事件呢！这样做的目的是( 摘自《Netty权威指南（第二版）》 )：

    1. 注册方式是多态的，它既可以被 NIOServerSocketChannel 用来监听客户端的连接接入，也可以注册 SocketChannel 用来监听网络读或者写操作。

    2. 通过

       SelectionKey#interestOps(int ops)
       

       方法可以方便地修改监听操作位。所以，此处注册需要获取 SelectionKey 并给 AbstractNIOChannel 的成员变量

       selectionKey
       

       赋值。

       • 如果不理解，没关系，在下文中，我们会看到服务端对 SelectionKey.OP_ACCEPT 事件的关注。😈

  • 第 8 至 20 行：TODO 1003 doRegister 异常

• 第 16 行：标记首次注册为 false 。

• 第 18 行：标记 Channel 为已注册。registered 变量声明在 AbstractChannel 中，代码如下：

  /**
   * 是否注册
   */
  private volatile boolean registered;
  

• 第 22 行：调用 DefaultChannelPipeline#invokeHandlerAddedIfNeeded() 方法，触发 ChannelInitializer 执行，进行 Handler 初始化。也就是说，我们在 「4.init」 写的 ServerBootstrap 对 Channel 设置的 ChannelInitializer 将被执行，进行 Channel 的 Handler 的初始化。

  • 具体的 pipeline 的内部调用过程，我们在后续文章分享。

• 第 25 行：调用 #safeSetSuccess(ChannelPromise promise) 方法，回调通知 promise 执行。在 「3.13.1 doBind」 小节，我们向 regFuture 注册的 ChannelFutureListener ，就会被立即回调执行。

  老艿艿：胖友在看完这小节的内容，可以调回 「3.13.2 doBind0」 小节的内容继续看。

• 第 28 行：调用 DefaultChannelPipeline#invokeHandlerAddedIfNeeded() 方法，触发通知 Channel 已注册的事件。

  • 具体的 pipeline 的内部调用过程，我们在后续文章分享。
  • 笔者目前调试下来，没有涉及服务端启动流程的逻辑代码。

• 第 33 至 43 行：TODO 芋艿

• 第 44 至 49 行：发生异常，和 #register(EventLoop eventLoop, final ChannelPromise promise) 方法的处理异常的代码，是一致的。

4. ServerBootstrap

io.netty.bootstrap.ServerBootstrap ，实现 AbstractBootstrap 抽象类，用于 Server 的启动器实现类。

4.1 构造方法

/**
 * 启动类配置对象
 */
private final ServerBootstrapConfig config = new ServerBootstrapConfig(this);
/**
 * 子 Channel 的可选项集合
 */
private final Map<ChannelOption<?>, Object> childOptions = new LinkedHashMap<ChannelOption<?>, Object>();
/**
 * 子 Channel 的属性集合
 */
private final Map<AttributeKey<?>, Object> childAttrs = new LinkedHashMap<AttributeKey<?>, Object>();
/**
 * 子 Channel 的 EventLoopGroup 对象
 */
private volatile EventLoopGroup childGroup;
/**
 * 子 Channel 的处理器
 */
private volatile ChannelHandler childHandler;

public ServerBootstrap() { }

private ServerBootstrap(ServerBootstrap bootstrap) {
    super(bootstrap);
    childGroup = bootstrap.childGroup;
    childHandler = bootstrap.childHandler;
    synchronized (bootstrap.childOptions) {
        childOptions.putAll(bootstrap.childOptions);
    }
    synchronized (bootstrap.childAttrs) {
        childAttrs.putAll(bootstrap.childAttrs);
    }
}

• config 属性，ServerBootstrapConfig 对象，启动类配置对象。
• 在 Server 接受一个 Client 的连接后，会创建一个对应的 Channel 对象。因此，我们看到 ServerBootstrap 的 childOptions、childAttrs、childGroup、childHandler 属性，都是这种 Channel 的可选项集合、属性集合、EventLoopGroup 对象、处理器。下面，我们会看到 ServerBootstrap 针对这些配置项的设置方法。

4.2 group

#group(..) 方法，设置 EventLoopGroup 到 group、childGroup 中。代码如下：

@Override
public ServerBootstrap group(EventLoopGroup group) {
    return group(group, group);
}

public ServerBootstrap group(EventLoopGroup parentGroup, EventLoopGroup childGroup) {
    super.group(parentGroup);
    if (childGroup == null) {
        throw new NullPointerException("childGroup");
    }
    if (this.childGroup != null) {
        throw new IllegalStateException("childGroup set already");
    }
    this.childGroup = childGroup;
    return this;
}

• 当只传入一个 EventLoopGroup 对象时，即调用的是 #group(EventLoopGroup group) 时，group 和 childGroup 使用同一个。一般情况下，我们不使用这个方法。

4.3 childOption

#childOption(ChannelOption<T> option, T value) 方法，设置子 Channel 的可选项。代码如下：

public <T> ServerBootstrap childOption(ChannelOption<T> childOption, T value) {
    if (childOption == null) {
        throw new NullPointerException("childOption");
    }
    if (value == null) { // 空，意味着移除
        synchronized (childOptions) {
            childOptions.remove(childOption);
        }
    } else { // 非空，进行修改
        synchronized (childOptions) {
            childOptions.put(childOption, value);
        }
    }
    return this;
}

4.4 childAttr

#childAttr(AttributeKey<T> key, T value) 方法，设置子 Channel 的属性。代码如下：

public <T> ServerBootstrap childAttr(AttributeKey<T> childKey, T value) {
    if (childKey == null) {
        throw new NullPointerException("childKey");
    }
    if (value == null) { // 空，意味着移除
        childAttrs.remove(childKey);
    } else { // 非空，进行修改
        childAttrs.put(childKey, value);
    }
    return this;
}

4.5 childHandler

#childHandler(ChannelHandler handler) 方法，设置子 Channel 的处理器。代码如下：

public ServerBootstrap childHandler(ChannelHandler childHandler) {
    if (childHandler == null) {
        throw new NullPointerException("childHandler");
    }
    this.childHandler = childHandler;
    return this;
}

4.6 validate

#validate() 方法，校验配置是否正确。代码如下：

@Override
public ServerBootstrap validate() {
    super.validate();
    if (childHandler == null) {
        throw new IllegalStateException("childHandler not set");
    }
    if (childGroup == null) {
        logger.warn("childGroup is not set. Using parentGroup instead.");
        childGroup = config.group();
    }
    return this;
}

4.7 clone

#clone() 方法，克隆 ServerBootstrap 对象。代码如下：

@Override
public ServerBootstrap clone() {
    return new ServerBootstrap(this);
}

• 调用参数为 bootstrap 为 ServerBootstrap 构造方法，克隆一个 ServerBootstrap 对象。

4.8 init

#init(Channel channel) 方法，初始化 Channel 配置。代码如下：

1: @Override
2: void init(Channel channel) throws Exception {
3:     // 初始化 Channel 的可选项集合
4:     final Map<ChannelOption<?>, Object> options = options0();
5:     synchronized (options) {
6:         setChannelOptions(channel, options, logger);
7:     }
8: 
9:     // 初始化 Channel 的属性集合
10:     final Map<AttributeKey<?>, Object> attrs = attrs0();
11:     synchronized (attrs) {
12:         for (Entry<AttributeKey<?>, Object> e: attrs.entrySet()) {
13:             @SuppressWarnings("unchecked")
14:             AttributeKey<Object> key = (AttributeKey<Object>) e.getKey();
15:             channel.attr(key).set(e.getValue());
16:         }
17:     }
18: 
19:     ChannelPipeline p = channel.pipeline();
20: 
21:     // 记录当前的属性
22:     final EventLoopGroup currentChildGroup = childGroup;
23:     final ChannelHandler currentChildHandler = childHandler;
24:     final Entry<ChannelOption<?>, Object>[] currentChildOptions;
25:     final Entry<AttributeKey<?>, Object>[] currentChildAttrs;
26:     synchronized (childOptions) {
27:         currentChildOptions = childOptions.entrySet().toArray(newOptionArray(0));
28:     }
29:     synchronized (childAttrs) {
30:         currentChildAttrs = childAttrs.entrySet().toArray(newAttrArray(0));
31:     }
32: 
33:     // 添加 ChannelInitializer 对象到 pipeline 中，用于后续初始化 ChannelHandler 到 pipeline 中。
34:     p.addLast(new ChannelInitializer<Channel>() {
35:         @Override
36:         public void initChannel(final Channel ch) throws Exception {
38:             final ChannelPipeline pipeline = ch.pipeline();
39: 
40:             // 添加配置的 ChannelHandler 到 pipeline 中。
41:             ChannelHandler handler = config.handler();
42:             if (handler != null) {
43:                 pipeline.addLast(handler);
44:             }
45: 
46:             // 添加 ServerBootstrapAcceptor 到 pipeline 中。
47:             // 使用 EventLoop 执行的原因，参见 https://github.com/lightningMan/netty/commit/4638df20628a8987c8709f0f8e5f3679a914ce1a
48:             ch.eventLoop().execute(new Runnable() {
49:                 @Override
50:                 public void run() {
52:                     pipeline.addLast(new ServerBootstrapAcceptor(
53:                             ch, currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));
54:                 }
55:             });
56:         }
57:     });
58: }}

• 第 3 至 7 行：将启动器配置的可选项集合，调用 #setChannelOptions(channel, options, logger) 方法，设置到 Channel 的可选项集合中。

• 第 9 至 17 行：将启动器配置的属性集合，设置到 Channel 的属性集合中。

• 第 21 至 31 行：记录启动器配置的子 Channel的属性，用于【第 52 至 53 行】的代码，创建 ServerBootstrapAcceptor 对象。

• 第 34 至 57 行：创建 ChannelInitializer 对象，添加到 pipeline 中，用于后续初始化 ChannelHandler 到 pipeline 中。

  • 第 40 至 44 行：添加启动器配置的 ChannelHandler 到 pipeline 中。

  • 第 46 至 55 行：创建 ServerBootstrapAcceptor 对象，添加到 pipeline 中。为什么使用 EventLoop 执行添加的过程？如果启动器配置的处理器，并且 ServerBootstrapAcceptor 不使用 EventLoop 添加，则会导致 ServerBootstrapAcceptor 添加到配置的处理器之前。示例代码如下：

    ServerBootstrap b = new ServerBootstrap();
    b.handler(new ChannelInitializer<Channel>() {
    
        @Override
        protected void initChannel(Channel ch) {
            final ChannelPipeline pipeline = ch.pipeline();
            ch.eventLoop().execute(new Runnable() {
                @Override
                public void run() {
                    pipeline.addLast(new LoggingHandler(LogLevel.INFO));
                }
            });
        }
    
    });
    

    • Netty 官方的提交，可见 github commit 。

  • ServerBootstrapAcceptor 也是一个 ChannelHandler 实现类，用于接受客户端的连接请求。详细解析，见后续文章。

  • 该 ChannelInitializer 的初始化的执行，在 AbstractChannel#register0(ChannelPromise promise) 方法中触发执行。

  • 那么为什么要使用 ChannelInitializer 进行处理器的初始化呢？而不直接添加到 pipeline 中。例如修改为如下代码：

    final Channel ch = channel;
    final ChannelPipeline pipeline = ch.pipeline();
    
    // 添加配置的 ChannelHandler 到 pipeline 中。
    ChannelHandler handler = config.handler();
    if (handler != null) {
        pipeline.addLast(handler);
    }
    
    // 添加 ServerBootstrapAcceptor 到 pipeline 中。
    // 使用 EventLoop 执行的原因，参见 https://github.com/lightningMan/netty/commit/4638df20628a8987c8709f0f8e5f3679a914ce1a
    ch.eventLoop().execute(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread() + ": ServerBootstrapAcceptor");
            pipeline.addLast(new ServerBootstrapAcceptor(
                    ch, currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));
        }
    });
    

    • 因为此时 Channel 并未注册到 EventLoop 中。如果调用 EventLoop#execute(Runnable runnable) 方法，会抛出 Exception in thread "main" java.lang.IllegalStateException: channel not registered to an event loop 异常。

666. 彩蛋

Netty 服务端启动涉及的流程非常多，所以有不理解的地方，胖友可以多多调试。在其中涉及到的 EventLoopGroup、EventLoop、Pipeline 等等组件，我们后在后续的文章，正式分享。

另外，也推荐如下和 Netty 服务端启动相关的文章，以加深理解：

• 闪电侠 《Netty 源码分析之服务端启动全解析》
• 小明哥 《【死磕 Netty 】—— 服务端启动过程分析》
• 占小狼 《Netty 源码分析之服务启动》
• 杨武兵 《Netty 源码分析系列 —— Bootstrap》
• 永顺 《Netty 源码分析之 一 揭开 Bootstrap 神秘的红盖头 (服务器端)》