netty源码分析（二）

前面已经做好了一些初始化工作了。

ChannelFuture channelFuture = serverBootstrap.bind(8899).sync();

public ChannelFuture bind(int inetPort) {
        return bind(new InetSocketAddress(inetPort));
    }
public ChannelFuture bind(SocketAddress localAddress) {
        // 校验工作，只是校验一下有没有初始化什么的,不管，
        validate();
        if (localAddress == null) {
            throw new NullPointerException("localAddress");
        }
        return doBind(localAddress);
    }

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

final ChannelFuture initAndRegister() {
        /**
前面serverBootstrap的channel()方法传入了NioServerSocketChannel类型，初始化了channel工厂,这里用这个工厂创建NioServerSocketChannel实例，
创建NioServerSocketChannel实例会调用NioServerSocketChannel的构造方法，看下文
    public T newChannel() {
        try {
            return clazz.newInstance();
        } catch (Throwable t) {
            throw new ChannelException("Unable to create Channel from class " + clazz, t);
        }
    }
*/
        final Channel channel = channelFactory.newChannel();
        try {
            init(channel);
        } catch (Throwable t) {
            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 = group().register(channel);
        if (regFuture.cause() != null) {
            if (channel.isRegistered()) {
                channel.close();
            } else {
                channel.unsafe().closeForcibly();
            }
        }
        return regFuture;
    }

创建NioServerSocketChannel实例。

    public NioServerSocketChannel() {
        this(newSocket(DEFAULT_SELECTOR_PROVIDER));
    }
private static ServerSocketChannel newSocket(SelectorProvider provider) {
        try {
              // nio的ServerSocketChannel的open方法也是这么创建ServerSocketChannel对象的，
// 所以provider是nio用来创建channel的底层类
            return provider.openServerSocketChannel();
        } catch (IOException e) {
            throw new ChannelException(
                    "Failed to open a server socket.", e);
        }
    }
// 创建了ServerSocketChannel后，创建NioServerSocketChannel
public NioServerSocketChannel(ServerSocketChannel channel) {
        super(null, channel, SelectionKey.OP_ACCEPT);
        config = new NioServerSocketChannelConfig(this, javaChannel().socket());
    }
// NioServerSocketChannel的ch变量维护了nio的ServerSocketChannel，
// ServerSocketChannel配置成非堵塞
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);
        }
    }
protected AbstractChannel(Channel parent) {
        this.parent = parent;
        id = newId();
        // unsafe其实是NioSocketChannelUnsafe类，里面的方法都是
        // doWrite、doRead等操作nio的包装类
        unsafe = newUnsafe();
        // 管道，我们自定义的handler往管道里添加
        pipeline = newChannelPipeline();
    }

Pipeline初始化的时候，就设置号了head和tail，结构为：head《=》tail双向链表。
Head实现了ChannelOutBoundHandler和ChannelInboudhandler，所以是输入和输出处理器，
tail则只实现了ChannelInboudhandler，所以是输入处理器

protected DefaultChannelPipeline newChannelPipeline() {
        return new DefaultChannelPipeline(this);
    }
// pipeline，维护了一个链表
protected DefaultChannelPipeline(Channel channel) {
        this.channel = ObjectUtil.checkNotNull(channel, "channel");
        // tail是ChannelInboundHandler接口实现类，也就是In类型handler
        tail = new TailContext(this);
        // head是ChannelOutboundHandler、ChannelInboundHandler实现类，
//也就是in类型和out类型handler
        head = new HeadContext(this);
        head.next = tail;
        tail.prev = head;
    }
 final class HeadContext extends AbstractChannelHandlerContext
            implements ChannelOutboundHandler, ChannelInboundHandler 
final class TailContext extends AbstractChannelHandlerContext implements ChannelInboundHandler

创建NioServerSocketChannel总结：NioServerSocketChannel内部开启了ServerSocketChannel，并设置为非堵塞，维护了一个pipline管道，管道有head和tail，和unsafe操作nio读写等的操作类。

回到initAndRegister方法

 final ChannelFuture initAndRegister() {
     // 前面分析了，这里的channel是NioServerSocketChannel，里面维护了pipling等很多东西
     final Channel channel = channelFactory.newChannel();
        try {
            // 现在分析这里，这里也很重要，看下文
            init(channel);
        } catch (Throwable t) {
            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 = group().register(channel);
        if (regFuture.cause() != null) {
            if (channel.isRegistered()) {
                channel.close();
            } else {
                channel.unsafe().closeForcibly();
            }
        }
        return regFuture;
    }

void init(Channel channel) throws Exception {
        final Map, Object> options = options0();
        synchronized (options) {
            channel.config().setOptions(options);
        }
        final Map, Object> attrs = attrs0();
        synchronized (attrs) {
            for (Entry, Object> e: attrs.entrySet()) {
                @SuppressWarnings("unchecked")
                AttributeKey