一. 开始

接上一篇 ServerBootstrap的初始化
https://blog.51cto.com/483181/2119149

创新互联专注于企业营销型网站建设、网站重做改版、双河网站定制设计、自适应品牌网站建设、H5响应式网站、商城网站制作、集团公司官网建设、成都外贸网站建设、高端网站制作、响应式网页设计等建站业务，价格优惠性价比高，为双河等各大城市提供网站开发制作服务。

二. bind过程

2.1 代码

先看下调用的源代码

public void bind(int port) throws Exception {
        ...
        try {
            ...

            ChannelFuture f = b.bind(port).sync(); //bind过程
            ...
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

2.2 bind

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

从上面代码可以看出几点：

1. bind方法逻辑很简单，经过一系列的判断后最后调用doBind()方法
2. 发现Netty代码里面，从外面调用进去后，内部方法一般用doxxx，xxx0这种命名；以前自己看安卓源代码的时候，安卓一般喜欢用xxxInner的命名。风格而已，也许自己以后写代码可以参考(看源代码除了了解原理外，学习别人的代码架构方法也是一种收获)。

继续看doBind

2.3 doBind

private ChannelFuture doBind(final SocketAddress localAddress) {
        final ChannelFuture regFuture = initAndRegister(); //1. init和register
        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;
        }
    }

上面这一段代码包含的东西就比较多了，先来看 initAndRegister

2.4 initAndRegister

顾名思义，这个方法包含初始化和注册两个步骤，代码如下：

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

        ChannelFuture regFuture = config().group().register(channel);
        if (regFuture.cause() != null) {
            if (channel.isRegistered()) {
                channel.close();
            } else {
                channel.unsafe().closeForcibly();
            }
        }
        return regFuture;
    }

从上面代码，我们可以看到几点：

1. channel = channelFactory.newChannel();
   channelFactory是什么？它的类型是ReflectiveChannelFactory，如果大家不记得了，可以看看上一篇channel设置那个地方。
   https://blog.51cto.com/483181/2119149

public B channel(Class channelClass) {
        return channelFactory(new ReflectiveChannelFactory(channelClass));
    }

public class ReflectiveChannelFactory implements ChannelFactory {
    @Override
    public T newChannel() {
        try {
            return clazz.getConstructor().newInstance();
        } catch (Throwable t) {

        }
    }   
}       

它的newChannel方法也是非常的简单，直接实例化传入的channel对象，也就是NioServerSocketChannel (可以看上一篇初始化的分析)
代码如下：

ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup)
                .channel(NioServerSocketChannel.class)

我们先看看NioServerSocketChannel的实现

2.5 NioServerSocketChannel

先看下NioServerSocketChannel的继承关系

NioServerSocketChannel提供了一个无参构造函数，然后分别有SelectorProvider，ServerSocketChannel的构造函数，如下：

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

    private static ServerSocketChannel newSocket(SelectorProvider provider) {
        try {
            return provider.openServerSocketChannel();
        } catch (IOException e) {
        }
    }

    private final ServerSocketChannelConfig config;

    /**
     * Create a new instance
     */
    public NioServerSocketChannel() {
        this(newSocket(DEFAULT_SELECTOR_PROVIDER));
    }

    /**
     * Create a new instance using the given {@link ServerSocketChannel}.
     */
    public NioServerSocketChannel(ServerSocketChannel channel) {
        super(null, channel, SelectionKey.OP_ACCEPT);
        config = new NioServerSocketChannelConfig(this, javaChannel().socket());
    }

无参构造函数里面调用newSocket(xx)，参数是SelectorProvider DEFAULT_SELECTOR_PROVIDER = SelectorProvider.provider();
先看看SelectorProvider.provider()

private static SelectorProvider provider = null;
public static SelectorProvider provider() {
        synchronized (lock) {
            if (provider != null)
                return provider;
                ...
        }
    }

可以看到provider是个单例，不知道大家是否记得上上一篇文章(NioEventLoopGroup实例化)分析的时候也有provider，类型是KQueueSelectorProvider
具体可以看： https://blog.51cto.com/483181/2118817

回到newSocket里面，调用的是provider.openServerSocketChannel()

代码是SelectorProviderImpl里面，返回的是 ServerSocketChannel

public ServerSocketChannel openServerSocketChannel() throws IOException {
        return new ServerSocketChannelImpl(this);
    }

得到ServerSocketChannel之后，继续调用构造函数

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

这个构造方法里面做了两件事

1. 调用父类的构造方法
2. 利用刚刚生成好的ServerSocketChannel实例化了一个NioServerSocketChannelConfig

看它的父类构造函数是怎么实现的

首先是AbstractNioChannel.java

protected AbstractNioChannel(Channel parent, SelectableChannel ch, int readInterestOp) {
        super(parent);
        this.ch = ch;
        this.readInterestOp = readInterestOp;
        try {
            ch.configureBlocking(false);
        } catch (IOException e) {
        }
    }

