BootStrap在netty的应用程序中负责引导服务器和客户端。netty包含了两种不同类型的引导：

• 使用服务器的ServerBootStrap，用于接受客户端的连接以及为已接受的连接创建子通道。
• 用于客户端的BootStrap，不接受新的连接，并且是在父通道类完成一些操作。

本文主要分析ServerBootstarp相关源码。

Bootstrap类继承图：

Bootstrap类继承图.png

1、ServerBootstarap启动流程分析

1.1、ServerBootstarap简单启动代码

EventLoopGroup bossGroup = new NioEventLoopGroup(1);//用于接受accept事件的group serverSocketChannel 
EventLoopGroup group = new NioEventLoopGroup();  //用于真正读写事件的group socketChannel
try {
    //create ServerBootstrap instance  
    ServerBootstrap b = new ServerBootstrap();  //启动装载器，用于转载配置
    //Specifies NIO transport, local socket address  
    //Adds handler to channel pipeline  
    //使用NIO通道                                   
    //保持连接，如果不设置则一次通讯后自动断开
    b.group(bossGroup, group).channel(NioServerSocketChannel.class).option(ChannelOption.SO_KEEPALIVE, true).localAddress(port)
            .handler(new SimpleServerHandler())//服务端handler
            .childHandler(new ChannelInitializer<Channel>() {  //channel使用的handler
                @Override
                protected void initChannel(Channel ch) throws Exception {
                    ch.pipeline().addLast(new EchoServerHandler2(), new EchoServerHandler());
                }
            });
    //Binds server, waits for server to close, and releases resources  
    ChannelFuture f = b.bind().sync();
    System.out.println(EchoServer.class.getName() + "started and listen on �" + f.channel().localAddress());
    f.channel().closeFuture().sync();
} finally {
    group.shutdownGracefully().sync();
}

主要处理说明：

（1）、新建NioEventLoopGroup类型的bossGroup和group。bossGroup主要处理服务端接收客户端连接处理，group主要处理读写等I/O事件及任务等；
（2）、创建ServerBootstrap，其主要对一些处理进行代理，如bind()等操作，其是其他类的一个简单门面；
（3）、channel()方法设置服务端的ServerSocketChannel实现类，本处实现类为NioServerSocketChannel。
（4）、option()方法设置Channel的相关选项，具体查看ChannelOption中的定义；
（5）、localAddress()设置服务端绑定的本地地址及端口；
（6）、handler()设置服务端的对应Channel的Handler;
（7）、childHandler()设置子连接的Channel的Handler；
（8）、bind()及sync()绑定本地地址并同步返回绑定结果；

1.2、bind()调用流程

bind()调用流程图：

bind()调用流程图.png

（1）、调用ServerBootstrap.bind()：应用调用ServerBootstrap的bind()操作；
（2）、调用AbstractBootstrap.bind()：调用doBind()对进行bind操作；
（3）、调用AbstractBootstrap.initAndRegister()：利用ChannelFactory.newChannel()实例化NioServerSocketChannel；
（4）、调用ServerBootstrap.init()：对NioServerSocketChannel进行初始化，主要操作如设置Channel相关的选项及属性、设置ChannelHandler为ServerBootstrapAcceptor等，ServerBootstrapAcceptor为inbound类型的ChannelHandler，其为ServerBootstrap的内部类，其主要实现ChannelRead()操作，将客户端的连接注册到EventLoopGroup的EventLoop中。
（5）、调用NioEventLoop.register()：将NioServerSocketChannel注册到bossGroup中。
（6）、调用AbstractBootstrap.doBind0：将实际的bind操作以任务的形式添加到bossGroup的EventLoop中。
（7）、调用NioServerSocketChannel.bind()：在EventLoop中以任务的形式调用此方法进行实际的bind()操作。

2、主要方法源码分析

2.1、doBind()源码分析

doBind()源码：

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

主要流程处理：

• 调用initAndRegister()初始化Channel并将其注册到bossGroup中的NioEventLoop中；
• 若注册成功，则调用doBind0()进行实际的bind操作；
• 若还未注册，则创建注册结果的监听器及doBind0()的异步结果，若Channel注册成功，则在结果监听器中进行doBind0()操作，并将bind()异步结果这种为成功；否则将在监听器中设置异步结果为失败；

2.2、initAndRegister()源码分析

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；
• 调用ServerBootstrap的init()方法对Channel进行初始化；

2.3、init()源码分析

init()源码：

void init(Channel channel) throws Exception {
    final Map<ChannelOption<?>, Object> options = options0();
    synchronized (options) {
        setChannelOptions(channel, options, logger);
    }

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

    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(0));
    }
    synchronized (childAttrs) {
        currentChildAttrs = childAttrs.entrySet().toArray(newAttrArray(0));
    }

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

            ch.eventLoop().execute(new Runnable() {
                @Override
                public void run() {
                    pipeline.addLast(new ServerBootstrapAcceptor(
                            ch, currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));
                }
            });
        }
    });
}

