netty源码深度解析-启动引导（2）客户端启动流程

导读

原创文章，转载请注明出处。

本文源码地址：netty-source-code-analysis

本文所使用的netty版本4.1.6.Final：带注释的netty源码

在“BIO vs NIO”这篇文章中我们给出了使用jdk原生nio编写的客户端Hello World。还记得其中的关键步骤吗，咱们再来温习一下。

1. 创建一个SocketChannel

2. 连接到服务方端口

3. 将SocketChannel设置为非阻塞的

4. 将SocketChannel注册到selector上

今天我们就以这几个关键步骤为目标来看一下在netty中是怎么做的，以及在这几个步骤的中间netty又多做了哪些工作。

1 客户端引导代码

以下代码引导启动一个客户端，在本文以下内容中我们以“引导代码”指代这段程序。

1. 创建一个EventLoopGroup，与服务端不同的是，这里不需要创建bossGroup，因为客户端不需要处理新连接的接入，所以这里的eventLoopGroup的作用相当于服务端的workerGroup。
2. 创建一个BootStrap并将eventLoopGroup传入，设置channel为NioSocketChannel（对应jdk SocketChannel）。
3. 设置一个Channel参数和一个Channel属性。
4. 配置一个handler，这个handler里我们什么也没做，仅仅是打印一些事件日志。
5. 调用bootstrap.connect方法连接到服务端。
   运行这段程序，将在控制台打印出如下结果：

HandlerAdded
ChannelRegistered
ChannelActive

/**
 * 欢迎关注公众号“种代码“，获取博主微信深入交流
 *
 * @author wangjianxin
 */
public class com.zhongdaima.netty.analysis.bootstrap.ClientBoot {
    public static void main(String[] args) {
        EventLoopGroup eventLoopGroup = new NioEventLoopGroup(1);
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(eventLoopGroup)
                    .channel(NioSocketChannel.class)
                    //设置Channel参数
                    .option(ChannelOption.TCP_NODELAY, true)
                    //设置Channel属性
                    .attr(AttributeKey.valueOf("ChannelName"), "ClientChannel")
                    .handler(new ChannelInboundHandlerAdapter(){
                        @Override
                        public void channelRegistered(ChannelHandlerContext ctx) throws Exception {
                            System.out.println("ChannelRegistered");
                        }

                        @Override
                        public void channelActive(ChannelHandlerContext ctx) throws Exception {
                            System.out.println("ChannelActive");
                        }

                        @Override
                        public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
                            System.out.println("HandlerAdded");
                        }
                    });
            ChannelFuture channelFuture = bootstrap.connect("127.0.0.1",8000);
            Channel channel = channelFuture.syncUninterruptibly().channel();
            channel.closeFuture().awaitUninterruptibly();
        } finally {
            eventLoopGroup.shutdownGracefully();
        }
    }
}

2 启动过程

我们从bootstrap.connect("127.0.0.1",8000)跟进去，这里的代码很简单，就是将host和port封装成InetSocketAddress，接着调用doResolveAndConnect方法。

public ChannelFuture connect(String inetHost, int inetPort) {
    return connect(InetSocketAddress.createUnresolved(inetHost, inetPort));
}

public ChannelFuture connect(SocketAddress remoteAddress) {
    return doResolveAndConnect(remoteAddress, config.localAddress());
}

我们来看一下oResolveAndConnect方法，这里的关键逻辑是调用initAndRegister和doResolveAndConnect0方法。

private ChannelFuture doResolveAndConnect(final SocketAddress remoteAddress, final SocketAddress localAddress) {
        //关键逻辑
        final ChannelFuture regFuture = initAndRegister();
        final Channel channel = regFuture.channel();

        if (regFuture.isDone()) {
            if (!regFuture.isSuccess()) {
                return regFuture;
            }
            //关键逻辑
            return doResolveAndConnect0(channel, remoteAddress, localAddress, channel.newPromise());
        } else {
            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 {
                        promise.registered();
                        //关键逻辑
                        doResolveAndConnect0(channel, remoteAddress, localAddress, promise);
                    }
                }
            });
            return promise;
        }
    }

initAndRegister方法内有关键的3步。1是通过channelFactory.newChannel()创建一个Channel，此处的chnnelFactory的赋值咱们已经在“服务端启动流程”分析过，这里不再赘述；2是init(channel)，这里init方法的实现在Boostrap类中；3是config().group().register(channel)。

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

接下来咱们重点分析initAndRegister方法内的这3个关键步骤和doResolveAndConnect0方法。

2.1 新创建一个NioSocketChannel

channelFactory.newChannel()调用Channel实现类的无参构造方法创建实例，此处的实现类为NioSocketChannel，咱们跟到该类的无参构造方法。这里与服务端启动时所使用的NioServerSocketChannel不同的是NioServerSocketChannel是调用provider.openServerSocketChannel()创建一个jdk的ServerSocketChannel，而客户端是调用provider.openSocketChannel()创建一个jdk的SocketChannel。到这里，我们看到了导读中提到的第1步“创建一个SocketChannel”。
最后调用到父类AbstractNioByteChannel的构造方法。

public NioSocketChannel() {
    this(DEFAULT_SELECTOR_PROVIDER);
}

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

private static SocketChannel newSocket(SelectorProvider provider) {
    try {
       return provider.openSocketChannel();
    } catch (IOException e) {
        throw new ChannelException("Failed to open a socket.", e);
    }
}

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

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

我们来看一下AbstractNioByteChannel的构造方法，很简单，继续调用父类AbstractNioChannel的构造方法。

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

AbstractNioChannel的构造方法内调用了ch.configureBlocking(false)将Channel设置为非阻塞的，并继续调用了父类AbstractChannel的构造方法。到这里我们看到了导读中提到的第3步“将SocketChannel设置为非阻塞的”。

 protected AbstractNioChannel(Channel parent, SelectableChannel ch, int readInterestOp) {
        super(parent);
        this.ch = ch;
        this.readInterestOp = readInterestOp;
        try {
            //设置为非阻塞的
            ch.configureBlocking(false);
        } catch (IOException e) {
           
        }
    }

AbstractChannel的构造方法里为Channel分配了一个id，创建了一个Unsafe和一个PipeLine，Unsafe和PipeLine咱们后面再讲。

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

2.2 初始化Channel

init方法的实现在Boostrap类中，这里将我们在引导代码所设置的handler添加到pipeline中，再为Channel设置一些参数（引导代码中的option(ChannelOption.TCP_NODELAY, true)）和属性(引导代码中的attr(AttributeKey.valueOf("ChannelName"), "ClientChannel"))。

@Override
@SuppressWarnings("unchecked")
void init(Channel channel) throws Exception {
    ChannelPipeline p = channel.pipeline();
    //添加引导代码中所设置的handler
    p.addLast(config.handler());
    
    //设置Channel参数
    final Map, Object> options = options0();
    synchronized (options) {
        for (Entry, Object> e: options.entrySet()) {
            try {
                if (!channel.config().setOption((ChannelOption