本文针对上一篇文章 【Netty】模型篇二:通过案例分析Netty线程模型以及Netty的核心组件 中涉及到的Netty核心组件进行分析讲解。回顾一下上一篇文章涉及到的组件:
- 在创建线程组的时候用到了
NioEventLoopGroup类
,它里面含有多个事件循环
,每一个事件循环是 NioEventLoop; - 在创建服务端启动对象时用到了
ServerBootstrap 类
;在创建客户端启动对象时用到了Bootstrap 类
; - 在为启动对象配置参数时我们用到了
NioServerSocketChannel类
、ChannelOption类
、ChannelInitializer类
;ChannelInitializer类继承了ChannelInboundHandlerAdapter类
; - 在自定义Handler时,我们继承了
ChannelInboundHandlerAdapter
类;在重写该类的方法中涉及到了ChannelHandlerContext 类
、ByteBuf 类
、Unpooled类
; - 在绑定端口并且同步,启动服务器,生成并返回一个
ChannelFuture类
的对象。
注意:这里强烈建议大家先学习一下 Java NIO。
1 EventLoopGroup 和其实现类 NioEventLoopGroup & NioEventLoop
1.1 原理讲解
EventLoopGroup 是一组 EventLoop 的抽象,Netty 为了更好的利用多核 CPU 资源,一般会有多个 EventLoop 同时工作,每个 EventLoop 维护着一个 Selector 实例。
EventLoopGroup 提供 next()
接口,可以从组里面按照一定规则获取其中一个EventLoop来处理任务。在 Netty 服务器端编程中,我们一般都需要提供两个EventLoopGroup,例如:BossEventLoopGroup
和 WorkerEventLoopGroup
。通常一个服务端口,即一个 ServerSocketChannel ,对应一个 Selector 和 一个 EventLoop 线程。BossEventLoop 负责接收客户端的连接并将 SocketChannel 交给 WorkerEventLoopGroup 来进行 I/O 处理。
- BossEventLoopGroup 通常是一个
单线程
的 EventLoop(也可以设置为多线程的),EventLoop 维护着一个注册了 ServerSocketChannel 的 Selector 实例
,BossEventLoop 不断轮询
Selector 将连接事件
分离出来; - BossEventLoop通常是处理
OP_ACCEPT
事件,然后将接收到的 SocketChannel 交给 WorkerEventLoopGroup; - WorkerEventLoopGroup 会通过
next()
方法选择其中一个自己线程组中的一个 EventLoop 来将这个 SocketChannel 注册到其维护的 Selector
并对其后续的 IO 事件进行处理。
常用方法
public NioEventLoopGroup()
:构造方法public Future<?> shutdownGracefully()
:断开连接,关闭线程
下面我们以上一篇文章 【Netty】模型篇二:通过案例分析Netty线程模型以及Netty的核心组件 中的实例程序为例,进行Debug分析。
1.2 Selector
大家如果没学过Java NIO的话,可能会对 EventLoop 维护着一个注册了 ServerSocketChannel 的 Selector 实例,这句话不理解,下面简单说明一下:
- Netty 基于 Selector 对象实现 I/O
多路复用
,通过 Selector 一个线程可以监听多个连接的 Channel 事件
。 - 当向一个 Selector 中注册 Channel 后,Selector 内部的机制就可以自动不断地查询(Select方法) 这些注册的 Channel 是否有已就绪的 I/O 事件(例如可读,可写,网络连接完成等),这样程序就可以很简单地使用一个线程高效地管理多个 Channel
这一部分如果大家不理解,建议学习一下 Java NIO
1.3 案例分析 之 BossGroup、WorkerGroup
在上一篇文章的案例中 ,我们在服务端创建两个事件循环组 BossGroup 和 WorkerGroup,他们的类型都是 NioEventLoopGroup。每个 事件循环组 中 包含有 多个事件循环 ,每一个事件循环是 NioEventLoop类型的。我们通过Debug来验证一下它们的类型
我们可以看到BossGroup的类型是 NioEventLoopGroup,它里面有一个属性 children,是 EventExecutor
类型,其实就是一个数组, NioEventLoop
是通过 EventExecutor
数组进行管理的。
BossGroup 和 WorkerGroup 中的 NioEventLoop的个数,默认是 cpu可用线程数 * 2
。
我们在来分析一下workerGroup中的线程分配机制
这里我们将 bossGroup 中线程数设为 1,workerGroup 工作线程数设为 8:
EventLoopGroup bossGroup = new NioEventLoopGroup(1);
EventLoopGroup workerGroup = new NioEventLoopGroup(8);
然后在 NettyServerHandler 中的 channelRead() 方法中打印一下线程的名字:
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
System.out.println("服务端读取线程:"+Thread.currentThread().getName());
System.out.println("客户端的地址是:"+ctx.channel().remoteAddress());
}
然后启动 9 个多个客户端,注意这里客户端比 workerGroup 中的线程多一个,查看输出结果:
我们可以看到如果客户端请求连接,那么线程是顺序分配的,如果超过了工作线程则循环分配。
2 Bootstrap & ServerBootstrap
Bootstrap 意思是引导,一个 Netty 应用通常由一个 Bootstrap 开始,主要作用是 配置整个 Netty 程序,串联各个组件
,Netty 中:
Bootstrap
类是客户端
程序的启动引导类;ServerBootstrap
是服务端
启动引导类。
ServerBootstrap bootstrap = new ServerBootstrap();
// 使用链式编程进行设置
bootstrap.group(bossGroup,workerGroup)// 设置两个线程组
.channel(NioServerSocketChannel.class)// 使用 NioSocketChannel 作为服务器的通道实现
.option(ChannelOption.SO_BACKLOG,128)// 设置线程队列得到连接个数
.childOption(ChannelOption.SO_KEEPALIVE,true)// 设置保持活动连接
// 给 WorkerGroup 的 EventLoop 对应的 管道 设置处理器
.childHandler(new ChannelInitializer<SocketChannel>() {
// 创建一个通道测试对象(匿名对象)
// 向 pipline 设置 处理器
@Override
protected void initChannel(SocketChannel socketChannel) throws Exception {
// 可以使用一个集合管理 SocketChannel,在推送消息时,可以将业务加入到各个channel
// 对应的NioEventLoop的taskQueue 或者 scheduleTaskQueue 中
System.out.println("客户socketChannel:"+socketChannel.hashCode());
// 通过 channel 可以拿到 pipline,也可以通过 pipline 拿到 channel
socketChannel.pipeline()
.addLast(new NettyServerHandler());// 向 pipline 添加 处理器
}
});
常见的方法
public ServerBootstrap group(EventLoopGroup parentGroup, EventLoopGroup childGroup)
,该方法用于服务器端,用来设置两个 EventLooppublic B group(EventLoopGroup group)
,该方法用于客户端
,用来设置一个 EventLoop
public B channel(Class<? extends C> channelClass)
,该方法用来设置一个服务器端的通道实现public <T> B option(ChannelOption<T> option, T value)
,用来给 ServerChannel 添加配置public <T> ServerBootstrap childOption(ChannelOption<T> childOption, T value)
,用来给接收到的通道添加配置public ServerBootstrap childHandler(ChannelHandler childHandler)
,该方法用来设置业务处理类(自定义的 handler)public ChannelFuture bind(int inetPort)
,该方法用于服务器端,用来设置占用的端口号public ChannelFuture connect(String inetHost, int inetPort)
,该方法用于客户端
,用来连接服务器端
3 Channel 及其实现类NioServerSocketChannel
Channel是Netty 网络通信的组件,用于执行网络 I/O 操作,它的作用如下;
- 获得当前网络连接的通道的状态;
- 获得 网络连接的配置参数 (例如接收缓冲区大小);
Channel 提供异步的网络 I/O 操作(如建立连接,读写,绑定端口),异步调用意味着任何 I/O 调用都将立即返回,并且不保证在调用结束时所请求的 I/O 操作已完成,调用Channel会立即返回一个 ChannelFuture
实例,通过 注册监听器到 ChannelFuture
上,可以在 I/O 操作成功、失败或取消时回调通知调用方。
不同协议、不同的阻塞类型的连接都有不同的 Channel 类型与之对应,常用的 Channel 类型:
NioSocketChannel
:异步的客户端 TCP Socket 连接。NioServerSocketChannel
:异步的服务器端 TCP Socket 连接。NioDatagramChannel
:异步的 UDP 连接。NioSctpChannel
:异步的客户端 Sctp 连接。NioSctpServerChannel
:异步的 Sctp 服务器端连接,这些通道涵盖了 UDP 和 TCP 网络 IO 以及文件 IO。
4 ChannelOption类
Netty 在创建 Channel 实例后,一般都需要设置 ChannelOption 参数。
ChannelOption 参数如下:
ChannelOption.SO_BACKLOG
:对应 TCP/IP 协议 listen 函数中的backlog 参数
,用来初始化服务器可连接队列大小。服务端处理客户端连接请求是顺序处理的,所以同一时间只能处理一个客户端连接。多个客户端来的时候,服务端将不能处理的客户端连接请求放在队列中等待处理,backlog 参数指定了队列的大小。ChannelOption.SO_KEEPALIVE
:一直保持连接活动状态
5 ChannelHandler 及其实现类(ChannelInboundHandlerAdapter等)
ChannelHandler 是一个接口,处理 I/O 事件或拦截 I/O 操作,并将其转发到其 ChannelPipeline(业务处理链)中的下一个处理程序
。ChannelHandler 本身并没有提供很多方法,因为这个接口有许多的方法需要实现,方便使用期间,可以继承它的子类。
- ChannelInboundHandler:用于处理
入站
I/O 事件。 - ChannelOutboundHandler:用于处理
出站
I/O 操作。 - ChannelInboundHandlerAdapter:用于处理
入站
I/O 事件。 - ChannelOutboundHandlerAdapter:用于处理
出站
I/O 操作。 - ChannelDuplexHandler:可以处理
入站和出站
事件。
说明:ChannelPipeline提供了ChannelHandler链的容器。以客户端应用程序为例,如果事件的运动方向是从客户端到服务端的,那么我们称这些事件为出站的,即客户端发送给服务端的数据会通过pipeline中的一系列ChannelOutboundHandler,并被这些Handler处理,反之则称为入站的。
假如我们要处理入站事件,那么我们需要自定义一个 Handler 类去继承ChannelInboundHandlerAdapter,然后通过重写相应方法实现业务逻辑,我们接下来看看一般都需要重写哪些方法:
public class ChannelInboundHandlerAdapter extends ChannelHandlerAdapter implements ChannelInboundHandler {
public void channelRegistered(ChannelHandlerContext ctx) throws Exception {
ctx.fireChannelRegistered();
}
public void channelUnregistered(ChannelHandlerContext ctx) throws Exception {
ctx.fireChannelUnregistered();
}
public void channelActive(ChannelHandlerContext ctx) throws Exception {
ctx.fireChannelActive();
}
public void channelInactive(ChannelHandlerContext ctx) throws Exception {
ctx.fireChannelInactive();
}
// 通道读取事件
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
ctx.fireChannelRead(msg);
}
// 数据读取完毕事件
public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
ctx.fireChannelReadComplete();
}
public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
ctx.fireUserEventTriggered(evt);
}
public void channelWritabilityChanged(ChannelHandlerContext ctx) throws Exception {
ctx.fireChannelWritabilityChanged();
}
// 通道发生异常事件
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
throws Exception {
ctx.fireExceptionCaught(cause);
}
}
6 Unpooled & ByteBuf
Unpooled类是 Netty 提供一个专门用来操作缓冲区(即Netty的数据容器)的工具类
常用方法如下所示
public static ByteBuf copiedBuffer(CharSequence string, Charset charset)
:通过给定的数据和字符编码返回一个 ByteBuf 对象
(类似于 NIO 中的 ByteBuffer 但有区别
)
ByteBuf 中维护了一个一个 byte数组以及 readerindex 、writerindex 两个参数。 readerindex(下一个要读的位置) 和 writerindex(下一个要写的位置) 和 capacity(容量)将 buffer 划分为三个区域:
- 0 – readerindex:表示读取过的区域;
- readerindex – writerindex:表示可读的区域;
- writerindex – capacity:表示可写的区域。
也正是由于这两个参数,使得 netty的 ByteBuf 不用像 NIO 中的 ByteBuffer 那样,需要使用 flip()
来切换读写状态。
示例一:ByteBuf的创建和遍历
public class NettyBytuBuf01 {
public static void main(String[] args) {
// 创建一个 ByteBuf
ByteBuf buffer = Unpooled.buffer(10);
for (int i = 0; i < 10; i++) {
buffer.writeByte(i);
}
// 输出方式一
for (int i = 0; i < buffer.capacity(); i++) {
System.out.print(buffer.getByte(i)+" ");
}
// 输出方式二
for (int i = 0; i < buffer.capacity(); i++) {
// 会导致 readerindex 变化
System.out.print(buffer.readByte()+" ");
}
}
}
示例二:ByteBuf相关方法使用
public class NettyBytuBuf02 {
public static void main(String[] args) {
// 创建 ByteBuf
ByteBuf buffer = Unpooled.copiedBuffer("hello,world!", CharsetUtil.UTF_8);
// 使用相关的方法
if (buffer.hasArray()) {
byte[] content = buffer.array();
System.out.println(new String(content, Charset.forName("utf-8")));
System.out.println(buffer.readerIndex());
System.out.println(buffer.writerIndex());
System.out.println(buffer.capacity());
// 返回当前可读取的字节数
System.out.println(buffer.readableBytes());
// 按照区间输出
System.out.println(buffer.getCharSequence(0,4,Charset.forName("utf-8")));
}
}
}
7 ChannelHandlerContext & Pipline & ChannelHandlerContext、Channel、Pipline之间的关系
7.1 ChannelHandlerContext 上下文对象
ChannelHandlerContext 保存 Channel 相关的所有 上下文信息
,同时关联一个 ChannelHandler 对象,即ChannelHandlerContext 中 包 含 一 个 具 体 的 事 件 处 理 器 ChannelHandler
,同 时ChannelHandlerContext 中也绑定了对应的 pipeline 和 Channel 的信息,方便对 ChannelHandler进行调用。
常用方法
ChannelFuture close()
:关闭通道ChannelOutboundInvoker flush()
:刷新ChannelFuture writeAndFlush(Object msg)
:将 数 据 写 到 ChannelPipeline 中当 前ChannelHandler 的下一个 ChannelHandler 开始处理(出站)
7.2 Pipeline 和 ChannelPipeline
- ChannelPipeline 是一个 Handler 的集合,它负责处理和拦截
inbound
或者outbound
的事件和操作,相当于一个贯穿 Netty 的链。也可以这样理解:ChannelPipeline 是 保存 ChannelHandler 的 List,用于处理或拦截 Channel 的入站事件和出站操作
。 - ChannelPipeline 实现了一种高级形式的拦截过滤器模式,使用户可以完全控制事件的处理方式,以及 Channel 中各个的 ChannelHandler 如何相互交互。
在 Netty 中每个 Channel 都有且仅有一个 ChannelPipeline 与之对应,它们的组成关系如下:
- 每个 Channel 都包含了一个 ChannelPipeline,而 ChannelPipeline 中又维护了一个由ChannelHandlerContext组成的
双向链表
,并且每个 ChannelHandlerContext 中又关联着一个 ChannelHandler。 - 入站事件和出站事件在一个双向链表中,入站事件会从链表 head 往后传递到最后一个入站的 handler,出站事件会从链表 tail 往前传递到最前一个出站的 handler,两种类型的 handler 互不干扰。(可以认为head端对应的Server,tail端对应的是client)
常用方法
ChannelPipeline addFirst(ChannelHandler ... handlers)
:把一个业务处理类(handler)添加到链中的第一个位置ChannelPipeline addLast(ChannelHandler ... handlers)
:把一个业务处理类(handler)添加到链中的最后一个位置
7.3 案例分析 之 channel、pipline、ChannelHandlerContext 之间的关系
以上一篇文章的案例为例 ,我们在 NettyServerHandler 中的 channelRead() Debug分析一下 channel、pipline、ctx 之间的关系:
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
System.out.println("服务端读取线程:"+Thread.currentThread().getName());
System.out.println("server ctx:"+ctx);
Channel channel = ctx.channel();
ChannelPipeline pipeline = ctx.pipeline();// 本质是一个双向链表
}
ctx真实的类型是 DefaultChannelHandlerContext 类,它代表的是 上下文对象
,它里面包含了 pipline
、channel
我们可以看到通过pipline可以获取channel,也能通过channel获取到 pipline,它们是一 一对应的关系,而pipline有head、tail,其实就是一个双向链表。
8 Future、ChannelFuture
Netty 中所有的 I/O 操作都是异步的,不能立刻得知消息是否被正确处理。但是可以过一会等它执行完成或者直接注册一个监听器,具体的实现就是通过 Future 和 ChannelFutures,他们可以注册一个监听,当操作执行成功或失败时监听会自动触发注册的监听事件
大家如果想详细了解可以参考:【Netty】模型篇四:异步模型 Future-Listener 机制
常见的方法有:
Channel channel()
:返回当前正在进行 IO 操作的通道
ChannelFuture sync()
:等待异步操作执行完毕
ChannelFuture cf = bootstrap.bind(8848).sync();
// 给 cf 注册监听器,监控我们关心的事件
cf.addListener(new ChannelFutureListener() {
@Override
public void operationComplete(ChannelFuture channelFuture) throws Exception {
if (cf.isSuccess()) {
System.out.println("监听端口 8848 成功");
} else {
System.out.println("监听端口 8848 失败");
}
}
});
// 4.对关闭通道事件进行监听
cf.channel().closeFuture().sync();