Netty入门之模块组件(三)
1. 前言
上一篇我们了解了Netty的基本使用,本篇我们来看看各组件的作用。
Netty的核心组件包含:
- EventLoopGroup、NioEventLoopGroup
- Bootstrap、ServerBootstrap
- Future、ChannelFuture
- Channel
- Selector
- ChannelHandler
- Pipeline 、ChannelPipeline
- ChannelHandlerContext
- ChannelOption
- Unpooled
下面将一次对这几个核心组件进行介绍。
2. EventLoopGroup、NioEventLoopGroup
// 创建 BossGroup 和 WorkerGroup
// 说明
// 1. 创建两个线程组 bossGroup 和 workerGroup
// 2. bossGroup 只是处理连接请求 , 真正的和客户端业务处理,会交给 workerGroup 完成
// 3. 两个都是无限循环
// 4. bossGroup 和 workerGroup 含有的子线程(NioEventLoop)的个数
// 默认实际 cpu 核数 * 2
EventLoopGroup bossGroup = new NioEventLoopGroup(1);
EventLoopGroup workerGroup = new NioEventLoopGroup();
首先我们来看看EventLoopGroup
public interface EventLoopGroup extends EventExecutorGroup {
EventLoop next();
ChannelFuture register(Channel var1);
ChannelFuture register(ChannelPromise var1);
/** @deprecated */
@Deprecated
ChannelFuture register(Channel var1, ChannelPromise var2);
}
跟进源码后我们不难发现其实它是一个抽象类,其主要就两个方法。
第一个是next()方法,它用来获取EventLoop,我们要知道每一个EventLoop维护着一个Selector实例。其实我们可以将EventLoopGroup看作一个线程池,而EventLoop看作一个线程,那么就不难理解了。通过next()方法获取一个EventLoop(线程),通过EventLoop(线程)来实现一些方法。
第二个是register()方法,它的作用就是将通道注册进来,并返回一个类,用来判断是否注册成功。关于ChannelFuture下面会讲到。
其次就是NioEventLoopGroup
对于NioEventLoopGroup比较复杂,其实就是一个具体的实现类。它继承了MultithreadEventLoopGroup这个抽象类,而MultithreadEventLoopGroup实现了EventLoopGroup这个接口。
NioEventLoopGroup可以传递参数,通过参数可以来设置EventLoop线程个数,默认为cpu 核数 * 2。
工作步骤:
-
BossEventLoopGroup通常是一个单线程的EventLoop,EventLoop维护这一个注册了ServerSocketChannel的Selector实例,EventLoop不断轮询Selector将连接事件分离出来
-
通常是OP_ACCEPT事件,然后将接收到的SocketChannel交给WorkerEventLoopGroup
-
WorkerEventLoopGroup会有next选择其中一个EventLoop来将这个SocketChannel注册到其维护的Selector并对其后续的IO事件进行处理。
3. Bootstrap、ServerBootstrap
// 创建服务器端的启动对象,配置参数
ServerBootstrap bootstrap = new ServerBootstrap();
// 使用链式编程来进行设置
bootstrap.group(bossGroup, workerGroup) // 设置两个线程组
.channel(NioServerSocketChannel.class) // 使用 NioSocketChannel 作为服务器的通道实现
.option(ChannelOption.SO_BACKLOG, 128) // 设置线程队列得到连接个数
.childOption(ChannelOption.SO_KEEPALIVE, true) // 设置保持活动连接状态
.childHandler(new ChannelInitializer<SocketChannel>() {// 创建一个通道测试对象(匿名对象)
// 给 pipeline 设置处理器
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ch.pipeline().addLast(new NettyServerHandler());
}
}); // 给我们的 workerGroup 的 EventLoop 对应的管道设置处理器
Bootstrap是一个引导,一个Netty应用通常由一个Bootstrap开始,主要作用是配置整个 Netty 程序,串联各个组件,Netty 中 Bootstrap 类是客户端程序的启动引导类,ServerBootstrap 是服务端启动引导类。
常见方法:
- public ServerBootstrap group(EventLoopGroup parentGroup, EventLoopGroup childGroup),该方法用于服务器端,用来设置两个 EventLoop
- public B group(EventLoopGroup group) ,该方法用于客户端,用来设置一个 EventLoop
- public B channel(Class<? extends C> 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) ,该方法用于客户端,用来连接服务器端
4. Future、ChannelFuture
Netty 中所有的 IO 操作都是异步的,不能立刻得知消息是否被正确处理。但是可以过一会等它执行完成或者直接注册一个监听,具体的实现就是通过 Future 和 ChannelFutures,他们可以注册一个监听,当操作执行成功或失败时监听会自动触发注册的监听事件。
上面的register()方法,就是用此返回值,作为判断是否注册成功。
常见方法:
- Channel channel(),返回当前正在进行 IO 操作的通道
- ChannelFuture sync(),等待异步操作执行完毕
5. Channel
- Netty 网络通信的组件,能够用于执行网络 I/O 操作
- 通过 Channel 可获得当前网络连接的通道的状态
- 通过 Channel 可获得 网络连接的配置参数 (例如接收缓冲区大小)
- Channel 提供异步的网络 I/O 操作(如建立连接,读写,绑定端口),异步调用意味着任何 I/O 调用都将立即返回,并且不保证在调用结束时所请求的 I/O 操作已完成
- 调用立即返回一个 ChannelFuture 实例,通过注册监听器到 ChannelFuture 上,可以 I/O 操作成功、失败或取消时回调通知调用方
- 支持关联 I/O 操作与对应的处理程序
- 不同协议、不同的阻塞类型的连接都有不同的 Channel 类型与之对应,常用的 Channel 类型:
- NioSocketChannel,异步的客户端 TCP Socket 连接
- NioServerSocketChannel,异步的服务器端 TCP Socket 连接
- NioDatagramChannel,异步的 UDP 连接
- NioSctpChannel,异步的客户端 Sctp 连接
- NioSctpServerChannel,异步的 Sctp 服务器端连接,这些通道涵盖了 UDP 和 TCP 网络 IO 以及文件 IO
6. Selector
Netty 基于 Selector 对象实现 I/O 多路复用,通过 Selector 一个线程可以监听多个连接的 Channel 事件。
当向一个 Selector 中注册 Channel 后,Selector 内部的机制就可以自动不断地查询(Select) 这些注册的Channel 是否有已就绪的 I/O 事件(例如可读,可写,网络连接完成等),这样程序就可以很简单地使用一个线程高效地管理多个 Channel
7. ChannelHandler
ChannelHandler 是一个接口,处理 I/O 事件或拦截 I/O 操作,并将其转发到其 ChannelPipeline(业务处理链)中的下一个处理程序。
ChannelHandler 本身并没有提供很多方法,因为这个接口有许多的方法需要实现,方便使用期间,可以继承它的子类
子类接口:
- ChannelInboundHandler 用于处理入站IO事件
- ChannelOutboundHandler 用于处理出站IO操作
适配器:
- ChannelInboundHandlerAdapter实现ChannelInboundHandler接口,用于处理入站IO事件
- ChannelOutboundHandlerAdapter实现ChannelOutboundHandler接口,用于处理出站IO操作
我们通常是自定义一个Handler类去实现ChannelInboundHandlerAdapter,然后通过重写相应方法实现业务逻辑。
8. Pipeline 、ChannelPipeline
ChannelPipeline 是一个 Handler 的集合,它负责处理和拦截 inbound 或者 outbound 的事件和操作,相当于一个贯穿 Netty 的链。(也可以这样理解:ChannelPipeline 是 保存 ChannelHandler 的 List,用于处理或拦截Channel 的入站事件和出站操作)。
ChannelPipeline 实现了一种高级形式的拦截过滤器模式,使用户可以完全控制事件的处理方式,以及 Channel中各个的 ChannelHandler 如何相互交互。
在 Netty 中每个 Channel 都有且仅有一个 ChannelPipeline 与之对应,它们的组成关系如下:
- 一个Channel包含了一个ChannePipeline,而ChannelPipeline中又维护了一个由ChannelHandlerContext组成的双向链表,并且每个ChannelHandlerContext中又关联着一个ChannelHandler
- 入站事件和出站事件在一个双向链表中,入站事件会从链表head往后传递到最后一个入站的handler,出站事件会从链表tail往前传递到最前一个出站的handler,两种handler互补干扰
常用方法:
- ChannelPipeline addFirst(ChannelHandler… handlers),把一个业务处理类(handler)添加到链中的第一个位置
- ChannelPipeline addLast(ChannelHandler… handlers),把一个业务处理类(handler)添加到链中的最后一个位置
9. ChannelHandlerContext
保存 Channel 相关的所有上下文信息,同时关联一个 ChannelHandler 对象。
即 ChannelHandlerContext 中 包 含 一 个 具 体 的 事 件 处 理 器 ChannelHandler ,同 时ChannelHandlerContext 中也绑定了对应的 pipeline 和 Channel 的信息,方便对 ChannelHandler 进行调用。
常用方法:
- ChannelFuture close() 关闭通道
- ChannelOutboundInvoker flush() 刷新
- ChannelFuture writeAndFlush() 将数据写到ChannelPipeline中并刷新
10. ChannelOption
Netty 在创建 Channel 实例后,一般都需要设置 ChannelOption 参数。
一般常用参数有两个:SO_BACKLOG和SO_KEEPALIVE
SO_BACKLOG:对应TCP/IP协议listen函数中的backlog参数,用来初始化服务器可连接队列大小。服务端处理客户端连接请求是顺序处理的,所以同一时间只能处理一个客户端连接。多个客户端来的时候,服务端将不能处理的客户端连接请求放在队列里等待处理,backlog参数指定队列大小。
SO_KEEPALIVE:一直保持连接活动状态。
11. Unpooled
Unpooled 是Netty 提供一个专门用来操作缓冲区(即 Netty 的数据容器)的工具类
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
public class NettyByteBuf01 {
public static void main(String[] args) {
//创建一个 ByteBuf
//说明
//1. 创建 对象,该对象包含一个数组 arr , 是一个 byte[10]
//2. 在 netty 的 buffer 中,不需要使用 flip 进行反转
// 底层维护了 readerindex 和 writerIndex
//3. 通过 readerindex 和 writerIndex 和 capacity, 将 buffer 分成三个区域
// 0---readerindex 已经读取的区域
// readerindex---writerIndex , 可读的区域
// writerIndex -- capacity, 可写的区域
ByteBuf buffer = Unpooled.buffer(10);
for (int i = 0; i < 10; i++) {
buffer.writeByte(i);
}
System.out.println("capacity=" + buffer.capacity());//10
//输出
// for (int i = 0; i < buffer.capacity(); i++) {
// System.out.println(buffer.getByte(i));
// }
for (int j = 0; j < buffer.capacity(); j++) {
System.out.println(buffer.readByte());
}
System.out.println("执行完毕");
}
}
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import java.nio.charset.Charset;
public class NettyByteBuf02 {
public static void main(String[] args) {
//创建 ByteBuf
ByteBuf byteBuf = Unpooled.copiedBuffer("hello,world!", Charset.forName("utf-8"));
//使用相关的方法
if (byteBuf.hasArray()) { // true
byte[] content = byteBuf.array();
//将 content 转成字符串
System.out.println(new String(content, Charset.forName("utf-8")));
System.out.println("byteBuf=" + byteBuf);
System.out.println(byteBuf.arrayOffset()); // 0
System.out.println(byteBuf.readerIndex()); // 0
System.out.println(byteBuf.writerIndex()); // 12
System.out.println(byteBuf.capacity()); // 36
//System.out.println(byteBuf.readByte()); //
System.out.println(byteBuf.getByte(0)); // 104
int len = byteBuf.readableBytes(); //可读的字节数 12
System.out.println("len=" + len);
//使用 for 取出各个字节
for (int i = 0; i < len; i++) {
System.out.println((char) byteBuf.getByte(i));
}
//按照某个范围读取
System.out.println(byteBuf.getCharSequence(0, 4, Charset.forName("utf-8")));
System.out.println(byteBuf.getCharSequence(4, 6, Charset.forName("utf-8")));
}
}
}
12. 模块组件总结
通过本篇博客,我们了解了各重要组件的作用,以及对其的一些API方法作用的讲解。
下一篇我们通过写一份实例,来深入了解各组件的应用。