netty基本组件介绍

Netty做为一款用于搭建高性能网络应用程序的高级框架，由以下几个主要构件组成：

一、Channel

Channel 是java NIO的一个基本构造，可以把channel看作是传入或者传出的数据载体，可以被打开或者关闭，连接或者断开连接。简单来说其实就是我们平常网络编程中经常使用的socket套接字对象。

二、EventLoop

EventLoop定义了Netty的核心对象，用于处理IO事件，多线程模型、并发。EventLoop及其相关的设计实现，我们这里不做深入了解。只需要暂时了解以下几点：

1、一个EventLoopGroup包含一个或者多个EventLoop;

2、一个EventLoop在它的生命周期内只和一个Thread绑定；

3、所有有EventLoop处理的I/O事件都将在它专有的Thread上被处理；

4、一个Channel在它的生命周期内只注册于一个EventLoop;

5、一个EventLoop可能会被分配给一个货多个Channel；

其实我们可以简单的把EventLoop及其相关的实现NioEventLoop、NioEventLoopGroup等理解为netty针对我们网络编程时创建的多线程进行了封装和优化，构建了自己的线程模型。

三、ChannelHandler和ChannelPipeline

ChannelHandler其实就是用于负责处理接收和发送数据的的业务逻辑，Netty中可以注册多个handler，以链式的方式进行处理，根据继承接口的不同，实现的顺序也不同。

1、ChannelInboundHandler：对接收的信息进行处理。一般用来执行解码、读取客户端数据、进行业务处理等。如ByteToMessageDecoder；

2、ChannelOutboundHandler：对发送的信息进行处理，一般用来进行编码、发送报文到客户端。如MessageToByteEncoder；

而ChannelPipeline为ChannelHandler链提供了容器。

四、ByteBuf

网络数据的操作归根到底是字节的操作，Netty的ByteBuf做为一个强大高效的字节容器，提供了更加丰富的API用于字节的操作，同时保持了卓越的功能性和灵活性；

总结：

以上四个做为Netty的基本组件，可以理解为Netty把我们之前网络编程中使用到的各部分都进行了优化和高性能的封装，对比到实际的通信流程中，可以简单的用下图直观的表示

—————–

在netty基本组件介绍中，我们大致了解了netty的一些基本组件，今天我们来搭建一个基于netty的Tcp服务端程序，通过代码来了解和熟悉这些组件的功能和使用方法。

public class TCPServer {
    private Logger log = LoggerFactory.getLogger(getClass());
    //端口号
    private int port=5080;
    //服务器运行状态
    private volatile boolean isRunning = false; 
    //处理Accept连接事件的线程，这里线程数设置为1即可，netty处理链接事件默认为单线程，过度设置反而浪费cpu资源
    private final EventLoopGroup bossGroup = new NioEventLoopGroup(1);
    //处理hadnler的工作线程，其实也就是处理IO读写 。线程数据默认为 CPU 核心数乘以2
    private final EventLoopGroup workerGroup = new NioEventLoopGroup();
     
    public void init() throws Exception{
        //创建ServerBootstrap实例
        ServerBootstrap serverBootstrap=new ServerBootstrap();
        //初始化ServerBootstrap的线程组
        serverBootstrap.group(workerGroup,workerGroup);//
        //设置将要被实例化的ServerChannel类
        serverBootstrap.channel(NioServerSocketChannel.class);//
        //在ServerChannelInitializer中初始化ChannelPipeline责任链，并添加到serverBootstrap中
        serverBootstrap.childHandler(new ServerChannelInitializer());
        //标识当服务器请求处理线程全满时，用于临时存放已完成三次握手的请求的队列的最大长度
        serverBootstrap.option(ChannelOption.SO_BACKLOG, 1024);
        // 是否启用心跳保活机机制
        serverBootstrap.childOption(ChannelOption.SO_KEEPALIVE, true);    
        //绑定端口后，开启监听
        ChannelFuture channelFuture = serverBootstrap.bind(port).sync();
        if(channelFuture.isSuccess()){
            System.out.println("TCP服务启动 成功---------------");
        }
    }
    
    /**
     * 服务启动
     */
    public synchronized void startServer() {
        try {
              this.init();
        }catch(Exception ex) {
            
        }
    }
    
