Netty解读 - 1.从ServerBootstrap认识Netty

版权声明：本文为博主原创文章，未经博主允许不得转载。

摘要

该系列文章主要是分析Netty源码4.1.16.Final，了解Netty框架的设计和其中各种组件的优化手段。
这篇文章作为系列的第一篇文章，以最简单的EchoServer为例，从ServerBootstrap开始跟踪其初始化和启动流程，让读者在直观上对Netty框架有大概的认识。

EchoServer

我们从Netty提供的EchoServer开始，重要的代码片段如下：

        // Configure the server.
        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();
                     if (sslCtx != null) {
                         p.addLast(sslCtx.newHandler(ch.alloc()));
                     }
                     //p.addLast(new LoggingHandler(LogLevel.INFO));
                     p.addLast(new EchoServerHandler());
                 }
             });

            // Start the server.
            ChannelFuture f = b.bind(PORT).sync();

            // Wait until the server socket is closed.
            f.channel().closeFuture().sync();
        } finally {
            // Shut down all event loops to terminate all threads.
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }

ServerBootstrap

ServerBootstrap作为一个启动辅助类，通过他可以很方便的创建一个Netty服务端。从EchoServer可以看出，实现一个Server大概分为这样几个步骤：

1. 设置bossGroup和workGroup。这里可以先理解为两个线程池，bossGroup设置一个线程，用于处理连接请求和建立连接，而workGroup线程池大小默认值2*CPU核数，在连接建立之后处理IO请求。EventLoopGroup体现了Netty对线程模型的抽象设计，之后会独立开篇介绍。
2. 指定使用NioServerSocketChannel来处理连接请求。channel(NioServerSocketChannel.class)这段代码实际上在设置channelFactory，而ServerBootstrap会通过channelFactory.newChannel来生产channel。这里channelFactory是一个ReflectiveChannelFactory，顾名思义这个工厂类以反射的方式来构建channel实例，而实例的类型就是我们指定的NioServerSocketChannel。

public T newChannel() {
    ...  
        return clazz.getConstructor().newInstance();
    ...
}

3. 配置TCP参数。
4. 配置handler和childHandler，数据处理器。
5. ServerBootstrap启动服务器。

真正的启动过程由ChannelFuture f = b.bind(PORT).sync();开始触发。调用链路：ServerBootstrap.bind → AbstractBootstrap.bind → AbstractBootstrap.doBind，重点分析一下doBind：

private ChannelFuture doBind(final SocketAddress localAddress) {
        final ChannelFuture regFuture = initAndRegister();
        final Channel channel = regFuture.channel();
        ...
            ChannelPromise promise = channel.newPromise();
            doBind0(regFuture, channel, localAddress, promise);
            return promise;
        ...
    }

这个过程分为两个关键步骤：

1. initAndRegister - 包括Channel的创建、初始化和注册三个子步骤
2. doBind0 - Channel绑定到监听端口

1.1 NioServerSocketChannel创建

final ChannelFuture initAndRegister() {
    ...
    channel = channelFactory.newChannel();
    init(channel);
    ...
    ChannelFuture regFuture = config().group().register(channel);
    ...
    return regFuture;
}

这里channelFactory就是上面提到的ReflectiveChannelFactory，他通过反射来创建NioServerSocketChannel实例，继续跟进NioServerSocketChannel的构造方法：

private static final SelectorProvider DEFAULT_SELECTOR_PROVIDER = SelectorProvider.provider();

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

private static ServerSocketChannel newSocket(SelectorProvider provider) {
      ...
      return provider.openServerSocketChannel();
      ...
}

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

因为获取provider的过程包含同步访问的消耗，所以NioServerSocketChannel缓存了provider并使用provider.openServerSocketChannel()来创建ServerSocketChannel实例。

除了创建ServerSocketChannel外，还要创建NioServerSocketChannelConfig。ChannelConfig的职责是统一保存channel配置，并提供读取和设置的接口。不同的ChannelConfig具体实现不一样，例如NioServerSocketChannelConfig提供的setReuseAddress接口，是为ServerSocketChannel设置useAddress参数。

