摘要：原理剖析第篇之服務端啟動工作原理分析下一大致介紹由于篇幅過長難以發布，所以本章節接著上一節來的，上一章節為原理剖析第篇之服務端啟動工作原理分析上那么本章節就繼續分析的服務端啟動，分析的源碼版本為二三四章節請看上一章節詳見原理剖析第篇之

-

1、由于篇幅過長難以發布，所以本章節接著上一節來的，上一章節為【原理剖析（第 010 篇）Netty之服務端啟動工作原理分析(上)】；
2、那么本章節就繼續分析Netty的服務端啟動，分析Netty的源碼版本為：netty-netty-4.1.22.Final；

詳見 原理剖析（第 010 篇）Netty之服務端啟動工作原理分析(上)

上一章節，我們主要分析了一下線程管理組對象是如何被實例化的，并且還了解到了每個線程管理組都有一個子線程數組來處理任務；
那么接下來我們就直接從4.6開始分析了：

1、源碼：
    // NettyServer.java
    // 將 Boss、Worker 設置到 ServerBootstrap 服務端引導類中
    serverBootstrap.group(bossGroup, workerGroup)
            .channel(NioServerSocketChannel.class)
            // 指定通道類型為NioServerSocketChannel，一種異步模式，OIO阻塞模式為OioServerSocketChannel
            .localAddress("localhost", port)//設置InetSocketAddress讓服務器監聽某個端口已等待客戶端連接。
            .childHandler(new ChannelInitializer() {//設置childHandler執行所有的連接請求
                @Override
                protected void initChannel(Channel ch) throws Exception {
                    ch.pipeline().addLast(new PacketHeadDecoder());
                    ch.pipeline().addLast(new PacketBodyDecoder());

                    ch.pipeline().addLast(new PacketHeadEncoder());
                    ch.pipeline().addLast(new PacketBodyEncoder());

                    ch.pipeline().addLast(new PacketHandler());
                }
            });

2、主要為后序的通信設置了一些配置參數而已，指定構建的Channel為NioServerSocketChannel，說明需要啟動的是服務端Netty；
   而后面的服務端Channel實例化，就是需要通過這個參數反射實例化得到；

3、同時還設置childHandler，這個childHandler也是有順序的，服務端讀數據時執行的順序是PacketHeadDecoder、PacketBodyDecoder、PacketHandler；
   而服務端寫數據時執行的順序是PacketHandler、PacketBodyEncoder、PacketHeadEncoder；
   所以在書寫方式大家千萬別寫錯了，按照本示例代碼的方式書寫即可；

1、源碼：
    // NettyServer.java
    // 最后綁定服務器等待直到綁定完成，調用sync()方法會阻塞直到服務器完成綁定,然后服務器等待通道關閉，因為使用sync()，所以關閉操作也會被阻塞。
    ChannelFuture channelFuture = serverBootstrap.bind().sync();

2、這里其實沒什么好看的，接下來我們就主要看看這個bind()方法主要干了些啥，就這么簡簡單單一句代碼就把服務端給啟動起來了，有點神氣了；

1、源碼：
    // AbstractBootstrap.java
    /**
     * Create a new {@link Channel} and bind it.
     */
    public ChannelFuture bind() {
        validate();
        SocketAddress localAddress = this.localAddress;
        if (localAddress == null) {
            throw new IllegalStateException("localAddress not set");
        }
        return doBind(localAddress); // 創建一個Channel，并且綁定它
    }

    // AbstractBootstrap.java
    private ChannelFuture doBind(final SocketAddress localAddress) {
        final ChannelFuture regFuture = initAndRegister(); // 初始化和注冊

        // 執行到此，服務端大概完成了以下幾件事情：
        // 1、實例化NioServerSocketChannel，并為Channel配備了pipeline、config、unsafe對象；
        // 2、將多個handler添加至pipeline雙向鏈表中，并且等待Channel注冊成功后需要給每個handler觸發添加或者移除事件；
        // 3、將NioServerSocketChannel注冊到NioEventLoop的多路復用器上；

        final Channel channel = regFuture.channel();
        if (regFuture.cause() != null) {
            return regFuture;
        }

        // 既然NioServerSocketChannel的Channel綁定到了多路復用器上，那么接下來就是綁定地址，綁完地址就可以正式進行通信了
        if (regFuture.isDone()) {
            // At this point we know that the registration was complete and successful.
            ChannelPromise promise = channel.newPromise();
            doBind0(regFuture, channel, localAddress, promise);
            return promise;
        } else {
            // Registration future is almost always fulfilled already, but just in case it"s not.
            final PendingRegistrationPromise promise = new PendingRegistrationPromise(channel);
            regFuture.addListener(new ChannelFutureListener() {
                @Override
                public void operationComplete(ChannelFuture future) throws Exception {
                    Throwable cause = future.cause();
                    if (cause != null) {
                        // Registration on the EventLoop failed so fail the ChannelPromise directly to not cause an
                        // IllegalStateException once we try to access the EventLoop of the Channel.
                        promise.setFailure(cause);
                    } else {
                        // Registration was successful, so set the correct executor to use.
                        // See https://github.com/netty/netty/issues/2586
                        promise.registered();

                        doBind0(regFuture, channel, localAddress, promise);
                    }
                }
            });
            return promise;
        }
    }

