netty源码分析(三)Netty服务端ServerBootstrap的初始化与反射在其中的应用分析

上一节说到EventLoopGroup只是对bossGroup和workerGroup的一些初始化，包括线程数量，执行器（命令模式），我们的服务端接下来使用ServerBootstrap对bossGroup和workerGroup进行了包装，整个过程是一个方法链的调用过程，每个方法返回调用者本身：

然后进行了启动，先看一下ServerBootstrap的结构：

 //{@link Bootstrap} sub-class which allows easy bootstrap of {@link ServerChannel}
 //Bootstrap的子类型，用来启动ServerChannel，父类是AbstractBootstrap，父类的泛型是它的子类类型ServerBootstrap和
 //要启动的ServerChannel类型。
public class ServerBootstrap extends AbstractBootstrap<ServerBootstrap, ServerChannel> {
    ...略    
    private volatile EventLoopGroup childGroup;//即之前创建的workerGroup，实际处理数据的EventLoopGroup。
    ...略    
    public ServerBootstrap() { } //构造器非常简化。
    ...略    

    /**
     * Set the {@link EventLoopGroup} for the parent (acceptor) and the child (client). These
     * {@link EventLoopGroup}'s are used to handle all the events and IO for {@link ServerChannel} and
     * {@link Channel}'s.
     * parentGroup放在父类AbstractBootstrap里边，即acceptor，childGroup放在当前类里边，即client
     * EventLoopGroup的作用就是处理所有的ServerChannel和Channel的io事件。
     */
    public ServerBootstrap group(EventLoopGroup parentGroup, EventLoopGroup childGroup) {
        super.group(parentGroup);//调父类的构造器，将parentGroup放在父类
        if (childGroup == null) {
            throw new NullPointerException("childGroup");
        }
        if (this.childGroup != null) {
            throw new IllegalStateException("childGroup set already");
        }
        this.childGroup = childGroup;//childGroup放在子类里边
        return this;
    }

我们切换到父类AbstractBootstrap：

//泛型B是AbstractBootstrap的子类类型，当前是ServerBootstrap，C是通道类型，当前是NioServerSocketChannel（后续会提到）
public abstract class AbstractBootstrap<B extends AbstractBootstrap<B, C>, C extends Channel> implements Cloneable {
    ...略    
        private volatile ChannelFactory<? extends C> channelFactory;//Channel类型的C会被反射成实体，放在ChannelFactory
        //里边，后边会说。
 /**
     * The {@link EventLoopGroup} which is used to handle all the events for the to-be-created
     * {@link Channel}
     */
    @SuppressWarnings("unchecked")
    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 (B) this;//返回子类型ServerBootstrap。
    }
        ...略    

接下来会调用serverBootstrap.group(bossGroup,workerGroup).channel(NioServerSocketChannel.class)，channel方法，channel位于父类AbstractBootstrap里边：

    /**
     * The {@link Class} which is used to create {@link Channel} instances from.
     * You either use this or {@link #channelFactory(io.netty.channel.ChannelFactory)} if your
     * {@link Channel} implementation has no no-args constructor.
     * channelClass即我们的参数NioServerSocketChannel.class，new ReflectiveChannelFactory<C>(channelClass)使用反射生成了
     * NioServerSocketChannel的实例（无参构造器），
     */
    public B channel(Class<? extends C> channelClass) {
        if (channelClass == null) {
            throw new NullPointerException("channelClass");
        }
        return channelFactory(new ReflectiveChannelFactory<C>(channelClass));
    }

这里用到了ReflectiveChannelFactory，这里牵扯了三个factory和他们之间的关系，如图：

这个图我们只要了解一下即可，接下来 return channelFactory(new ReflectiveChannelFactory(channelClass));，进入channelFactory方法：

//入参：channelFactory类型io.netty.channel.ChannelFactory
    public B channelFactory(io.netty.channel.ChannelFactory<? extends C> channelFactory) {
        return channelFactory((ChannelFactory<C>) channelFactory);
    }

继续走：

//入参：channelFactory类型io.netty.bootstrap.ChannelFactory
    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;
         //即AbstractBootstrap的成员变量channelFactory被赋值，实际上是一个ReflectiveChannelFactory。
         //private volatile ChannelFactory<? extends C> channelFactory;

        return (B) this;//返回子类型ServerBootstrap 为了链式方法调用
    }

接下是serverBootstrap.group(bossGroup,workerGroup).channel(NioServerSocketChannel.class).childHandler(new MyServerInitializer());，childHandler方法：

    /**
     * Set the {@link ChannelHandler} which is used to serve the request for the {@link Channel}'s.
     * childHandler是为了服务客户端的request请求。
     */
    public ServerBootstrap childHandler(ChannelHandler childHandler) {
        if (childHandler == null) {
            throw new NullPointerException("childHandler");
        }
        this.childHandler = childHandler;//只是简单的赋值
        return this;
    }

到目前为止：
bossGroup 位于父类AbstractBootstrap，workerGroup位于ServerBootstrap ，NioServerSocketChannel位于AbstractBootstrap
ChannelHandler位于ServerBootstrap ，这写操作都是数据的准备，为了后边的启动：

ChannelFuture channelFuture = serverBootstrap.bind(8899).sync();

bind方法：

    /**
     * Create a new {@link Channel} and bind it.
     * 创建一个新的channel绑定到ServerBootstrap 上
     */
    public ChannelFuture bind(int inetPort) {
        return bind(new InetSocketAddress(inetPort));
    }

方法最终调用dobind：
这个方法是启动服务的比较重要的一个实现

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

下一节我们从initAndRegister方法开始讲解。