    /**
     * 服务关闭
     */
    public synchronized void stopServer() {
        if (!this.isRunning) {
            throw new IllegalStateException(this.getName() + " 未启动 .");
        }
        this.isRunning = false;
        try {
            Future<?> future = this.workerGroup.shutdownGracefully().await();
            if (!future.isSuccess()) {
                log.error("workerGroup 无法正常停止:{}", future.cause());
            }

            future = this.bossGroup.shutdownGracefully().await();
            if (!future.isSuccess()) {
                log.error("bossGroup 无法正常停止:{}", future.cause());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.log.info("TCP服务已经停止...");
    }
    
    private String getName() {
        return "TCP-Server";
    }
}

@ChannelHandler.Sharable
public class ServerChannelInitializer extends ChannelInitializer<SocketChannel> {
    static final EventExecutorGroup group = new DefaultEventExecutorGroup(2);
     
    public ServerChannelInitializer() throws InterruptedException {
    }
    
    @Override
    protected void initChannel(SocketChannel socketChannel) throws Exception {    
        ChannelPipeline pipeline = socketChannel.pipeline();
        //IdleStateHandler心跳机制,如果超时触发Handle中userEventTrigger()方法
        pipeline.addLast("idleStateHandler",
                new IdleStateHandler(15, 0, 0, TimeUnit.MINUTES));
        // netty基于分割符的自带解码器，根据提供的分隔符解析报文，这里是0x7e;1024表示单条消息的最大长度，解码器在查找分隔符的时候，达到该长度还没找到的话会抛异常
//        pipeline.addLast(
//                new DelimiterBasedFrameDecoder(1024, Unpooled.copiedBuffer(new byte[] { 0x7e }),
//                        Unpooled.copiedBuffer(new byte[] { 0x7e })));
         //自定义编解码器
         pipeline.addLast(
                 new MessagePacketDecoder(),
                 new MessagePacketEncoder()
                );
        //自定义Hadler
        pipeline.addLast("handler",new TCPServerHandler());
        //自定义Hander,可用于处理耗时操作，不阻塞IO处理线程
        pipeline.addLast(group,"BussinessHandler",new BussinessHandler());
    }
}

pipeline.addLast(group,"BussinessHandler",new BussinessHandler());

public class MessagePacketDecoder extends ByteToMessageDecoder
{

    public MessagePacketDecoder() throws Exception
    {
    }

    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf buffer, List<Object> out) throws Exception
    {
        try {
            if (buffer.readableBytes() > 0) {
                // 待处理的消息包
                byte[] bytesReady = new byte[buffer.readableBytes()];
                buffer.readBytes(bytesReady);
                //这之间可以进行报文的解析处理
                out.add(bytesReady );
            }
        }finally {
            
        }
    }


}

public class MessagePacketEncoder extends MessageToByteEncoder<Object>
{
    public MessagePacketEncoder()
    {
    }

    @Override
    protected void encode(ChannelHandlerContext ctx, Object msg, ByteBuf out) throws Exception
    {
        try {
            //在这之前可以实现编码工作。
            out.writeBytes((byte[])msg); 
        }finally {
            
        }  
    }
}

    public class TCPServerHandler extends ChannelInboundHandlerAdapter {
        public TCPServerHandler() {
        }

        @Override
        public void channelRead(ChannelHandlerContext ctx, Object source) throws Exception {
            // 拿到传过来的msg数据，开始处理
            ByteBuf recvmg = (ByteBuf) source;// 转化为ByteBuf
            ctx.writeAndFlush(respmsg);// 收到及发送，这里如果没有writeAndFlush，上面声明的ByteBuf需要ReferenceCountUtil.release主动释放

        }
    }

———————

ServerBootstrap与Bootstrap分别是netty中服务端与客户端的引导类，主要负责服务端与客户端初始化、配置及启动引导等工作，接下来我们就通过netty源码中的示例对ServerBootstrap与Bootstrap的源码进行一个简单的分析。首先我们知道这两个类都继承自AbstractBootstrap类

接下来我们就通过netty源码中ServerBootstrap的实例入手对其进行一个简单的分析。

         // Configure the server.
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        final EchoServerHandler serverHandler = new EchoServerHandler();
        try {
            //初始化一个服务端引导类
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup) //设置线程组
             .channel(NioServerSocketChannel.class)//设置ServerSocketChannel的IO模型  分为epoll与Nio
             .option(ChannelOption.SO_BACKLOG, 100)//设置option参数，保存成一个LinkedHashMap<ChannelOption<?>, Object>()
             .handler(new LoggingHandler(LogLevel.INFO))//这个hanlder 只专属于 ServerSocketChannel 而不是 SocketChannel。
             .childHandler(new ChannelInitializer<SocketChannel>() { //这个handler 将会在每个客户端连接的时候调用。供 SocketChannel 使用。
                 @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);
                 }
             });

            // Start the server. 启动服务
            ChannelFuture f = b.bind(PORT).sync();

            // Wait until the server socket is closed.
            f.channel().closeFuture().sync();
        } finally {
            // Shut down all event loops to terminate all threads.
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }

