volatile EventLoopGroup **group**;  
private volatile ChannelFactory<? extends C> **channelFactory**;  
private final Map<ChannelOption<?>, Object> **options** = new LinkedHashMap<ChannelOption<?>, Object>();  
private final Map<AttributeKey<?>, Object> **attrs** \= new LinkedHashMap<AttributeKey<?>, Object>();  
private volatile ChannelHandler **handler**;

public B **group**(EventLoopGroup group) {  
    if (group == null) {  
        throw new NullPointerException("group");  
    }  
    if (this.group != null) {  
        throw new IllegalStateException("group set already");  
    }  
    this.group = group;  
    return self();  
}

private B self() {  
    return (B) this;  
}

public B **channel**(Class<? extends C> channelClass) {  
    if (channelClass == null) {  
        throw new NullPointerException("channelClass");  
    }  
    return channelFactory(new ReflectiveChannelFactory<C>(channelClass));  
}

@Deprecated  
public B **channelFactory**(ChannelFactory<? extends C> channelFactory) {  
    if (channelFactory == null) {  
        throw new NullPointerException("channelFactory");  
    }  
    if (this.channelFactory != null) {  
        throw new IllegalStateException("channelFactory set already");  
    }

    this.channelFactory = channelFactory;  
    return self();  
}

public B **channelFactory**(io.netty.channel.ChannelFactory<? extends C> channelFactory) {  
    return channelFactory((ChannelFactory<C>) channelFactory);  
}

public <T> B **option**(ChannelOption<T> option, T value) {  
    if (option == null) {  
        throw new NullPointerException("option");  
    }  
    if (value == null) {  
        synchronized (options) {  
            options.remove(option);  
        }  
    } else {  
        synchronized (options) {  
            options.put(option, value);  
        }  
    }  
    return self();  
}

public <T> B **attr**(AttributeKey<T> key, T value) {  
    if (key == null) {  
        throw new NullPointerException("key");  
    }  
    if (value == null) {  
        synchronized (attrs) {  
            attrs.remove(key);  
        }  
    } else {  
        synchronized (attrs) {  
            attrs.put(key, value);  
        }  
    }  
    return self();  
}

public B **validate**() {  
    if (group == null) {  
        throw new IllegalStateException("group not set");  
    }  
    if (channelFactory == null) {  
        throw new IllegalStateException("channel or channelFactory not set");  
    }  
    return self();  
}

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**() {  
    Channel channel = null;  
    try {  
        channel = channelFactory.newChannel();  
        init(channel);  
    } 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);  
    }

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

    return regFuture;  
}

abstract void **init**(Channel channel) throws Exception;

private static void **doBind0**(  
        final ChannelFuture regFuture, final Channel channel,  
        final SocketAddress localAddress, final ChannelPromise promise) {

    // This method is invoked before channelRegistered() is triggered.  Give user handlers a chance to set up  
    // the pipeline in its channelRegistered() implementation.  
    channel.eventLoop().execute(new Runnable() {  
        @Override  
        public void run() {  
            if (regFuture.isSuccess()) {  
                channel.bind(localAddress, promise).addListener(ChannelFutureListener.CLOSE\_ON\_FAILURE);  
            } else {  
                promise.setFailure(regFuture.cause());  
            }  
        }  
    });  
}

public B **handler**(ChannelHandler handler) {  
    if (handler == null) {  
        throw new NullPointerException("handler");  
    }  
    this.handler = handler;  
    return self();  
}public abstract AbstractBootstrapConfig<B, C> config();

}

现在我们以示例代码为出发点，来详细分析一下引导类内部实现细节：

1、 首先看看服务端的b.group(bossGroup, workerGroup)：

 调用ServerBootstrap的group方法，设置react模式的主线程池 以及 IO 操作线程池，ServerBootstrap中的group代码如下：

public ServerBootstrap group(EventLoopGroup parentGroup, EventLoopGroup childGroup) {
super.group(parentGroup); if (childGroup == null) {
throw new NullPointerException("childGroup");
}
if (this.childGroup != null) {
throw new IllegalStateException("childGroup set already");
}
this.childGroup = childGroup; return this;
}

