Netty源码分析-Bootstrap

Bootstrap 是 Netty 提供的客户端和服务器启动入口类，其提供了完善的服务配置参数，供开发者合理化配置自身服务。源码分析将从Bootstrap开始着手，逐个分析Netty的各个核心组建及设计理念。

写在前面

Java NIO已经将Java对于网络IO的操作提供了完善的API，Netty只是将其包装更方便使用，因此Netty源码分析的重点应该是Java NIO，因此需要先行了解Java NIO的API。

入手

开发一个TCP服务一般从EchoServer和EcheClient开始，顾名思义就是讲发送的内容原封不动的返回至客户端。

客户端代码核心：

EventLoopGroup group = new NioEventLoopGroup();
try {
    Bootstrap b = new Bootstrap();
    b.group(group)
     .channel(NioSocketChannel.class)
     .option(ChannelOption.TCP_NODELAY, true)
     .handler(new ChannelInitializer() {
         @Override
         public void initChannel(SocketChannel ch) throws Exception {
             ChannelPipeline p = ch.pipeline();
             p.addLast(new EchoClientHandler());
         }
     });

    // Start the client.
    ChannelFuture f = b.connect(HOST, PORT).sync();

    // Wait until the connection is closed.
    f.channel().closeFuture().sync();
} finally {
    // Shut down the event loop to terminate all threads.
    group.shutdownGracefully();
}

服务器代码核心：

EventLoopGroup bossGroup = new NioEventLoopGroup(1);
EventLoopGroup workerGroup = new NioEventLoopGroup();
try {
    ServerBootstrap b = new ServerBootstrap();
    b.group(bossGroup, workerGroup)
     .channel(NioServerSocketChannel.class)
     .option(ChannelOption.SO_BACKLOG, 100)
     .handler(new LoggingHandler(LogLevel.INFO))
     .childHandler(new ChannelInitializer() {
         @Override
         public void initChannel(SocketChannel ch) throws Exception {
             ChannelPipeline p = ch.pipeline();
             p.addLast(new EchoServerHandler());
         }
     });
    ChannelFuture f = b.bind(PORT).sync();
    f.channel().closeFuture().sync();
} finally {
    bossGroup.shutdownGracefully();
    workerGroup.shutdownGracefully();
}

上述demo是一个netty的入门demo，但是这里包含了很多接下来将会重点介绍的内容，包括Reactor模型的NioEventLoop，抽象连接的Channel，处理数据的ChannelHandler和非阻塞相关的ChannelFuture。

1.EventLoop

客户端和服务器初始化EventLoopGroup时明显存在差异，服务器会初始化两个EventLoopGroup，其中bossGroup用户处理连接请求，workerGroup用于处理后续连接上的IO事件。因此客户端只需要一个workerGroup去处理IO事件。

在初始化bootstrap时，传入的EventLoop类型都是NioEventLoopGroup，分析其构造函数最终调用的是MultithreadEventExecutorGroup的构造函数。Netty允许我们设置EventLoop中线程数量，如果没有设置则使用处理器核心数 * 2。

    protected MultithreadEventExecutorGroup(int nThreads, Executor executor,
                                            EventExecutorChooserFactory chooserFactory, Object... args) {
        ...
        children = new EventExecutor[nThreads];

        for (int i = 0; i < nThreads; i ++) {
            boolean success = false;
            try {
                children[i] = newChild(executor, args);
                success = true;
            } catch (Exception e) {
                throw new IllegalStateException("failed to create a child event loop", e);
            } finally {
                ...
            }
        }

        chooser = chooserFactory.newChooser(children);
        ...
    }

根据代码, 我们可以发现生成了一个大小为 nThreads 的 EventExecutor数组，newChild方法的实现在NioEventLoopGroup中，生成的实例是NioEventLoop。另外根据 nThreads是否是2的幂选择chooser，如果是2的幂使用PowerOfTwoEventExecutorChooser，反之使用 GenericEventExecutorChooser。chooser的功能是每当 Netty 需要一个 EventLoop 时，会调用 next() 方法获取一个可用的 EventLoop，其实现方式基本类似。

public EventExecutor next() {
    return chooser.next();
}

2.Channel

我们以TCP为例，Netty使用Channel抽象一个Socket连接，它提供了完善的Socket连接状态查询以及网络IO读写等操作。另外Netty也提供了很多不同阻塞类型和不同协议的Channel，其中NIO为前缀的表示非阻塞，OIO为前缀的便是阻塞：

• NioSocketChannel, 代表异步的客户端 TCP Socket 连接.
• NioServerSocketChannel, 异步的服务器端 TCP Socket 连接.
• NioDatagramChannel, 异步的 UDP 连接
• NioSctpChannel, 异步的客户端 Sctp 连接.
• NioSctpServerChannel, 异步的 Sctp 服务器端连接.
• OioSocketChannel, 同步的客户端 TCP Socket 连接.
• OioServerSocketChannel, 同步的服务器端 TCP Socket 连接.
• OioDatagramChannel, 同步的 UDP 连接
• OioSctpChannel, 同步的 Sctp 服务器端连接.
• OioSctpServerChannel, 同步的客户端 TCP Socket 连接.

Bootstrap通过channel()方法设置创建的Channel类型，其实现过程是设置了ChannelFactory

