12、Bootstrap和ServerBootstrap啥关系

一、Bootstrap、ServerBootstrap啥关系

Bootstrap客户端引导类，ServerBootstrap服务端引导类。

二、BootStrap介绍

1、客户端BootStrap

Bootstrap是Netty提供的一个便利的工厂类，可以通过它来完成客户端或服务端的Netty初始化。

先来看一个例子，从客户端和服务端分别分析Netty的程序是如何启动的。首先，从客户端的代码片段开始。

import com.xiepanpan.chat.client.handler.ChatClientHandler;
import com.xiepanpan.chat.protocol.IMDecoder;
import com.xiepanpan.chat.protocol.IMEncoder;
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;

/**
 * @Description: 聊天客户端
 */
public class ChatClient {

    private ChatClientHandler chatClientHandler;
    private String host;
    private int port;

    public ChatClient(String nickName) {
        this.chatClientHandler = new ChatClientHandler(nickName);
    }

    public static void main(String[] args) {
        new ChatClient("xp").connect("127.0.0.1",80);
    }

    private void connect(String host, int port) {
        this.host = host;
        this.port = port;

        EventLoopGroup workerGroup = new NioEventLoopGroup();;

        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(workerGroup);
            bootstrap.channel(NioSocketChannel.class);
            bootstrap.option(ChannelOption.SO_KEEPALIVE,true);
            bootstrap.handler(new ChannelInitializer() {
                protected void initChannel(SocketChannel socketChannel) throws Exception {
                    socketChannel.pipeline().addLast(new IMDecoder());
                    socketChannel.pipeline().addLast(new IMEncoder());
                    socketChannel.pipeline().addLast(chatClientHandler);
                }
            });
            ChannelFuture channelFuture = bootstrap.connect(this.host, this.port).sync();
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            workerGroup.shutdownGracefully();
        }
    }
}

2、客户端初始化过程

1、EventLoopGroup：不论是服务端还是客户端，都必须指定EventLoopGroup。在这个例子中，指定了NioEventLoopGroup，表示一个NIO的EventLoopGroup。

2、ChannelType：指定Channel的类型。因为是客户端，所以使用了NioSocketChannel。

3、Handler：设置处理数据的Handler。

下面继续看一下客户端启动Bootstrap后都做了哪些工作？

1、NioSocketChannel 的初始化过程

在Netty中，Channel 是一个Socket 的抽象，它为用户提供了关于Socket状态(是否是连 接还是断开)以及对Socket 的读写等操作.每当Netty 建立了一个连接后，都会有一个对应 的Channel实例. Ni oSocketChannel的类层次结构如下:

接下来我们着重分析一下Channel的初始化过程。

2、ChannelFactory 和Channel类型的确定

除了TCP协议以外，Netty 还支持很多其他的连接协议，并且每种协议还有NI0(非阻塞I0) 和0I0(0ld-I0, 即传统的阻塞I0)版本的区别.不同协议不同的阻塞类型的连接都有不同的Channel类型与之对应下面是一些常用的Channel 类型: NioSocketChannel,代表异步的客户端TCP Socket 连接. NioServerSocketChannel,异步的服务器端TCP Socket 连接. NioDatagramChannel,异步的UDP连接 NioSctpChannel，异步的客户端Sctp连接. NioSctpServerChannel，异步的Sctp 服务器端连接. 0ioSocketChannel，同步的客户端TCP Socket连接. 0ioServerSocketChannel，同步的服务器端TCP Socket 连接. 0ioDatagramChannel,同步的UDP连接 0ioSctpChannel，同步的Sctp服务器端连接. 0ioSctpServerChannel，同步的客户端TCP Socket 连接. 那么我们是如何设置所需要的Channel的类型的呢?答案是channel() 方法的调用. 回想一下我们在客户端连接代码的初始化Bootstrap 中，会调用channel() 方法，传入NioSocketChannel. class，这个方法其实就是初始化了一个ReflectiveChannelFactory:

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

而ReflectiveChannelFactory 实现了ChanneIFactory 接口，它提供了唯一的方法，即newChannel. ChannelFactory， 顾名思义，就是产生Channel的工厂类. 进入到ReflectiveChanne lFactory. newChannel中，我们看到其实现代码如下:

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

根据上面代码的提示，我们就可以确定: 1、Bootstrap 中的ChannelFactory 的实现是ReflectiveChannelFactory 2、生成的Channel 的具体类型是NioSocketChannel.

Channel的实例化过程，其实就是调用的. ChannelFactory. newChannel方法，而实例化的Channel的具体的类型又是和在初始化Bootstrap 时传入的channel() 方法的参数相关.因此对于我们这个例子中的客户端的Bootstrap而言，生成的的Channel 实例就是NioSocketChannel.

