NettyClient源码分析

可以先看下NettyClient启动流程分析

以EchoClient为例，其main方法代码如下：

EventLoopGroup group = new NioEventLoopGroup();
    try {
        Bootstrap b = new Bootstrap();
        b.group(group)
         .channel(NioSocketChannel.class)
         .option(ChannelOption.TCP_NODELAY, true)
         .handler(new ChannelInitializer() {
             @Override
             public void initChannel(SocketChannel ch) throws Exception {
                 ChannelPipeline p = ch.pipeline();
                 if (sslCtx != null) {
                     p.addLast(sslCtx.newHandler(ch.alloc(), HOST, PORT));
                 }
                 //p.addLast(new LoggingHandler(LogLevel.INFO));
                 p.addLast(new EchoClientHandler());
             }
         });

        // Start the client.
        ChannelFuture f = b.connect(HOST, PORT).sync();

        // Wait until the connection is closed.
        f.channel().closeFuture().sync();
    } finally {
        // Shut down the event loop to terminate all threads.
        group.shutdownGracefully();
    }

connect调用链为Bootstrap.connect->Bootstrap.doConnect->Bootstrap.doConnect0->

Bootstrap.doConnect方法如下：

private ChannelFuture doConnect(final SocketAddress remoteAddress, final SocketAddress localAddress) {
    final ChannelFuture regFuture = initAndRegister();(1)
    final Channel channel = regFuture.channel();
    if (regFuture.cause() != null) {
        return regFuture;
    }

    final ChannelPromise promise = channel.newPromise();
    if (regFuture.isDone()) {
        doConnect0(regFuture, channel, remoteAddress, localAddress, promise);(2)
    } else {
        regFuture.addListener(new ChannelFutureListener() {
            @Override
            public void operationComplete(ChannelFuture future) throws Exception {
                doConnect0(regFuture, channel, remoteAddress, localAddress, promise);
            }
        });
    }

    return promise;
}

(1)initAndRegister方法定义如下：

final ChannelFuture initAndRegister() {
    Channel channel = null;
    try {
        /**
         * 创建channel对象，server端为NioServerSocketChannel，client端为NioSocketChannel
         */
        channel = channelFactory().newChannel();(3)
        /**
         * init方法主要是初始化用户设置的初始化handler，这个handler为ChannelIntializer类型，
         * server端通过ServerBootstrap.childHandler传入这个handler，除了这个handler，init方法也会把通过ServerBootstrap.handler传入的handler添加到pipeline
         * client端通过Bootstrap.handler传入这个handler
         */
        init(channel);(4)
    } 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);
    }

    /**
     * 对于server：
     *      在boss EventLoopGroup中注册该channel（NioServerSocketChannel）
     *      从boss EventLoopGroup中选出一个EventLoop注册该channel ->SingleThreadEventLoop.register -> channel.unsafe().register
     * 对于client：
     *      没有boss EventLoopGroup和worker EventLoopGroup之分，只有1个EventLoopGroup，会在这个EventLoopGroup注册该channel（NioSocketChannel）
     *      会从EventLoopGroup中选择一个EventLoop来注册这个channel ->SingleThreadEventLoop.register -> channel.unsafe().register
     */
    ChannelFuture regFuture = group().register(channel);(5)
    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;
}

(3)创建该NioSocketChannel对象，仅仅是创建了该对象，没有与server建立连接和注册
(4)初始化channel，主要是设置用户通过Bootstrap设置的初始化handler

@Override
@SuppressWarnings("unchecked")
void init(Channel channel) throws Exception {
    ChannelPipeline p = channel.pipeline();
    /**
     * handler()方法返回用户通过Bootstrap.handle方法设置的hanler，这个handler是ChannelIntializer类型，并不是真正的业务handler，
     * 而是用来初始化业务handler pipeline的handler，其initChannel方法里为用户设置的初始化业务pipeline的逻辑
     */
    p.addLast(handler());

    final Map, Object> options = options();
    synchronized (options) {
        for (Entry, Object> e: options.entrySet()) {
            try {
                if (!channel.config().setOption((ChannelOption