服务端启动流程

我们回顾前面讲解的netty启动流程，服务端这边有两个EventLoopGroup，一个专门用来处理连接，一个用来处理后续的io事件

服务端启动还是跟nio一样，绑定端口进行监听，我们先来看绑定流程

// 绑定端口并同步阻塞直到绑定结束
ChannelFuture cf = serverBootstrap.bind(8080).sync();

private ChannelFuture doBind(final SocketAddress localAddress) {
// 注册一个NioServerScoketChannel
final ChannelFuture regFuture = initAndRegister();
final Channel channel = regFuture.channel();
if (regFuture.cause() != null) {
return regFuture;
}

if (regFuture.isDone()) {  
    // 注册完成 进行端口绑定，并返回一个异步绑定结果  
    ChannelPromise promise = channel.newPromise();  
    // 绑定端口  
    doBind0(regFuture, channel, localAddress, promise);  
    return promise;  
} else {  
    // 未注册完成 返回带注册结果的promise  
    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) {  
                // 注册时有发生异常 通知相关监听器  
                promise.setFailure(cause);  
            } else {  
                // 设置注册结果为true  
                promise.registered();  
                // 绑定端口  
                doBind0(regFuture, channel, localAddress, promise);  
            }  
        }  
    });  
    return promise;  
}  

}

final ChannelFuture initAndRegister() {
Channel channel = null;
try {
/**
* 通过我们之前设置的socket类型进行实例化
* serverBootstrap.channel(NioServerSocketChannel.class) 会返回一个ReflectiveChannelFactory工厂
**/
channel = channelFactory.newChannel(); // 1
// 初始化channel
init(channel); // 2
} catch (Throwable t) {
if (channel != null) {
// 发生异常 将内部nio中的channel进行关闭
channel.unsafe().closeForcibly();
// 返回一个结果失败的Promise
return new DefaultChannelPromise(channel, GlobalEventExecutor.INSTANCE).setFailure(t);
}
return new DefaultChannelPromise(new FailedChannel(), GlobalEventExecutor.INSTANCE).setFailure(t);
}

// 将channel注册到bossEventLoopGroup上，里面会将channel注册到EventLoop中的selector  
ChannelFuture regFuture = config().group().register(channel); // 3  
if (regFuture.cause() != null) {  
    if (channel.isRegistered()) {  
        channel.close();  
    } else {  
        channel.unsafe().closeForcibly();  
    }  
}  
return regFuture;  

}

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

// 添加一个异步绑定任务  
channel.eventLoop().execute(new Runnable() {  
    @Override  
    public void run() {  
        if (regFuture.isSuccess()) {  

　　　　　　　　　　// 绑定！！！
channel.bind(localAddress, promise).addListener(ChannelFutureListener.CLOSE_ON_FAILURE); // 4
} else {
promise.setFailure(regFuture.cause());
}
}
});
}

对上述流程进行一个简单的说明: 先创建一个NioServerScoketChannel，然后进行初始化操作，然后注册到bossEventLoop中selector上，nio需要做的流程 netty都要做，然后进行绑定 返回一个绑定异步promise

绑定流程有4个比较重要的操作 我们来一一详解

1、实例化NioServerScoketChannel，内部会创建一个ServerSocketChannel 然后持有，同时创建unsafe和pipeline

/***********************_NioServerSocketChannel_**********************/
// selector提供者，提供创建selector、ServerSocketChannel、SocketChannel
private static final SelectorProvider DEFAULT_SELECTOR_PROVIDER = SelectorProvider.provider();

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

private static ServerSocketChannel newSocket(SelectorProvider provider) {
try {
// 返回一个nio中的ServerSocketChannel
return provider.openServerSocketChannel();
} catch (IOException e) {
throw new ChannelException(
"Failed to open a server socket.", e);
}
}

public NioServerSocketChannel(ServerSocketChannel channel) {
// 调用父类构造
super(null, channel, SelectionKey.OP_ACCEPT);
// NioServerSocketChannel配置类
config = new NioServerSocketChannelConfig(this, javaChannel().socket());
}

/***********************_AbstractNioChannel_***********************/
protected AbstractNioChannel(Channel parent, SelectableChannel ch, int readInterestOp) {
super(parent);
this.ch = ch;
this.readInterestOp = readInterestOp;
try {
// 将ServerSocketChannel设置为非阻塞
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 实例为NioMessageUnsafe类型 unsafe = newUnsafe(); // 创建pipeline,类型为DefaultChannelPipeline pipeline = newChannelPipeline(); } /***********************DefaultChannelPipeline_*************************/
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;  

}

2、初始化NioServerScoketChannel

/***********************_ServerBootstrap_*************************/
void init(Channel channel) throws Exception {
final Map, Object> options = options0();
// 设置我们之前设置的options serverBootstrap.option(ChannelOption option, T value)
synchronized (options) {
setChannelOptions(channel, options, logger);
}
// 设置channel自定义属性
final Map, Object> attrs = attrs0();
synchronized (attrs) {
for (Entry, Object> e: attrs.entrySet()) {
@SuppressWarnings("unchecked")
AttributeKey