面试官：说说Netty核心组件？-51CTO.COM

Netty 核心组件是指 Netty 在执行过程中所涉及到的重要概念，这些核心组件共同组成了 Netty 框架，使 Netty 框架能够正常的运行。

Netty 核心组件包含以下内容：

启动器 Bootstrap/ServerBootstrap
事件循环器 EventLoopGroup/EventLoop
通道 Channel
通道处理器 ChannelHandler
通道管道 ChannelPipeline

这些组件的交互流程如下：

上图是 Netty 逻辑处理架构，这个逻辑处理架构为典型网络分层架构设计，共分为网络通信层、事件调度层、服务编排层，每一层各司其职，共同成为了 Netty 的核心组件。

1.Bootstrap/ServerBootstrap【启动器】

Bootstrap 是“引导”的意思，它主要负责整个 Netty 程序的启动、初始化、服务器连接等过程，它相当于一条主线，串联了 Netty 的其他核心组件。

“
PS：Netty 中的引导器共分为两种类型：一个为用于客户端引导的 Bootstrap，另一个为用于服务端引导的 ServerBootStrap。

2.Channel【通道】

Channel 是网络数据的传输通道，它代表了到实体（如硬件设备、文件、网络套接字或能够执行 I/O 操作的程序组件）的开放连接，如读操作和写操作。

Channel 提供了基本的 API 用于网络 I/O 操作，如 register、bind、connect、read、write、flush 等。Netty 自己实现的 Channel 是以 JDK NIO Channel 为基础的，相比较于 JDK NIO，Netty 的 Channel 提供了更高层次的抽象，同时屏蔽了底层 Socket 的复杂性，赋予了 Channel 更加强大的功能，你在使用 Netty 时基本不需要再与 Java Socket 类直接打交道。

常见的 Channel 类型有以下几个：

NioServerSocketChannel 异步 TCP 服务端。
NioSocketChannel 异步 TCP 客户端。
OioServerSocketChannel 同步 TCP 服务端。
OioSocketChannel 同步 TCP 客户端。
NioDatagramChannel 异步 UDP 连接。
OioDatagramChannel 同步 UDP 连接。

当然 Channel 也会有多种状态，如连接建立、连接注册、数据读写、连接销毁等状态。

3.EventLoopGroup/EventLoop【事件循环器】

EventLoopGroup 是一个处理 I/O 操作和任务的线程组。在 Netty 中，EventLoopGroup 负责接受客户端的连接，以及处理网络事件，如读/写事件。它包含多个 EventLoop，每个 EventLoop 包含一个 Selector 和一个重要的组件，用于处理注册到其上的 Channel 的所有 I/O 事件

（1）EventLoopGroup、EventLoop和Channel

它们三者的关系如下：

一个 EventLoopGroup 往往包含一个或者多个 EventLoop。EventLoop 用于处理 Channel 生命周期内的所有 I/O 事件，如 accept、connect、read、write 等 I/O 事件。
EventLoop 同一时间会与一个线程绑定，每个 EventLoop 负责处理多个 Channel。
每新建一个 Channel，EventLoopGroup 会选择一个 EventLoop 与其绑定。该 Channel 在生命周期内都可以对 EventLoop 进行多次绑定和解绑。

（2）线程模型

Netty 通过创建不同的 EventLoopGroup 参数配置，就可以支持 Reactor 的三种线程模型：

单线程模型：EventLoopGroup 只包含一个 EventLoop，Boss 和 Worker 使用同一个EventLoopGroup；
多线程模型：EventLoopGroup 包含多个 EventLoop，Boss 和 Worker 使用同一个EventLoopGroup；
主从多线程模型：EventLoopGroup 包含多个 EventLoop，Boss 是主 Reactor，Worker 是从 Reactor，它们分别使用不同的 EventLoopGroup，主 Reactor 负责新的网络连接 Channel 创建，然后把 Channel 注册到从 Reactor。

4.ChannelHandler【通道处理器】

ChannelHandler 是 Netty 处理 I/O 事件或拦截 I/O 操作的组件。当发生某种 I/O 事件时（如数据接收、连接打开、连接关闭等），ChannelHandler 会被调用并处理这个事件。

例如，数据的编解码工作以及其他转换工作实际都是通过 ChannelHandler 处理的。站在开发者的角度，最需要关注的就是 ChannelHandler，我们很少会直接操作 Channel，都是通过 ChannelHandler 间接完成。

5.ChannelPipeline【通道管道】

ChannelPipeline 是 ChannelHandler 的容器，提供了一种方式，以链式的方式组织和处理跨多个 ChannelHandler 之间的交互逻辑。当数据在管道中流动时，它会按照 ChannelHandler 的顺序被处理。

6.Netty 简单示例

下面是一个使用 Netty 构建的最简单服务器端和客户端示例，这个例子中，服务器接收到客户端的消息后，会直接将消息原样回传给客户端。

（1）服务器端

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

public class NettyServer {

    public static void main(String[] args) throws Exception {
        // 创建BossGroup和WorkerGroup，它们都是EventLoopGroup的实现
        // BossGroup负责接收进来的连接
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        // WorkerGroup负责处理已经被接收的连接
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            // 创建服务器端的启动对象，配置参数
            ServerBootstrap bootstrap = new ServerBootstrap();

            // 设置两个线程组
            bootstrap.group(bossGroup, workerGroup)
                    // 设置服务器通道实现类型
                    .channel(NioServerSocketChannel.class)
                    // 设置通道初始化器，主要用来配置管道中的处理器
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            // 向管道加入处理器
                            // 解码器：ByteBuf -> String
                            ch.pipeline().addLast(new StringDecoder());
                            // 编码器：String -> ByteBuf
                            ch.pipeline().addLast(new StringEncoder());

                            // 自定义的处理器
                            ch.pipeline().addLast(new ServerHandler());
                        }
                    });

            System.out.println("服务器 is ready...");

            // 绑定一个端口并且同步，生成了一个ChannelFuture对象
            ChannelFuture cf = bootstrap.bind(6668).sync();

            // 对关闭通道进行监听
            cf.channel().closeFuture().sync();
        } finally {
            // 优雅关闭线程组
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

（2）客户端代码

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

public class NettyClient {

    public static void main(String[] args) throws Exception {
        // 创建EventLoopGroup，相当于线程池
        EventLoopGroup group = new NioEventLoopGroup();

        try {
            // 创建客户端启动对象
            Bootstrap bootstrap = new Bootstrap();

            // 设置相关参数
            bootstrap.group(group) // 设置线程组
                    .channel(NioSocketChannel.class) // 设置客户端通道实现类型
                    .handler(new ChannelInitializer<SocketChannel>() { // 设置处理器
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            // 向管道加入处理器
                            ch.pipeline().addLast(new StringDecoder());
                            ch.pipeline().addLast(new StringEncoder());
                            // 自定义的处理器
                            ch.pipeline().addLast(new ClientHandler());
                        }
                    });

            System.out.println("客户端 is ready...");

            // 发起异步连接操作
            ChannelFuture future = bootstrap.connect("127.0.0.1", 6668).sync();

            // 发送消息
            future.channel().writeAndFlush("Hello Server!");

            // 对关闭通道进行监听
            future.channel().closeFuture().sync();
        } finally {
            group.shutdownGracefully(); // 优雅关闭线程组
        }
    }
}

参考&鸣谢

《Netty核心原理剖析与RPC实践》