@Override
public void start() throws WebServerException {
    if (this.disposableServer == null) {
        try {
            // 启动httpServer
            this.disposableServer = startHttpServer();
        }
        catch (Exception ex) {
            PortInUseException.ifCausedBy(ex, ChannelBindException.class, (bindException) -> {
                if (bindException.localPort() > 0 && !isPermissionDenied(bindException.getCause())) {
                    throw new PortInUseException(bindException.localPort(), ex);
                }
            });
            throw new WebServerException("Unable to start Netty", ex);
        }
        if (this.disposableServer != null) { // 启动成功，打印日志
            logger.info("Netty started" + getStartedOnMessage(this.disposableServer));
        }

        // 创建线程
        startDaemonAwaitThread(this.disposableServer);
    }
}

DisposableServer startHttpServer() {
    HttpServer server = this.httpServer;
    // 下面这个条件默认是true
    if (this.routeProviders.isEmpty()) {
        // 设置请求处理器
        server = server.handle(this.handler);
    }
    else {
        server = server.route(this::applyRouteProviders);
    }
    if (this.lifecycleTimeout != null) {
        return server.bindNow(this.lifecycleTimeout);
    }
    /*
     * 执行bind操作，HttpServer是reactor-netty提供的，所以离开了spring-boot范畴，
     * 最后会一直执行到netty层面的ServerBootstrap#bind()
     */
    return server.bindNow();
}

public final HttpServer handle(
        BiFunction<? super HttpServerRequest, ? super HttpServerResponse, ? extends Publisher<Void>> handler) {
    Objects.requireNonNull(handler, "handler");
    return childObserve(new HttpServerHandle(handler));
}

/*
 * 在SpringBoot中的NettyWebServer中的startHttpServer方法中调用了该方法
 */
public final DisposableServer bindNow() {
    // 设置绑定操作的超时时间为45秒
    return bindNow(Duration.ofSeconds(45));
}

public final DisposableServer bindNow(Duration timeout) {
    Objects.requireNonNull(timeout, "timeout");
    try {
        // 调用bind方法，必须在timeout之内绑定完成
        return Objects.requireNonNull(bind().block(timeout), "aborted");
    }
    catch (IllegalStateException e) {
        if (e.getMessage()
             .contains("blocking read")) {
            throw new IllegalStateException(getClass().getSimpleName() + " couldn't be started within " + timeout.toMillis() + "ms");
        }
        throw e;
    }
}

public Mono<? extends DisposableServer> bind() {
    // 这里的config参考HttpServerBind的无参构造器
    CONF config = configuration();
    Objects.requireNonNull(config.bindAddress(), "bindAddress");

    Mono<? extends DisposableServer> mono =  Mono.create(sink -> {
        // 在HttpServerBind中设置的以及这里获取到的都是InetSocketAddress
        SocketAddress local = Objects.requireNonNull(config.bindAddress().get(), "Bind Address supplier returned null");
        // HttpServerBind中的设置的是InetSocketAddress类型的
        if (local instanceof InetSocketAddress) {
            InetSocketAddress localInet = (InetSocketAddress) local;

            // 如果地址还没解析过则解析
            if (localInet.isUnresolved()) {
                local = AddressUtils.createResolved(localInet.getHostName(), localInet.getPort());
            }
        }

        boolean isDomainSocket = false;
        // 创建disposableServer
        DisposableBind disposableServer;
        // 对于HttpServerBind来说，这里的local是InetSocketAddress类型的，不是DomainSocketAddress
        if (local instanceof DomainSocketAddress) {
            isDomainSocket = true;
            disposableServer = new UdsDisposableBind(sink, config, local);
        }
        else {
            // 创建server
            disposableServer = new InetDisposableBind(sink, config, local);
        }

        /*
         * 创建连接观察者，config中的childObserver默认是空操作。
         * 所以在Spring Boot中会往HttpServer中添加一个handler，然后会被封装为ConnectionObserver。
         */
        ConnectionObserver childObs =
                new ChildObserver(config.defaultChildObserver().then(config.childObserver()));
        /*
         * 从config中获取eventLoop和channelInitializer来创建acceptor
         * 该acceptor就是reactor模型中的重要角色，
         * 这里通过config来获取EventLoopGroup、ChannelHandler、childOptions、childAttrs，
         * 这些都是Netty中的概念或组件。
         * 对于EventLoopGroup的获取，内部会通过LoopResources来实现。
         *
         * 这里的Acceptor继承了ChannelInboundHandlerAdapter，该类是Netty中的概念。
         *
         * 客户端连接到服务端后，Acceptor的channelRead方法会把通道注册到child事件循环中。
         */
        Acceptor acceptor = new Acceptor(config.childEventLoopGroup(), config.channelInitializer(childObs, null, true),
                config.childOptions, config.childAttrs, isDomainSocket);
        /*
         * 执行底层的bind操作
         * 这里的AcceptorInitializer是一个ChannelInitializer，用于初始化channel
         */
        TransportConnector.bind(config, new AcceptorInitializer(acceptor), local, isDomainSocket)
                          .subscribe(disposableServer);
    });

    // 这里默认是null，所以可以忽略
    if (config.doOnBind() != null) {
        // 执行bind回调
        mono = mono.doOnSubscribe(s -> config.doOnBind().accept(config));
    }
    return mono;
}