public B channel(Class channelClass) {
    if (channelClass == null) {
        throw new NullPointerException("channelClass");
    }
    return channelFactory(new BootstrapChannelFactory(channelClass));
}

而 BootstrapChannelFactory 实现了 ChannelFactory 接口, 它提供了唯一的方法, 即 newChannel()。其核心代码如下：

@Override
public T newChannel() {
    try {
        return clazz.newInstance();
    } catch (Throwable t) {
        throw new ChannelException("Unable to create Channel from class " + clazz, t);
    }
}

客户端和服务器的行为是不同的，因此在实例化Channel这个动作也存在不同，客户端通过connect()触发，而服务器通过bind()触发，这两个操作对于客户端或者服务器来说虽然不同但是却必须的操作。

初始化Channel的函数是AbstractBootstrap#initAndRegister()，共三步：

1. 创建Channel实例
2. 第二步初始化Channel
3. Channel注册至EventLoop。

final ChannelFuture initAndRegister() {
    final Channel channel = channelFactory().newChannel();
    try {
        init(channel);
    } catch (Throwable t) {
       ...
    }
    ChannelFuture regFuture = group().register(channel);
    ...
}

2.1创建Channel

ChannelFactory#newChannel 中，通过newInstance 来创建一个新 Channel 实例，客户端和服务器传入的Channel类型不同，其中客户端传入的是NioSocketChannel ，而服务器传入的是ServerSocketChannel。

我们首先分析NioSocketChannel 默认构造器代码如下:

public NioSocketChannel() {
    this(DEFAULT_SELECTOR_PROVIDER);
}

/**
 * Create a new instance using the given {@link SelectorProvider}.
 */
public NioSocketChannel(SelectorProvider provider) {
    this(newSocket(provider));
}

/**
 * Create a new instance using the given {@link SocketChannel}.
 */
public NioSocketChannel(SocketChannel socket) {
    this(null, socket);
}

public NioSocketChannel(Channel parent, SocketChannel socket) {
    super(parent, socket);
    config = new NioSocketChannelConfig(this, socket.socket());
}

其调用的父类构造函数过程：NioSocketChannel->AbstractNioByteChannel->AbstractNioChannel->AbstractChannel。AbstractNioByteChannel的构造函数中可以看到客户端主动连接的channel的监听事件是OP_READ

protected AbstractNioByteChannel(Channel parent, SelectableChannel ch) {
    super(parent, ch, SelectionKey.OP_READ);
}

其中newSocket方法会通过创建一个新的Java NIO socketChannel

private static SocketChannel newSocket(SelectorProvider provider) {
    try {
        return provider.openSocketChannel();
    } catch (IOException e) {
        throw new ChannelException("Failed to open a socket.", e);
    }
}

AbstractNioChannel中可以看到将channel设置为非阻塞。

protected AbstractNioChannel(Channel parent, SelectableChannel ch, int readInterestOp) {
    super(parent);
    this.ch = ch;
    this.readInterestOp = readInterestOp;
    try {
        ch.configureBlocking(false);
    } catch (IOException e) {
        try {
            ch.close();
        } catch (IOException e2) {
            if (logger.isWarnEnabled()) {
                logger.warn(
                        "Failed to close a partially initialized socket.", e2);
            }
        }

        throw new ChannelException("Failed to enter non-blocking mode.", e);
    }
}

这里我们可以得到几个结论：

1. parent为null
2. 每个channel都会生成一个id
3. 在创建channel时会创建一个与之相关联的unsafe。unsafe是java对于底层实现的封装，不同类型的channel的不同表现主要通过unsafe来体现，关于unsafe会在后续章节详细介绍。
4. 同样每个channel还会创建出与之相关联的ChannelPipeline。ChannelPipeline是netty对于数据流转及数据读写的重要通道，其根据IO读写分为两个数据流向，是Netty中非常关键的核心流程。关于ChannelPipeline会在后续章节详细介绍。

protected AbstractChannel(Channel parent) {
    this.parent = parent;
    id = newId();
    unsafe = newUnsafe();
    pipeline = newChannelPipeline();
}

而NioServerSocketChannel的默认构造函数代码如下，可以看到服务器创建的channel的监听事件是OP_ACCEPT。：

public NioServerSocketChannel() {
    this(newSocket(DEFAULT_SELECTOR_PROVIDER));
}

public NioServerSocketChannel(SelectorProvider provider) {
    this(newSocket(provider));
}

public NioServerSocketChannel(ServerSocketChannel channel) {
    super(null, channel, SelectionKey.OP_ACCEPT);
    config = new NioServerSocketChannelConfig(this, javaChannel().socket());
}

NioServerSocketChannel的构造过程NioServerSocketChannel->AbstractNioMessageChannel->AbstractNioChannel->AbstractChannel。可以看到服务器和客户端拥有不同的channel父类，可想而知其unsafe的实现也是不一样的。

2.2初始化Channel

其中init(channel)方法是个抽象方法，由子类Bootstrap和ServerBootstrap

abstract void init(Channel channel) throws Exception;

Bootstrap中init的方法的主要功能是设置Channel的属性

void init(Channel channel) throws Exception {
    ChannelPipeline p = channel.pipeline();
    p.addLast(handler());

    final Map, Object> options = options();
    synchronized (options) {
        for (Entry, Object> e: options.entrySet()) {
            try {
                if (!channel.config().setOption((ChannelOption