主要处理流程：

• 如果设置了Channel选项，则调用setChannelOptions()对Channel进行选项设置；
• 如果设置了属性，则将对应属性设置为Channel的属性；
• 设置子Channel的选项及属性；
• 初始化NioServerSocketChannel的ChannelHandler为ServerBootstrapAcceptor，ServerBootstrapAcceptor为inbound类型的ChannelHandler，其主要功能是将已经接受连接的子Channel注册到workerGroup的NioEventLoop中；

2.4、doBind0()源码分析

doBind0()源码：

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

主要处理流程：

• 将NioServerSocketChannel.bind()操作封装为任务，并将任务提交给其对应的EventLoop进行处理；

2.5、ServerBootstrapAcceptor源码分析

2.5.1、ServerBootstrapAcceptor类继承图：

ServerBootstrapAcceptor类继承图.png

ServerBootstrapAcceptor为NioServerSocketChannel的ChannelHandler，其类型为Inbound类型；

2.5.2、ServerBootstrapAcceptor源码：

private static class ServerBootstrapAcceptor extends ChannelInboundHandlerAdapter {

    private final EventLoopGroup childGroup;
    private final ChannelHandler childHandler;
    private final Entry<ChannelOption<?>, Object>[] childOptions;
    private final Entry<AttributeKey<?>, Object>[] childAttrs;
    private final Runnable enableAutoReadTask;

    ServerBootstrapAcceptor(
            final Channel channel, EventLoopGroup childGroup, ChannelHandler childHandler,
            Entry<ChannelOption<?>, Object>[] childOptions, Entry<AttributeKey<?>, Object>[] childAttrs) {
        this.childGroup = childGroup;
        this.childHandler = childHandler;
        this.childOptions = childOptions;
        this.childAttrs = childAttrs;

        // Task which is scheduled to re-enable auto-read.
        // It's important to create this Runnable before we try to submit it as otherwise the URLClassLoader may
        // not be able to load the class because of the file limit it already reached.
        //
        // See https://github.com/netty/netty/issues/1328
        enableAutoReadTask = new Runnable() {
            @Override
            public void run() {
                channel.config().setAutoRead(true);
            }
        };
    }

    @Override
    @SuppressWarnings("unchecked")
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        final Channel child = (Channel) msg;

        child.pipeline().addLast(childHandler);

        setChannelOptions(child, childOptions, logger);

        for (Entry<AttributeKey<?>, Object> e: childAttrs) {
            child.attr((AttributeKey<Object>) e.getKey()).set(e.getValue());
        }

        try {
            childGroup.register(child).addListener(new ChannelFutureListener() {
                @Override
                public void operationComplete(ChannelFuture future) throws Exception {
                    if (!future.isSuccess()) {
                        forceClose(child, future.cause());
                    }
                }
            });
        } catch (Throwable t) {
            forceClose(child, t);
        }
    }

    private static void forceClose(Channel child, Throwable t) {
        child.unsafe().closeForcibly();
        logger.warn("Failed to register an accepted channel: {}", child, t);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        final ChannelConfig config = ctx.channel().config();
        if (config.isAutoRead()) {
            // stop accept new connections for 1 second to allow the channel to recover
            // See https://github.com/netty/netty/issues/1328
            config.setAutoRead(false);
            ctx.channel().eventLoop().schedule(enableAutoReadTask, 1, TimeUnit.SECONDS);
        }
        // still let the exceptionCaught event flow through the pipeline to give the user
        // a chance to do something with it
        ctx.fireExceptionCaught(cause);
    }
}

ServerBootstrapAcceptor主要实现了以下方法：
（1）、channelRead()：设置子连接的ChannelHandler、设置子连接的Channel选项，设置子连接的Channel属性，将子连接注册的child对应的EventLoop中（即workerGroup的EventLoop中）；
（2）、exceptionCaught()：若ServerSocketChannel在accept子连接时抛出异常，若ServerSocketChannel的autoRead为true，则设置其为false，即不允许自动接收客户端连接，并延迟1s后再设置其为true，使其允许自动接收客户端连接；

相关阅读:
Netty源码愫读（一）ByteBuf相关源码学习 【https://www.jianshu.com/p/016daa404957】
Netty源码愫读（二）Channel相关源码学习【https://www.jianshu.com/p/02eac974258e】
Netty源码愫读（三）ChannelPipeline、ChannelHandlerContext相关源码学习【https://www.jianshu.com/p/be82d0fcdbcc】
Netty源码愫读（四）ChannelHandler相关源码学习【https://www.jianshu.com/p/6ee0a3b9d73a】
Netty源码愫读（五）EventLoop与EventLoopGroup相关源码学习【https://www.jianshu.com/p/05096995d296】

参考书籍：

《Netty权威指南》第二版