3、Channel的实例化

前面我们已经知道了如何确定一个Channel 的类型，并且了解到Channel 是通过工厂方法ChannelFactory. newChannel()来实例化的，那么ChannelFactory. newChannel()方法在哪里调用呢?继续跟踪，我们发现其调用链是: Bootstrap. connect->Bootstrap . doResolveAndConnect->AbstractBootstrap.initAndRegister 在AbstractBootstrap. initAndRegister中调用了channelFactory () . newChannel()来获取一个新的NioSocketChannel实例，其源码如下:

ChannelFuture channelFuture = bootstrap.connect(this.host, this.port).sync();

进入connect方法 doResolveAndConnect 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);
    }

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

在.newChannel中，通过类对象的newInstance来获取一个新Channel 实例，因而会调用NioSocketChannel的默认构造器. NioSocketChannel默认构造器代码如下:

public NioSocketChannel() {
    this(DEFAULT_SELECTOR_PROVIDER);
}

这里的代码比较关键，我们看到，在这个构造器中，会调用newSocket 来打开一个新的Java NioSocketChannel

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

private static SocketChannel newSocket(SelectorProvider provider) {
    try {
        /**
         *  Use the {@link SelectorProvider} to open {@link SocketChannel} and so remove condition in
         *  {@link SelectorProvider#provider()} which is called by each SocketChannel.open() otherwise.
         *
         *  See #2308.
         */
        return provider.openSocketChannel();
    } catch (IOException e) {
        throw new ChannelException("Failed to open a socket.", e);
    }
}

复制

进入this方法

public NioSocketChannel(SocketChannel socket) {
    this(null, socket);
}

复制

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

复制

接着调用父类，即AbstractNioByteChannel的构造器

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

并传入参数parent 为null, ch为刚才使用newSocket 创建的Java NI0 SocketChannel,因此生成的NioSocketChannel 的parent channel是空的. 接着会继续调用父类AbstractNioChannel的构造器，并传入了参数readInterest0p =SelectionKey.OP_READ

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

复制

然后调用父类的AbstractChannel的构造器

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

复制

到这里，一个完整的NioSocketChannel 就初始化完成了，我们可以稍微总结一下构造一个NioSocketChannel所需要做的工作: 1、调用NioSocketChannel. newSocket (DEFAULT_ SELECTOR_ PROVIDER) 打开一个新的Java NI0 SocketChannel 2、AbstractChannel (Channel parent) 中 初始化AbstractChannel 的属性:parent属性置为null unsafe通过newUnsafe() 实例化一个unsafe对象，它的类型是AbstractNioByteChannel. NioByteUnsafe内部类 pipeline是new Defaul tChannelPipeline(this)新创建的实例.这里体现了:Each channel has its own pipeline and it is created automatically when a new channel is created.

3、AbstractNioChannel 中的属性: SelectableChannel ch设置为Java SocketChannel,即NioSocketChannel. newSocket返回的Java NIO SocketChannel. readInterestOp被设置为Belect ionKey. OP_ READ SelectableChannel ch 被配置为非阻塞的ch. configureBlocking(false) 4、NioSocketChannel中的属性: SocketChanne lConfig config=new NioSocketChannelConfig(this,socket. socket ())

1.1.4关于unsafe字段的初始化

我们简单地提到了，在实例化NioSocketChannel的过程中，会在父类AbstractChannel的构造器中，调用newUnsafe()来获取一个unsafe实例.那么unsafe是怎么初始化的呢?它的作用是什么? 其实unsafe特别关键，它封装了对Java 底层Socket 的操作，因此实际上是沟通Netty 上层和Java底层的重要的桥梁. Unsafe的方法其实都会对应到相关的Java 底层的Socket的操作. 回到AbstraptChannel 的构造方法中，在这里调用了newUnsafe() 获取一个新的unsafe对象，而newUnsafe 方法在NioSocketChannel中被重写了:

@Override
protected AbstractNioUnsafe newUnsafe() {
    return new NioByteUnsafe();
}

复制

NioSocketChannel. newUnsafe方法会返回一个NioSocketChannelUnsafe实例.从这里我们就可以确定了，在实例化的NioSocketChannel 中的unsafe字段，其实是一个NioSocketChannelUnsafe的实例.

1.1.5关于pi peline的初始化

上面我们分析了一个Channel (在这 个例子中是NioSocketChannel) 的大体初始化过程，但是我们漏掉了一个关键的部分，即ChannelPipeline 的初始化. 根据Each channel has its own pipeline and it is created automatically when a new channel is created.，我们知道，在实例化一个Channel 时，必然伴随着实例化一个ChannelPipeline. 而我们确实在AbstractChannel 的构造器看到了pipeline字段被初始化为DefaultChannelPipeline 的实例. 那么我们就来看一下，Defaul tChannelPipeline构造器做了哪些工作吧:

protected DefaultChannelPipeline(Channel channel) {
    this.channel = ObjectUtil.checkNotNull(channel, "channel");
    succeededFuture = new SucceededChannelFuture(channel, null);
    voidPromise =  new VoidChannelPromise(channel, true);

    tail = new TailContext(this);
    head = new HeadContext(this);

    head.next = tail;
    tail.prev = head;
}

复制

我们调用Defaul tChannelPipeline的构造器，传入了一个channel, 而这个channel 其实就是我们实例化的NioSocketChannel, Defaul tChannelPipeline会将这个NioSocketChannel对象保存在channel字段中. DefaultChannelPipeline 中，还有两个特殊的字段，即head和tail, 而这两个字段是一个双向链表的头和尾.其实在Defaul tChannelPipeline中， 维护了一个以AbstractChanne lHandlerContext为节点的双向链表，这个链表是Netty 实现Pipeline 机制的关键.关于Defaul tChannelPipeline中的双向链表以及它所起的作用，这一节我们暂时不做详细分析。 先看看HeadContext的继承层次结构如下所示:

;

TailContext的继承层次结构如下所示:

;

我们可以看到，链表中head是一个 Channe lOutboundHandler，而tail 则是一个Channel InboundHandler. 接着看一下HeadContext的构造器:

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

复制

它调用了父类AbstractChannelHandlerContext的构造器，并传入参数inbound = false,outbound = true. Tai lContext的构造器与HeadContext的相反，它调用了父类AbstractChannelHandlerContext的构造器，并传入参数inbound = true, outbound = false. 即header是一个outboundHandler, 而tail 是一个inboundHandler,关于这一点，大家要特别注意，因为在分析到Netty Pipeline 时，我们会反复用到inbound 和outbound 这两个属性.

1.1.6关于EventLoop的初始化

回到最开始的ChatClient. java代码中，我们在一开始 就实例化了一个NioEventLoopGroup对象，因此我们就从它的构造器中追踪一下EventLoop 的初始化过程. 首先来看一下NioEventLoopGroup的类继承层次:

;

NioEventLoop有几个重载的构造器，不过内容都没有什么大的区别，最终都是调用的父类Multi threadEventLoopGroup构造器:

protected MultithreadEventLoopGroup(int nThreads, Executor executor, Object... args) {
    super(nThreads == 0 ? DEFAULT_EVENT_LOOP_THREADS : nThreads, executor, args);
}

复制

其中有一点有意思的地方是，如果我们传入的线程数nThreads 是0，那么Netty 会为我们设置默认的线程数DEFAULT_EVENT_LOOP_THREADS，而这个默认的线程数是怎么确定的呢? 其实很简单，在静态代码块中，会首先确定DEFAULT_EVENT_LOOP_THREADS 的值:

static {
    DEFAULT_EVENT_LOOP_THREADS = Math.max(1, SystemPropertyUtil.getInt(
            "io.netty.eventLoopThreads", Runtime.getRuntime().availableProcessors() * 2));

    if (logger.isDebugEnabled()) {
        logger.debug("-Dio.netty.eventLoopThreads: {}", DEFAULT_EVENT_LOOP_THREADS);
    }
}

复制

Netty会首先从系统属性中获取"io. netty. eventLoopThreads"的值，如果我们没有设置它的话，那么就返回默认值:处理器核心数* 2. 回到MultithreadEventLoopGroup 构造器中，这个构造器会继续调用父类MultithreadEventExecutorGroup的构造器:

protected MultithreadEventExecutorGroup(int nThreads, Executor executor,
                                        EventExecutorChooserFactory chooserFactory, Object... args) {
    if (nThreads <= 0) {
        throw new IllegalArgumentException(String.format("nThreads: %d (expected: > 0)", nThreads));
    }

    if (executor == null) {
        executor = new ThreadPerTaskExecutor(newDefaultThreadFactory());
    }

    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) {
            // TODO: Think about if this is a good exception type
            throw new IllegalStateException("failed to create a child event loop", e);
        } finally {
            if (!success) {
                for (int j = 0; j < i; j ++) {
                    children[j].shutdownGracefully();
                }

                for (int j = 0; j < i; j ++) {
                    EventExecutor e = children[j];
                    try {
                        while (!e.isTerminated()) {
                            e.awaitTermination(Integer.MAX_VALUE, TimeUnit.SECONDS);
                        }
                    } catch (InterruptedException interrupted) {
                        // Let the caller handle the interruption.
                        Thread.currentThread().interrupt();
                        break;
                    }
                }
            }
        }
    }

    chooser = chooserFactory.newChooser(children);

    final FutureListener