Netty源码分析（一）--探索服务端启动流程

9527出列
154 阅读5分钟

前言

书接上文，在计算机网络专栏中，笔者较为系统地揭示了网络通信的底层原理。正是基于这些基础认知，我们才能深入剖析 Netty 框架的核心机制。作为业界领先的开源 NIO 框架，Netty 以其高性能、易扩展的架构设计，在网络基础设施、中间件以及游戏服务器等场景中得到了广泛应用，具备不可替代的行业地位。

本系列文章适用于具备一定计算机网络与 Java 网络编程基础的研发人员，旨在帮助读者进一步提升对 Netty 的理解与实践能力。

服务端启动示例

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
import io.netty.util.AttributeKey;

public class NettyServer {

    private final int port;

    public NettyServer(int port) {
        this.port = port;
    }

    public void start() throws InterruptedException {
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            // 创建 AttributeKey
            AttributeKey<String> serverNameKey = AttributeKey.valueOf("serverName");
            AttributeKey<String> clientKey = AttributeKey.valueOf("clientKey");

            ServerBootstrap bootstrap = new ServerBootstrap();

            bootstrap.group(bossGroup, workerGroup)
                     .channel(NioServerSocketChannel.class)
                     // 服务端 Channel 的初始化逻辑（通常用于启动日志）
                     .handler(new ChannelInitializer<NioServerSocketChannel>() {
                         @Override
                         protected void initChannel(NioServerSocketChannel ch) {
                             ch.pipeline().addLast(new LoggingHandler(LogLevel.INFO));
                         }
                     })
                     // 客户端连接 SocketChannel 的初始化逻辑
                     .childHandler(new ChannelInitializer<SocketChannel>() {
                         @Override
                         protected void initChannel(SocketChannel ch) {
                             ChannelPipeline pipeline = ch.pipeline();
                             pipeline.addLast(new SimpleServerHandler());
                         }
                     })
                     // 给服务端 ServerChannel 设置属性
                     .attr(serverNameKey, "nettyServer")
                     // 给每个客户端连接的 Channel 设置属性
                     .childAttr(clientKey, "clientValue")
                     .option(ChannelOption.SO_BACKLOG, 128)
                     .childOption(ChannelOption.SO_KEEPALIVE, true);

            ChannelFuture future = bootstrap.bind(port).sync();
            System.out.println("Netty server started on port: " + port);

            future.channel().closeFuture().sync();
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new NettyServer(8080).start();
    }
}


import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

public class SimpleServerHandler extends ChannelInboundHandlerAdapter {
    
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        String clientVal = ctx.channel().attr(AttributeKey.valueOf("clientKey")).get();
        System.out.println("Client connected with attr: " + clientVal);
        super.channelActive(ctx);
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        System.out.println("收到消息: " + msg);
        ctx.writeAndFlush(msg); // 回写消息（回显服务器）
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        cause.printStackTrace();
        ctx.close();
    }
}

这是一个简单的服务端启动示例代码，我们通过构造一个辅助启动类ServerBootstrap并设置一些参数，最终调用这个辅助类的bind()方法来启动服务端。bind()方法返回ChannelFuture对象，调用ChannelFuture对象的sync()方法阻塞当前线程，直到绑定操作完成。在netty中，所有的IO操作都是异步的。
future.channel().closeFuture().sync();这行会让主线程等待服务端关闭事件发生，确保 Netty 服务一直运行，这是一个阻塞等待关闭的机制。

ServerBootstrap类和它的方法。

image.png ServerBootstrap这个类继承抽象类AbstractBootstrap，定义了我们示例代码中传入的所有变量。

group()方法

bootstrap.group(bossGroup, workerGroup)

这个方法的实现如下
ServerBootstrap

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");
    }
    this.childGroup = childGroup;
    return this;
}

AbstractBootstrap

public B group(EventLoopGroup group) {
    if (group == null) {
        throw new NullPointerException("group");
    }
    if (this.group != null) {
        throw new IllegalStateException("group set already");
    }
    this.group = group;
    return (B) this;
}

将工作线程组保存在子类的childGroup中，将boss线程组保存在父类的group中。这里要说明下线程组的类型 NioEventLoopGroup是childGroup和group的类型EventLoopGroup的实现类。
另外，这里使用抽象类的作用之一是：客户端没有boss线程，所以定义了ServerBootstrap类来保存服务端独有的一些参数。

channel()方法

.channel(NioServerSocketChannel.class)

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

//3
@Deprecated
@SuppressWarnings("unchecked")
public B channelFactory(ChannelFactory<? extends C> channelFactory) {
    if (channelFactory == null) {
        throw new NullPointerException("channelFactory");
    }
    if (this.channelFactory != null) {
        throw new IllegalStateException("channelFactory set already");
    }

    this.channelFactory = channelFactory;
    return (B) this;
}