2、大致一看，原來doBind方法主要干了兩件事情，initAndRegister與doBind0；

3、initAndRegister主要做的事情就是初始化服務端Channel，并且將服務端Channel注冊到bossGroup子線程的多路復用器上；

4、doBind0則主要完成服務端啟動的最后一步，綁定地址，綁定完后就可以正式進行通信了；

1、源碼：
    // AbstractBootstrap.java
    final ChannelFuture initAndRegister() {
        Channel channel = null;
        try {
            // 反射調用clazz.getConstructor().newInstance()實例化類
            // 同時也實例化了Channel，如果是服務端的話則為NioServerSocketChannel實例化對象
            // 在實例化NioServerSocketChannel的構造方法中，也為每個Channel創建了一個管道屬性對象DefaultChannelPipeline=pipeline對象
            // 在實例化NioServerSocketChannel的構造方法中，也為每個Channel創建了一個配置屬性對象NioServerSocketChannelConfig=config對象
            // 在實例化NioServerSocketChannel的構造方法中，也為每個Channel創建了一個unsafe屬性對象NioMessageUnsafe=unsafe對象
            channel = channelFactory.newChannel(); // 調用ReflectiveChannelFactory的newChannel方法

            // 初始化剛剛被實例化的channel
            init(channel);
        } catch (Throwable t) {
            if (channel != null) {
                // channel can be null if newChannel crashed (eg SocketException("too many open files"))
                channel.unsafe().closeForcibly();
                // as the Channel is not registered yet we need to force the usage of the GlobalEventExecutor
                return new DefaultChannelPromise(channel, GlobalEventExecutor.INSTANCE).setFailure(t);
            }
            // as the Channel is not registered yet we need to force the usage of the GlobalEventExecutor
            return new DefaultChannelPromise(new FailedChannel(), GlobalEventExecutor.INSTANCE).setFailure(t);
        }

        // config().group()=bossGroup或parentGroup，然后利用parentGroup去注冊NioServerSocketChannel=channel
        ChannelFuture regFuture = config().group().register(channel);
        if (regFuture.cause() != null) {
            if (channel.isRegistered()) {
                channel.close();
            } else {
                channel.unsafe().closeForcibly();
            }
        }

        // If we are here and the promise is not failed, it"s one of the following cases:
        // 1) If we attempted registration from the event loop, the registration has been completed at this point.
        //    i.e. It"s safe to attempt bind() or connect() now because the channel has been registered.
        // 2) If we attempted registration from the other thread, the registration request has been successfully
        //    added to the event loop"s task queue for later execution.
        //    i.e. It"s safe to attempt bind() or connect() now:
        //         because bind() or connect() will be executed *after* the scheduled registration task is executed
        //         because register(), bind(), and connect() are all bound to the same thread.

        return regFuture;
    }

2、逐行分析后會發現，首先通過反射實例化服務端channel對象，然后將服務端channel初始化一下；

3、然后調用bossGroup的注冊方法，將服務端channel作為參數傳入；

4、至此，方法名也表明該段代碼的意圖，實例化并初始化服務端Channel，然后注冊到bossGroup子線程的多路復用器上；

1、源碼：
    // ServerBootstrap.java
    @Override
    void init(Channel channel) throws Exception {
        final Map, Object> options = options0();
        synchronized (options) {
            setChannelOptions(channel, options, logger);
        }

        final Map, Object> attrs = attrs0();
        synchronized (attrs) {
            for (Entry, Object> e: attrs.entrySet()) {
                @SuppressWarnings("unchecked")
                AttributeKey