从辅助类ServerBootstrap开始，一文讲解Netty启动全流程

// 创建两个EventLoop线程池
EventLoopGroup bossGroup = new NioEventLoopGroup(1);
EventLoopGroup workerGroup = new NioEventLoopGroup();


// 自定义Handler，本例中handler的功能就是简单的echo
final EchoServerHandler serverHandler = new EchoServerHandler();
try {
    // 正式流程开始
    // #1：创建ServerBootstrap:启动netty服务端的辅助类
    ServerBootstrap b = new ServerBootstrap();
    // #2：绑定EventLoopGroup:netty的Reactor线程池
    b.group(bossGroup, workerGroup)
    // #3：初始化channel:我们需要创建NioServerSocketChannel对象、同步创建了ChannelPipeline
     .channel(NioServerSocketChannel.class)
    // 参数配置先略过
     .option(ChannelOption.SO_BACKLOG, 100)
    // #4：服务端收到新的请求的时候处理，用来处理 ServerSocketChannel 实例
     .handler(new LoggingHandler(LogLevel.INFO))
    // #5：给新创建的连接用的，服务端 ServerSocketChannel 在 accept 一个连接以后，需要创建 SocketChannel 的实例
     .childHandler(new ChannelInitializer<SocketChannel>() {
         @Override
         public void initChannel(SocketChannel ch) throws Exception {
             // #6：添加ChannelHandler,串行的加入ChannelPipeline中，有顺序
             ChannelPipeline p = ch.pipeline();
             
             p.addLast(new LoggingHandler(LogLevel.INFO));
             p.addLast(serverHandler);
         }
     });


    // #7：绑定监听端口、启动服务端
    ChannelFuture f = b.bind(PORT).sync();


            // 阻塞等到channel关闭
    f.channel().closeFuture().sync();
} finally {
    
    // 关闭两个EventLoop线程池
    bossGroup.shutdownGracefully();
    workerGroup.shutdownGracefully();
}

// SocketChannel 的 parent 是 ServerSocketChannel
private final Channel parent;
// 唯一标识
private final ChannelId id;
// Netty 内部使用
private final Unsafe unsafe;
// pipeline 下面会讲
private final DefaultChannelPipeline pipeline;
// 绑定的线程
private volatile EventLoop eventLoop;

    // AbstractBootstrap#channel()
public B channel(Class<? extends C> channelClass) {
      // 设置 channelFactory 为 ReflectiveChannelFactory实例
      return channelFactory(new ReflectiveChannelFactory<C>(
              ObjectUtil.checkNotNull(channelClass, "channelClass")
      ));
}
// ReflectiveChannelFactory
// 工厂模式，通过反射拿到构造函数，再创建一个无参数的Channel实例
public ReflectiveChannelFactory(Class<? extends T> clazz) {
    ObjectUtil.checkNotNull(clazz, "clazz");
    try {
        this.constructor = clazz.getConstructor();
    } catch (NoSuchMethodException e) {
        throw new IllegalArgumentException("Class " + StringUtil.simpleClassName(clazz) +
                " does not have a public non-arg constructor", e);
    }
}


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

// 很重要的方法
final ChannelFuture initAndRegister() {
    Channel channel = null;
    try {
         // #1: 实例化一个channel
        channel = channelFactory.newChannel();
        // #2: 完善 pipeline，添加 handler
        init(channel);
    } catch (Throwable t) {
           ...
    }
    // #3：注册channel 到 eventLoop
    ChannelFuture regFuture = config().group().register(channel);
    ...
    return regFuture;
}


// 本小节只讲 channel 相关的 #1， #2、#3 下面再详细讲

AbstractBootstrap#initAndRegister()
AbstractBootstrap#doBind()
AbstractBootstrap#bind()
// 绑定监听端口、启动服务端
ChannelFuture f = b.bind(PORT).sync();

// 无参数构造方法
public NioServerSocketChannel() {
    // newSocket(provider) 方法会创建 JDK 的 ServerSocketChannel
    this(newSocket(DEFAULT_SELECTOR_PROVIDER));
}


// newSocket 方法
private static ServerSocketChannel newSocket(SelectorProvider provider) {
    try {
         // 创建一个 JDK 的 ServerSocketChannel
        return provider.openServerSocketChannel();
    } catch (IOException e) {
        throw new ChannelException(
                "Failed to open a server socket.", e);
    }
}

public NioServerSocketChannel(ServerSocketChannel channel) {
    // 服务端监听的的是 OP_ACCEPT事件，在这里设置了
    super(null, channel, SelectionKey.OP_ACCEPT);
    // 初始化一个Channel 的配置信息
    config = new NioServerSocketChannelConfig(this, javaChannel().socket());
}