1. 继续调用父类的构造方法
2. 首先吧传入的ServerSocketChannel保存起来，变量是ch
3. 然后把readInterestOp存起来，变量是readInterestOp，值是SelectionKey.OP_ACCEPT
4. 调用ch.configureBlocking(false);把channel设置成非阻塞。
   这里稍微介绍下SelectionKey.OP_ACCEPT
   SelectionKey有4种类型，是java提供的，分别是

public static final int OP_READ = 1 << 0;

public static final int OP_WRITE = 1 << 2;

public static final int OP_CONNECT = 1 << 3;

public static final int OP_ACCEPT = 1 << 4;

然后继续看AbstractNioChannel的父类构造方法，也就是AbstractChannel

private final ChannelId id;
protected abstract AbstractUnsafe newUnsafe();
private final DefaultChannelPipeline pipeline;

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

可以看到这几点:

1. Channel parent变量，null
2. 初始化ChannelId id
3. 初始化unsafe
4. 初始化pipeline

先看unsafe的初始化

2.6 newUnsafe

在AbstractChannel里面，它是一个抽象类

protected abstract AbstractUnsafe newUnsafe();

实现类在子类AbstractNioMessageChannel里面，如下，类型是NioMessageUnsafe

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

NioMessageUnsafe代码后面再看。

继续看pipeline的初始化，初始化了一个 DefaultChannelPipeline

protected DefaultChannelPipeline newChannelPipeline() {
        return new DefaultChannelPipeline(this);
    }

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

在DefaultChannelPipeline里面初始化了一个head和tail,分别是HeadContext和TailConext类型，而且head和tail组成双向链表。
head和tail的区别之一就是inbound和outbound值是相反的，如下:

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

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

借一张图显示下ChannelInBound和ChannelOutBound，如下。head是发送出去的入口，tail是接收消息的入口。

另外我们来看一下添加一个ChannelHandler的流程，比如addLast

public final ChannelPipeline addLast(EventExecutorGroup group, String name, ChannelHandler handler) {
        final AbstractChannelHandlerContext newCtx;
        synchronized (this) {
            checkMultiplicity(handler);

            newCtx = newContext(group, filterName(name, handler), handler);

            addLast0(newCtx);

            ...
                    return this;
    }

private AbstractChannelHandlerContext newContext(EventExecutorGroup group, String name, ChannelHandler handler) {
        return new DefaultChannelHandlerContext(this, childExecutor(group), name, handler);
    }       

private void addLast0(AbstractChannelHandlerContext newCtx) {
        AbstractChannelHandlerContext prev = tail.prev;
        newCtx.prev = prev;
        newCtx.next = tail;
        prev.next = newCtx;
        tail.prev = newCtx;
    }       

1. 首先它初始化了一个DefaultChannelHandlerContext对象，里面封装了要add的channelHandler，这个很重要，在Netty的pipeLine里面，都是通过ChannelHandlerContext来描述的，不是直接添加channelHandler。

2. addLast0()里面就是简单的双向链表添加的方法，把封装了channelHandler的ChannelHandlerContext对象添加到tail的前一个节点。

那，我们来总结下NioServerSocketChannel的初始化过程:

1. NioServerSocketChannel提供了一个无参构造函数，里面SelectorProvider DEFAULT_SELECTOR_PROVIDER，它是一个单例，类型是KQueueSelectorProvider。

2. 我们调用KQueueSelectorProvider.openServerSocketChannel()方法，得到一个ServerSocketChannel

3. 我们用生成的ServerSocketChannel对象创建了一个ServerSocketChannelConfig config，具体是NioServerSocketChannelConfig对象，存在NioServerSocketChannel里面

4. 我们用生成的ServerSocketChannel调用它的父类构造函数，先来到了AbstractNioChannel

5. 在AbstractNioChannel会把ServerSocketChannel存起来，变量是ch，然后把channel设置成非阻塞。

6. AbstractNioChannel还会把readInterestOp存起来，类型是SelectionKey.OP_ACCEPT

7. 继续调用父类构造函数，来到AbstractChannel

8. AbstractChannel里面的parent设置成null

9. AbstractChannel初始化channel id

10. AbstractChannel初始化unsafe，类型是NioMessageUnsafe.

11. AbstractChannel初始化pipeline，类型是DefaultChannelPipeline, 每个Channel都有一个自己的Pipeline

看完NioServerSocketChannel的实例化方法后，我们继续往下看init

2.7 init

abstract void init(Channel channel) throws Exception;

AbstractBootstrap里面的init(channel)方法是一个抽象方法，参数是Channel类型，其实就是上一步实例化好的NioServerSocketChannel对象。

具体实现方法在它的子类ServerBootstrap和Bootstrap(给客户端启动使用的)，那我们是分析服务端的代码，所以看ServerBootstrap里面的实现。

void init(Channel channel) throws Exception {
        final Map, Object> options = options0();
        synchronized (options) { //1. 设置options
            setChannelOptions(channel, options, logger);
        }

        final Map, Object> attrs = attrs0();
        synchronized (attrs) {
            for (Entry, Object> e: attrs.entrySet()) { //设置attr属性
                @SuppressWarnings("unchecked")
                AttributeKey