接下来我们主要从服务端的socket在哪里初始化与哪里accept连接这两个问题入手对netty服务端启动的流程进行分析；

我们首先要知道，netty服务的启动其实可以分为以下四步：

• 创建服务端Channel
• 初始化服务端Channel
• 注册Selector
• 端口绑定

一、创建服务端Channel

1、服务端Channel的创建，主要为以下流程

我们通过跟踪代码能够看到

final ChannelFuture regFuture = initAndRegister();// 初始化并创建 NioServerSocketChannel

我们在initAndRegister()中可以看到channel的初始化。

channel = channelFactory.newChannel(); // 通过 反射工厂创建一个 NioServerSocketChannel

我进一步看newChannel()中的源码，在ReflectiveChannelFactory这个反射工厂中，通过clazz这个类的反射创建了一个服务端的channel。

    @Override
    public T newChannel() {
        try {
            return clazz.getConstructor().newInstance();//反射创建
        } catch (Throwable t) {
            throw new ChannelException("Unable to create Channel from class " + clazz, t);
        }
    }

既然通过反射，我们就要知道clazz类是什么，那么我我们来看下channelFactory这个工厂类是在哪里初始化的，初始化的时候我们传入了哪个channel。

这里我们需要看下demo实例中初始化ServerBootstrap时.channel(NioServerSocketChannel.class)这里的具体实现，我们看下源码

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

通过上面的代码我可以直观的看出正是在这里我们通过NioServerSocketChannel这个类构造了一个反射工厂。

那么到这里就很清楚了，我们创建的Channel就是一个NioServerSocketChannel，那么具体的创建我们就需要看下这个类的构造函数。首先我们看下一个NioServerSocketChannel创建的具体流程

首先是newsocket(),我们先看下具体的代码，在NioServerSocketChannel的构造函数中我们创建了一个jdk原生的ServerSocketChannel

    /**
     * Create a new instance
     */
    public NioServerSocketChannel() {
        this(newSocket(DEFAULT_SELECTOR_PROVIDER));//传入默认的SelectorProvider
    }

    private static ServerSocketChannel newSocket(SelectorProvider provider) {
        try {
            /**
             *  Use the {@link SelectorProvider} to open {@link SocketChannel} and so remove condition in
             *  {@link SelectorProvider#provider()} which is called by each ServerSocketChannel.open() otherwise.
             *
             *  See <a href="https://github.com/netty/netty/issues/2308">#2308</a>.
             */
            return provider.openServerSocketChannel();//可以看到创建的是jdk底层的ServerSocketChannel 
        } catch (IOException e) {
            throw new ChannelException(
                    "Failed to open a server socket.", e);
        }
    }

第二步是通过NioServerSocketChannelConfig配置服务端Channel的构造函数，在代码中我们可以看到我们把NioServerSocketChannel这个类传入到了NioServerSocketChannelConfig的构造函数中进行配置

    /**
     * Create a new instance using the given {@link ServerSocketChannel}.
     */
    public NioServerSocketChannel(ServerSocketChannel channel) {
        super(null, channel, SelectionKey.OP_ACCEPT);//调用父类构造函数,传入创建的channel
        config = new NioServerSocketChannelConfig(this, javaChannel().socket());
    }

第三步在父类AbstractNioChannel的构造函数中把创建服务端的Channel设置为非阻塞模式

    /**
     * Create a new instance
     *
     * @param parent            the parent {@link Channel} by which this instance was created. May be {@code null}
     * @param ch                the underlying {@link SelectableChannel} on which it operates
     * @param readInterestOp    the ops to set to receive data from the {@link SelectableChannel}
     */
    protected AbstractNioChannel(Channel parent, SelectableChannel ch, int readInterestOp) {
        super(parent);
        this.ch = ch;//这个ch就是传入的通过jdk创建的Channel
        this.readInterestOp = readInterestOp;
        try {
            ch.configureBlocking(false);//设置为非阻塞
        } catch (IOException e) {
            try {
                ch.close();
            } catch (IOException e2) {
                if (logger.isWarnEnabled()) {
                    logger.warn(
                            "Failed to close a partially initialized socket.", e2);
                }
            }

            throw new ChannelException("Failed to enter non-blocking mode.", e);
        }
    }

