对于上述属性定义，整体总结如下：

1. 提供了一个ChannelFactory对象用来创建Channel,一个Channel会对应一个EventLoop用于IO的事件处理，在一个Channel的整个生命周期中 只会绑定一个EventLoop,这里可理解给Channel分配一个线程进行IO事件处理，结束后回收该线程。

2. AbstractBootstrap没有提供EventLoop而是提供了一个EventLoopGroup，其实我认为这里只用一个EventLoop就行了。

3. 不管是服务器还是客户端的Channel都需要绑定一个本地端口这就有了SocketAddress类的对象localAddress。

4. Channel有很多选项所有有了options对象LinkedHashMap, Object>

5. 怎么处理Channel的IO事件呢，我们添加一个事件处理器ChannelHandler对象。

ServerBootstrap属性定义

ServerBootstrap可以理解为服务器启动的工厂类，我们可以通过它来完成服务器端的 Netty 初始化。主要职责:|

• EventLoop初始化
• channel的注册
• pipeline的初始化
• handler的添加过程
• 服务端连接处理。

public class ServerBootstrap extends AbstractBootstrap {    private static final InternalLogger logger = InternalLoggerFactory.getInstance(ServerBootstrap.class);    // The order in which child ChannelOptions are applied is important they may depend on each other for validation    // purposes.    //SocketChannel相关的属性配置    private final Map, Object> childOptions = new LinkedHashMap, Object>();    private final Map, Object> childAttrs = new ConcurrentHashMap, Object>();    private final ServerBootstrapConfig config = new ServerBootstrapConfig(this); //配置类    private volatile EventLoopGroup childGroup;  //工作线程组    private volatile ChannelHandler childHandler; //负责SocketChannel的IO处理相关的Handler    public ServerBootstrap() { }}

服务端启动过程分析

了解了ServerBootstrap相关属性的配置之后，我们继续来看服务的启动过程，在开始往下分析的时候，先不妨来思考以下这些问题

• Netty自己实现的Channel与底层JDK提供的Channel是如何联系并且构建实现的
• ChannelInitializer这个特殊的Handler处理器的作用以及实现原理
• Pipeline是如何初始化以的

ServerBootstrap.bind

先来看ServerBootstrap.bind()方法的定义，这里主要用来绑定一个端口并且发布服务端监听。

根据我们使用NIO相关API的理解，无非就是使用JDK底层的API来打开一个服务端监听并绑定一个端口。