//2
@SuppressWarnings({ "unchecked", "deprecation" })
public B channelFactory(io.netty.channel.ChannelFactory<? extends C> channelFactory) {
    return channelFactory((ChannelFactory<C>) channelFactory);
}

ReflectiveChannelFactory这个类定义如下

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

    private final Class<? extends T> clazz;

    public ReflectiveChannelFactory(Class<? extends T> clazz) {
        if (clazz == null) {
            throw new NullPointerException("clazz");
        }
        this.clazz = clazz;
    }

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

    @Override
    public String toString() {
        return StringUtil.simpleClassName(clazz) + ".class";
    }
}

到这里就可看到，channel()方法的作用是给channelFactory属性赋值，在后续的流程中，会通过真正的工厂类ReflectiveChannelFactory的newChannel()方法来实例化NioServerSocketChannel的一个实例。

handler()方法

handler(new ChannelInitializer<NioServerSocketChannel>() {
    @Override 
    protected void initChannel(NioServerSocketChannel ch) { 
        ch.pipeline().addLast(new LoggingHandler(LogLevel.INFO)); 
    } 
})

这个方法的入参是抽象类ChannelInitializer的一个实现并重写了initChannel()方法，可以看到，我们在这个方法中获取NioServerSocketChannel这个channel的pipline对象并给这个对象添加我们的自定义handler()，initChannel()方法会再后续初始化和注册方法中真正执行。这个抽象类是ChannelInboundHandlerAdapter的一个子类，这说明这个handler可以处理Inbound事件。

public B handler(ChannelHandler handler) {
    if (handler == null) {
        throw new NullPointerException("handler");
    }
    this.handler = handler;
    return (B) this;
}

同样的，这个new出来的handler会被赋值给AbstractBootstrap的handler属性。

childHandler()方法

// 客户端连接 SocketChannel 的初始化逻辑 
.childHandler(new ChannelInitializer<SocketChannel>() { 
    @Override 
    protected void initChannel(SocketChannel ch) { 
        ChannelPipeline pipeline = ch.pipeline(); 
        pipeline.addLast(new SimpleServerHandler()); 
    } 
})

这个方法与handler()方法类似，区别在于这个方法是处理客户端连接的逻辑，会给客户端的channel添加对象的handler

剩下的几个attr()和option()方法笔者就不再介绍了，各位读者可以自行翻阅源码。

bind()方法

这个方法是ServerBootstrap这个类的核心方法，因为涉及到的类比较复杂，迭代较深，因此笔者将使用流程图的方式将bind()方法执行逻辑展示出来。

