四、netty源码分析之ServerBootstrap

一、功能概述

前两篇我们分别介绍了EventLoopGroup和EventLoop在netty中的作用。但是仅仅知道这些，可能对netty如何完成一整个网络事件监控到任务分发处理还是有些模糊。本篇我们要分析一下netty的启动流程。在我们使用netty编程的时候，我们的使用ServerBootstrap和Bootstrap来实现服务端和客户端的启动。我们先来看一下这两个类的相关类图：

AbstractBootstrap

netty定义了抽象类AbstractBootstrap，然后在此基础上实现了ServerBootstrap和Bootstrap分别作为服务端和客户端的启动类。本篇，我们以ServerBootstrap为例，分析一下服务端的启动流程。

我们根据下面的测试代码分析一下具体的流程，这也是我们创建netty服务端的基本流程：

        EventLoopGroup bossGroup = new NioEventLoopGroup(); // (1)
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap b = new ServerBootstrap(); // (2)
            b.group(bossGroup, workerGroup)
             .channel(NioServerSocketChannel.class) // (3)
             .childHandler(new ChannelInitializer() { // (4)
                 @Override
                 public void initChannel(SocketChannel ch) throws Exception {
                     ch.pipeline().addLast(new DiscardServerHandler());
                 }
             })
             .option(ChannelOption.SO_BACKLOG, 128)          // (5)
             .childOption(ChannelOption.SO_KEEPALIVE, true); // (6)
    
            // Bind and start to accept incoming connections.
            ChannelFuture f = b.bind(port).sync(); // (7)
    
            // Wait until the server socket is closed.
            // In this example, this does not happen, but you can do that to gracefully
            // shut down your server.
            f.channel().closeFuture().sync();
        } finally {.
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }

二、ServerBootstrap启动的过程

我们看一下上面测试代码的内容，先是创建了两个EventLoopGroup的对象，bossGroup、workerGroup。然后又创建了一个ServerBootstrap对象，将这两个EventLoopGroup注册到ServerBootstrap中，然后设置一系列的参数，这些方法其实都是简单地设置ServerBootstrap的一些属性。设置完这些属性调用bind()方法实现端口的绑定，也就是整个netty服务端启动的核心过程。我们来分析一下bind()方法的的过程：

    public ChannelFuture bind() {
        validate();
        SocketAddress localAddress = this.localAddress;
        if (localAddress == null) {
            throw new IllegalStateException("localAddress not set");
        }
        return doBind(localAddress);
    }

    private ChannelFuture doBind(final SocketAddress localAddress) {
        final ChannelFuture regFuture = initAndRegister();
        final Channel channel = regFuture.channel();
        if (regFuture.cause() != null) {
            return regFuture;
        }

        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;
        }
    }

    private static void doBind0(
            final ChannelFuture regFuture, final Channel channel,
            final SocketAddress localAddress, final ChannelPromise promise) {

        // This method is invoked before channelRegistered() is triggered.  Give user handlers a chance to set up
        // the pipeline in its channelRegistered() implementation.
        channel.eventLoop().execute(new Runnable() {
            @Override
            public void run() {
                if (regFuture.isSuccess()) {
                    channel.bind(localAddress, promise).addListener(ChannelFutureListener.CLOSE_ON_FAILURE);
                } else {
                    promise.setFailure(regFuture.cause());
                }
            }
        });
    }

bind()方法在父类AbstractBootstrap中，这里我们有理由怀疑，这部分有用到了模板方法模式。首先调用了validate()方法，来验证参数的完整性，我们来看一下都验证了那些内容：

    /**
     * Validate all the parameters. Sub-classes may override this, but should
     * call the super method in that case.
     */
    public B validate() {
        if (group == null) {
            throw new IllegalStateException("group not set");
        }
        if (channelFactory == null) {
            throw new IllegalStateException("channel or channelFactory not set");
        }
        return self();
    }

这里验证了group和channelFactory这两个属性。在我们调用b.group(bossGroup, workerGroup)的时候，bossGroup就是validate()方法中验证的对象。AbstractBootstrap这个抽象类只持有了这一个EventLoopGroup对象，而workerGroup是我们ServerBootstrap扩展出来的。我们可以看到AbstractBootstrap.validate的方法注释中写道，子类可以重写这个方法，但是必须要调用super method。所以我们看一下ServerBootstrap有么有重写这个方法：

    @Override
    public ServerBootstrap validate() {
        super.validate();
        if (childHandler == null) {
            throw new IllegalStateException("childHandler not set");
        }
        if (childGroup == null) {
            logger.warn("childGroup is not set. Using parentGroup instead.");
            childGroup = config.group();
        }
        return this;
    }

果不其然，ServerBootstrap也重写了这个方法，这里验证了childGroup，也就是workerGroup。也验证了childHandler。这个childHandler我们后面在分析。
做完验证之后，调用了doBind(final SocketAddress localAddress)方法。我们看一下这个方法的内容。这个方法中，先是调用initAndRegister()创建并且注册Channel，并返回ChannelFuture。这个方法我们后面在看，我们先把doBind方法的主要流程理清楚。接下来，判断创建的Channel是否注册完成，如果完成就直接调用doBind0(regFuture, channel, localAddress, promise)，否则就添加一个监听器，等到Channel是否注册完成后再调用doBind0(regFuture, channel, localAddress, promise)。
doBind0(regFuture, channel, localAddress, promise)做了什么呢？其实也很简单，获取channel绑定的eventLoop事件处理器，然后提交一个任务，任务的内容就是调用channel的bind(SocketAddress localAddress, ChannelPromise promise)方法。其实这不是真正的将我们的服务绑定到指定端口的方法，这里的bind只是执行了一个生名周期中的回调方法而已，调用所有注册到ChannelPipeline当中的ChannelOutboundHandler对象的bind方法。
那么真正的将我们的服务绑定到指定端口的操作在哪里呢？我们目前还有initAndRegister()没有分析，所以，真正的绑定端口的操作，一定在这个方法里！我们看一下：

    final ChannelFuture initAndRegister() {
        Channel channel = null;
        try {
            channel = channelFactory.newChannel();
            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);
        }

        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;
    }

首先，通过我们设置的channelFactory来创建一个Channel。然后调用init方法来初始化Channel。我们可以看一下init方法。

   abstract void init(Channel channel) throws Exception

是一个抽象方法，交给子类去实现，这印证了我们刚开始猜测的·AbstractBootstrap.bind·是一个模板方法。我们先不看ServerBootstrap是怎么初始化channel的。我们还是先看一下initAndRegister()整体的流程。在初始化完channel后，通过调用config().group().register(channel)将channel注册到EventLoopGroup中，这个EventLoopGroup到底是哪个EventLoopGroup呢？其实是我们传入的bossGroup。这个过程做了什么操作呢？我们以传入的NioServerSocketChannel为例：结合我们前两偏分析的NioEventLoopGroup、NioEventLoop，我们可以知道，这个操作就是把NioServerSocketChannel持有的java的SelectableChannel注册到NioEventLoop持有的java的Selector中去，让Selector来监听IO事件。注册完之后initAndRegister()的处理过程就结束了。我们回过头去看ServerBootstrap是怎么实现abstract void init(Channel channel) throws Exception的：

    @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