NioServerSocketChannel的构造过程并没有这么简单，还要继续向上看看父类的构造函数。

NioServerSocketChannel类图.png

先来看AbstractNioChannel的构造方法：

protected AbstractNioChannel(Channel parent, SelectableChannel ch, int readInterestOp) {
    super(parent);
    this.ch = ch;
    this.readInterestOp = readInterestOp;
    ...
       //设置channel非阻塞模式
       ch.configureBlocking(false);
    ...
   }
}

接下来是AbstractChannel类的构造方法：

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

代码清楚的交代了3件事情：

1. 为当前channel生成ID（由机器名，进程名，序列号，进程号和随机数组成）。
2. 创建Unsafe实例（NioMessageUnSafe）。所有的UnSafe类都主要用于网络方面的操作，比如read，write，close等，Channel关于网络的操作都会委托给该unsafe来完成。
3. 创建DefaultChannelPipeline，他就是大名鼎鼎的Pipeline机制。先从DefaultChannelPipeline构造函数入手：

protected DefaultChannelPipeline(Channel channel) {
     this.channel = ObjectUtil.checkNotNull(channel, "channel");
     ...
     tail = new TailContext(this);
     head = new HeadContext(this);
     head.next = tail;
     tail.prev = head;
}

pipeline内部会组织一个ChannelHandlerContext的链表，上下行的事件都会经过这个链表依次处理。但是在构造Pipeline时，就只有两个ChannelHandlerContext：HeadContext主要用于处理输出事件，而TailContext用于处理输入事件。用户添加的Handler也会被封装在新的Context然后插入到链表中，参与事件的处理，这一点后面会再提到。
先来看看TailContext构造函数：

TailContext(DefaultChannelPipeline pipeline) {
      super(pipeline, null, TAIL_NAME, true, false);
      ...
 }

AbstractChannelHandlerContext(DefaultChannelPipeline pipeline, EventExecutor executor, String name,
                                  boolean inbound, boolean outbound) {
      this.name = ObjectUtil.checkNotNull(name, "name");
      this.pipeline = pipeline;
      this.executor = executor;
      this.inbound = inbound;
      this.outbound = outbound;
      ordered = executor == null || executor instanceof OrderedEventExecutor;
}

值得注意的是inbound和outbound两个属性，TailContext（inbound=true，outbound=false），而HeadContext刚好相反（inbound=false，outbound=true），这两个属性由于标识该Context是用于处理输入事件还是输出事件的，当事件处理时会根据是事件输入还是输出而选择相应的Context来处理。
再来看HeadContext：

HeadContext(DefaultChannelPipeline pipeline) {
      super(pipeline, null, HEAD_NAME, false, true);
      unsafe = pipeline.channel().unsafe();
      ...
}

与TailContext
相比，HeadContext多了unsafe属性，是从pipeline中的channel中获取的，即NioSocketChannel构造函数中提到的unsafe对象。TailContext实现的很多方法都是空的，不做任何处理；而HeadContext实现的方法就比较多了，包括bind，connect，disconnect，read，write等，都是依赖unsafe来完成的。

到这里NioServerSocketChannel的创建过程才算结束，总结一下这个过程都包含了那些步骤：

• ServerBootStrap通过ReflectiveChannelFactory创建NioServerSocketChannel实例。
• NioServerSocketChannel实例内部创建了ServerSocketChannel。
• 每个Channel（AbstractChannel）内部都会创建ChannelID，unsafe以及pipeline。

1.2 NioServerSocketChannel初始化

回到AbstractBootstrap.initAndRegister：

final ChannelFuture initAndRegister() {
    ...
    channel = channelFactory.newChannel();
    init(channel);
    ...
    ChannelFuture regFuture = config().group().register(channel);
    ...
    return regFuture;
}

上一节介绍了channel的创建过程，接下来再看ServerBootstrap.init：

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