netty Bootstrap解析

netty 抽象BootStrap定义：[url]http://donald-draper.iteye.com/blog/2392492[/url]
netty ServerBootStrap解析：[url]http://donald-draper.iteye.com/blog/2392572[/url]
[size=medium][b]引言：[/b][/size]
上面一篇文章我们看了ServerBootstrap，先来回顾一下：
服务端Bootstrap虽然继承与抽象Bootstrap，但他有自己的child通道选项及属性集，事件循环组和通道处理器，这些是用于配置，当Server通道接收客户端的请求，创建与客户端交互的通道。当构造Server引导配置时，如果传递一个事件循环，则Server通道监听器和客户端交互的通道公用一个事件循环组，否则parentGroup事件循环组用于监听器ServerChannel接受连接,childGroup事件循环组用于处理与客户端交互的通道相关事件和IO操作。
Server引导配置绑定socket地址，首先初始化通道，对于Server引导配置，这个通道为NioServerSocketChannel，初始化通道，即初始化Server通道；初始化Server通道，首先将Server引导配置的父类抽象Bootstrap的选项和属性配置给Server通道，然后添加ServerBootstrapAcceptor到Server通道内部的Channel管道内，然后将Server通道注册到事件循环组parentGroup中，然后通过Server通道#bind方法完成实际socket地址；Server引导配置监听器实际为一个Inbound通道处理器，每当有客户端连接请求时，则创建一个与客户端交互的通道，将child通道选项及属性配置给通道，并将通道注册到childGroup事件循环组，然后将通道处理器添加到与客户端交互的通道内部的Channel管道中。
今天我们来看客户端Bootstrap：

package io.netty.bootstrap;

import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelOption;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.ChannelPromise;
import io.netty.channel.EventLoop;
import io.netty.channel.EventLoopGroup;
import io.netty.resolver.AddressResolver;
import io.netty.resolver.DefaultAddressResolverGroup;
import io.netty.resolver.NameResolver;
import io.netty.resolver.AddressResolverGroup;
import io.netty.util.AttributeKey;
import io.netty.util.concurrent.Future;
import io.netty.util.concurrent.FutureListener;
import io.netty.util.internal.logging.InternalLogger;
import io.netty.util.internal.logging.InternalLoggerFactory;

import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.util.Map;
import java.util.Map.Entry;

/**
 * A {@link Bootstrap} that makes it easy to bootstrap a {@link Channel} to use
 * for clients.
 引导程序Bootstrap使客户端很容易启动一个通道。
 *
 * The {@link #bind()} methods are useful in combination with connectionless transports such as datagram (UDP).
 * For regular TCP connections, please use the provided {@link #connect()} methods.

 绑定方法#bind对无连接的报文通信UDP非常有用。对于Socket连接TCP，可以使用#connect连接方法。
 */
public class Bootstrap extends AbstractBootstrap {

    private static final InternalLogger logger = InternalLoggerFactory.getInstance(Bootstrap.class);

    private static final AddressResolverGroup DEFAULT_RESOLVER = DefaultAddressResolverGroup.INSTANCE;
   //引导配置
    private final BootstrapConfig config = new BootstrapConfig(this);

    @SuppressWarnings("unchecked")
    private volatile AddressResolverGroup resolver =
            (AddressResolverGroup) DEFAULT_RESOLVER;
    private volatile SocketAddress remoteAddress;//远端socket地址
     public Bootstrap() { }

    private Bootstrap(Bootstrap bootstrap) {
        super(bootstrap);
        resolver = bootstrap.resolver;
        remoteAddress = bootstrap.remoteAddress;
    }
}

由于客户端引导配置Bootstrap，不像Server引导配置需要创建交互通道，所以可以看到客户端引导配置没有在配置
子事件循环。在客户端实例中有这么几句：

EventLoopGroup workerGroup = new NioEventLoopGroup();
try {
	//Bootstrap，用于配置客户端，一般为Socket通道
	Bootstrap bootstrap = new Bootstrap();
	bootstrap.group(workerGroup)
	 .channel(NioSocketChannel.class)
	 .handler(new ChannelInitializer() {
	     @Override
	     protected void initChannel(SocketChannel ch) throws Exception {
		 //添加安全套接字处理器和通道处理器到
		 ChannelPipeline pipeline = ch.pipeline();
		 if (sslCtx != null) {
			 pipeline.addLast(sslCtx.newHandler(ch.alloc(), ip, port));
		 }
		 pipeline.addLast(new LoggingHandler(LogLevel.INFO));
		 pipeline.addLast(new EchoClientHandler());
	     }
	 });
	 ...
	//连接socket地址
	ChannelFuture f = bootstrap.connect(inetSocketAddress).sync();
...
}

我们需要关注的是这一句：

bootstrap.connect(inetSocketAddress).sync();

引导配置连接远端socket地址：

/**
 * Connect a {@link Channel} to the remote peer.
 */
public ChannelFuture connect(String inetHost, int inetPort) {
    return connect(InetSocketAddress.createUnresolved(inetHost, inetPort));
}

/**
 * Connect a {@link Channel} to the remote peer.
 */
public ChannelFuture connect(InetAddress inetHost, int inetPort) {
    return connect(new InetSocketAddress(inetHost, inetPort));
}

/**
 * Connect a {@link Channel} to the remote peer.
 */
public ChannelFuture connect(SocketAddress remoteAddress) {
    if (remoteAddress == null) {
        throw new NullPointerException("remoteAddress");
    }

    validate();
    return doResolveAndConnect(remoteAddress, config.localAddress());
}


/**
 * Connect a {@link Channel} to the remote peer.
 */
public ChannelFuture connect(SocketAddress remoteAddress, SocketAddress localAddress) {
    if (remoteAddress == null) {
        throw new NullPointerException("remoteAddress");
    }
    validate();
    return doResolveAndConnect(remoteAddress, localAddress);
}

从上面来了，连接远端socket地址，实际委托给doResolveAndConnect方法：

/**
 * @see #connect()
 连接操作
 */
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;
        }
	//初始化成功，则委托给doResolveAndConnect0完成实际连接操作
        return doResolveAndConnect0(channel, remoteAddress, localAddress, channel.newPromise());
    } 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 {
                // Directly obtain the cause and do a null check so we only need one volatile read in case of a
                // failure.
                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();
                    doResolveAndConnect0(channel, remoteAddress, localAddress, promise);
                }
            }
        });
        return promise;
    }
}

下面我们先看一下初始化通道方法，再来看实际连接完成方法doResolveAndConnect0。
//初始化通道

@Override
@SuppressWarnings("unchecked")
void init(Channel channel) throws Exception {
   //添加通道处理器到通道内存的Channel管道中
    ChannelPipeline p = channel.pipeline();
    p.addLast(config.handler());

   //配置通道选项和属性
    final Map, Object> options = options0();
    synchronized (options) {
        setChannelOptions(channel, options, logger);
    }

    final Map, Object> attrs = attrs0();
    synchronized (attrs) {
        for (Entry, Object> e: attrs.entrySet()) {
            channel.attr((AttributeKey