美文网首页Java
Netty源码(五)服务端启动流程分析

Netty源码(五)服务端启动流程分析

作者: 挪威的senlin | 来源:发表于2020-07-05 17:03 被阅读0次

    前言

    在源码分析的第一部分Netty源码(一)Netty架构解析里面提到了netty的几个关键组件

    • EventLoop
      EventLoop是Netty中最重要的组件,一个单线程事件循环,监听IO事件、处理IO事件和任务队列。
    • EventLoopGroup
      EventLoopGroup顾名思义,管理多个EventLoop。
    • Channel
      Channel是能够进行IO操作组件的抽象,如读、写、连接和绑定。
    • ChannelHandler
      ChannelHandler是我们使用Netty开发最关心的一个组件,它是对IO事件的具体处理逻辑。
    • ChannelPipeline
      ChannelPipeline则是ChannelHandler的容器,本质是一个双向链表,将所有的ChannelHandler按照顺序连接起。

    在本篇文章将会分析一个netty服务器的启动流程,以及是如何将这个组件给串联起来的。

    服务端代码

    下面是一段服务端的启动代码,来自netty官网

        private int port;
    
        public DiscardServer(int port) {
            this.port = port;
        }
    
        public void run() throws Exception {
            EventLoopGroup bossGroup = new NioEventLoopGroup(); // (1)
            EventLoopGroup workerGroup = new NioEventLoopGroup();
            try {
                ServerBootstrap b = new ServerBootstrap(); // (2)
                b.group(bossGroup, workerGroup)
                        .channel(NioServerSocketChannel.class) // (3)
                        .childHandler(new ChannelInitializer<SocketChannel>() { // (4)
                            @Override
                            public void initChannel(SocketChannel ch) {
                                ch.pipeline().addLast(new DiscardServerHandler());
                            }
                        })
                        .option(ChannelOption.SO_BACKLOG, 128)          // (5)
                        .childOption(ChannelOption.SO_KEEPALIVE, true); // (6)
    
                // Bind and start to accept incoming connections.
                ChannelFuture f = b.bind(port).sync(); // (7)
    
                // Wait until the server socket is closed.
                // In this example, this does not happen, but you can do that to gracefully
                // shut down your server.
                f.channel().closeFuture().sync();
            } finally {
                workerGroup.shutdownGracefully();
                bossGroup.shutdownGracefully();
            }
        }
    
    1. EventLoopGroup 之前以及详细介绍过了,处理IO操作的多线程事件循环,分为bossGroup和workGroup,分别处理连接事件和读写事件。可以通过构造参数指定EventLoopGroup 的线程数量,默认为当前cup数量的两倍;
    2. ServerBootstrap 为了方便构建服务器的辅助类;
    3. channel:由于是服务器端,使用NioServerSocketChannel构建一个Channel用于接收传入的连接;
    4. childHandler:添加用户自定义的ChannelHandler,比如解码、编码处理器和业务处理的Handler。
    5. option:设置Channel的一些参数,比如这里正在实现一个TCP/IP服务器,可以指定一些TCP参数比如tcpNoDelay和keepAlive。
    6. childOption:option与childOption不同在于,option指定的是传入channel的参数如现在的NioServerSocketChannel,而childOption指定的是NioServerSocketChannel接受的Channel。
    7. 将服务绑定到指定的端口,并启动服务。

    可以看见netty构建一个服务器代码是很简单明了,大家如果看过用NIO构建一个服务器的代码是非常复杂和抽象的,而netty用极短的代码就能构建出一个服务器,可见netty框架对底层细节的抽象和对框架的设计的能力。

    Channel初始化

    接下来开始分析服务端的启动流程,上面代码构造的服务器最关键的一步就是调用bind(),其他的group、childHandler方法都是做一些简单的赋值操作,这里就不分析了,而bind()是将上一步赋值的参数全部串起来,然后启动服务。

        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();
            // ......
           doBind0(regFuture, channel, localAddress, promise);
            // ......
        }
    

    总结起来这个方法做了两个事件:

    1. initAndRegister(): 初始化传入的Channel并且注册到EventLoopGroup
    2. doBind0():绑定端口

    initAndRegister()

    由名字可知初始化并且注册,但是初始化什么、注册到哪里?虽然已经告诉了答案,
    初始化传入的Channel并且注册到EventLoopGroup,还是要具体分析一下是怎么初始化和注册的。
    initAndRegister()

        final ChannelFuture initAndRegister() {
            Channel channel = null;
            try {
                //初始化Channel
                channel = channelFactory.newChannel();
                init(channel);
            } catch (Throwable t) {
                // ......
            }
            //注册到EventLoopGroup
            ChannelFuture regFuture = config().group().register(channel);
            
            return regFuture;
        }
    

    初始化

    channel = channelFactory.newChannel();
    

    看到这行代码要channelFactory是什么,做什么作用?分析源码的过程中很容易就迷失,找不到关键的地方,带着问题去分析是最好的方法。比如这里当我们不知道这个channelFactory是什么的时候,首先看他的定义是什么

    public interface ChannelFactory<T extends Channel> {
        /**
         * Creates a new channel.
         */
        T newChannel();
    }
    

    定义了一个接口,初始化Channel,可以知道channelFactory的职责是初始化一个Channel。那这里channelFactory的具体实现是什么呢?
    最简单的方法就是使用debug的方式找到channelFactory的实现类,或者使用编译器看这个变量这哪里被调用,做的复制操作。通过这些方法我们定位到了代码

        public B channel(Class<? extends C> channelClass) {
            return channelFactory(new ReflectiveChannelFactory<C>(
                    ObjectUtil.checkNotNull(channelClass, "channelClass")
            ));
        }
    

    上诉代码可以知道我们在调用.channel(NioServerSocketChannel.class)的时候就对channelFactory做了初始化,默认为ReflectiveChannelFactory,顾名思义通过反射初始化Channel,下面代码就展示了ReflectiveChannelFactory的实现。通过反射拿到Channel的构造器,然后调用初始化方法。
    ReflectiveChannelFactory

        //.....
         this.constructor = clazz.getConstructor();
        //.....
        public T newChannel() {
            try {
                return constructor.newInstance();
            } catch (Throwable t) {
                throw new ChannelException("Unable to create Channel from class " + constructor.getDeclaringClass(), t);
            }
        }
    

    所以分析到这里,我们就可以知道channel = channelFactory.newChannel();
    这里的初始化的Channel就是第一步构造ServerBootstrap传入的NioServerSocketChannel。

    接下来分析第二步init(channel)

    abstract void init(Channel channel) throws Exception;
    

    可以看见是一个抽象方法,找到服务端的具体实现

        void init(Channel channel) {
            //设置属性
            setChannelOptions(channel, newOptionsArray(), logger);
            setAttributes(channel, attrs0().entrySet().toArray(EMPTY_ATTRIBUTE_ARRAY));
    
            ChannelPipeline p = channel.pipeline();
            // ......
    
            p.addLast(new ChannelInitializer<Channel>() {
                // 将启动类传入的ChannelHandler 加入pipeline
                @Override
                public void initChannel(final Channel ch) {
                    final ChannelPipeline pipeline = ch.pipeline();
                    ChannelHandler handler = config.handler();
                    if (handler != null) {
                        pipeline.addLast(handler);
                    }
                    // acceptor角色
                    ch.eventLoop().execute(new Runnable() {
                        @Override
                        public void run() {
                            pipeline.addLast(new ServerBootstrapAcceptor(
                                    ch, currentChildGroup, currentChildHandler, currentChildOptions, currentChildAttrs));
                        }
                    });
                }
            });
        }
    

    这段代码比较长,个人认为有两个点需要重点分析

    1. ChannelPipeline p = channel.pipeline();
    2. ServerBootstrapAcceptor

    ChannelPipeline netty中的一个关键的组件在这里出现了,ChannelPipeline是ChannelHandler 的容器,这里是调用channel的pipeline()返回的ChannelPipeline对象。所以需要找一下ChannelPipeline 是什么、在什么时候初始化的,按照之前的方法很轻松的在AbstractChannel找到代码

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

    可见是在Channel初始化的时候创建的ChannelPipeline默认为DefaultChannelPipeline,所以在这里也可以知道每个Channel都对应着一个ChannelPipeline。
    接下来分析很关键的代码

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

    在pipeline中添加了名为ServerBootstrapAcceptor的处理器,在第一篇文章中我们提到过Reactor模式,里面就有一个acceptor角色用于将mainReactor角色介绍的连接转给subReactor,这里看一下ServerBootstrapAcceptor是不是也在做这个事情。

    private static class ServerBootstrapAcceptor extends ChannelInboundHandlerAdapter
    

    继承自ChannelInboundHandlerAdapter,可见是一个ChannelHandler而且处理的是入站事件,下面分析它是怎么处理的入站事件。

            public void channelRead(ChannelHandlerContext ctx, Object msg) {
                // 父Channel监听的是连接事件,所有直接转为Channel 
                final Channel child = (Channel) msg;
                //添加 启动类传入的childHandler
                child.pipeline().addLast(childHandler);
                //设置启动类传入的属性
                setChannelOptions(child, childOptions, logger);
                setAttributes(child, childAttrs);
    
                try {
                    // 将boosWorup获得的连接注册到childGroup上
                    childGroup.register(child).addListener(new ChannelFutureListener() {
                       // ......
                    });
                } catch (Throwable t) {
                     // ......
                }
            }
    
    1. 将父Channel(NioServerSocketChannel)读取的信息强转为Channel
    2. 添加 启动类传入的childHandler
    3. 设置启动类传入的属性
    4. 将boosWorup获得的连接注册到childGroup上

    分析到这里可以知道netty是通过ChannelHandler的形式将bossGroup与workGroup联系起来,当bossGroup接受到新的连接就将其注册到childGroup上。

    最后再回到initAndRegister()这个方法的最后一步

     ChannelFuture regFuture = config().group().register(channel);
    

    这个方法就是将我们实体化的NioServerSocketChannel注册到bossGroup上。

    分析到这里对initAndRegister()做一个简单的总结

    1. 通过channelFactory使用反射的形式将启动类传入的Channel(NioServerSocketChannel)实例化;
    2. 实例化Channel的时候会创建一个ChannelPipeline对象,以Channel一一对应;
    3. 通过ServerBootstrapAcceptor将bossGroup接入的连接转给workGroup;
    4. 将实例化的Channel(NioServerSocketChannel)注册到boosGroup上。

    所以initAndRegister()实例化的是启动类传入的Channel对象并注册在boosGroup上。

    绑定地址

    这里分析服务启动第二步doBind0绑定端口地址

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

    跟进去channel.bind(SocketAddress localAddress, ChannelPromise promise)找到AbstractChannel的bind方法

        public ChannelFuture bind(SocketAddress localAddress, ChannelPromise promise) {
            return pipeline.bind(localAddress, promise);
        }
    

    调用pipeline的bind方法,再跟进去

        @Override
        public final ChannelFuture bind(SocketAddress localAddress, ChannelPromise promise) {
            return tail.bind(localAddress, promise);
        }
    

    之前说过ChannelPipeline是管理ChannelHandler的容器,DefaultChannelPipeline的实现就是用一个双向链表,初始化的是一个有一个头节点HeadContext和尾节点TailContext,这里不具体分析。
    这里分析需要打上断点一步一步调用,最好找到实现在AbstractUnsafe中的bind方法

            @Override
            public final void bind(final SocketAddress localAddress, final ChannelPromise promise) {
                //......
                boolean wasActive = isActive();
                try {
                  //绑定端口地址
                    doBind(localAddress);
                } catch (Throwable t) {
                   //......
                }
    
                if (!wasActive && isActive()) {
                    invokeLater(new Runnable() {
                        @Override
                        public void run() {
                           //触发channelActive事件
                            pipeline.fireChannelActive();
                        }
                    });
                }
                //绑定成功
                safeSetSuccess(promise);
            }
    

    简化之后做三件事情调用jdk底层绑定端口,触发channelActive事件,将promise设置为成功。
    doBind 调用jdk底层绑定端口

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

    就此服务端启动的流程结束,当然这里分析不是所有细节都涉及到了,只是对netty服务端启动流程的一个简要分析。

    总结

    1. 通过ServerBootstrap将主要的组件先添加进去,比如NioEventLoopGroup、Channel、ChannelHandler、option、childOption等;
    2. 通过反射创建出Channel,并且在创建Channel的时候也会初始化ChannelPipeline;
    3. 将ChannelHandler添加到Channel所对应的ChannelPipeline中;
    4. 通过ServerBootstrapAcceptor将Channel所接受的连接转交给workGroup处理;
    5. 将第2步初始化Channel注册到bossGroup上;
    6. 调用jdk底层绑定端口地址;
    7. 触发fireChannelActive事件;

    netty服务端的启动流程主要就是上面的流程,越看netty的源码就越感觉netty设计的精妙。不管是底层细节、还是整体框架的设计,比如创建一个netty的客户端如下

        public static void main(String[] args) throws Exception {
            String host = args[0];
            int port = Integer.parseInt(args[1]);
            EventLoopGroup workerGroup = new NioEventLoopGroup();
            
            try {
                Bootstrap b = new Bootstrap(); // (1)
                b.group(workerGroup); // (2)
                b.channel(NioSocketChannel.class); // (3)
                b.option(ChannelOption.SO_KEEPALIVE, true); // (4)
                b.handler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    public void initChannel(SocketChannel ch) throws Exception {
                        ch.pipeline().addLast(new TimeClientHandler());
                    }
                });
                
                // Start the client.
                ChannelFuture f = b.connect(host, port).sync(); // (5)
    
                // Wait until the connection is closed.
                f.channel().closeFuture().sync();
            } finally {
                workerGroup.shutdownGracefully();
            }
        }
    

    对比服务器只有少数不同的地方。或者不使用NioServerSocketChannel作为服务器的底层连接将NioServerSocketChannel替换就可以了比如EpollServerSocketChannel就可以,不需要调整其他地方。本篇的源码分析就到此为止。

    相关文章

      网友评论

        本文标题:Netty源码(五)服务端启动流程分析

        本文链接:https://www.haomeiwen.com/subject/cxbeghtx.html