@SuppressWarnings("FutureReturnValueIgnored")
public static Mono<Channel> bind(TransportConfig config, ChannelInitializer<Channel> channelInitializer,
        SocketAddress bindAddress, boolean isDomainSocket) {
    Objects.requireNonNull(config, "config");
    Objects.requireNonNull(bindAddress, "bindAddress");
    Objects.requireNonNull(channelInitializer, "channelInitializer");

    /*
     * 先通过doInitAndRegister创建channel对象
     * config.eventLoopGroup().next()会从EventLoopGroup中选一个EventLoop
     */
    return doInitAndRegister(config, channelInitializer, isDomainSocket, config.eventLoopGroup().next())
            .flatMap(channel -> {
                MonoChannelPromise promise = new MonoChannelPromise(channel);
                // "FutureReturnValueIgnored" this is deliberate
                // 执行bind操作，至此进入了netty的范畴
                channel.eventLoop().execute(() -> channel.bind(bindAddress, promise.unvoid()));
                return promise;
            });
}

@Override
protected final EventLoopGroup eventLoopGroup() {
    // 获取boss事件循环组
    return loopResources().onServerSelect(isPreferNative());
}

final EventLoopGroup childEventLoopGroup() {
    /*
     * 创建worker group
     *
     * 这里的isPreferNative返回的是父类的属性preferNative，在父类的构造器中赋值为LoopResources.DEFAULT，
     * 而在LoopResources中，是获取名为reactor.netty.native的系统属性。（这里一般考虑为false的情况就行）
     */
    return loopResources().onServer(isPreferNative());
}

public final LoopResources loopResources() {
    // 这里考虑为null的情况
    return loopResources != null ? loopResources : defaultLoopResources();
}

protected abstract LoopResources defaultLoopResources();

int DEFAULT_IO_WORKER_COUNT = Integer.parseInt(System.getProperty(
        ReactorNetty.IO_WORKER_COUNT,
        // 默认是（逻辑）处理器个数，但是不能少于4
        "" + Math.max(Runtime.getRuntime().availableProcessors(), 4)));

int DEFAULT_IO_SELECT_COUNT = Integer.parseInt(System.getProperty(
        ReactorNetty.IO_SELECT_COUNT,
        // 默认是-1，没有选择线程，DefaultLoopResources的构造方法中会修改为和worker一样的数量
        "" + -1));

static LoopResources create(String prefix) {
    if (Objects.requireNonNull(prefix, "prefix").isEmpty()) {
        throw new IllegalArgumentException("Cannot use empty prefix");
    }
    // 创建默认的LoopResources实例，第二和第三个参数都是从系统属性中获取
    return new DefaultLoopResources(prefix, DEFAULT_IO_SELECT_COUNT, DEFAULT_IO_WORKER_COUNT, true);
}

long DEFAULT_POOL_ACQUIRE_TIMEOUT = Long.parseLong(System.getProperty(
        ReactorNetty.POOL_ACQUIRE_TIMEOUT,
        // 默认最多等45秒
        "" + 45000));

static ConnectionProvider create(String name, int maxConnections) {
    return builder(name).maxConnections(maxConnections) // 设置最大连接数
                        .pendingAcquireTimeout(Duration.ofMillis(DEFAULT_POOL_ACQUIRE_TIMEOUT))
                        .build();
}

// 创建HttpResources实例
HttpResources(LoopResources loops, ConnectionProvider provider) {
    super(loops, provider);
    http2ConnectionProvider = new AtomicReference<>();
}

@Override
public EventLoopGroup onServer(boolean useNative) {
    // 调用DefaultLoopResources中的方法
    return defaultLoops.onServer(useNative);
}

