Netty笔记01-Netty的基本概念与用法

齐飞

已于 2024-09-20 11:06:21 修改

阅读量1.1k

点赞数 14

分类专栏：技术学习笔记 # 网络编程相关笔记网络编程文章标签：笔记 nio java 后端 spring boot

于 2024-09-11 23:00:00 首次发布

本文链接：https://blog.csdn.net/weixin_46425661/article/details/141925732

版权

技术学习笔记同时被 3 个专栏收录

23 篇文章 1 订阅

订阅专栏

网络编程

18 篇文章 0 订阅

订阅专栏

网络编程相关笔记

15 篇文章 0 订阅

订阅专栏

文章目录

1. 概述
2. 第一个程序

1. 概述

1.1 Netty 是什么？

Netty is an asynchronous event-driven network application framework
for rapid development of maintainable high performance protocol servers & clients.
Netty 是一个异步的、基于事件驱动的网络应用框架，用于快速开发可维护、高性能的网络服务器和客户端。

Netty 提供了一套简洁的 API 来帮助开发者处理各种网络通信任务，支持多种传输协议，包括 TCP、UDP、文件传输等，并且能够很好地适配各种操作系统。

1.2 Netty 的特点

异步非阻塞：Netty 使用异步非阻塞 I/O 模型，可以处理大量的并发连接，非常适合构建高性能的服务器和客户端应用程序。
高度模块化：Netty 的架构设计非常灵活，采用了责任链模式（ChannelPipeline）来处理入站和出站的数据流，使得开发者可以轻松地添加自己的处理逻辑。
事件驱动：Netty 通过 EventLoop 来处理 I/O 事件，可以高效地处理大量的并发连接。
高并发：Netty 能够高效地处理成千上万的并发连接，非常适合构建大规模的分布式系统。
跨平台：Netty 支持多种操作系统，并且能够根据不同的操作系统选择最佳的 I/O 模型，例如在 Linux 系统上可以使用更高效的 Epoll 模型。
广泛的协议支持：Netty 支持多种协议，包括 HTTP、WebSocket、SMTP、FTP、Mysql 等，并且提供了丰富的编解码工具。
易于扩展：Netty 的设计考虑到了可扩展性，开发者可以根据需要轻松地扩展框架的功能。

1.3 Netty 的作者

在这里插入图片描述
他还是另一个著名网络应用框架 Mina 的重要贡献者

1.4 Netty 的地位

Netty 在 Java 网络应用框架中的地位就好比：Spring 框架在 JavaEE 开发中的地位
以下的框架都使用了 Netty，因为它们有网络通信需求！

Cassandra - nosql 数据库
Spark - 大数据分布式计算框架
Hadoop - 大数据分布式存储框架
RocketMQ - ali 开源的消息队列
ElasticSearch - 搜索引擎
gRPC - rpc 框架
Dubbo - rpc 框架
Spring 5.x - flux api 完全抛弃了 tomcat ，使用 netty 作为服务器端
Zookeeper - 分布式协调框架

1.5 Netty 的优势

性能：Netty 的异步非阻塞 I/O 模型使其能够处理大量的并发连接，非常适合高并发场景。
易用性：Netty 提供了一套简洁的 API，使得开发者可以快速地开发网络应用程序。
社区支持：Netty 拥有一个活跃的社区，提供了丰富的文档和支持。

Netty vs NIO，NIO工作量大，bug 多
- 需要自己构建协议
- 解决 TCP 传输问题，如粘包、半包
- epoll 空轮询导致 CPU 100%
- 对 API 进行增强，使之更易用，如 FastThreadLocal => ThreadLocal，ByteBuf => ByteBuffer
Netty vs 其它网络应用框架
- Mina 由 apache 维护，将来 3.x 版本可能会有较大重构，破坏 API 向下兼容性，Netty 的开发迭代更迅速，API 更简洁、文档更优秀
- 久经考验，16年，Netty 版本
  - 2.x 2004
  - 3.x 2008
  - 4.x 2013
  - 5.x 已废弃（没有明显的性能提升，维护成本高）

1.6 Netty 的工作原理

Netty 的工作原理主要包括以下几个方面：

创建 Channel：当启动一个 Netty 应用程序时，会创建一个或多个 Channel。
- 如果是服务器，则创建一个 ServerChannel（如 NioServerSocketChannel），用于监听连接；
- 如果是客户端，则创建一个 ClientChannel（如 NioSocketChannel），用于发起连接。
注册到 EventLoop：每个 Channel 都会注册到一个 EventLoop 上，EventLoop 负责监听该 Channel 上的 I/O 事件。
事件处理：当 Channel 上有 I/O 事件发生时，EventLoop 会调用 ChannelPipeline 中的 ChannelHandler 来处理这些事件。
任务执行：除了处理 I/O 事件之外，EventLoop 还可以执行与 Channel 相关的任务，如用户提交的业务逻辑任务。

1.7 Netty 的应用场景

Netty 被广泛应用于多种领域，包括但不限于：

Web 服务器：构建高性能的 HTTP 服务器。
游戏服务器：处理大量的玩家连接和游戏数据交换。
即时通讯系统：构建高并发的聊天应用。
分布式系统：作为基础的通信框架，支撑大规模的分布式系统。
大数据处理：用于处理大规模的数据流。
IoT 应用：处理来自物联网大量设备的数据。

1.8 Netty 的重要组件