sequenceDiagram
autonumber
ServerBootstrap->>AbstractBootstrap: bind(port)
AbstractBootstrap-)AbstractBootstrap: doBind(localAddress)
AbstractBootstrap-)AbstractBootstrap: initAndRegister()
AbstractBootstrap->>ReflectiveChannelFactory: newChannel()
ReflectiveChannelFactory->>NioServerSocketChannel: NioServerSocketChannel()
NioServerSocketChannel-)NioServerSocketChannel: NioServerSocketChannel()
NioServerSocketChannel-)NioServerSocketChannel: newSocket(SelectorProvider provider)
NioServerSocketChannel->>SelectorProviderImpl: openServerSocketChannel()
SelectorProviderImpl->>ServerSocketChannelImpl: ServerSocketChannelImpl(SelectorProvider var1)
ServerSocketChannelImpl-->>SelectorProviderImpl: return java领域的serverSocketchannel
SelectorProviderImpl-->>NioServerSocketChannel: return java领域的serverSocketchannel
NioServerSocketChannel-)NioServerSocketChannel: NioServerSocketChannel(java领域的channel)
NioServerSocketChannel->>AbstractNioMessageChannel: super(null, channel,SelectionKey.OP_ACCEPT)
AbstractNioMessageChannel->>AbstractNioChannel: super(parent, ch, readInterestOp)
AbstractNioChannel->>AbstractChannel: super(null)
AbstractChannel-)AbstractChannel:id = newId(),netty领域的channel唯一id
AbstractChannel-)AbstractChannel:id = unsafe = newUnsafe()，netty领域的channel的IO操作对象
AbstractChannel->>AbstractNioMessageChannel:newUnsafe()，调子类方法
AbstractNioMessageChannel-)AbstractNioMessageChannel:newUnsafe()，内部类
AbstractNioMessageChannel-->>AbstractChannel:return 内部类对象
AbstractChannel-)AbstractChannel:pipeline = newChannelPipeline()，netty领域的channel的pipline
AbstractChannel->>DefaultChannelPipeline:new DefaultChannelPipeline(netty领域的channel)
DefaultChannelPipeline-)DefaultChannelPipeline:new TailContext(this)内部类
DefaultChannelPipeline->>TailContext:TailContext(DefaultChannelPipeline pipeline)构造函数
TailContext->>AbstractChannelHandlerContext:super(pipeline, null, TAIL_NAME, true, false)
AbstractChannelHandlerContext-)AbstractChannelHandlerContext:this.pipline = pipline，每个context都持有pipline外围对象
TailContext->>AbstractChannelHandlerContext:setAddComplete设置节点状态
AbstractChannelHandlerContext-)AbstractChannelHandlerContext:cas设置节点状态（对象字段Atomic更新器）
TailContext -->>DefaultChannelPipeline:return 双向链表的尾节点
DefaultChannelPipeline-)DefaultChannelPipeline:new HeadContext(this)内部类
DefaultChannelPipeline->>HeadContext:HeadContext(DefaultChannelPipeline pipeline)构造函数
HeadContext->>AbstractChannelHandlerContext:super(pipeline, null, HEAD_NAME, false, true)
AbstractChannelHandlerContext-)AbstractChannelHandlerContext:this.pipline = pipline，每个context都持有pipline外围对象
HeadContext->>AbstractChannel:获取之前创建的unsafe对象
AbstractChannel-->>HeadContext:return unsafe
HeadContext-)HeadContext:this.unsafe = unsafe
HeadContext->>AbstractChannelHandlerContext:setAddComplete设置节点状态
AbstractChannelHandlerContext-)AbstractChannelHandlerContext:cas设置节点状态（对象字段Atomic更新器）
HeadContext -->>DefaultChannelPipeline:return 双向链表的头节点
DefaultChannelPipeline -->>AbstractChannel:return pipline
AbstractNioChannel-)AbstractNioChannel:this.ch = ch，将java领域的serverSocketChannel赋值给类变量（设计模式?）
AbstractNioChannel-)AbstractNioChannel:this.readInterestOp = readInterestOp，accept事件
AbstractNioChannel-)AbstractNioChannel:ch.configureBlocking(false)，设置为非阻塞
NioServerSocketChannel-)NioServerSocketChannel:config = new NioServerSocketChannelConfig(this, javaChannel().socket());
NioServerSocketChannel->>ServerSocketChannelImpl:socket(),javaChannel()方法来拿到之前创建的java领域的serverSocketChannel，就是ServerSocketChannelImpl对象
ServerSocketChannelImpl-)ServerSocketChannelImpl:给java领域的channel设置ServerSocket，对象互相引用
NioServerSocketChannel->>NioServerSocketChannelConfig:NioServerSocketChannelConfig()构造函数
NioServerSocketChannelConfig->>DefaultServerSocketChannelConfig:super(channel, javaSocket)
DefaultServerSocketChannelConfig->>DefaultChannelConfig:super(channel)
DefaultChannelConfig-)DefaultChannelConfig:构建一个自动调节分配的ByteBuf大小的分配器
DefaultChannelConfig-)DefaultChannelConfig:this.channel = channel
DefaultServerSocketChannelConfig-)DefaultServerSocketChannelConfig:this.javaSocket =javaSocket;
NioServerSocketChannelConfig-->>NioServerSocketChannel:return config对象
ReflectiveChannelFactory-->>AbstractBootstrap: return NioServerSocketChannel实例
AbstractBootstrap -)AbstractBootstrap:Channel channel = 返回的NioServerSocketChannel



