文章目录
一、Netty基本介绍
1. 原生NIO存在的问题
- NIO 的类库和 API 繁杂，使用麻烦：需要熟练掌握 Selector、ServerSocketChannel、 SocketChannel、ByteBuffer等。
- 需要具备其他的额外技能：要熟悉 Java 多线程编程，因为 NIO 编程涉及到 Reactor 模式，你必须 对多线程和网络编程非常熟悉，才能编写出高质量的 NIO 程序。
- 开发工作量和难度都非常大：例如客户端面临断连重连、网络闪断、半包读写、失败缓存、网络拥 塞和异常流的处理等等。
- JDK NIO 的 Bug：臭名昭著的 Epoll Bug，它会导致 Selector 空轮询，最终导致 CPU 100%。直到 JDK 1.7版本该问题仍旧存在，没有被根本解决。
2. Netty是什么？
- Netty 是由 JBOSS 提供的一个 Java 开源框架。Netty 提供异步的、基于事件驱动的网络应用程序框架，用以快速开发高性能、高可靠性的网络 IO 程序。
- Netty 是一个基于 NIO 的网络编程框架，使用 Netty 可以帮助你快速、简单的开发出一个网络应用，相当于简化和流程化了 NIO 的开发过程。
3. Netty的优点
- 设计优雅，提供阻塞和非阻塞的 Socket；提供灵活可拓展的事件模型；提供高度可定制的线程模型。
- 具备更高的性能和更大的吞吐量，使用零拷贝技术最小化不必要的内存复制，减少资源的消耗。
- 提供安全传输特性。
- 支持多种主流协议；预置多种编解码功能，支持用户开发私有协议。
4. Netty的应用场景
Netty 在互联网领域、大数据分布式计算领域、游戏行业、 通信行业等获得了 广泛的应用，知名的 Elasticsearch 、Dubbo 框架内部都采用了 Netty。
二、线程模型
netty采用了线程模型，而不同的线程模型对程序的性能影响很大。所以接下来需要先了解线程模型，然后再学习Netty对应的线程模型。
1.线程模型有哪些？
- 传统阻塞 I/O 服务模型
- Reactor 模型
- 单 Reactor 单线程
- 单 Reactor 多线程
- 主从 Reactor 多线程
2. 各个线程模型介绍
2.1 传统阻塞I/O模型
工作模式：
采用阻塞 IO 模式获取输入的数据, 每个连接都需要独立的线程完成数据的输入 , 业务处理和数据返回工作。
存在问题
- 并发数大时，创建线程多，占用很多系统资源
- 连接创建后，没有数据传输，会造成线程阻塞在read函数，形成资源浪费。
2.2 Reactor模型
Reactor模型定义：
通过一个或多个输入同时传递给服务处理器的模式 , 服务器端程序处理传入的多个 请求,并将它们同步分派到相应的处理线程， 因此 Reactor 模式也叫 Dispatcher模式。
Reactor 模式使用 IO 复用监听事件, 收到事件后，分发给某个线程(进程), 这点就是网络服务器高并发处理关键。
-
单Reactor 单线程
工作模式：
-
Selector是可以实现应用程序通过一个阻塞对象监听多路连接请求。
-
Reactor 对象通过 Selector监控客户端请求事件，收到事件后通过 Dispatch 进行分发。
-
若Selector监听到的事件是建立连接请求事件，则由 Acceptor 通过 Accept 处理连接请求，然后创建一个 Handler 对象处理连接完成后的后续业务处理。
-
Handler 会完成 Read→业务处理→Send 的完整业务流程
优点：
模型简单，没有多线程、进程通信、竞争的问题，全部都在一个线程中完成
缺点：
- 性能问题: 只有一个线程，无法完全发挥多核 CPU 的性能。Handler 在处理某个连接上的业务时， 整个进程无法处理其他连接事件，很容易导致性能瓶颈
- 可靠性问题: 线程意外终止或者进入死循环，会导致整个系统通信模块不可用，不能接收和处理外部消息，造成节点故障
-
-
单Reactor 多线程
工作模式:
- Reactor 对象通过 selector 监控客户端请求事件, 收到事件后，通过 dispatch 进行分发
- 若Selector监听到的事件是建立连接请求事件, 则由 Acceptor 通过accept 处理连接请求
- 如果不是连接请求，则由 reactor 分发调用连接对应的 handler 来处理
- handler 只负责响应事件，不做具体的业务处理, 通过 read 读取数据后，会分发给后面的 worker 线程池的某个线程处理业务
- worker 线程池会分配独立线程完成真正的业务，并将结果返回给 handler
- handler 收到响应后，通过 send 将结果返回给 client
优点:
可以充分的利用多核 cpu 的处理能力
缺点:
reactor 处理所有的事件的监听和响应，在单线程中运行，这在高并发场景容易出现性能瓶颈
-
主从Reactor多线程
工作模式:
- Reactor 主线程 MainReactor 对象通过 select 监听客户端连接事件，收到事件后，通过 Acceptor 处理客户端连接事件
- 当 Acceptor 处理完客户端连接事件之后（与客户端建立好 Socket 连接），MainReactor 将 连接分配给 SubReactor。（即：MainReactor 只负责监听客户端连接请求，和客户端建立连 接之后将连接交由 SubReactor 监听后面的 IO 事件)
- SubReactor 将连接加入到自己的连接队列进行监听，并创建 Handler 对各种事件进行处理
- 当连接上有新事件发生的时候，SubReactor 就会调用对应的 Handler 处理
- Handler 通过 read 从连接上读取请求数据，将请求数据分发给 Worker 线程池进行业务处理
- Worker 线程池会分配独立线程来完成真正的业务处理，并将处理结果返回给 Handler。 Handler 通过 send 向客户端发送响应数据
- 一个 MainReactor 可以对应多个 SubReactor，即一个 MainReactor 线程可以对应多个 SubReactor 线程
优点:
- MainReactor 线程与 SubReactor 线程的数据交互简单职责明确，MainReactor 线程只需要 接收新连接，SubReactor 线程完成后续的业务处理
- MainReactor 线程与 SubReactor 线程的数据交互简单， MainReactor 线程只需要把新连接 传给 SubReactor 线程，SubReactor 线程无需返回数据
- 多个 SubReactor 线程能够应对更高的并发请求
缺点:
这种模式的缺点是编程复杂度较高。但是由于其优点明显，在许多项目中被广泛使用，包括 Nginx、Memcached、Netty 等。这种模式也被叫做服务器的 1+M+N 线程模式，即使用该模式开 发的服务器包含一个（或多个，1 只是表示相对较少）连接建立线程+M 个 IO 线程+N 个业务处理 线程。这是业界成熟的服务器程序设计模式。
三、Netty线程模型
Netty 的设计主要基于主从 Reactor 多线程模式，并做了一定的改进。
1. 简单版
工作模式：
- BossGroup 线程维护 Selector，ServerSocketChannel 注册到这个 Selector 上，只关注连接 建立请求事件（主 Reactor）
- 当接收到来自客户端的连接建立请求事件的时候，通过 ServerSocketChannel.accept 方法获得对应的 SocketChannel，并封装成 NioSocketChannel 注册到 WorkerGroup 线程中的 Selector，每个 Selector 运行在一个线程中（从 Reactor）
- 当 WorkerGroup 线程中的 Selector 监听到自己感兴趣的 IO 事件后，就调用 Handler 处理
2. 进阶版
工作模式：
- 有两组线程池：BossGroup 和 WorkerGroup，BossGroup 中的线程专门负责和客户端建立 连接，WorkerGroup 中的线程专门负责处理连接上的读写
- BossGroup 和 WorkerGroup 含有多个不断循环的执行事件处理的线程，每个线程都包含一 个 Selector，用于监听注册在其上的 Channel
- 每个 BossGroup 中的线程循环执行以下三个步骤
- 轮询注册在其上的 ServerSocketChannel 的 accept 事件（OP_ACCEPT 事件）
- 处理 accept 事件，与客户端建立连接，生成一个 NioSocketChannel，并将其注册到 WorkerGroup 中某个线程上的 Selector 上
- 再去以此循环处理任务队列中的下一个事件
- 每个 WorkerGroup 中的线程循环执行以下三个步骤
- 轮训注册在其上的 NioSocketChannel 的 read/write 事件（OP_READ/OP_WRITE 事 件）
- 在对应的 NioSocketChannel 上处理 read/write 事件
- 再去以此循环处理任务队列中的下一个事件
3. 详细版
工作模式：
- Netty抽象两组线程池：BosssGroup 和 WorkerGroup，也可以叫做 BossNioEventLoopGroup 和 WorkerNioEventLoopGroup。每个线程池中都有 NioEventLoop 线程。BossGroup 中的线程专门负责和客户端建立连接，WorkerGroup 中的 线程专门负责处理连接上的读写。BossGroup 和 WorkerGroup 的类型都是 NioEventLoopGroup
- NioEventLoopGroup 相当于一个事件循环组，这个组中含有多个事件循环，每个事件循环就 是一个 NioEventLoop。
- NioEventLoop 表示一个不断循环的执行事件处理的线程，每个 NioEventLoop 都包含一个 Selector，用于监听注册在其上的 Socket 网络连接（Channel）。
- NioEventLoopGroup 可以含有多个线程，即可以含有多个 NioEventLoop
- 每个 BossNioEventLoop 中循环执行以下三个步骤
- select：轮询注册在其上的 ServerSocketChannel 的 accept 事件（OP_ACCEPT 事件）
- processSelectedKeys：处理 accept 事件，与客户端建立连接，生成一个 NioSocketChannel，并将其注册到某个 WorkerNioEventLoop 上的 Selector 上
- runAllTasks：再去以此循环处理任务队列中的其他任务
- 每个 WorkerNioEventLoop 中循环执行以下三个步骤
- select：轮询注册在其上的 NioSocketChannel 的 read/write 事件 （OP_READ/OP_WRITE 事件）
- processSelectedKeys：在对应的 NioSocketChannel 上处理 read/write 事件
- runAllTasks：再去以此循环处理任务队列中的其他任务
- 在以上两个processSelectedKeys步骤中，会使用 Pipeline（管道），Pipeline 中引用了 Channel，即通过 Pipeline 可以获取到对应的 Channel，Pipeline 中维护了很多的处理器 （拦截处理器、过滤处理器、自定义处理器等）。
四、Netty的基本使用
1. 核心API介绍
-
ChannelHandler 及其实现类
-
ChannelHandler接口定义了许多事件处理的方法，我们可以通过重写这些方法去实现具体的业务逻辑。
-
类结构图：
-
Netty开发中需要自定义一个 Handler 类去实现 ChannelHandle接口或其子接口或其实现类，然后通过重写相应方法实现业务逻辑。我们接下来看看一般都需要重写哪些方法:
方法 介绍 public void channelActive(ChannelHandlerContext ctx) 通道就绪事件 public void channelRead(ChannelHandlerContext ctx, Object msg) 通道读取数据事件 public void channelReadComplete(ChannelHandlerContext ctx) 数据读取完毕事件 public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) 通道发生异常事 件
-
-
ChannelPiepeline
- ChannelPipeline 是一个 Handler 的集合，它负责处理和拦截 inbound 或者 outbound 的事件和操作，相当于一个贯穿 Netty 的责任链.
- ChannelHandler分类：
- ChannelInboundHandler：只处理消息入站
- ChannelOutboundHandler：只处理消息出站
- 混合型handler（即实现了ChannelOutboundHandler 和 ChannelInboundHandler两个类）：既可以处理入站信息，又可以处理出站信息。
- InboundHandler是按照Pipleline的加载顺序的顺序执行, OutboundHandler 是按照Pipeline的加载顺序的逆序执行 ：
- 假设pipleline加载的handler集合为：handler1（混合）、handler2（ChannelOutboundHandler）、handler3（ChannelInboundHandler）、handler4（ChannelInboundHandler）
- 客户端向服务端发送消息时，客户端消息出站 经过 handler2 --> handler1，服务器消息入站 经过 hanlder1 --> handler3 --> handler4
- 服务端向客户端响应消息时，服务端消息出站 经过 handler2 --> handler1，客户器消息入站 经过 hanlder1 --> handler3 --> handler4
-
ChannelHandlerContext
这 是 事 件 处 理 器 上 下 文 对 象 ， Pipeline 链 中 的 实 际 处 理 节 点 。 每 个 处 理 节 点 ChannelHandlerContext 中 包 含 一 个 具 体 的 事 件 处 理 器 ChannelHandler ,同时 ChannelHandlerContext 中也绑定了对应的 ChannelPipeline和 Channel 的信息，方便对 ChannelHandler 进行调用。
常用方法：
方法 介绍 ChannelFuture close() 关闭通道 ChannelOutboundInvoker flush() 刷新 ChannelFuture writeAndFlush(Object msg) 将 数 据 写 到 ChannelPipeline 中 当 前 ChannelHandler 的下一个 ChannelHandler 开始处理（出站） -
ChannelOption
Netty 在创建 Channel 实例后,一般都需要设置 ChannelOption 参数。
方法 介绍 ChannelOption.SO_BACKLOG 服务端处理 客户端连接请求是顺序处理的，所以同一时间只能处理一个客户端连接。多个客户端来的时候，服 务端将不能处理的客户端连接请求放在队列中等待处理，backlog 参数指定了队列的大小。 ChannelOption.SO_KEEPALIVE 一直保持连接活动状态。该参数用于设置TCP连接，当设置该选项以后，会测试连接的状态，这个选项用于可能长时间没有数据交流的连接。当设置该选项以后，如果在两小时内没有数据的通信时，TCP会自动发送一个活动探测数据报文。 -
ChannelFuture
表示 Channel 中异步 I/O 操作的结果，在 Netty 中所有的 I/O 操作都是异步的，I/O 的调用会直接返回，调用者并不能立刻获得结果，但是可以通过 ChannelFuture 来获取 I/O 操作的处理状态。
方法 介绍 Channel channel() 返回当前正在进行 IO 操作的通道 ChannelFuture sync() 等待异步操作执行完毕,将异步改为同步 -
EventLoopGroup和实现类NioEventLoopGroup
- EventLoopGroup 是一组 EventLoop 的抽象，Netty 为了更好的利用多核 CPU 资源，一般 会有多个 EventLoop 同时工作，每个 EventLoop 维护着一个 Selector 实例。
- EventLoopGroup 提供 next 接口，可以从组里面按照一定规则获取其中一个 EventLoop 来处理任 务。在 Netty 服务器端编程中，我们一般都需要提供两个 EventLoopGroup，例如： BossEventLoopGroup 和 WorkerEventLoopGroup。 通常一个服务端口即一个 ServerSocketChannel 对应一个Selector 和一个EventLoop线程。 BossEventLoop 负责接收客户端的连接并将 SocketChannel 交给 WorkerEventLoopGroup 来进 行 IO 处理。
- BossEventLoopGroup 通常是一个单线程的 EventLoop，EventLoop 维护着一个注册了 ServerSocketChannel 的 Selector 实例，BossEventLoop 不断轮询 Selector 将连接事件分离出来， 通 常是 OP_ACCEPT 事件，然后将接收到的 SocketChannel 交给 WorkerEventLoopGroup， WorkerEventLoopGroup 会由 next 选择其中一个 EventLoop 来将这个 SocketChannel 注册到其维护的 Selector 并对其后续的 IO 事件进行处理。
- 一般情况下我们都是用实现类NioEventLoopGroup.
方法 介绍 public NioEventLoopGroup() 构造方法,创建线程组 public Future shutdownGracefully() 断开连接，关闭线程 -
ServerBootstrap 和 Bootstrap
- ServerBootstrap 是 Netty 中的服务器端启动助手，通过它可以完成服务器端的各种配置；
- Bootstrap 是 Netty 中的客户端启动助手，通过它可以完成客户端的各种配置。
| 方法 | 介绍 |
|---|---|
| public ServerBootstrap group(EventLoopGroup parentGroup, EventLoopGroup childGroup) | 该方法用于服务器端，用来设置两个 EventLoop |
| public B group(EventLoopGroup group) | 该方法用于客户端，用来设置一个 EventLoop |
| public B channel(Class channelClass) | 该方法用来设置一个服务器端的通道 实现 |
| public B option(ChannelOption option, T value) | 用来给 ServerChannel 添加配置 |
| public ServerBootstrap childOption(ChannelOption childOption, T value) | 用来给接收到的通 道添加配置 |
| public ServerBootstrap childHandler(ChannelHandler childHandler | 该方法用来设置业务 处 理类（自定义的 handler) |
| public ChannelFuture bind(int inetPort) | 该方法用于服务器端，用来设置占用的端口号 |
| public ChannelFuture connect(String inetHost, int inetPort) | 该方法用于客户端，用来连接服 务器端 |
-
Unpooled
这是 Netty 提供的一个专门用来操作缓冲区的工具类 。
方法 介绍 public static ByteBuf copiedBuffer(CharSequence string, Charset charset) 通过给定的数据 和 字符编码返回一个 ByteBuf 对象（类似于 NIO 中的 ByteBuffer 对象）
2. 案例
- 导入Netty的jar包
<dependencies>
<dependency>
<groupId>io.netty</groupId>
<artifactId>netty-all</artifactId>
<version>4.1.42.Final</version>
</dependency>
</dependencies>
-
服务端：
-
步骤：
- 创建bossGroup线程组: 处理网络事件–连接事件
- 创建workerGroup线程组: 处理网络事件–读写事件
- 创建服务端启动助手
- 设置bossGroup线程组和workerGroup线程组
- 设置服务端通道实现为NIO
- 参数设置
- 创建一个通道初始化对象
- 向pipeline中添加自定义业务处理handler
- 启动服务端并绑定端口,同时将异步改为同步
- 关闭通道和关闭连接池
-
实现代码：
-
public class Server {
public static void main(String[] args) throws InterruptedException {
//1. 创建bossGroup线程组: 处理网络事件--连接事件
EventLoopGroup bossGroup = new NioEventLoopGroup();
//2. 创建workerGroup线程组: 处理网络事件--读写事件
EventLoopGroup workerGroup = new NioEventLoopGroup();
//3. 创建服务端启动助手
ServerBootstrap serverBootstrap = new ServerBootstrap();
//4. 设置bossGroup线程组和workerGroup线程组
serverBootstrap.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)//5. 设置服务端通道实现为NIO
.option(ChannelOption.SO_BACKLOG, 128)//6. 参数设置，消息排队队列的消息个数
.childOption(ChannelOption.SO_KEEPALIVE, Boolean.TRUE)//6. 参数设置，测试连接状态
.childHandler(new ChannelInitializer<SocketChannel>() {//7. 创建一个通道初始化对象
@Override
protected void initChannel(SocketChannel channel) throws Exception {
//8. 向pipeline中添加自定义业务处理handler
channel.pipeline().addLast(new NettyServerHandler());
}
});
//9. 启动服务端并绑定端口,同时将异步改为同步，绑定端口的操作需要成功后再执行后续操作
ChannelFuture channelFuture = serverBootstrap.bind(9988).sync();
System.out.println("server start...");
//10. 关闭通道(并不是真正意义上的关闭,而是监听通道关闭状态)和关闭连接池
channelFuture.channel().closeFuture().sync();
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}
}
自定义handler处理器部分：
public class NettyServerHandler implements ChannelInboundHandler {
@Override
public void channelActive(ChannelHandlerContext channelHandlerContext) throws Exception {
}
//通道读取事件
@Override
public void channelRead(ChannelHandlerContext channelHandlerContext, Object o) throws Exception {
ByteBuf byteBuf = (ByteBuf) o;
System.out.println("客户端消息：" + byteBuf.toString(CharsetUtil.UTF_8));
}
//读取完毕
@Override
public void channelReadComplete(ChannelHandlerContext channelHandlerContext) throws Exception {
channelHandlerContext.writeAndFlush(Unpooled.copiedBuffer("hello,nettyClient...", CharsetUtil.UTF_8));
}
//异常发生事件
@Override
public void exceptionCaught(ChannelHandlerContext channelHandlerContext, Throwable throwable) throws Exception {
throwable.printStackTrace();
channelHandlerContext.close();
}
@Override
public void channelRegistered(ChannelHandlerContext channelHandlerContext) throws Exception {
}
@Override
public void channelUnregistered(ChannelHandlerContext channelHandlerContext) throws Exception {
}
@Override
public void channelInactive(ChannelHandlerContext channelHandlerContext) throws Exception {
}
@Override
public void userEventTriggered(ChannelHandlerContext channelHandlerContext, Object o) throws Exception {
}
@Override
public void channelWritabilityChanged(ChannelHandlerContext channelHandlerContext) throws Exception {
}
@Override
public void handlerAdded(ChannelHandlerContext channelHandlerContext) throws Exception {
}
@Override
public void handlerRemoved(ChannelHandlerContext channelHandlerContext) throws Exception {
}
}
-
客户端：
-
步骤：
-
创建线程组
-
创建客户端启动助手
-
设置线程组
-
设置客户端通道实现为NIO
-
创建一个通道初始化对象
-
向pipeline中添加自定义业务处理handler
-
启动客户端,等待连接服务端,同时将异步改为同步
-
关闭通道和关闭连接池
-
-
实现代码：
public class Client { public static void main(String[] args) throws InterruptedException { //1. 创建线程组 EventLoopGroup group = new NioEventLoopGroup(); //2. 创建客户端启动助手 Bootstrap bootstrap = new Bootstrap(); //3. 设置线程组 bootstrap.group(group) .channel(NioSocketChannel.class)//4. 设置客户端通道实现为NIO .handler(new ChannelInitializer<>() {//5. 创建一个通道初始化对象 @Override protected void initChannel(Channel channel) throws Exception { //6. 向pipeline中添加自定义业务处理handler channel.pipeline().addLast(new NettyClientHandler()); } }); //7. 启动客户端,等待连接服务端,同时将异步改为同步 ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 9988).sync(); //8. 关闭通道和关闭连接池 channelFuture.channel().closeFuture().sync(); group.shutdownGracefully(); } }自定义handler处理器：
public class NettyClientHandler implements ChannelInboundHandler { //通道就绪 @Override public void channelActive(ChannelHandlerContext channelHandlerContext) throws Exception { channelHandlerContext.writeAndFlush(Unpooled.copiedBuffer("hello，nettyServer...", CharsetUtil.UTF_8)); } //通道读事件 @Override public void channelRead(ChannelHandlerContext channelHandlerContext, Object o) throws Exception { ByteBuf byteBuf = (ByteBuf) o; System.out.println("服务端消息：" + byteBuf.toString(CharsetUtil.UTF_8)); } @Override public void channelRegistered(ChannelHandlerContext channelHandlerContext) throws Exception { } @Override public void channelUnregistered(ChannelHandlerContext channelHandlerContext) throws Exception { } @Override public void channelInactive(ChannelHandlerContext channelHandlerContext) throws Exception { } @Override public void channelReadComplete(ChannelHandlerContext channelHandlerContext) throws Exception { } @Override public void userEventTriggered(ChannelHandlerContext channelHandlerContext, Object o) throws Exception { } @Override public void channelWritabilityChanged(ChannelHandlerContext channelHandlerContext) throws Exception { } @Override public void handlerAdded(ChannelHandlerContext channelHandlerContext) throws Exception { } @Override public void handlerRemoved(ChannelHandlerContext channelHandlerContext) throws Exception { } @Override public void exceptionCaught(ChannelHandlerContext channelHandlerContext, Throwable throwable) throws Exception { } }
-
-
测试结果：
总结
- netty封装了原生的NIO，简化了socket编程。
- Netty 是一个异步的、基于事件驱动的网络应用程序框架，用以快速开发高性能、高可靠性的网络 IO 程序。
- Netty基于主从Reactor模型做了改进，BossGroup 中的线程专门负责和客户端建立连接，WorkerGroup 中的 线程专门负责处理连接上的读写，Pipeline 中引用了 Channel，即通过 Pipeline 可以获取到对应的 Channel， Pipeline 中维护了很多的处理器 （拦截处理器、过滤处理器、自定义处理器等）。
- 关于Netty一些高级应用敬请期待~
427
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
