Netty源码（五）服务端启动流程分析

前言

在源码分析的第一部分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就可以，不需要调整其他地方。本篇的源码分析就到此为止。

©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 212,657评论 6赞 492
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 90,662评论 3赞 385
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 158,143评论 0赞 348
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 56,732评论 1赞 284
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 65,837评论 6赞 386
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 50,036评论 1赞 291
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 39,126评论 3赞 410
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 37,868评论 0赞 268
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 44,315评论 1赞 303
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,641评论 2赞 327
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,773评论 1赞 341
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 34,470评论 4赞 333
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 40,126评论 3赞 317
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,859评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,095评论 1赞 267
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 46,584评论 2赞 362
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 43,676评论 2赞 351