1. Netty核心功能与线程模型详解
Netty
- 1. 认识Netty
- 2. 第一个Netty程序
- 3. Netty组件
-
- 3.1 EventLoop和EventLoopGroup
- Channel
- ChannelPipeline和ChannelHandlerContext
- ChannelPipeline中ChannelHandler
- ChannelPipeline
本文是按照自己的理解进行笔记总结，如有不正确的地方，还望大佬多多指点纠正，勿喷。
课程内容：
01、Netty核心组件快速了解
02、Hello,Netty!
03、深入理解Channel、EventLoop(Group)
04、深入理解EventLoop和EventLoopGroup
05、ChannelHandler和它的适配器
06、ChannelPipeline辨析
07、ChannelHandlerContext辨析
08、用Netty解决TCP粘包/半包
09、Netty中的编解码器
10、实战Netty快速实现Web服务器
11、序列化框架Netty集成实战
12、Netty中的单元测试
1. 认识Netty
Netty 4.1.42.Final版本进行
<dependency>
<groupId>io.netty</groupId>
<artifactId>netty-all</artifactId>
<version>4.1.42.Final</version>
<scope>compile</scope>
</dependency>
基于Netty的知名项目
- 数据库:Cassandra
- 大数据处理:Spark、Hadoop
- 消息中间件:RocketMQ
- 检索:Elasticsearch
- 框架:gRPC、Apache Dubbo、Spring5 WebFlux
- 分布式协调器:ZooKeeper
Netty的优势
- API使用简单，开发门槛低;
- 功能强大，预置了多种编解码功能,支持多种主流协议;
- 定制能力强，可以通过ChannelHandler对通信框架进行灵活地扩展;
- 性能高，通过与其他业界主流的NIO框架对比，Netty的综合性能最优;
- 成熟、稳定，Netty修复了已经发现的所有JDK NIO BUG，业务开发人员不需要再为NIO的BUG而烦恼;
- 社区活跃，版本迭代周期短，发现的BUG可以被及时修复，同时，更多的新功能会加入;
- 经历了大规模的商业应用考验，质量得到验证。
为什么不用Netty5 ?
Netty5有两个重大改变：支持AIO（异步编程，就是要回调），将线程模型改成了favk/join。通过测试发现其实对性能的提高不是很大，几乎不明显。
因为Netty5还处于Alpha1版本，几乎停止维护了
为什么Netty使用NIO而不是AIO?
Linux下的AIO是一个伪AIO，Linux下的AIO性能也不如NIO的强。
为什么不用Mina ?
其实根据诞生关系是Netty的诞生稍微比Mina早了那么一点，这个Netty与Mina是同一个作者，这个作者在完成了Mina之后又投身于Netty种了，相当于Mina处于缺少维护的状态。并且Netty之后发布的版本的性能都比Mina优秀，因此就没有使用Mina
2. 第一个Netty程序
Netty的核心组件初步认识
- Bootstrap、EventLoop(Group)、Channel
- 事件和ChannelHandler、ChannelPipeline
- ChannelFuture
Bootstrap是Netty框架启动类和主入口类。Bootstrap分为服务端的与客户端的，
在 Netty 中，Channel 是网络通信的基本概念和抽象。它代表着一个开放的连接，可以进行数据的读写和事件的处理。
具体来说，Channel 可以理解为应用程序与网络套接字之间的通道，它提供了以下主要功能：
- 数据的读写：通过 Channel，应用程序可以从网络中读取数据或将数据写入网络。它提供了高效的读写操作，支持异步非阻塞的 I/O 操作。可以通过 Channel 的读写方法来实现数据的传输和交换。
- 事件的处理：Channel 是一个事件驱动的实体，它可以处理各种网络事件，例如连接建立、数据到达、写就绪等。通过注册不同类型的事件处理器（ChannelHandler），应用程序可以根据需要处理这些事件，执行相应的逻辑处理。
- 状态的管理：Channel 提供了连接的状态管理，包括打开、关闭、活动状态等。应用程序可以通过 Channel 的状态变化事件进行相应的处理，例如连接建立或断开时的处理操作。
- 通道的配置：Channel 可以进行各种配置，如设置缓冲区大小、接收和发送缓冲区的设置、超时设置等。通过配置 Channel，可以调整网络通信的性能和行为。
总之，Channel 在 Netty 中扮演着非常重要的角色，它是应用程序与网络之间的桥梁，提供了数据读写、事件处理和状态管理等功能。通过使用 Channel，开发者可以方便地进行网络编程，实现高性能和可靠的网络通信。
EventLoop(Group)
在 Netty 中，EventLoop 是用于处理 I/O 事件和任务的线程。它是 Netty 异步事件驱动的核心组件，负责管理 Channel 的生命周期、处理事件和执行任务。
EventLoop 在 EventLoopGroup 中扮演着重要角色，而 EventLoopGroup 则是一组维护和管理 EventLoop 的容器。一般情况下，一个应用程序只需要一个 EventLoopGroup，而其中的多个 EventLoop 可以同时处理多个 Channel 的 I/O 操作。
EventLoop 的主要功能包括：
- I/O 事件的处理：EventLoop 负责处理 Channel 的 I/O 事件，如数据的读写、连接的建立和关闭等。当一个 I/O 事件发生时，EventLoop 会调用相应的 ChannelHandler 处理事件，并触发相应的回调方法。通过事件驱动的方式，实现了高效的异步非阻塞 I/O。
- 任务的执行：除了处理 I/O 事件外，EventLoop 还可以执行用户自定义的任务。这些任务可以是一些耗时的计算、定时任务、事件调度等。通过将任务提交给 EventLoop，可以在事件循环中异步执行，避免了阻塞主线程的情况。
- 定时任务的处理：EventLoop 提供了定时任务的调度和执行，支持在一定的时间间隔或固定的时间点执行任务。这对于需要定时执行一些操作的应用场景非常有用，例如心跳检测、定时数据刷新等。
需要注意的是，EventLoop 在内部维护一个事件循环（Event Loop），它会不断地轮询 I/O 事件和任务，以便及时处理。每个 EventLoop 都有一个独立的线程来执行这个循环，确保了并发的安全性。
总之，EventLoop 是 Netty 中负责处理 I/O 事件和任务的线程，通过事件驱动的方式实现了高效的异步非阻塞 I/O。它在 EventLoopGroup 中起着重要的作用，为应用程序提供了高性能和可扩展的网络编程能力。
在 Netty 中，事件（Event）、ChannelHandler 和 ChannelPipeline 是实现高效网络通信的重要组件。
- 事件（Event）：事件是 Netty 中的核心概念，它代表了网络通信过程中发生的各种状态和操作，如连接建立、数据到达、数据写就绪等。Netty 使用事件来驱动整个网络通信过程，通过触发和处理事件来实现异步的、非阻塞的网络通信。
- ChannelHandler：ChannelHandler 是用于处理事件和执行业务逻辑的组件。它定义了一组回调方法，如 channelRead()、channelActive()、channelInactive() 等，用于处理不同类型的事件。开发者可以实现自己的 ChannelHandler，并将其注册到 ChannelPipeline 中，以便在特定事件发生时执行相应的逻辑处理。
- ChannelPipeline：ChannelPipeline 是 ChannelHandler 的容器，它负责管理和执行 ChannelHandler 的调用顺序。每个 Channel 都会有一个对应的 ChannelPipeline，用于处理该 Channel 上的事件和数据。当一个事件被触发时，ChannelPipeline 会按照预定的顺序依次调用注册的 ChannelHandler 来处理事件。通过配置不同的 ChannelHandler，可以实现数据的编解码、数据处理、安全认证等功能。
ChannelPipeline 的设计遵循了责任链模式，每个 ChannelHandler 只负责自己关心的事件，通过调用下一个 ChannelHandler 来传递事件和数据。这样可以实现组件的解耦和灵活的功能扩展。
通过将不同的 ChannelHandler 注册到 ChannelPipeline 中，可以构建一个处理器链，每个处理器负责特定的功能。数据在经过 ChannelPipeline 时，会按照处理器链的顺序依次经过每个处理器，最终被发送到合适的目标。
总结来说，事件、ChannelHandler 和 ChannelPipeline 是 Netty 中实现高效网络通信的核心组件。事件用于驱动整个网络通信过程，ChannelHandler 用于处理事件和执行业务逻辑，而 ChannelPipeline 则是管理和执行 ChannelHandler 的调用顺序，实现了组件的解耦和灵活的功能扩展。通过合理配置和使用这些组件，可以实现高性能、可扩展的网络应用。
在 Netty 中，ChannelFuture 是用于异步操作结果的表示和处理的对象。它表示一个尚未完成的 I/O 操作，可以通过 ChannelFuture 来获取操作的结果、添加监听器以及执行后续的操作。
ChannelFuture 提供了以下主要功能：
- 异步操作的结果：ChannelFuture 可以获取异步操作的结果，如数据的发送、连接的建立等。它提供了方法来判断操作是否完成，获取操作的成功或失败状态，以及获取操作返回的结果对象。
- 添加操作完成的监听器：可以通过 ChannelFuture 添加一个或多个监听器，以便在操作完成后执行相应的操作。例如，可以添加一个监听器来处理操作完成时的逻辑，或者添加一个监听器来处理操作失败时的错误处理。通过监听器，可以对异步操作的结果进行处理。
- 等待和同步操作：可以通过 ChannelFuture 进行等待和同步操作，即阻塞当前线程，直到操作完成。这对于需要等待操作结果并进行后续处理的情况非常有用。可以使用 ChannelFuture 的一些方法，如 await()、sync() 等来实现等待和同步操作。
- 链式操作：ChannelFuture 支持链式操作，可以在一个操作完成后继续执行下一个操作。通过调用 ChannelFuture 的一些方法，如 addListener()、addListener(ChannelFutureListener) 等，可以实现链式操作的编写，简化了代码的编写。
总之，ChannelFuture 在 Netty 中用于表示和处理异步操作的结果。通过它，可以获取操作的结果、添加监听器来处理操作完成后的逻辑，进行等待和同步操作，以及实现链式操作。它提供了灵活的方式来处理和管理异步操作，使得网络编程更加简洁和高效。
Hello,Netty! 我们的第一个Netty程序
首先导入依赖
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0modelVersion>
<parent>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-parentartifactId>
<version>2.6.3version>
<relativePath/>
parent>
<groupId>com.dinggroupId>
<artifactId>nettyartifactId>
<version>0.0.1-SNAPSHOTversion>
<name>nettyname>
<description>Demo project for Spring Bootdescription>
<properties>
<java.version>17java.version>
properties>
<dependencies>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-testartifactId>
<scope>testscope>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-testartifactId>
<scope>testscope>
dependency>
<dependency>
<groupId>org.springframework.datagroupId>
<artifactId>spring-data-redisartifactId>
<version>2.5.1version>
dependency>
<dependency>
<groupId>org.redissongroupId>
<artifactId>redissonartifactId>
<version>3.6.2version>
dependency>
<dependency>
<groupId>io.nettygroupId>
<artifactId>netty-allartifactId>
<version>4.1.42.Finalversion>
<scope>compilescope>
dependency>
dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-maven-pluginartifactId>
plugin>
plugins>
build>
project>
只要使用Netty，下面这个代码是必写的，唯一不同的是每个应用的handler不太一样。
package com.ding.nettybasic;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.net.InetSocketAddress;
public class EchoServer {
private static final Logger LOG = LoggerFactory.getLogger(EchoServer.class);
private final int port;
public EchoServer(int port) {
this.port = port;
}
public static void main(String[] args) throws InterruptedException {
int port = 9999;
EchoServer echoServer = new EchoServer(port);
LOG.info("服务器即将启动");
echoServer.start();
LOG.info("服务器关闭");
}
private void start() throws InterruptedException {
/*线程组*/
NioEventLoopGroup group = new NioEventLoopGroup();
try {
/*服务端启动必备*/
ServerBootstrap b = new ServerBootstrap();
b.group(group)
.channel(NioServerSocketChannel.class)/*指定使用NIO的通信模式*/
.localAddress(new InetSocketAddress(port))
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ch.pipeline().addLast(new EchoServerHandler());
}
});
/*异步绑定到服务器，sync()会阻塞到完成*/
ChannelFuture f = b.bind().sync();
/*阻塞当前线程，知道服务器的ServerChannel被关闭*/
f.channel().closeFuture().sync();
}finally {
group.shutdownGracefully().sync();
}
}
}
SocketChannel在与业务流转之间还有一个Buffer，因此这个里面也要有一个Buffer
package com.ding.nettybasic;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;
public class EchoServerHandler extends ChannelInboundHandlerAdapter {
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
ByteBuf in = (ByteBuf)msg;
System.out.println("server accept:"+in.toString(CharsetUtil.UTF_8));
ctx.writeAndFlush(in);
ctx.close();
}
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
System.out.println("连接已建立");
super.channelActive(ctx);
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
cause.printStackTrace();
ctx.close();
}
}
package com.ding.nettybasic;
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.NioServerSocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.net.InetSocketAddress;
public class EchoClient {
private static final Logger LOG = LoggerFactory.getLogger(EchoClient.class);
private final int port;
private final String host;
public EchoClient(int port, String host) {
this.port = port;
this.host = host;
}
public void start() throws InterruptedException {
/*线程组*/
EventLoopGroup group = new NioEventLoopGroup();
try {
/*服务端启动必备*/
Bootstrap b = new Bootstrap();
b.group(group)
.channel(NioSocketChannel.class)/*指定使用NIO的通信模式*/
.remoteAddress(new InetSocketAddress(host,port))
.handler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ch.pipeline().addLast(new EchoClientHandler());
}
});
/*异步绑定到服务器，sync()会阻塞到完成*/
ChannelFuture f = b.connect().sync();
/*阻塞当前线程，知道服务器的ServerChannel被关闭*/
f.channel().closeFuture().sync();
}finally {
group.shutdownGracefully().sync();
}
}
public static void main(String[] args) throws InterruptedException {
new EchoClient(9999,"127.0.0.1").start();
}
}
package com.ding.nettybasic;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.util.CharsetUtil;
public class EchoClientHandler extends SimpleChannelInboundHandler<ByteBuf> {
@Override
protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) throws Exception {
/*读取网络数据后进行业务处理，并关闭连接*/
System.out.println("client Accept" + msg.toString(CharsetUtil.UTF_8));
/*关闭连接*/
ctx.close();
}
/*channel活跃后，做业务处理*/
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
ctx.writeAndFlush(Unpooled.copiedBuffer("Hello Netty",CharsetUtil.UTF_8));
}
}
3. Netty组件
3.1 EventLoop和EventLoopGroup
关系说明
- 一个EventLoopGroup包含一个或者多个EventLoop;
- 一个EventLoop在它的生命周期内只和一个Thread 绑定;
- 所有由EventLoop 处理的I/O事件都将在它专有的Thread上被处理;
Channel
- Channel-Socket;
- EventLoop—控制、多线程处理、并发;
ChannelPipeline和ChannelHandlerContext
ChannelPipeline 提供了ChannelHandler链的容器，并定义了用于在该链上传播入站和出站事件流的APl。
ChannelHandler 的生命周期
ChannelHandler 的生命周期
在ChannelHandler被添加到ChannelPipeline 中或者被从ChannelPipeline中移除时会调用下面这些方法。这些方法中的每一个都接受一个ChannelHandlerContext参数。
handlerAdded当把 ChannelHandler 添加到ChannelPipeline 中时被调用
handlerRemoved当从ChannelPipeline中移除ChannelHandler时被调用
exceptionCaught当处理过程中在 ChannelPipeline中有错误产生时被调用
ChannelPipeline中ChannelHandler
Netty会把出站Handler和入站Handler放到一个Pipeline中，数据结构上是一个双向链表
ChannelPipeline
那么分属出站和入站不同的Handler，在业务没要求的情况下是可以不考虑顺序的。
而同属一个方向的Handler则是有顺序的，因为上一个Handler处理的结果往往是下一个Handler的要求的输入。