文章目录
- 1. 概述
- 1.1 Netty 是什么？
- 1.2 Netty 的特点
- 1.3 Netty 的作者
- 1.4 Netty 的地位
- 1.5 Netty 的优势
- 1.6 Netty 的工作原理
- 1.7 Netty 的应用场景
- 1.8 Netty 的重要组件
- 2. 第一个程序
- 2.1 目标
- 2.2 服务器端
- 2.3 客户端
- 2.4 流程梳理
- 💡 提示
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 的规划（代码）处理数据，可以为每道工序指定不同的工人
可以理解为Handler就是一道道工序，对接受的原式数据进行加工处理
EventLoop内部是有一个selector，EventLoop通过多路复用可以管理多个channel的IO操作。