EventLoop：负责处理 I/O 事件，并执行与 Channel 相关联的任务。
EventLoopGroup：管理一组 EventLoop 实例，为 Channel 提供一个或多个 EventLoop 供其使用。
Channel：代表一个网络连接，用于进行数据的读取和写入操作。
ChannelFuture：代表一个异步操作的结果。ChannelFuture 提供了对异步操作完成状态的检查方法。
ChannelPipeline：用于处理入站和出站的数据流，是一个责任链模式的实现。
ChannelHandler：处理具体的业务逻辑，例如解码、编码、业务逻辑处理等。
ByteBuf：用于存储和操作二进制数据的缓冲区。ByteBuf 提供了高效的数据读写操作。
Bootstrap：用于创建新的 Channel，配置 Channel 的参数和初始化 ChannelPipeline。

2. 第一个程序

2.1 目标

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

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

加入依赖

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

2.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 的业务处理器，使用上一个处理器的处理结果

完整代码

public class HelloServer {
    public static void main(String[] args) {
        // 1. 启动器，负责组装 netty 组件，启动服务器
        new ServerBootstrap()
            // 2. BossEventLoop, WorkerEventLoop(selector,thread)，表示通过group加入了一个EventLoop的组
                //EventLoopGroup内部使用线程和选择器不断循环监听是否有新的事件
            .group(new NioEventLoopGroup())//一开始监听accept事件，由其中的一个EventLoop进行处理accept事件
                //当接受到客户端发送的数据时，触发read事件，由某个EventLoop处理，交给initChannel()中配置的处理器，从上到下进行处理
            // 3. 选择服务器的ServerSocketChannel实现，NioServerSocketChannel相当于对ServerSocketChannel做了封装
            .channel(NioServerSocketChannel.class) // 还支持OIO(OioServerSocketChannel)，其实就是BIO
            // 4. boss 负责处理连接，worker(child) 负责处理读写，
            // childHandler决定了 worker(child) 能执行哪些操作/业务（handler）
                //注意这里只是添加了handler，并没有执行，initChannel()只有在连接建立后才会执行
            .childHandler(
                    // 5. channel 代表和客户端进行数据读写的通道，Initializer 初始化，负责添加别的 handler
                new ChannelInitializer<NioSocketChannel>() {
                //连接建立后，调用该初始化方法（initChannel()）
                //当客户端连接后(触发了accept事件)，运行initChannel()内代码
                @Override
                protected void initChannel(NioSocketChannel ch) throws Exception {
                    // 添加具体 handler
                    ch.pipeline().addLast(new LoggingHandler());
                    ch.pipeline().addLast(new StringDecoder()); // 负责解码的ChannelHandler，将ByteBuf转换为字符串
                    ch.pipeline().addLast(new ChannelInboundHandlerAdapter() { // 自定义 handler
                        @Override // 读事件
                        public void channelRead(ChannelHandlerContext ctx,Object msg) throws Exception {
                            System.out.println(msg); // 打印上一步(new StringDecoder())转换好的字符串
                        }
                    });
                }
            })
            // 6. 绑定监听端口
            .bind(8080);
    }
}

2.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 先后被触发，走完一个流程

public class HelloClient {
    public static void main(String[] args) throws InterruptedException {
        // 1. 启动类，启动客户端
        new Bootstrap()
            // 2. 添加 EventLoop
            .group(new NioEventLoopGroup())//如果服务器端发来数据，客户端的EventLoop就可以从selector触发读事件进行处理
            // 3. 选择客户端 channel 实现，底层封装了SocketChannel
            .channel(NioSocketChannel.class)
            // 4. 添加处理器
            .handler(new ChannelInitializer<NioSocketChannel>() {
                @Override // 在连接建立后被调用
                protected void initChannel(NioSocketChannel ch) throws Exception {
                    ch.pipeline().addLast(new StringEncoder());//编码器，将字符串编码成ByteBuf进行发送
                }
            })
            // 5. 连接到服务器
            .connect(new InetSocketAddress("localhost", 8080))
            .sync()//sync()是一个阻塞方法，只有连接建立后才会继续执行
            .channel()//.channel()表示拿到服务器和客户端之间的SocketChannel(连接对象)
            // 6. 向服务器发送数据
            .writeAndFlush("hello, world");
    }
}

2.4 流程梳理

在这里插入图片描述
凡是收发数据都要走handler
客户端和服务器在连接建立后调用初始化方法(initChannel()方法)，调用完初始化方法会将处理器(Handler)加载好，下次发送数据时直接使用处理器。

💡 提示

一开始需要树立正确的观念
把 channel 理解为数据的通道

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

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

工序有多道，合在一起就是 pipeline，pipeline 负责发布事件（读、读取完成…）传播给每个 handler， handler 对自己感兴趣的事件进行处理（重写了相应事件处理方法）
handler 分 Inbound 和 Outbound 两类

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

工人可以管理多个 channel 的 io 操作，并且一旦工人负责了某个 channel，就要负责到底（eventLoop绑定channel）
工人既可以执行 io 操作，也可以进行任务处理，每位工人有任务队列，队列里可以堆放多个 channel 的待处理任务，任务分为普通任务、定时任务(eventLoop底层使用了线程池，只不过是单线程的线程池)
工人按照 pipeline 顺序，依次按照 handler 的规划（代码）处理数据，可以为每道工序指定不同的工人