第四步调用AbstractChannel这个抽象类的构造函数设置Channel的id（每个Channel都有一个id，唯一标识）,unsafe（tcp相关底层操作），pipeline（逻辑链）等，而不管是服务的Channel还是客户端的Channel都继承自这个抽象类，他们也都会有上述相应的属性。我们看下AbstractChannel的构造函数

    /**
     * Creates a new instance.
     *
     * @param parent
     *        the parent of this channel. {@code null} if there's no parent.
     */
    protected AbstractChannel(Channel parent) {
        this.parent = parent;
        id = newId();//创建Channel唯一标识 
        unsafe = newUnsafe();//netty封装的TCP 相关操作类
        pipeline = newChannelPipeline();//逻辑链
    }

2、初始化服务端创建的Channel

init(channel);// 初始化这个 NioServerSocketChannel

我们首先列举下init(channel)中具体都做了哪了些功能：

• 设置ChannelOptions、ChannelAttrs ,配置服务端Channel的相关属性；
• 设置ChildOptions、ChildAttrs，配置每个新连接的Channel的相关属性；
• Config handler，配置服务端pipeline;
• add ServerBootstrapAcceptor,添加连接器，对accpet接受到的新连接进行处理，添加一个nio线程；

那么接下来我们通过代码，对每一步设置进行一下分析：

首先是在SeverBootstrap的init()方法中对ChannelOptions、ChannelAttrs 的配置的关键代码

        final Map<ChannelOption<?>, Object> options = options0();//拿到你设置的option
        synchronized (options) {
            setChannelOptions(channel, options, logger);//设置NioServerSocketChannel相应的TCP参数，其实这一步就是把options设置到channel的config中
        }

        final Map<AttributeKey<?>, Object> attrs = attrs0();
        synchronized (attrs) {
            for (Entry<AttributeKey<?>, Object> e: attrs.entrySet()) {
                @SuppressWarnings("unchecked")
                AttributeKey<Object> key = (AttributeKey<Object>) e.getKey();
                channel.attr(key).set(e.getValue());
            }
        }

然后是对ChildOptions、ChildAttrs配置的关键代码

        //可以看到两个都是局部变量，会在下面设置pipeline时用到
        final Entry<ChannelOption<?>, Object>[] currentChildOptions;
        final Entry<AttributeKey<?>, Object>[] currentChildAttrs;
        synchronized (childOptions) {
            currentChildOptions = childOptions.entrySet().toArray(newOptionArray(0));
        }
        synchronized (childAttrs) {
            currentChildAttrs = childAttrs.entrySet().toArray(newAttrArray(0));
        }

第三步对服务端Channel的handler进行配置

        p.addLast(new ChannelInitializer<Channel>() {
            @Override
            public void initChannel(final Channel ch) throws Exception {
                final ChannelPipeline pipeline = ch.pipeline();
                ChannelHandler handler = config.handler();//拿到我们自定义的hanler
                if (handler != null) {
                    pipeline.addLast(handler);
                }

                ch.eventLoop().execute(new Runnable() {
                    @Override
                    public void run() {
                        pipeline.addLast(new ServerBootstrapAcceptor(
                                ch, currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));
                    }
                });
            }
        });

第四步添加ServerBootstrapAcceptor连接器，这个是netty向服务端Channel自定义添加的一个handler，用来处理新连接的添加与属性配置，我们来看下关键代码

                ch.eventLoop().execute(new Runnable() {
                    @Override
                    public void run() {
                        //在这里会把我们自定义的ChildGroup、ChildHandler、ChildOptions、ChildAttrs相关配置传入到ServerBootstrapAcceptor构造函数中，并绑定到新的连接上
                        pipeline.addLast(new ServerBootstrapAcceptor(
                                ch, currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));
                    }
                });

三、注册Selector

一个服务端的Channel创建完毕后，下一步就是要把它注册到一个事件轮询器Selector上，在initAndRegister()中我们把上面初始化的Channel进行注册

ChannelFuture regFuture = config().group().register(channel);//注册我们已经初始化过的Channel

而这个register具体实现是在AbstractChannel中的AbstractUnsafe抽象类中的

 /**
         * 1、先是一系列的判断。
         * 2、判断当前线程是否是给定的 eventLoop 线程。注意：这点很重要，Netty 线程模型的高性能取决于对于当前执行的Thread 的身份的确定。如果不在当前线程，那么就需要很多同步措施（比如加锁），上下文切换等耗费性能的操作。
         * 3、异步（因为我们这里直到现在还是 main 线程在执行，不属于当前线程）的执行 register0 方法。
         */
        @Override
        public final void register(EventLoop eventLoop, final ChannelPromise promise) {
            if (eventLoop == null) {
                throw new NullPointerException("eventLoop");
            }
            if (isRegistered()) {
                promise.setFailure(new IllegalStateException("registered to an event loop already"));
                return;
            }
            if (!isCompatible(eventLoop)) {
                promise.setFailure(
                        new IllegalStateException("incompatible event loop type: " + eventLoop.getClass().getName()));
                return;
            }

            AbstractChannel.this.eventLoop = 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);
                }
            }
        }

