Netty篇（入门编程）

一、Hello World

1. 目标

2. 服务器端

3. 客户端

4. 流程梳理

💡 提示

5. 运行结果截图

二、Netty执行流程

1. 流程分析

2. 代码案例

2.1. 引入依赖

2.2. 服务端

服务端

服务端处理器

2.3. 客户端

客户端

客户端处理器

2.4. 代码截图

一、Hello World

1. 目标

开发一个简单的服务器端和客户端

客户端向服务器端发送 hello, world
服务器仅接收，不返回

加入依赖

<dependency>
    <groupId>io.netty</groupId>
    <artifactId>netty-all</artifactId>
    <version>4.1.39.Final</version>
</dependency>

2. 服务器端

new ServerBootstrap()
    .group(new NioEventLoopGroup()) // 1 
    .channel(NioServerSocketChannel.class) // 2
    .childHandler(new ChannelInitializer<NioSocketChannel>() { // 3
        protected void initChannel(NioSocketChannel ch) {
            ch.pipeline().addLast(new StringDecoder()); // 5
            ch.pipeline().addLast(new SimpleChannelInboundHandler<String>() { // 6
                @Override
                protected void channelRead0(ChannelHandlerContext ctx, String msg) {
                    System.out.println(msg);
                }
            });
        }
    })
    .bind(8080); // 4

代码解读

1 处，创建 NioEventLoopGroup，可以简单理解为线程池 + Selector 后面会详细展开
2 处，选择服务 Scoket 实现类，其中 NioServerSocketChannel 表示基于 NIO 的服务器端实现，其它实现

还有

3 处，为啥方法叫 childHandler，是接下来添加的处理器都是给 SocketChannel 用的，而不是给

ServerSocketChannel。

ChannelInitializer 处理器（仅执行一次），它的作用是待客户端 SocketChannel 建立连接后，执行

initChannel 以便添加更多的处理器

4 处，ServerSocketChannel 绑定的监听端口
5 处，SocketChannel 的处理器，解码 ByteBuf => String
6 处，SocketChannel 的业务处理器，使用上一个处理器的处理结果

3. 客户端

new Bootstrap()
    .group(new NioEventLoopGroup()) // 1
    .channel(NioSocketChannel.class) // 2
    .handler(new ChannelInitializer<Channel>() { // 3
        @Override
        protected void initChannel(Channel ch) {
            ch.pipeline().addLast(new StringEncoder()); // 8
        }
    })
    .connect("127.0.0.1", 8080) // 4
    .sync() // 5
    .channel() // 6
    .writeAndFlush(new Date() + ": hello world!"); // 7

代码解读

1 处，创建 NioEventLoopGroup，同 Server
2 处，选择客户 Socket 实现类，NioSocketChannel 表示基于 NIO 的客户端实现，其它实现还有

3 处，添加 SocketChannel 的处理器，ChannelInitializer 处理器（仅执行一次），它的作用是待客户端

SocketChannel 建立连接后，执行 initChannel 以便添加更多的处理器

4 处，指定要连接的服务器和端口
5 处，Netty 中很多方法都是异步的，如 connect，这时需要使用 sync 方法等待 connect 建立连接完毕
6 处，获取 channel 对象，它即为通道抽象，可以进行数据读写操作
7 处，写入消息并清空缓冲区
8 处，消息会经过通道 handler 处理，这里是将 String => ByteBuf 发出
数据经过网络传输，到达服务器端，服务器端 5 和 6 处的 handler 先后被触发，走完一个流程

4. 流程梳理

💡 提示

一开始需要树立正确的观念

把 channel 理解为数据的通道
把 msg 理解为流动的数据，最开始输入是 ByteBuf，但经过 pipeline 的加工，会变成其它类型对象，最后

输出又变成 ByteBuf

把 handler 理解为数据的处理工序

- 工序有多道，合在一起就是 pipeline，pipeline 负责发布事件（读、读取完成...）传播给每个

handler， handler 对自己感兴趣的事件进行处理（重写了相应事件处理方法）

- handler 分 Inbound 和 Outbound 两类

把 EeventLoop 理解为处理数据的工人

- 工人可以管理多个 channel 的 io 操作，并且一旦工人负责了某个 channel，就要负责到底（绑定）
- 工人既可以执行 io 操作，也可以进行任务处理，每位工人有任务队列，队列里可以堆放多个 channel

的待处理任务，任务分为普通任务、定时任务

- 工人按照 pipeline 顺序，依次按照 handler 的规划（代码）处理数据，可以为每道工序指定不同的工

人

5. 运行结果截图

二、Netty执行流程

1. 流程分析

Netty 抽象出两组线程池BossGroup专门负责接收客户端的连接, WorkerGroup专门负责网络的读写
BossGroup和WorkerGroup类型都是NioEventLoopGroup
NioEventLoopGroup相当于一个事件循环组,这个组中含有多个事件循环，每一个事件循环是

NioEventLoop

NioEventLoop表示一个不断循环的执行处理任务的线程，每个NioEventLoop都有一个 selector ,

用于监听绑定在其上的 socket 的网络通讯用于监听绑定在其上的 socket 的网络通讯

NioEventLoopGroup可以有多个线程,即可以含有多个NioEventLoop
每个BossNioEventLoop 循环执行的步骤有3步轮询 accept事件，处理 accept事件, 与client建立连

接 , 生成 NioSocketChannel ,并将其注册到某个worker 的NIOEventLoop上的selector处理任务队

列的任务，即runAllTasks

每个Worker NIOEventLoop循环执行的步骤

轮询 read, write 事件，处理 i/o 事件，即read , write事件，在对应 NioSocketChannel处理，处理

任务队列的任务，即runAllTasks

每个Worker 的NIOEventLoop处理业务时，会使用 pipeline(管道), pipeline中包含了channel ,

即通过 pipeline可以获取到对应通道, 管道中维护了很多的处理器