protected AbstractNioMessageChannel(Channel parent, SelectableChannel ch, int readInterestOp) {
    // 结合上面得知，NioServerSocketChannel 的parent 为null
    super(parent, ch, readInterestOp);
}

protected AbstractNioChannel(Channel parent, SelectableChannel ch, int readInterestOp) {
    super(parent);
    this.ch = ch;
    this.readInterestOp = readInterestOp;
    try {
        // 设置channel为非阻塞
        ch.configureBlocking(false);
    } catch (IOException e) {
        ...
}

protected AbstractChannel(Channel parent) {
    this.parent = parent;
    // 初始化一个唯一ID
    id = newId();
    // 初始化一个 unsafe 实例
    unsafe = newUnsafe();
    // 初始化一个pipeline 实例
    pipeline = newChannelPipeline();
}

protected DefaultChannelPipeline(Channel channel) {
this.channel = ObjectUtil.checkNotNull(channel, "channel");
    succeededFuture = new SucceededChannelFuture(channel, null);
    voidPromise =  new VoidChannelPromise(channel, true);
    tail = new TailContext(this);
    head = new HeadContext(this);
    head.next = tail;
    tail.prev = head;
}

void init(Channel channel) throws Exception {
    ......
    // 拿到 channel 内部的 pipeline 实例
    ChannelPipeline p = channel.pipeline();
    ...
    // 开始往 pipeline 中添加一个 handler，这个 handler 是 ChannelInitializer 的实例
    p.addLast(new ChannelInitializer<Channel>() {


        //  initChannel 方法, 这里其实是可以自己实现一个ChannelInitializer，重新initChannel方法的
        @Override
        public void initChannel(final Channel ch) throws Exception {
            final ChannelPipeline pipeline = ch.pipeline();
            // 这个方法返回我们最开始指定的 LoggingHandler 实例
            ChannelHandler handler = config.handler();
            if (handler != null) {
                // 添加 LoggingHandler
                pipeline.addLast(handler);
            }


            // eventLoop 执行
            ch.eventLoop().execute(new Runnable() {
                @Override
                public void run() {
                    // 添加一个 handler 到 pipeline 中：ServerBootstrapAcceptor，用于接收客户端请求
                    pipeline.addLast(new ServerBootstrapAcceptor(
                            ch, currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));
                }
            });
        }
    });
}

// ChannelPromise 先不用管，知道是异步编程获取结果的一直方式就行
public final void register(EventLoop eventLoop, final ChannelPromise promise) {
    ...
    // 将这个 eventLoop 实例设置给这个 channel，从此这个 channel 就是有 eventLoop 的了
    // 我觉得这一步其实挺关键的，因为后续该 channel 中的所有异步操作，都要提交给这个 eventLoop 来执行
    AbstractChannel.this.eventLoop = eventLoop;


    // 如果发起 register 动作的线程就是 eventLoop 实例中的线程，那么直接调用 register0(promise)
    // 基本不会进入到这个分支，除非是先 unregister，然后再 register 的，后面再仔细看
    if (eventLoop.inEventLoop()) {
        register0(promise);
    } else {
        try {
            // 否则，提交任务给 eventLoop，eventLoop 中的线程会负责调用 register0(promise)
            eventLoop.execute(new Runnable() {
                @Override
                public void run() {
                    register0(promise);
                }
            });
        } catch (Throwable t) {
            ...
        }
    }
}

private void register0(ChannelPromise promise) {
    try {
        ...
        boolean firstRegistration = neverRegistered;
        // 进行 JDK 底层的操作：Channel 注册到 Selector
        doRegister();


        neverRegistered = false;
        registered = true;


        // 这一步也很关键，因为这涉及到了 ChannelInitializer 的 init(channel)
        // 我们之前说过，init 方法会将 ChannelInitializer 内部添加的 handlers 添加到 pipeline 中
        pipeline.invokeHandlerAddedIfNeeded();


        // 设置当前 promise 的状态为 success
        // 因为当前 register 方法是在 eventLoop 中的线程中执行的，需要通知提交 register 操作的线程
        safeSetSuccess(promise);


        // 当前的 register 操作已经成功，该事件应该被 pipeline 上
        // 所有关心 register 事件的 handler 感知到，往 pipeline 中扔一个事件
        pipeline.fireChannelRegistered();


        // 这里 active 指的是 channel 已经打开
        if (isActive()) {
            // 如果该 channel 是第一次执行 register，那么 fire ChannelActive 事件
            if (firstRegistration) {
                pipeline.fireChannelActive();
            } else if (config().isAutoRead()) {
                // 该 channel 之前已经 register 过了，
                // 这里让该 channel 立马去监听通道中的 OP_READ 事件
                beginRead();
            }
        }
    } catch (Throwable t) {
        ...
    }
}