首先我们对整个注册的流程做一个梳理

接下来我们进入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();//jdk channel的底层注册
                neverRegistered = false;
                registered = true;

                // 触发绑定的handler事件
                // 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();
                // 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);
            }
        }

AbstractNioChannel中doRegister()的具体实现就是把jdk底层的channel绑定到eventLoop的selecor上

    @Override
    protected void doRegister() throws Exception {
        boolean selected = false;
        for (;;) {
            try {
                //把channel注册到eventLoop上的selector上
                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;
                }
            }
        }
    }

到这里netty就把服务端的channel注册到了指定的selector上，下面就是服务端口的绑定

三、端口绑定

首先我们梳理下netty中服务端口绑定的流程

我们来看下AbstarctUnsafe中bind()方法的具体实现

 @Override
        public final void bind(final SocketAddress localAddress, final ChannelPromise promise) {
            assertEventLoop();

            if (!promise.setUncancellable() || !ensureOpen(promise)) {
                return;
            }

            // See: https://github.com/netty/netty/issues/576
            if (Boolean.TRUE.equals(config().getOption(ChannelOption.SO_BROADCAST)) &&
                localAddress instanceof InetSocketAddress &&
                !((InetSocketAddress) localAddress).getAddress().isAnyLocalAddress() &&
                !PlatformDependent.isWindows() && !PlatformDependent.maybeSuperUser()) {
                // Warn a user about the fact that a non-root user can't receive a
                // broadcast packet on *nix if the socket is bound on non-wildcard address.
                logger.warn(
                        "A non-root user can't receive a broadcast packet if the socket " +
                        "is not bound to a wildcard address; binding to a non-wildcard " +
                        "address (" + localAddress + ") anyway as requested.");
            }

            boolean wasActive = isActive();//判断绑定是否完成
            try {
                doBind(localAddress);//底层jdk绑定端口
            } catch (Throwable t) {
                safeSetFailure(promise, t);
                closeIfClosed();
                return;
            }

            if (!wasActive && isActive()) {
                invokeLater(new Runnable() {
                    @Override
                    public void run() {
                        pipeline.fireChannelActive();//触发ChannelActive事件
                    }
                });
            }

            safeSetSuccess(promise);
        }

在doBind(localAddress)中netty实现了jdk底层端口的绑定

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

在 pipeline.fireChannelActive()中会触发pipeline中的channelActive()方法

        @Override
        public void channelActive(ChannelHandlerContext ctx) throws Exception {
            ctx.fireChannelActive();

            readIfIsAutoRead();
        }

在channelActive中首先会把ChannelActive事件往下传播，然后调用readIfIsAutoRead()方法出触发channel的read事件，而它最终调用AbstractNioChannel中的doBeginRead()方法

    @Override
    protected void doBeginRead() throws Exception {
        // Channel.read() or ChannelHandlerContext.read() was called
        final SelectionKey selectionKey = this.selectionKey;
        if (!selectionKey.isValid()) {
            return;
        }

        readPending = true;

        final int interestOps = selectionKey.interestOps();
        if ((interestOps & readInterestOp) == 0) {
            selectionKey.interestOps(interestOps | readInterestOp);//readInterestOp为  SelectionKey.OP_ACCEPT
        }
    }

在doBeginRead()方法，netty会把accept事件注册到Selector上。

到此我们对netty服务端的启动流程有了一个大致的了解，整体可以概括为下面四步：

1、channelFactory.newChannel()，其实就是创建jdk底层channel，并初始化id、piepline等属性；

2、init(channel)，添加option、attr等属性，并添加ServerBootstrapAcceptor连接器；

3、config().group().register(channel)，把jdk底层的channel注册到eventLoop上的selector上；

4、doBind0(regFuture, channel, localAddress, promise)，完成服务端端口的监听，并把accept事件注册到selector上；

以上就是对netty服务端启动流程进行的一个简单分析，有很多细节没有关注与深入，其中如有不足与不正确的地方还望指出与海涵。

来源： https://www.cnblogs.com/dafanjoy/p/9689566.html