在group方法中，会继续调用父类的group方法，而通过类继承图我们知道，super.group(parentGroup)其实调用的就是AbstractBootstrap的group方法。AbstractBootstrap中group代码如下：

public B group(EventLoopGroup group) {
if (group == null) {
throw new NullPointerException("group");
}
if (this.group != null) {
throw new IllegalStateException("group set already");
}
this.group = group; return self();
}

通过以上分析，我们知道了AbstractBootstrap中定义了主线程池group的引用，而子线程池childGroup的引用是定义在ServerBootstrap中。

当我们查看客户端Bootstrap的group方法时，我们发现，其是直接调用的父类AbstractBoostrap的group方法。

2、示例代码中的 channel()方法

无论是服务端还是客户端，channel调用的都是基类的channel方法，其实现细节如下：

public B channel(Class channelClass) {
if (channelClass == null) {
throw new NullPointerException("channelClass");
}
return channelFactory(new ReflectiveChannelFactory(channelClass));
}

public B channelFactory(ChannelFactory channelFactory) {
if (channelFactory == null) {
throw new NullPointerException("channelFactory");
}
if (this.channelFactory != null) {
throw new IllegalStateException("channelFactory set already");
}

    **this.channelFactory = channelFactory;** return self();  
}

我们发现，其实channel方法内部，只是初始化了一个用于生产指定channel类型的工厂实例。

3、option / handler / attr 方法

option： 设置通道的选项参数， 对于服务端而言就是ServerSocketChannel， 客户端而言就是SocketChannel；

　 handler： 设置主通道的处理器， 对于服务端而言就是ServerSocketChannel，也就是用来处理Acceptor的操作；

　　　　　　对于客户端的SocketChannel，主要是用来处理 业务操作；

attr： 设置通道的属性；

　option / handler / attr方法都定义在AbstractBootstrap中， 所以服务端和客户端的引导类方法调用都是调用的父类的对应方法。

4、childHandler / childOption / childAttr 方法（只有服务端ServerBootstrap才有child类型的方法）

　  对于服务端而言，有两种通道需要处理， 一种是ServerSocketChannel：用于处理用户连接的accept操作， 另一种是SocketChannel，表示对应客户端连接。而对于客户端，一般都只有一种channel，也就是SocketChannel。

　  因此以child开头的方法，都定义在ServerBootstrap中，表示处理或配置服务端接收到的对应客户端连接的SocketChannel通道。

　 childHandler / childOption / childAttr 在ServerBootstrap中的对应代码如下：

public ServerBootstrap childHandler(ChannelHandler childHandler) {
if (childHandler == null) {
throw new NullPointerException("childHandler");
}
this.childHandler = childHandler; return this;
}

public ServerBootstrap childOption(ChannelOption childOption, T value) {
if (childOption == null) {
throw new NullPointerException("childOption");
}
if (value == null) {
synchronized (childOptions) {
childOptions.remove(childOption);
}
} else {
synchronized (childOptions) {
childOptions.put(childOption, value);
}
}
return this;
}

public ServerBootstrap childAttr(AttributeKey childKey, T value) {
if (childKey == null) {
throw new NullPointerException("childKey");
}
if (value == null) {
childAttrs.remove(childKey);
} else {
childAttrs.put(childKey, value);
}
return this;
}

至此，引导类的属性配置都设置完毕了。

本篇总结：

1、服务端由两种线程池，用于Acceptor的React主线程和用于I/O操作的React从线程池； 客户端只有用于连接及IO操作的React的主线程池；

2、ServerBootstrap中定义了服务端React的"从线程池"对应的相关配置，都是以child开头的属性。 而用于"主线程池"channel的属性都定义在AbstractBootstrap中；

本篇只是简单介绍了一下引导类的配置属性， 下一篇我将详细介绍服务端引导类的Bind过程分析。