AbstractBootstrap ->>ServerBootstrap:init(Channel channel)
ServerBootstrap -)ServerBootstrap:保存server端的attr和option分别到\n当前channel和channel的config
ServerBootstrap -)DefaultChannelPipeline:addLast(ChannelHandler... handlers)\n向当前channel的pipline中添加handler，\n这个handler会添加handler()方法传入的handler\n接着通过EventLoop异步添加ServerBootstrapAcceptor处理器\n，确保它在用户自定义处理器之后执行，\n以正确处理客户端连接.\n
DefaultChannelPipeline -)DefaultChannelPipeline:执行addLast()方法，准备添加handler
DefaultChannelPipeline -)DefaultChannelPipeline:newContext()方法，包装成ctx
DefaultChannelPipeline ->>AbstractChannelHandlerContext:super()方法，
DefaultChannelPipeline ->>DefaultChannelHandlerContext:this.handler = handler
DefaultChannelPipeline -)DefaultChannelPipeline:addLast0()方法，向pipline中添加handler
DefaultChannelPipeline ->>AbstractChannelHandlerContext:设置ctx的状态为pending，\n表示等待回调hanlerAdd方法
DefaultChannelPipeline -)DefaultChannelPipeline:callHandlerCallbackLater,\n向pendingHandlerCallbackHead添加回调任务\n pendingHandlerCallbackHead\n维护一个回调任务队列
AbstractBootstrap -)AbstractBootstrap:config().group().register(channel)\ngroup()方法传入的线程组，父类为MultithreadEventLoopGroup
AbstractBootstrap ->>MultithreadEventLoopGroup:register(Channel channel)
MultithreadEventLoopGroup ->>SingleThreadEventLoop:register(Channel channel)
SingleThreadEventLoop -)SingleThreadEventLoop:register(new DefaultChannelPromise(channel, this))
SingleThreadEventLoop -)SingleThreadEventLoop:promise.channel().unsafe().register(this, promise)
SingleThreadEventLoop ->>AbstractUnsafe:register(EventLoop eventLoop, final ChannelPromise promise)\nAbstractUnsafe是AbstractChannel内部类，\n此刻，设计完成了闭环
AbstractUnsafe -)AbstractUnsafe:AbstractChannel.this.eventLoop = eventLoop\n这行代码为当前channel绑定一个boss线程
AbstractChannel -)AbstractChannel:异步执行register0(ChannelPromise promise)
AbstractChannel -->>AbstractNioChannel:register0调用doRegister()
AbstractNioChannel -)AbstractNioChannel:javaChannel().register(eventLoop().selector, 0, this)\n这里将java领域的channel和selector绑定\n并将当前netty领域的channel最为附件添加到selectionKey
AbstractChannel ->>DefaultChannelPipeline:invokeHandlerAddedIfNeeded()
DefaultChannelPipeline -)DefaultChannelPipeline:callHandlerAddedForAllHandlers
DefaultChannelPipeline ->>PendingHandlerAddedTask:异步调用execute()
PendingHandlerAddedTask -->>DefaultChannelPipeline:execute调用callHandlerAdded0(ctx)
DefaultChannelPipeline -) DefaultChannelPipeline:回调当前handler的added方法 \n在这里，前面添加的ChannelInitializer的\n initChannel()方法被执行，\n handler()方法添加的服务端处理器添加到pipline中
DefaultChannelPipeline -) DefaultChannelPipeline:将当前handler的状态设置为ADD_COMPLETE
AbstractChannel ->> NioServerSocketChannel:检验java领域的channel的\n localAddress是否非空 \n初始化的时候是空值，后续非空时会执行\n fireChannelActive()或beginRead()
AbstractChannel ->> DefaultChannelPipeline:执行fireChannelRegistered方法
DefaultChannelPipeline ->> AbstractChannelHandlerContext:执行所有handler的重载\n channelRegistered()方法
AbstractBootstrap ->>AbstractChannel:doBind(localAddress)
AbstractChannel->>NioServerSocketChannel:javaChannel().bind(localAddress, config.getBacklog()) \n 执行真正的绑定操作，设置Tcp属性\n 将fd和协议栈开辟的空间关联
AbstractBootstrap ->>AbstractChannel:pipeline.fireChannelActive() \n与其他几个方法如added类似，不在赘述

整个bind()方法的流程过于长，如果将整个流程放到同一个时序图中，不方便观看。因此我将其拆分为数个部分。

1、实例化ServerSocketChannel-1

image.png

1、实例化ServerSocketChannel-2

image.png

2、初始化ServerSocketChannel-1

image.png

2、初始化ServerSocketChannel-2

image.png

到这里整个启动流程就结束了，我们对上述流程进行总结，可以看到netty的启动流程大致分为以下几个步骤。

  1. 创建JDK底层Channel，创建对应Config对象，设置该Channel为非阻塞模式。
  2. 创建Server对应的Channel，创建各大组件，包括ChannelConfig、ChannelId、ChannelPipeline、ChannelHandler、Unsafe等。
  3. 初始化Server对应的Channel，设置Option、Attr，以及设置子Channel的Option、Attr，给Server的Channel添加连接接入器，用于接收新连接，并触发addHandler、register等事件。
  4. 调用JDK底层注册Selector，将Netty领域的Channel当作attachment注册到Selector。
  5. 调用JDk底层做端口绑定，并触发active事件。当active事件被触发时，才真正做服务端口绑定。

总结

本节内容讲解了 Netty 服务端的启动流程，笔者带着大家一步步拆解了其中的各个环节。相信读到这里，大家对 Netty 的启动机制已经有了较为清晰的认识。
回顾开篇的启动示例代码，其中 EventLoopGroup bossGroup = new NioEventLoopGroup(1); 这段用于创建线程组 EventLoopGroup 的逻辑，我们尚未深入探讨。这个线程组是 Netty 高性能的重要支撑之一，我们将把它的原理与实现放到下一节进行详细解析。

avatar
文章
阅读
粉丝