@Override
public EventLoopGroup onServerSelect(boolean useNative) {
    // 调用DefaultLoopResources中的方法
    return defaultLoops.onServerSelect(useNative);
}

@Override
public EventLoopGroup onServer(boolean useNative) {
    // 考虑useNative为false的情况
    if (useNative && LoopResources.hasNativeSupport()) {
        return cacheNativeServerLoops();
    }
    return cacheNioServerLoops();
}

@Override
public EventLoopGroup onServerSelect(boolean useNative) {
    if (useNative && LoopResources.hasNativeSupport()) {
        return cacheNativeSelectLoops();
    }
    return cacheNioSelectLoops();
}

@SuppressWarnings("FutureReturnValueIgnored")
EventLoopGroup cacheNioSelectLoops() {
    if (serverSelectLoops == serverLoops) {
        return cacheNioServerLoops();
    }

    // 获取缓存
    EventLoopGroup eventLoopGroup = serverSelectLoops.get();
    // 没有缓存
    if (null == eventLoopGroup) {
        // 新建boss事件循环组，负责select
        EventLoopGroup newEventLoopGroup = new NioEventLoopGroup(selectCount,
                threadFactory(this, "select-nio"));
        // 通过CAS设置
        if (!serverSelectLoops.compareAndSet(null, newEventLoopGroup)) {
            //"FutureReturnValueIgnored" this is deliberate
            // 设置失败则关闭新建的事件循环组
            newEventLoopGroup.shutdownGracefully(0, 0, TimeUnit.MILLISECONDS);
        }
        // 递归
        eventLoopGroup = cacheNioSelectLoops();
    }
    return eventLoopGroup;
}

static Mono<Channel> doInitAndRegister(
        TransportConfig config,
        ChannelInitializer<Channel> channelInitializer,
        boolean isDomainSocket,
        EventLoop eventLoop) {
    // 获取创建Channel对象的工厂，这里返回了一个lambda，内部仍然是通过LoopResources来创建Channel
    ChannelFactory<? extends Channel> channelFactory = config.connectionFactory(config.eventLoopGroup(), isDomainSocket);

    Channel channel = null;
    try {
        // 创建channel对象
        channel = channelFactory.newChannel();
        if (channelInitializer instanceof ServerTransport.AcceptorInitializer) {
            // 开启auto read
            ((ServerTransport.AcceptorInitializer) channelInitializer).acceptor.enableAutoReadTask(channel);
        }
        /*
         * 设置Channel初始化器，内部是把Acceptor添加在pipeline的末尾了，为什么这里不直接添加Acceptor？
         */
        channel.pipeline().addLast(channelInitializer);
        // 设置通道的选项，这里的选项在HttpServerBind中有设置
        setChannelOptions(channel, config.options, isDomainSocket);
        // 设置通道的属性，默认在HttpServerBind中没有设置任何属性
        setAttributes(channel, config.attrs);
    }
    catch (Throwable t) {
        if (channel != null) {
            channel.unsafe().closeForcibly();
        }
        return Mono.error(t);
    }

    MonoChannelPromise monoChannelPromise = new MonoChannelPromise(channel);
    // 将channel注册到事件循环中，但是此时还没有进行监听
    channel.unsafe().register(eventLoop, monoChannelPromise);
    return monoChannelPromise;
}

protected ChannelFactory<? extends Channel> connectionFactory(EventLoopGroup elg, boolean isDomainSocket) {
    /*
     * 返回一个Channel工厂，用于创建Channel实例。这里是通过LoopResources来创建的。
     * 这里考虑isDomainSocket为false的情况，所以通道类型为ServerSocketChannel。
     */
    return () -> loopResources().onChannel(channelType(isDomainSocket), elg);
}

protected abstract Class<? extends Channel> channelType(boolean isDomainSocket);

@Override
public <CHANNEL extends Channel> CHANNEL onChannel(Class<CHANNEL> channelType, EventLoopGroup group) {
    requireNonNull(channelType, "channelType");
    requireNonNull(group, "group");
    return defaultLoops.onChannel(channelType, group);
}

/*
 * 这里的channelType，重点考虑为ServerSocketChannel的情况
 */
