Netty源码解析(六) —— 服务端channel如何完成注册

先看ServerBootstrap的继承关系

---

ServerBootstrap的成员变量

    //worker group
    private volatile EventLoopGroup childGroup;
    //设置进来的childHandler
    private volatile ChannelHandler childHandler;

AbstractBootstrap:

    /**
     * EventLoopGroup 对象  boss group
     */
    volatile EventLoopGroup group;
    /**
     * channel工厂用于创建channel
     */
    @SuppressWarnings("deprecation")
    private volatile ChannelFactory channelFactory;
    /**
     * 本地地址
     */
    private volatile SocketAddress localAddress;
    /**
     * 可选项集合
     */
    private final Map, Object> options = new LinkedHashMap, Object>();
    /**
     * 属性集合
     */
    private final Map, Object> attrs = new LinkedHashMap, Object>();
    /**
     * 启动的时候设置的处理器  .handler(new LoggingHandler(LogLevel.INFO))
     * 设置进来的
     */
    private volatile ChannelHandler handler;

---

先看服务端启动的代码

        //创建boss worker线程
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        final EchoServerHandler serverHandler = new EchoServerHandler();
        try {
            //创建netty服务端启动器
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup)//给启动器配置boss worker
             .channel(NioServerSocketChannel.class)//设置使用NioServerSocketChannel
             .option(ChannelOption.SO_BACKLOG, 100)
             .handler(new LoggingHandler(LogLevel.INFO))
             .childHandler(new ChannelInitializer() {
                 @Override
                 public void initChannel(SocketChannel ch) throws Exception {
                     ChannelPipeline p = ch.pipeline();
                     if (sslCtx != null) {
                         p.addLast(sslCtx.newHandler(ch.alloc()));
                     }
                     //p.addLast(new LoggingHandler(LogLevel.INFO));
                     p.addLast(serverHandler);
                 }
             });

io.netty.bootstrap.ServerBootstrap#group(io.netty.channel.EventLoopGroup,io.netty.channel.EventLoopGroup)

    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");
        }
        //保存到worker group
        this.childGroup = childGroup;
        return this;
    }
    public B group(EventLoopGroup group) {
        if (group == null) {
            throw new NullPointerException("group");
        }
        if (this.group != null) {//不允许重复设置
            throw new IllegalStateException("group set already");
        }
        //保存到boss group
        this.group = group;
        return self();
    }

io.netty.bootstrap.AbstractBootstrap#channel

    /**
     * 设置要被实例化的 Channel 的类
     */
    public B channel(Classextends C> channelClass) {
        if (channelClass == null) {
            throw new NullPointerException("channelClass");
        }
        return channelFactory(new ReflectiveChannelFactory(channelClass));
    }

ReflectiveChannelFactory工厂,用于反射生产channel对象

public class ReflectiveChannelFactory<T extends Channel> implements ChannelFactory<T> {

    //Channel 对应的类
    private final Classextends T> clazz;

    public ReflectiveChannelFactory(Classextends T> clazz) {
        if (clazz == null) {
            throw new NullPointerException("clazz");
        }
        this.clazz = clazz;
    }

    @Override
    public T newChannel() {
        try {
            // 反射调用默认构造方法，创建 Channel 对象
            return clazz.getConstructor().newInstance();
        } catch (Throwable t) {
            throw new ChannelException("Unable to create Channel from class " + clazz, t);
        }
    }

这个工厂模式一目了然
io.netty.bootstrap.AbstractBootstrap#handler(io.netty.channel.ChannelHandler)

    /**
     * the {@link ChannelHandler} to use for serving the requests.
     * 设置创建 Channel 的处理器
     */
    public B handler(ChannelHandler handler) {
        if (handler == null) {
            throw new NullPointerException("handler");
        }
        //保存处理器
        this.handler = handler;
        return self();
    }
    public ServerBootstrap childHandler(ChannelHandler childHandler) {
        if (childHandler == null) {
            throw new NullPointerException("childHandler");
        }
        //保存到childHandler处理器
        this.childHandler = childHandler;
        return this;
    }

io.netty.bootstrap.AbstractBootstrap#bind(int)根据调用链,最后走到
.bootstrap.AbstractBootstrap#doBind

    private ChannelFuture doBind(final SocketAddress localAddress) {
        // 初始化并注册一个 Channel 对象，因为注册是异步的过程，所以返回一个 ChannelFuture 对象。
        final ChannelFuture regFuture = initAndRegister();
        final Channel channel = regFuture.channel();
        if (regFuture.cause() != null) {// 若发生异常，直接进行返回
            return regFuture;
        }

        // 绑定 Channel 的端口，并注册 Channel 到 SelectionKey 中。
        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;
        }
    }

io.netty.bootstrap.AbstractBootstrap#initAndRegister

    final ChannelFuture initAndRegister() {
        Channel channel = null;
        try {
            // 创建 Channel 对象(工厂模式反射创建)
            channel = channelFactory.newChannel();
            // 初始化 Channel 配置
            init(channel);
        } catch (Throwable t) {
            if (channel != null) {// 已创建 Channel 对象
                channel.unsafe().closeForcibly();// 强制关闭 Channel
                /**
                 * 因为创建 Channel 对象失败，所以需要创建一个 FailedChannel 对象，设置到 DefaultChannelPromise 中才可以返回。
                 */
                return new DefaultChannelPromise(channel, GlobalEventExecutor.INSTANCE).setFailure(t);
            }
            return new DefaultChannelPromise(new FailedChannel(), GlobalEventExecutor.INSTANCE).setFailure(t);
        }

        /**
         * 首先获得 EventLoopGroup 对象，后调用 EventLoopGroup#register(Channel) 方法，注册 Channel 到 EventLoopGroup 中。
         * 实际在方法内部，EventLoopGroup 会分配一个 EventLoop 对象，将 Channel 注册到其上。
         *
         * 注册 Channel 到 EventLoopGroup 中
         * config().group()拿到的是boss线程调度
         *
         */
        ChannelFuture regFuture = config().group().register(channel);
        if (regFuture.cause() != null) {
            if (channel.isRegistered()) {
                channel.close();
            } else {
                // 强制关闭 Channel
                channel.unsafe().closeForcibly();
            }
        }
        return regFuture;
    }

io.netty.bootstrap.AbstractBootstrap#init初始化 Channel 配置

    @Override
    void init(Channel channel) throws Exception {
        final Map, Object> options = options0();
        synchronized (options) {
            setChannelOptions(channel, options, logger);
        }

        //设置options  attrs给服务端的channel对象
        final Map, Object> attrs = attrs0();
        synchronized (attrs) {
            for (Entry, Object> e: attrs.entrySet()) {
                @SuppressWarnings("unchecked")
                AttributeKey