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

-

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

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

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

1、源碼：
    // NettyServer.java
    // 將 Boss、Worker 設(shè)置到 ServerBootstrap 服務(wù)端引導(dǎo)類中
    serverBootstrap.group(bossGroup, workerGroup)
            .channel(NioServerSocketChannel.class)
            // 指定通道類型為NioServerSocketChannel，一種異步模式，OIO阻塞模式為OioServerSocketChannel
            .localAddress("localhost", port)//設(shè)置InetSocketAddress讓服務(wù)器監(jiān)聽某個端口已等待客戶端連接。
            .childHandler(new ChannelInitializer() {//設(shè)置childHandler執(zhí)行所有的連接請求
                @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、主要為后序的通信設(shè)置了一些配置參數(shù)而已，指定構(gòu)建的Channel為NioServerSocketChannel，說明需要啟動的是服務(wù)端Netty；
   而后面的服務(wù)端Channel實例化，就是需要通過這個參數(shù)反射實例化得到；

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

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

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

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); // 創(chuàng)建一個Channel，并且綁定它
    }

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

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

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

        // 既然NioServerSocketChannel的Channel綁定到了多路復(fù)用器上，那么接下來就是綁定地址，綁完地址就可以正式進行通信了
        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主要做的事情就是初始化服務(wù)端Channel，并且將服務(wù)端Channel注冊到bossGroup子線程的多路復(fù)用器上；

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

1、源碼：
    // AbstractBootstrap.java
    final ChannelFuture initAndRegister() {
        Channel channel = null;
        try {
            // 反射調(diào)用clazz.getConstructor().newInstance()實例化類
            // 同時也實例化了Channel，如果是服務(wù)端的話則為NioServerSocketChannel實例化對象
            // 在實例化NioServerSocketChannel的構(gòu)造方法中，也為每個Channel創(chuàng)建了一個管道屬性對象DefaultChannelPipeline=pipeline對象
            // 在實例化NioServerSocketChannel的構(gòu)造方法中，也為每個Channel創(chuàng)建了一個配置屬性對象NioServerSocketChannelConfig=config對象
            // 在實例化NioServerSocketChannel的構(gòu)造方法中，也為每個Channel創(chuàng)建了一個unsafe屬性對象NioMessageUnsafe=unsafe對象
            channel = channelFactory.newChannel(); // 調(diào)用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、逐行分析后會發(fā)現(xiàn)，首先通過反射實例化服務(wù)端channel對象，然后將服務(wù)端channel初始化一下；

3、然后調(diào)用bossGroup的注冊方法，將服務(wù)端channel作為參數(shù)傳入；

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

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