default <CHANNEL extends Channel> CHANNEL onChannel(Class<CHANNEL> channelType, EventLoopGroup group) {
    // 这里就考虑DefaultLoopNativeDetector.NIO，其是一个DefaultLoopNIO类型的实例。
    DefaultLoop channelFactory =
            DefaultLoopNativeDetector.INSTANCE.supportGroup(group) ?
                    DefaultLoopNativeDetector.INSTANCE :
                    DefaultLoopNativeDetector.NIO;

    return channelFactory.getChannel(channelType);
}

@Override
@SuppressWarnings("unchecked")
public <CHANNEL extends Channel> CHANNEL getChannel(Class<CHANNEL> channelClass) {
    if (channelClass.equals(SocketChannel.class)) {
        return (CHANNEL) new NioSocketChannel();
    }
    if (channelClass.equals(ServerSocketChannel.class)) {
        // 创建Netty组件：非阻塞服务端网络通道
        return (CHANNEL) new NioServerSocketChannel();
    }
    if (channelClass.equals(DatagramChannel.class)) {
        return (CHANNEL) new NioDatagramChannel();
    }
    throw new IllegalArgumentException("Unsupported channel type: " + channelClass.getSimpleName());
}

static final class AcceptorInitializer extends ChannelInitializer<Channel> {

    final Acceptor acceptor;

    AcceptorInitializer(Acceptor acceptor) {
        this.acceptor = acceptor;
    }

    // 把acceptor添加到channel的管道末尾
    @Override
    public void initChannel(final Channel ch) {
        ch.eventLoop().execute(() -> ch.pipeline().addLast(acceptor));
    }
}

// 该方法会处理客户端连接通道。
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) {
    final Channel child = (Channel) msg;

    /*
     * 为客户端通道添加handler，这里的childHandler的类型其实是TransportChannelInitializer，是一个通道初始化器。
     * 这里执行add操作后，该handler被添加到通道的pipeline后，会封装延时任务，等通道注册时会执行这些延时任务。
     * 所以通道注册时会调用该handler的handlerAdd回调，在该回调中会调用initChannel方法。
     */
    child.pipeline().addLast(childHandler);

    // 为通道设置选项和属性
    TransportConnector.setChannelOptions(child, childOptions, isDomainSocket);
    TransportConnector.setAttributes(child, childAttrs);

    try {
        /*
         * 将客户端的通道注册到worker组的事件循环中，
         * 在register内部会调用next()方法来选择一个事件循环，然后将通道注册到该循环中。
         */
        childGroup.register(child).addListener((ChannelFutureListener) future -> {
            if (!future.isSuccess()) {
                forceClose(child, future.cause());
            }
        });
    }
    catch (Throwable t) {
        forceClose(child, t);
    }
}

public final ChannelInitializer<Channel> channelInitializer(ConnectionObserver connectionObserver,
        @Nullable SocketAddress remoteAddress, boolean onServer) {
    requireNonNull(connectionObserver, "connectionObserver");
    return new TransportChannelInitializer(this, connectionObserver, remoteAddress, onServer);
}

@Override
public ChannelFuture bind(SocketAddress localAddress) {
    return pipeline.bind(localAddress);
}

@Override
public void bind(
        ChannelHandlerContext ctx, SocketAddress localAddress, ChannelPromise promise) {
    // 调用通道的unsafe对象执行底层的bind操作。
    unsafe.bind(localAddress, promise);
}

@Override
public final void bind(final SocketAddress localAddress, final ChannelPromise promise) {
    assertEventLoop();

    if (!promise.setUncancellable() || !ensureOpen(promise)) {
        return;
    }

    boolean wasActive = isActive();
    try {
        // 调用JDK底层绑定端口
        doBind(localAddress);
    } catch (Throwable t) {
        safeSetFailure(promise, t);
        closeIfClosed();
        return;
    }

    /*
     * 这里判断了两个条件，避免重复发布事件，在上面的register0方法中也有发布该事件的逻辑，注意区分情况。
     */
    if (!wasActive && isActive()) {
        invokeLater(new Runnable() {
            @Override
            public void run() {
                // 传播channelActive事件
                pipeline.fireChannelActive();
            }
        });
    }

    safeSetSuccess(promise);
}

@SuppressJava6Requirement(reason = "Usage guarded by java version check")
@Override
protected void doBind(SocketAddress localAddress) throws Exception {
    if (PlatformDependent.javaVersion() >= 7) { // JDK版本大于等于7的情况
        // 通过底层JDK的通道执行bind操作，注意内部不仅会bind，还会listen
        javaChannel().bind(localAddress, config.getBacklog());
    } else {
        javaChannel().socket().bind(localAddress, config.getBacklog());
    }
}