1. 唠叨

及时分享学习所得。希望与您共勉，一起学习共同进步。

2. 服务端 Channel 初始化

（重点）我们还是先抓重点。下面是初始化 Netty 服务端 Channel 的主线，请牢记。

1. ServerBootstrap.bind(int inetPort)
2. AbstractBootstrap.bind(SocketAddress localAddress)
3. AbstractBootstrap.doBind(final SocketAddress localAddress)
4. AbstractBootstrap.initAndRegister()
5. ServerBootstrap.init(Channel channel)

前 4 步，与上一讲服务端 Channel 创建原理一致。所以，初始化流程都在 ServerBootstrap.init 中

2.1 一起看源码

（唠叨）又到了有趣的查看源码环节。现在打开您的 IDE 我们一起走一遍上面的流程。我们看到 ServerBootstrap.init 中大部分逻辑都是在初始化与创建对象。嗑...嗑...嗑...对本章就在学习初始化原理。相当正确没跑题。

（重点）那初始化了什么？又创建了什么？

1. 初始化 NioServerSocketChannel 的 config 与 attributes
2. 在 pipeline 中添加 config.handler()
3. 创建 ServerBootstrapAcceptor（连接器）并添加到 pipeline 中

源码 1

// 我是 ServerBootstrap 类的 init 方法源码
void init(Channel channel) throws Exception {
        // 初始化 NioServerSocketChannel 的 config 与 attributes
        final Map<ChannelOption<?>, Object> options = options0();
        synchronized (options) {
            channel.config().setOptions(options);   // 1
        }

        final Map<AttributeKey<?>, Object> attrs = attrs0();
        synchronized (attrs) {
            for (Entry<AttributeKey<?>, Object> e: attrs.entrySet()) {
                @SuppressWarnings("unchecked")
                AttributeKey<Object> key = (AttributeKey<Object>) e.getKey();
                channel.attr(key).set(e.getValue());  // 2
            }
        }

        ChannelPipeline p = channel.pipeline();

        final EventLoopGroup currentChildGroup = childGroup;
        final ChannelHandler currentChildHandler = childHandler;
        final Entry<ChannelOption<?>, Object>[] currentChildOptions;
        final Entry<AttributeKey<?>, Object>[] currentChildAttrs;
        synchronized (childOptions) {
            currentChildOptions = childOptions.entrySet().toArray(newOptionArray(childOptions.size())); 
        }
        synchronized (childAttrs) {
            currentChildAttrs = childAttrs.entrySet().toArray(newAttrArray(childAttrs.size())); 
        }

        p.addLast(new ChannelInitializer<Channel>() {
            @Override
            public void initChannel(Channel ch) throws Exception {
                final ChannelPipeline pipeline = ch.pipeline();
                ChannelHandler handler = config.handler();  // 3
                if (handler != null) {
                    pipeline.addLast(handler);  // 在 pipeline 中添加 config.handler()
                }

                // We add this handler via the EventLoop as the user may have used a ChannelInitializer as handler.
                // In this case the initChannel(...) method will only be called after this method returns. Because
                // of this we need to ensure we add our handler in a delayed fashion so all the users handler are
                // placed in front of the ServerBootstrapAcceptor.
                ch.eventLoop().execute(new Runnable() {
                    @Override
                    public void run() {
                        // 创建 ServerBootstrapAcceptor（连接器）并添加到 pipeline 中
                        pipeline.addLast(new ServerBootstrapAcceptor(
                                currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));  
                    }
                });
            }
        });
    }

2.2 出师了

恭喜您，您已经掌握了服务端 Channel 的初始化原理。这次时候是真的，源码也确实很简单。是不是没什么疑问了？真的没有了？那么请尝试回答这几个问题 channel.config() 是什么？channel.attr 是什么？ChannelHandler handler 是什么？ServerBootstrapAcceptor 中的 4 个参数又什么是呢？（我又来卖关子了，你能怎样？）如果以上问题您都清楚，那么恭喜您真的懂了。否则，我们继续研究。

2.3 channel.config() 是什么

其实我上节讲过，有图有真相

图 1

所以 NioServerSocketChannel 的配置保存在 ServerSocketChannelConfig 的实例对象 config 中，它是在 NioServerSocketChannel 的构造函数中创建的。

2.4 channel.attr 是什么

如果你已经打开了 IDE 此时你会发现它是 DefaultAttributeMap 中的方法。
（唠叨）慌了东西越来越多，每次看开源代码都是这样，调用层次越来越深。最后直到迷失、放弃。
不急，下面我帮您分析一下。

1. NioServerSocketChannel extends AbstractNioMessageChannel
2. AbstractNioMessageChannel extends AbstractNioChannel
3. AbstractNioChannel extends AbstractChannel
4. AbstractChannel extends DefaultAttributeMap

怎么样？懂了吗？DefaultAttributeMap 是 NioServerSocketChannel 的爸爸。那它的 attr 自然也就被孩子继承了。它里面存储我们自定义的一些属性（key，value）。

2.5 ChannelHandler handler 是什么

它是通过 AbstractBootstrapConfig 的 handler 方法获取的

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

而 bootstrap.handler() 调用了 AbstractBootstrap 的 handler 方法，最终直接返回 handler

    final ChannelHandler handler() {
        return handler;
    }

现在我又需要上图了

图 2
由图可知，它就是在第一节，源码 1 标注 6 处我们传入的 ServerHandler (这是一个自定义的 handler)。

2.6 ServerBootstrapAcceptor 中的 4 个参数是什么

currentChildGroup 就是 childGroup。 而 childGroup 需要参看 图 2 源码标准 2 处，我们调用了 ServerBootstrap 的 group(EventLoopGroup parentGroup, EventLoopGroup childGroup) 方法。所以，childGroup 就是我们传入的 workerGroup

    public ServerBootstrap group(EventLoopGroup parentGroup, EventLoopGroup childGroup) {
        // 省略
        this.childGroup = childGroup;
        return this;
    }

currentChildHandler 就是 childHandler。而 childHandler 需要参看 图 2 源码标准 7 处，我们调用了 ServerBootstrap 的 childHandler(ChannelHandler childHandler) 方法。所以，childHandler 就是我们传入的 ChannelInitializer
同理 currentChildOptions 和 currentChildAttrs 也很容易查找到，这里留给您自行分析。
通过以上分析，相信您已经掌握了服务端 Channel 的初始化原理。
最后，感谢您的阅读，希望以上内容对您有所帮助。如果有疑问，欢迎留言与我讨论。