 ChannelFuture channelFuture=bootstrap.bind(port).sync();

public ChannelFuture bind(SocketAddress localAddress) {    validate();    return doBind(ObjectUtil.checkNotNull(localAddress, "localAddress"));}

• validate()， 验证ServerBootstrap核心成员属性的配置是否正确，比如group、channelFactory、childHandler、childGroup等，这些属性如果没配置，那么服务端启动会报错

• localAddress，绑定一个本地端口地址

doBind

doBind方法比较长，从大的代码结构，可以分为三个部分

• initAndRegister 初始化并注册Channel，并返回一个ChannelFuture，说明初始化注册Channel是异步实现
• regFuture.cause() 用来判断initAndRegister()是否发生异常，如果发生异常，则直接返回
• regFuture.isDone()， 判断initAndRegister()方法是否执行完成。
  • 如果执行完成，则调用doBind0()方法。
  • 如果未执行完成，regFuture添加一个监听回调，在监听回调中再次判断执行结果进行相关处理。
  • PendingRegistrationPromise 用来保存异步执行结果的状态

从整体代码逻辑来看，逻辑结构还是非常清晰的， initAndRegister()方法负责Channel的初始化和注册、doBind0()方法用来绑定端口。这个无非就是我们使用NIO相关API发布服务所做的事情。

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

这个方法顾名思义，就是初始化和注册，基于我们整个流程的分析可以猜测到

• 初始化，应该就是构建服务端的Handler处理链
• register，应该就是把当前服务端的连接注册到selector上

下面我们通过源码印证我们的猜想。

final ChannelFuture initAndRegister() {    Channel channel = null;    try {        //通过ChannelFactory创建一个具体的Channel实现        channel = channelFactory.newChannel();        init(channel); //初始化    } catch (Throwable t) {        //省略....    }    //这个代码应该和我们猜想是一致的，就是将当前初始化的channel注册到selector上，这个过程同样也是异步的    ChannelFuture regFuture = config().group().register(channel);    if (regFuture.cause() != null) { //获取regFuture的执行结果        if (channel.isRegistered()) {             channel.close();        } else {            channel.unsafe().closeForcibly();        }    }    return regFuture;}

channelFactory.newChannel()

这个方法在分析之前，我们可以继续推测它的逻辑。

在最开始构建服务端的代码中，我们通过channel设置了一个NioServerSocketChannel.class类对象，这个对象表示当前channel的构建使用哪种具体的API

bootstrap.group(bossGroup, workerGroup)    //配置Server的通道，相当于NIO中的ServerSocketChannel    .channel(NioServerSocketChannel.class)

而在initAndRegister方法中，又用到了channelFactory.newChannel()来生成一个具体的Channel实例，因此不难想到，这两者必然有一定的联系，我们也可以武断的认为，这个工厂会根据我们配置的channel来动态构建一个指定的channel实例。

channelFactory有多个实现类，所以我们可以从配置方法中找到channelFactory的具体定义，代码如下。

public B channel(Class channelClass) {    return channelFactory(new ReflectiveChannelFactory(        ObjectUtil.checkNotNull(channelClass, "channelClass")    ));}

channelFactory对应的具体实现是：ReflectiveChannelFactory，因此我们定位到newChannel()方法的实现。

ReflectiveChannelFactory.newChannel

在该方法中，使用constructor构建了一个实例。

@Overridepublic T newChannel() {    try {        return constructor.newInstance();    } catch (Throwable t) {        throw new ChannelException("Unable to create Channel from class " + constructor.getDeclaringClass(), t);    }}

construtor的初始化代码如下， 用到了传递进来的clazz类，获得该类的构造器，该构造器后续可以通过newInstance创建一个实例对象

而此时的clazz其实就是：NioServerSocketChannel

public class ReflectiveChannelFactory implements ChannelFactory {    private final Constructor constructor;    public ReflectiveChannelFactory(Class clazz) {        ObjectUtil.checkNotNull(clazz, "clazz");        try {            this.constructor = clazz.getConstructor();        } catch (NoSuchMethodException e) {            throw new IllegalArgumentException("Class " + StringUtil.simpleClassName(clazz) +                    " does not have a public non-arg constructor", e);        }    }}

NioServerSocketChannel

NioServerSocketChannel的构造方法定义如下。

public class NioServerSocketChannel extends AbstractNioMessageChannel                             implements io.netty.channel.socket.ServerSocketChannel {    private static ServerSocketChannel newSocket(SelectorProvider provider) {        try {            return provider.openServerSocketChannel();        } catch (IOException e) {            throw new ChannelException(                    "Failed to open a server socket.", e);        }    }    public NioServerSocketChannel() {        this(newSocket(DEFAULT_SELECTOR_PROVIDER));    }}

当NioServerSocketChannel实例化后，调用newSocket方法创建了一个服务端实例。

newSocket方法中调用了provider.openServerSocketChannel()，来完成ServerSocketChannel的创建，ServerSocketChannel就是Java中NIO中的服务端API。

public ServerSocketChannel openServerSocketChannel() throws IOException {    return new ServerSocketChannelImpl(this);}

通过层层推演，最终看到了Netty是如何一步步封装，完成ServerSocketChannel的创建。

设置非阻塞

在NioServerSocketChannel中的构造方法中，先通过super调用父类做一些配置操作

public NioServerSocketChannel(ServerSocketChannel channel) {    super(null, channel, SelectionKey.OP_ACCEPT);    config = new NioServerSocketChannelConfig(this, javaChannel().socket());}

最终，super会调用AbstractNioChannel中的构造方法，

protected AbstractNioChannel(Channel parent, SelectableChannel ch, int readInterestOp) {    super(parent);    this.ch = ch;    this.readInterestOp = readInterestOp; //设置关心事件，此时是一个连接事件，所以是OP_ACCEPT    try {        ch.configureBlocking(false); //设置非阻塞    } catch (IOException e) {        try {            ch.close();        } catch (IOException e2) {            logger.warn(                "Failed to close a partially initialized socket.", e2);        }        throw new ChannelException("Failed to enter non-blocking mode.", e);    }}

继续分析initAndRegister

分析完成channel的初始化后，接下来就是要将当前channel注册到Selector上，所以继续回到initAndRegister方法。

final ChannelFuture initAndRegister() {//省略....    //这个代码应该和我们猜想是一致的，就是将当前初始化的channel注册到selector上，这个过程同样也是异步的    ChannelFuture regFuture = config().group().register(channel);    if (regFuture.cause() != null) { //获取regFuture的执行结果        if (channel.isRegistered()) {             channel.close();        } else {            channel.unsafe().closeForcibly();        }    }    return regFuture;}

注册到某个Selector上，其实就是注册到某个EventLoopGroup中，如果大家能有这个猜想，说明前面的内容是听懂了的。

config().group().register(channel)这段代码，其实就是获取在ServerBootstrap中配置的bossEventLoopGroup，然后把当前的服务端channel注册到该group中。

此时，我们通过快捷键想去看一下register的实现时，发现EventLoopGroup又有多个实现，我们来看一下类关系图如图8-2所示。

而我们在前面配置的EventLoopGroup的实现类是NioEventLoopGroup，而NioEventLoopGroup继承自MultithreadEventLoopGroup，所以在register()方法中，我们直接找到父类的实现方法即可。

MultithreadEventLoopGroup.register

这段代码大家都熟了，从NioEventLoopGroup中选择一个NioEventLoop，将当前channel注册上去

@Overridepublic ChannelFuture register(Channel channel) {    return next().register(channel);}

next()方法返回的是NioEventLoop，而NioEventLoop又有多个实现类，我们来看图8-4所示的类关系图。

从类关系图中发现，发现NioEventLoop派生自SingleThreadEventLoop，所以next().register(channel);方法，执行的是SingleThreadEventLoop中的register

SingleThreadEventLoop.register

@Overridepublic ChannelFuture register(Channel channel) {    return register(new DefaultChannelPromise(channel, this));}

@Overridepublic ChannelFuture register(final ChannelPromise promise) {    ObjectUtil.checkNotNull(promise, "promise");    promise.channel().unsafe().register(this, promise);    return promise;}

ChannelPromise， 派生自Future，用来实现异步任务处理回调功能。简单来说就是把注册的动作异步化，当异步执行结束后会把执行结果回填到ChannelPromise中

AbstractChannel.register

抽象类一般就是公共逻辑的处理，而这里的处理主要就是针对一些参数的判断，判断完了之后再调用register0()方法。

@Overridepublic final void register(EventLoop eventLoop, final ChannelPromise promise) {    ObjectUtil.checkNotNull(eventLoop, "eventLoop");    if (isRegistered()) { //判断是否已经注册过        promise.setFailure(new IllegalStateException("registered to an event loop already"));        return;    }    if (!isCompatible(eventLoop)) { //判断eventLoop类型是否是EventLoop对象类型，如果不是则抛出异常        promise.setFailure(            new IllegalStateException("incompatible event loop type: " + eventLoop.getClass().getName()));        return;    }    AbstractChannel.this.eventLoop = eventLoop;    //Reactor内部线程调用，也就是说当前register方法是EventLoop线程触发的，则执行下面流程    if (eventLoop.inEventLoop()) {        register0(promise);    } else { //如果是外部线程        try {            eventLoop.execute(new Runnable() {                @Override                public void run() {                    register0(promise);                }            });        } catch (Throwable t) {            logger.warn(                "Force-closing a channel whose registration task was not accepted by an event loop: {}",                AbstractChannel.this, t);            closeForcibly();            closeFuture.setClosed();            safeSetFailure(promise, t);        }    }}

AbstractChannel.register0

Netty从EventLoopGroup线程组中选择一个EventLoop和当前的Channel绑定，之后该Channel生命周期中的所有I/O事件都由这个EventLoop负责。

register0方法主要做四件事：

• 调用JDK层面的API对当前Channel进行注册
• 触发HandlerAdded事件
• 触发channelRegistered事件
• Channel状态为活跃时，触发channelActive事件

在当前的ServerSocketChannel连接注册的逻辑中，我们只需要关注下面的doRegister方法即可。

private void register0(ChannelPromise promise) {    try {        // check if the channel is still open as it could be closed in the mean time when the register        // call was outside of the eventLoop        if (!promise.setUncancellable() || !ensureOpen(promise)) {            return;        }        boolean firstRegistration = neverRegistered;        doRegister();  //调用JDK层面的register()方法进行注册        neverRegistered = false;        registered = true;        // Ensure we call handlerAdded(...) before we actually notify the promise. This is needed as the        // user may already fire events through the pipeline in the ChannelFutureListener.        pipeline.invokeHandlerAddedIfNeeded(); //触发Handler，如果有必要的情况下        safeSetSuccess(promise);        pipeline.fireChannelRegistered();        // Only fire a channelActive if the channel has never been registered. This prevents firing        // multiple channel actives if the channel is deregistered and re-registered.        if (isActive()) { //此时是ServerSocketChannel的注册，所以连接还处于非活跃状态            if (firstRegistration) {                pipeline.fireChannelActive();             } else if (config().isAutoRead()) {                // This channel was registered before and autoRead() is set. This means we need to begin read                // again so that we process inbound data.                //                // See https://github.com/netty/netty/issues/4805                beginRead();            }        }    } catch (Throwable t) {        // Close the channel directly to avoid FD leak.        closeForcibly();        closeFuture.setClosed();        safeSetFailure(promise, t);    }}

AbstractNioChannel.doRegister

进入到AbstractNioChannel.doRegister方法。

javaChannel().register()负责调用JDK层面的方法，把channel注册到eventLoop().unwrappedSelector()上，其中第三个参数传入的是Netty自己实现的Channel对象，也就是把该对象绑定到attachment中。

这样做的目的是，后续每次调Selector对象进行事件轮询时，当触发事件时，Netty都可以获取自己的Channe对象。

@Overrideprotected void doRegister() throws Exception {    boolean selected = false;    for (;;) {        try {            selectionKey = javaChannel().register(eventLoop().unwrappedSelector(), 0, this);            return;        } catch (CancelledKeyException e) {            if (!selected) {                // Force the Selector to select now as the "canceled" SelectionKey may still be                // cached and not removed because no Select.select(..) operation was called yet.                eventLoop().selectNow();                selected = true;            } else {                // We forced a select operation on the selector before but the SelectionKey is still cached                // for whatever reason. JDK bug ?                throw e;            }        }    }}

服务注册总结

上述代码比较绕，但是整体总结下来并不难理解

• 初始化指定的Channel实例
• 把该Channel分配给某一个EventLoop
• 然后把Channel注册到该EventLoop的Selector中

AbstractBootstrap.doBind0

分析完了注册的逻辑后，再回到AbstractBootstrap类中的doBind0方法，这个方法不用看也能知道，ServerSocketChannel初始化了之后，接下来要做的就是绑定一个ip和端口地址。

private static void doBind0(    final ChannelFuture regFuture, final Channel channel,    final SocketAddress localAddress, final ChannelPromise promise) {    //获取当前channel中的eventLoop实例，执行一个异步任务。    //需要注意，以前我们在课程中讲过，eventLoop在轮询中一方面要执行select遍历，另一方面要执行阻塞队列中的任务，而这里就是把任务添加到队列中异步执行。    channel.eventLoop().execute(new Runnable() {        @Override        public void run() {            //如果ServerSocketChannel注册成功，则调用该channel的bind方法            if (regFuture.isSuccess()) {                channel.bind(localAddress, promise).addListener(ChannelFutureListener.CLOSE_ON_FAILURE);            } else {                promise.setFailure(regFuture.cause());            }        }    });}

channel.bind方法，会根据ServerSocketChannel中的handler链配置，逐个进行调用，由于在本次案例中，我们给ServerSocketChannel配置了一个 LoggingHandler的处理器，所以bind方法会先调用LoggingHandler，然后再调用DefaultChannelPipeline中的bind方法，调用链路

-> DefaultChannelPipeline.ind

​ -> AbstractChannel.bind

​ -> NioServerSocketChannel.doBind

最终就是调用前面初始化好的ServerSocketChannel中的bind方法绑定本地地址和端口。

protected void doBind(SocketAddress localAddress) throws Exception {    if (PlatformDependent.javaVersion() >= 7) {        javaChannel().bind(localAddress, config.getBacklog());    } else {        javaChannel().socket().bind(localAddress, config.getBacklog());    }}

构建SocketChannel的Pipeline

在ServerBootstrap的配置中，我们针对SocketChannel，配置了入站和出站的Handler，也就是当某个SocketChannel的IO事件就绪时，就会按照我们配置的处理器链表进行逐一处理，那么这个链表是什么时候构建的，又是什么样的结构呢？下面我们来分析这部分的内容

.childHandler(new ChannelInitializer() {    @Override    protected void initChannel(SocketChannel socketChannel) throws Exception {        socketChannel.pipeline()            .addLast(new NormalInBoundHandler("NormalInBoundA",false))            .addLast(new NormalInBoundHandler("NormalInBoundB",false))            .addLast(new NormalInBoundHandler("NormalInBoundC",true));        socketChannel.pipeline()            .addLast(new NormalOutBoundHandler("NormalOutBoundA"))            .addLast(new NormalOutBoundHandler("NormalOutBoundB"))            .addLast(new NormalOutBoundHandler("NormalOutBoundC"))            .addLast(new ExceptionHandler());    }});

childHandler的构建

childHandler的构建过程，在AbstractChannel.register0方法中实现

final ChannelFuture initAndRegister() {        Channel channel = null;        try {            channel = channelFactory.newChannel(); //这是是创建channel            init(channel); //这里是初始化        } catch (Throwable t) {            //省略....        }        ChannelFuture regFuture = config().group().register(channel); //这是是注册        if (regFuture.cause() != null) {            if (channel.isRegistered()) {                channel.close();            } else {                channel.unsafe().closeForcibly();            }        }        return regFuture;    }

ServerBootstrap.init

init方法，调用的是ServerBootstrap中的init()，代码如下。

@Overridevoid init(Channel channel) {    setChannelOptions(channel, newOptionsArray(), logger);    setAttributes(channel, newAttributesArray());    ChannelPipeline p = channel.pipeline();    final EventLoopGroup currentChildGroup = childGroup;    final ChannelHandler currentChildHandler = childHandler;  //childHandler就是在服务端配置时添加的ChannelInitializer    final Entry, Object>[] currentChildOptions = newOptionsArray(childOptions);    final Entry, Object>[] currentChildAttrs = newAttributesArray(childAttrs);    // 此时的Channel是NioServerSocketChannel，这里是为NioServerSocketChannel添加处理器链。    p.addLast(new ChannelInitializer() {        @Override        public void initChannel(final Channel ch) {            final ChannelPipeline pipeline = ch.pipeline();            ChannelHandler handler = config.handler(); //如果在ServerBootstrap构建时，通过.handler添加了处理器，则会把相关处理器添加到NioServerSocketChannel中的pipeline中。            if (handler != null) {                pipeline.addLast(handler);            }            ch.eventLoop().execute(new Runnable() { //异步天剑一个ServerBootstrapAcceptor处理器，从名字来看，                @Override                public void run() {                    pipeline.addLast(new ServerBootstrapAcceptor(                        //currentChildHandler，表示SocketChannel的pipeline，当收到客户端连接时，就会把该handler添加到当前SocketChannel的pipeline中                        ch, currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));                }            });        }    });}

其中，对于上述代码的核心部分说明如下

• ChannelPipeline 是在AbstractChannel中的构造方法中初始化的一个DefaultChannelPipeline

  protected AbstractChannel(Channel parent) {  this.parent = parent;  id = newId();  unsafe = newUnsafe();  pipeline = newChannelPipeline();}

• p.addLast是为NioServerSocketChannel添加handler处理器链，这里添加了一个ChannelInitializer回调函数，该回调是异步触发的，在回调方法中做了两件事

  • 如果ServerBootstrap.handler添加了处理器，则会把相关处理器添加到该pipeline中，在本次演示的案例中，我们添加了LoggerHandler
  • 异步执行添加了ServerBootstrapAcceptor，从名字来看，它是专门用来接收新的连接处理的。

我们在这里思考一个问题，为什么NioServerSocketChannel需要通过ChannelInitializer回调处理器呢？ ServerBootstrapAcceptor为什么通过异步任务添加到pipeline中呢？

原因是，NioServerSocketChannel在初始化的时候，还没有开始将该Channel注册到Selector对象上，也就是没办法把ACCEPT事件注册到Selector上，所以事先添加了ChannelInitializer处理器，等待Channel注册完成后，再向Pipeline中添加ServerBootstrapAcceptor。

ServerBootstrapAcceptor

按照下面的方法演示一下SocketChannel中的Pipeline的构建过程

1. 启动服务端监听
2. 在ServerBootstrapAcceptor的channelRead方法中打上断点
3. 通过telnet 连接，此时会触发debug。

public void channelRead(ChannelHandlerContext ctx, Object msg) {    final Channel child = (Channel) msg;    child.pipeline().addLast(childHandler);  //在这里，将handler添加到SocketChannel的pipeline中    setChannelOptions(child, childOptions, logger);    setAttributes(child, childAttrs);    try {        //把当前客户端的链接SocketChannel注册到某个EventLoop中。        childGroup.register(child).addListener(new ChannelFutureListener() {            @Override            public void operationComplete(ChannelFuture future) throws Exception {                if (!future.isSuccess()) {                    forceClose(child, future.cause());                }            }        });    } catch (Throwable t) {        forceClose(child, t);    }}

ServerBootstrapAcceptor是服务端NioServerSocketChannel中的一个特殊处理器，该处理器的channelRead事件只会在新连接产生时触发，所以这里通过final Channel child = (Channel) msg;可以直接拿到客户端的链接SocketChannel。

ServerBootstrapAcceptor接着通过childGroup.register()方法，把当前NioSocketChannel注册到工作线程中。

事件触发机制的流程

在ServerBootstrapAcceptor中，收到客户端连接时，会调用childGroup.register(child)把当前客户端连接注册到指定NioEventLoop的Selector中。

这个注册流程和前面讲解的NioServerSocketChannel注册流程完全一样，最终都会进入到AbstractChannel.register0方法。

AbstractChannel.register0

private void register0(ChannelPromise promise) {    try {        // check if the channel is still open as it could be closed in the mean time when the register        // call was outside of the eventLoop        if (!promise.setUncancellable() || !ensureOpen(promise)) {            return;        }        boolean firstRegistration = neverRegistered;        doRegister();        neverRegistered = false;        registered = true;        // Ensure we call handlerAdded(...) before we actually notify the promise. This is needed as the        // user may already fire events through the pipeline in the ChannelFutureListener.        pipeline.invokeHandlerAddedIfNeeded();        safeSetSuccess(promise);        pipeline.fireChannelRegistered(); //执行pipeline中的ChannelRegistered()事件。        // Only fire a channelActive if the channel has never been registered. This prevents firing        // multiple channel actives if the channel is deregistered and re-registered.        if (isActive()) {            if (firstRegistration) {                pipeline.fireChannelActive();            } else if (config().isAutoRead()) {                // This channel was registered before and autoRead() is set. This means we need to begin read                // again so that we process inbound data.                //                // See https://github.com/netty/netty/issues/4805                beginRead();            }        }    } catch (Throwable t) {        // Close the channel directly to avoid FD leak.        closeForcibly();        closeFuture.setClosed();        safeSetFailure(promise, t);    }}

pipeline.fireChannelRegistered()

@Overridepublic final ChannelPipeline fireChannelRegistered() {    AbstractChannelHandlerContext.invokeChannelRegistered(head);    return this;}

下面的事件触发，分为两个逻辑

• 如果当前的任务是在eventLoop中触发的，则直接调用invokeChannelRegistered
• 否则，异步执行invokeChannelRegistered。

static void invokeChannelRegistered(final AbstractChannelHandlerContext next) {    EventExecutor executor = next.executor();    if (executor.inEventLoop()) {        next.invokeChannelRegistered();    } else {        executor.execute(new Runnable() {            @Override            public void run() {                next.invokeChannelRegistered();            }        });    }}

invokeChannelRegistered

触发下一个handler的channelRegistered方法。

private void invokeChannelRegistered() {    if (invokeHandler()) {        try {            ((ChannelInboundHandler) handler()).channelRegistered(this);        } catch (Throwable t) {            invokeExceptionCaught(t);        }    } else {        fireChannelRegistered();    }}

Netty服务端启动总结

到此为止，整个服务端启动的过程，我们就已经分析完成了，主要的逻辑如下

• 创建服务端Channel，本质上是根据用户配置的实现，调用JDK原生的Channel
• 初始化Channel的核心属性，unsafe、pipeline
• 初始化Channel的Pipeline，主要是添加两个特殊的处理器，ChannelInitializer和ServerBootstrapAcceptor
• 注册服务端的Channel，添加OP_ACCEPT事件，这里底层调用的是JDK层面的实现，讲Channel注册到BossEventLoop中的Selector上
• 绑定端口，调用JDK层面的API，绑定端口。