Netty高性能架构设计
一、Netty概述
1.1 原生NIO存在的问题
NIO
的类库和API
繁杂,使用麻烦:需要熟练掌握Selector
、ServerSocketChannel
、SocketChannel
、ByteBuffer
等。- 需要具备其他的额外技能:要熟悉
Java
多线程编程,因为NIO
编程涉及到Reactor
模式,必须对多线程和网络编程非常熟悉,才能编写出高质量的NIO
程序。 - 开发工作量和难度都非常大:例如客户端面临断连重连、网络闪断、半包读写、失败缓存、网络拥塞和异常流的处理等等。
JDK NIO
的Bug
:例如臭名昭著的Epoll Bug
,它会导致Selector
空轮询,最终导致CPU100%
。直到JDK1.7
版本该问题仍旧存在,没有被根本解决。
1.2 Netty的介绍
Netty
是由JBOSS
提供的一个Java
开源框架,现为Github
上的独立项目。Netty
是一个异步的、基于事件驱动的网络应用框架,用以快速开发高性能、高可靠性的网络IO
程序。 主要针对在TCP
协议下,面向Client
端的高并发应用,或者Peer-to-Peer
场景下的大量数据持续传输的应用。Netty
本质是一个NIO
框架,适用于服务器通讯相关的多种应用场景。
1.3 Netty官网说明
Netty is an asynchronous event-driven network application framework for rapid development of maintainable high performance protocol servers & clients.
Netty
版本分为Netty 3.x
和Netty 4.x
、Netty 5.x
。因为Netty 5
出现重大bug
,已经被官网废弃了。在官网可下载的版本Netty 3.x
、Netty 4.0.x
和Netty 4.1.x
。目前推荐使用的是Netty 4.1.x
的稳定版本。
Netty
下载地址:https://netty.io/downloads.html
1.4 Netty的优点
Netty
对JDK
自带的NIO
的API
进行了封装,解决了上述问题。
- 设计优雅:适用于各种传输类型的统一
API
阻塞和非阻塞Socket
;基于灵活且可扩展的事件模型,可以清晰地分离关注点;高度可定制的线程模型-单线程,一个或多个线程池。 - 高性能、吞吐量更高:延迟更低;减少资源消耗;最小化不必要的内存复制。
- 安全:完整的
SSL/TLS
和StartTLS
支持。
1.5 Netty的应用场景
1.5.1 互联网行业
在分布式系统中,各个节点之间需要远程服务调用,高性能的RPC
框架必不可少,Netty
作为异步高性能的通信框架,往往作为基础通信组件被这些RPC
框架使用。典型的应用有:阿里分布式服务框架Dubbo
的RPC
框架使用Dubbo
协议进行节点间通信,Dubbo
协议默认使用Netty
作为基础通信组件,用于实现各进程节点之间的内部通信。
1.5.2 游戏行业
无论是手游服务端还是大型的网络游戏,Java
语言得到了越来越广泛的应用。Netty
作为高性能的基础通信组件,提供了TCP/UDP
和HTTP
协议栈,方便定制和开发私有协议栈,账号登录服务器。地图服务器之间可以方便的通过Netty
进行高性能的通信。
1.5.3 大数据领域
经典的Hadoop
的高性能通信和序列化组件Avro
的RPC
框架,默认采用Netty
进行跨界点通信。它的NettyService
基于Netty
框架二次封装实现。
1.5.4 其它开源项目使用到Netty
网址:https://netty.io/wiki/related-projects.html
二、Netty高性能架构设计
2.1 线程模型基本介绍
目前存在的线程模型有:
- 传统阻塞
I/O
服务模型 Reactor
模式
根据Reactor
的数量和处理资源池线程的数量不同,有3
种典型的实现
- 单
Reactor
单线程; - 单
Reactor
多线程; - 主从
Reactor
多线程
Netty
主要基于主从Reactor
多线程模型做了一定的改进,其中主从Reactor
多线程模型有多个Reactor
2.2 传统阻塞I/O服务模型
以上是工作原理图:黄色的框表示对象,蓝色的框表示线程,白色的框表示方法(API
)
2.2.1 模型特点
- 采用阻塞
IO
模式获取输入的数据 - 每个连接都需要独立的线程完成数据的输入,业务处理,数据返回
2.2.2 问题分析
- 当并发数很大,就会创建大量的线程,占用很大系统资源
- 连接创建后,如果当前线程暂时没有数据可读,该线程会阻塞在
read
操作,造成线程资源浪费
2.2.3 模型实现代码示例
由于模型的逻辑主要集中在服务端,所以所有模型代码示例基本上都是服务端的示例
public static void main(String[] args) throws IOException {
//1、创建一个线程池
//2、如果有客户端连接,就创建一个线程,与之通讯(单独写一个方法)
ExecutorService executorService = Executors.newCachedThreadPool();
//创建ServerSocket
ServerSocket serverSocket = new ServerSocket(6666);
System.out.println("服务器启动了");
while (true) {
//监听,等待客户端连接
final Socket socket = serverSocket.accept();
System.out.println("连接到一个客户端");
//创建一个线程,与之通讯
executorService.execute(() -> {
//重写Runnable方法,与客户端进行通讯
handler(socket);
});
}
}
//编写一个Handler方法,和客户端通讯。主要进行数据的读取和业务处理。
public static void handler(Socket socket) {
try {
byte[] bytes = new byte[1024];
//通过socket获取输入流
InputStream inputStream = socket.getInputStream();
//循环的读取客户端发送的数据
while (true){
int read = inputStream.read(bytes);
if (read != -1){
System.out.println(new String(bytes, 0, read));//输出客户端发送的数据
} else {
break;
}
}
} catch (IOException e) {
e.printStackTrace();
} finally {
System.out.println("关闭和client的连接");
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
2.3 Reactor模式
针对传统阻塞I/O
服务模型的2
个缺点,
解决方案:
- 基于
I/O
复用模型:多个连接共用一个阻塞对象,应用程序只需要在一个阻塞对象等待,无需阻塞等待所有连接。当某个连接有新的数据可以处理时,操作系统通知应用程序,线程从阻塞状态返回,开始进行业务处理Reactor
对应的叫法:1反应器模式;2分发者模式(Dispatcher);3通知者模式(notifier) - 基于线程池复用线程资源:不必再为每个连接创建线程,将连接完成后的业务处理任务分配给线程进行处理,一个线程可以处理多个连接的业务。
I/O
复用结合线程池,就是Reactor
模式基本设计思想,如图
Reactor
模式,通过一个或多个输入同时传递给服务处理器的模式(基于事件驱动)- 服务器端程序处理传入的多个请求,并将它们同步分派到相应的处理线程,因此
Reactor
模式也叫Dispatcher
模式 Reactor
模式使用IO
复用监听事件,收到事件后,分发给某个线程(进程),这点就是网络服务器高并发处理关键
Reactor
模式中核心组成
Reactor
:Reactor
在一个单独的线程中运行,负责监听和分发事件,分发给适当的处理程序来对IO
事件做出反应。它就像公司的电话接线员,它接听来自客户的电话并将线路转移到适当的联系人;Handlers
:处理程序执行I/O
事件要完成的实际事件,类似于客户想要与之交谈的公司中的实际官员。Reactor
通过调度适当的处理程序来响应I/O
事件,处理程序执行非阻塞操作。
2.4 单Reactor单线程
方案说明
Select
是前面I/O
复用模型介绍的标准网络编程API
,可以实现应用程序通过一个阻塞对象监听多路连接请求Reactor
对象通过Select
监控客户端请求事件,收到事件后通过Dispatch
进行分发- 如果是建立连接请求事件,则由
Acceptor
通过Accept
处理连接请求,然后创建一个Handler
对象处理连接完成后的后续业务处理 - 如果不是建立连接事件,则
Reactor
会分发调用连接对应的Handler
来响应 Handler
会完成Read
→业务处理→Send
的完整业务流程
结合实例:服务器端用一个线程通过多路复用搞定所有的IO
操作(包括连接,读、写等),编码简单,清晰明了,但是如果客户端连接数量较多,将无法支撑,前面的NIO
案例就属于这种模型。
2.4.1 方案优缺点分析
- 优点:模型简单,没有多线程、进程通信、竞争的问题,全部都在一个线程中完成
- 缺点:性能问题,只有一个线程,无法完全发挥多核
CPU
的性能。Handler
在处理某个连接上的业务时,整个进程无法处理其他连接事件,很容易导致性能瓶颈 - 缺点:可靠性问题,线程意外终止,或者进入死循环,会导致整个系统通信模块不可用,不能接收和处理外部消息,造成节点故障
- 使用场景:客户端的数量有限,业务处理非常快速,比如
Redis
在业务处理的时间复杂度O(1)
的情况
2.4.2 模型实现代码示例
这里面我为了简便,我将
Reactor
和Acceptor
和Handler
三个对象搞成了方法。
public class SReactorSThread {
private Selector selector;
private ServerSocketChannel serverSocketChannel;
private int PORT = 6666;
public SReactorSThread() {
try {
selector = Selector.open();
serverSocketChannel = ServerSocketChannel.open();
serverSocketChannel.bind(new InetSocketAddress(PORT));
serverSocketChannel.configureBlocking(false);
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
} catch (IOException e) {
e.printStackTrace();
}
}
//对客户端进行监听
public void listen() {
try {
while (true) {
int count = selector.select();
//表示有客户端产生事件
if (count > 0) {
Set<SelectionKey> selectionKeys = selector.selectedKeys();//取出产生事件的Channel
Iterator<SelectionKey> iterator = selectionKeys.iterator();//准备对其进行遍历
while (iterator.hasNext()) {
SelectionKey key = iterator.next();
//将key交给dispatch去处理
dispatch(key);
iterator.remove();
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
//dispatch
private void dispatch(SelectionKey key) {
if (key.isAcceptable()){
accept(key);
}else {
handler(key);
}
}
//建立新的连接
private void accept(SelectionKey key) {
try {
SocketChannel socketChannel = serverSocketChannel.accept();
socketChannel.configureBlocking(false);
socketChannel.register(selector, SelectionKey.OP_READ);
} catch (IOException e) {
e.printStackTrace();
}
}
//对请求进行处理,接收消息---业务处理---返回消息
private void handler(SelectionKey key) {
SocketChannel channel = null;
try {
channel = (SocketChannel) key.channel();
ByteBuffer buffer = ByteBuffer.allocate(3);
StringBuilder msg = new StringBuilder();
while (channel.read(buffer) > 0) {
msg.append(new String(buffer.array()));
buffer.clear();
}
System.out.println("接收到消息:" + msg.toString());
//发送消息
String ok = "OK";
buffer.put(ok.getBytes());
//这个flip非常重要哦,是将position置0,limit置于position的位置,
// 以便下面代码进行写入操作能够正确写入buffer中的所有数据
buffer.flip();
channel.write(buffer);
buffer.clear();
} catch (IOException e) {
try {
System.out.println(channel.getRemoteAddress() + "离线了");
//取消该通道的注册并关闭通道,这里非常重要,没有这一步的话当客户端断开连接就会不断抛出IOException
//是因为,select会一直产生该事件。
key.cancel();
channel.close();
} catch (IOException ex) {
ex.printStackTrace();
}
}
}
/********调用**************/
public static void main(String[] args) {
SReactorSThread sReactorSThread = new SReactorSThread();
sReactorSThread.listen();
}
}
2.5 单Reactor多线程
方案说明
Reactor
对象通过Select
监控客户端请求事件,收到事件后,通过Dispatch
进行分发- 如果建立连接请求,则右
Acceptor
通过accept
处理连接请求,然后创建一个Handler
对象处理完成连接后的各种事件 - 如果不是连接请求,则由
Reactor
分发调用连接对应的handler
来处理 handler
只负责响应事件,不做具体的业务处理,通过read
读取数据后,会分发给后面的worker
线程池的某个线程处理业务worker
线程池会分配独立线程完成真正的业务,并将结果返回给handler
handler
收到响应后,通过send
将结果返回给client
2.5.1 方案优缺点分析
- 优点:可以充分的利用多核
cpu
的处理能力 - 缺点:多线程数据共享和访问比较复杂,
Reactor
处理所有的事件的监听和响应,在单线程运行,在高并发场景容易出现性能瓶颈。
2.6 主从Reactor多线程
针对单Reactor
多线程模型中,Reactor
在单线程中运行,高并发场景下容易成为性能瓶颈,可以让Reactor
在多线程中运行
方案说明
Reactor
主线程MainReactor
对象通过select
监听连接事件,收到事件后,通过Acceptor
处理连接事件- 当
Acceptor
处理连接事件后,MainReactor
将连接分配给SubReactor
subreactor
将连接加入到连接队列进行监听,并创建handler
进行各种事件处理- 当有新事件发生时,
subreactor
就会调用对应的handler
处理 handler
通过read
读取数据,分发给后面的worker
线程处理worker
线程池分配独立的worker
线程进行业务处理,并返回结果handler
收到响应的结果后,再通过send
将结果返回给client
Reactor
主线程可以对应多个Reactor
子线程,即MainRecator
可以关联多个SubReactor
Scalable IO in Java
对Multiple Reactors
的原理图解
2.6.1 方案优缺点说明
- 优点:父线程与子线程的数据交互简单职责明确,父线程只需要接收新连接,子线程完成后续的业务处理。
- 优点:父线程与子线程的数据交互简单,
Reactor
主线程只需要把新连接传给子线程,子线程无需返回数据。 - 缺点:编程复杂度较高
- 结合实例:这种模型在许多项目中广泛使用,包括
Nginx
主从Reactor
多进程模型,Memcached
主从多线程,Netty
主从多线程模型的支持
2.7 Reactor模式小结
2.7.1 3种模式用生活案例来理解
- 单
Reactor
单线程,前台接待员和服务员是同一个人,全程为顾客服务 - 单
Reactor
多线程,1
个前台接待员,多个服务员,接待员只负责接待 - 主从
Reactor
多线程,多个前台接待员,多个服务生
2.7.2 Reactor模式具有如下的优点
- 响应快,不必为单个同步时间所阻塞,虽然
Reactor
本身依然是同步的 - 可以最大程度的避免复杂的多线程及同步问题,并且避免了多线程/进程的切换开销
- 扩展性好,可以方便的通过增加
Reactor
实例个数来充分利用CPU
资源 - 复用性好,
Reactor
模型本身与具体事件处理逻辑无关,具有很高的复用性
2.8 Netty模型
2.8.1 主从Reactor进阶
Netty
主要基于主从Reactors
多线程模型(如图)做了一定的改进,其中主从Reactor
多线程模型有多个Reactor
- 如图所示,增加了BossGroup来维护多个主Reactor,主Reactor还是只关注连接的Accept;增加了WorkGroup来维护多个从Reactor,从Reactor将接收到的请求交给Handler进行处理。
- 在主Reactor中接收到Accept事件,获取到对应的SocketChannel,Netty会将它进一步封装成NIOSocketChannel对象,这个封装后的对象还包含了该Channel对应的SelectionKey、通信地址等详细信息
- Netty会将装个封装后的Channel对象注册到WorkerGroup中的从Reactor中。
- 当WorkerGroup中的从Reactor监听到事件后,就会将之交给与此Reactor对应的Handler进行处理。
2.8.3 进阶版
Netty
将Selector
以及Selector
相关的事件及任务封装了NioEventLoop
,这样BossGroup
就可以通过管理NioEventLoop
去管理各个Selector
。- 同时,
Netty
模型中主要存在两个大的线程池组BossGroup
和WorkerGroup
,用于管理主Reactor
线程和从Reactor
线程。
2.8.4 详细版
Netty
抽象出两组线程池,BossGroup
专门负责接收客户端的连接,WorkerGroup
专门负责网络的读写。BossGroup
和WorkerGroup
类型都是NioEventLoopGroup
类型。NioEventLoopGroup
相当于一个事件循环组,这个组中含有多个事件循环,每一个事件循环是NioEventLoop
NioEventLoop
表示一个不断循环的执行处理任务的线程,每个NioEventLoop
都有一个Selector
,用于监听绑定在其上的socket
的网络通讯NioEventLoopGroup
可以有多个线程,即可以含有多个NioEventLoop
- 每个
BossNioEventLoop
循环执行的步骤有3
步- 轮询
accept
事件 - 处理
accept
事件,与client
建立连接,生成NioScocketChannel
,并将其注册到某个worker
NIOEventLoop
上的Selector
- 处理任务队列的任务,即
runAllTasks
- 轮询
- 每个
Worker
NIOEventLoop
循环执行的步骤- 轮询
read
,write
事件 - 处理
I/O
事件,即read
,write
事件,在对应NioScocketChannel
处理 - 处理任务队列的任务,即
runAllTasks
- 轮询
- 每个
Worker NioEventLoop
处理业务时,会使用pipeline
(管道),pipeline
中维护了一个ChannelHandlerContext
链表,而ChannelHandlerContext
则保存了Channel
相关的所有上下文信息,同时关联一个ChannelHandler
对象。如图所示,Channel
和pipeline
一一对应,ChannelHandler
和ChannelHandlerContext
一一对应。
ChannelHandler
是一个接口,负责处理或拦截I/O
操作,并将其转发到Pipeline
中的下一个处理Handler
进行处理。
I/O Request
via Channel or
ChannelHandlerContext
|
+---------------------------------------------------+---------------+
| ChannelPipeline | |
| \|/ |
| +---------------------+ +-----------+----------+ |
| | Inbound Handler N | | Outbound Handler 1 | |
| +----------+----------+ +-----------+----------+ |
| /|\ | |
| | \|/ |
| +----------+----------+ +-----------+----------+ |
| | Inbound Handler N-1 | | Outbound Handler 2 | |
| +----------+----------+ +-----------+----------+ |
| /|\ . |
| . . |
| ChannelHandlerContext.fireIN_EVT() ChannelHandlerContext.OUT_EVT()|
| [ method call] [method call] |
| . . |
| . \|/ |
| +----------+----------+ +-----------+----------+ |
| | Inbound Handler 2 | | Outbound Handler M-1 | |
| +----------+----------+ +-----------+----------+ |
| /|\ | |
| | \|/ |
| +----------+----------+ +-----------+----------+ |
| | Inbound Handler 1 | | Outbound Handler M | |
| +----------+----------+ +-----------+----------+ |
| /|\ | |
+---------------+-----------------------------------+---------------+
| \|/
+---------------+-----------------------------------+---------------+
| | | |
| [ Socket.read() ] [ Socket.write() ] |
| |
| Netty Internal I/O Threads (Transport Implementation) |
+-------------------------------------------------------------------+
2.8.5 Netty快速入门实例 - TCP服务
package com.test.netty.simple;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
public class NettyServer {
public static void main(String[] args) throws Exception {
//创建BossGroup和WorkerGroup
//说明
//1. 创建两个线程组bossGroup和workerGroup
//2. bossGroup只是处理连接请求,真正的和客户端业务处理,会交给workerGroup完成
//3. 两个都是无限循环
//4. bossGroup和workerGroup含有的子线程(NioEventLoop)的个数
// 默认实际cpu核数 * 2
EventLoopGroup bossGroup = new NioEventLoopGroup(1);
EventLoopGroup workerGroup = new NioEventLoopGroup(); //8
try {
//创建服务器端的启动对象,配置参数
ServerBootstrap bootstrap = new ServerBootstrap();
//使用链式编程来进行设置
bootstrap.group(bossGroup, workerGroup) //设置两个线程组
.channel(NioServerSocketChannel.class) //使用NioSocketChannel作为服务器的通道实现
.option(ChannelOption.SO_BACKLOG, 128) //设置线程队列得到连接个数
.childOption(ChannelOption.SO_KEEPALIVE, true) //设置保持活动连接状态
//.handler(null) //该handler对应bossGroup,childHandler对应workerGroup
//创建一个通道初始化对象(匿名对象)
.childHandler(new ChannelInitializer<SocketChannel>() {
//给pipeline设置处理器
@Override
protected void initChannel(SocketChannel ch) throws Exception {
//可以使用一个集合管理SocketChannel,再推送消息时,
//可以将业务加入到各个channel对应的NIOEventLoop的taskQueue或者scheduleTaskQueue
System.out.println("客户socketChannel hashcode=" + ch.hashCode());
ch.pipeline().addLast(new NettyServerHandler());
}
}); // 给我们的workerGroup的EventLoop对应的管道设置处理器
System.out.println(".....服务器 is ready...");
//绑定一个端口并且同步,生成了一个ChannelFuture对象
//启动服务器(并绑定端口)
ChannelFuture cf = bootstrap.bind(6668).sync();
//给cf注册监听器,监控我们关心的事件
cf.addListener(new ChannelFutureListener() {
@Override
public void operationComplete(ChannelFuture future) throws Exception {
if (cf.isSuccess()) {
System.out.println("监听端口6668成功");
} else {
System.out.println("监听端口6668失败");
}
}
});
//对关闭通道进行监听
cf.channel().closeFuture().sync();
} finally {
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}
}
}
package com.test.netty.simple;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.channel.ChannelPipeline;
import io.netty.util.CharsetUtil;
/**
* 说明
* 1. 我们自定义一个Handler需要继续netty规定好的某个HandlerAdapter(规范)
* 2. 这时我们自定义一个Handler,才能称为一个handler
*/
public class NettyServerHandler extends ChannelInboundHandlerAdapter {
//读取数据实际(这里我们可以读取客户端发送的消息)
/**
* 1. ChannelHandlerContext ctx:上下文对象,含有管道pipeline,通道channel,地址
* 2. Object msg: 就是客户端发送的数据 默认Object
*/
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
System.out.println("服务器读取线程 " + Thread.currentThread().getName()
+ " channle =" + ctx.channel());
System.out.println("server ctx =" + ctx);
System.out.println("看看channel和pipeline的关系");
Channel channel = ctx.channel();
ChannelPipeline pipeline = ctx.pipeline(); //本质是一个双向链接,出站入站
//将msg转成一个ByteBuf
//ByteBuf是Netty提供的,不是NIO的ByteBuffer.
ByteBuf buf = (ByteBuf) msg;
System.out.println("客户端发送消息是:" + buf.toString(CharsetUtil.UTF_8));
System.out.println("客户端地址:" + channel.remoteAddress());
}
//数据读取完毕
@Override
public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
//writeAndFlush是write + flush
//将数据写入到缓存,并刷新
//一般讲,我们对这个发送的数据进行编码
ctx.writeAndFlush(Unpooled.copiedBuffer("hello, 客户端~(>^ω^<)喵1", CharsetUtil.UTF_8));
}
//处理异常,一般是需要关闭通道
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
ctx.close();
}
}
package com.test.netty.simple;
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.NioSocketChannel;
public class NettyClient {
public static void main(String[] args) throws Exception {
//客户端需要一个事件循环组
EventLoopGroup group = new NioEventLoopGroup();
try {
//创建客户端启动对象
//注意客户端使用的不是ServerBootstrap而是Bootstrap
Bootstrap bootstrap = new Bootstrap();
//设置相关参数
bootstrap.group(group) //设置线程组
.channel(NioSocketChannel.class) // 设置客户端通道的实现类(反射)
.handler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ch.pipeline().addLast(new NettyClientHandler()); //加入自己的处理器
}
});
System.out.println("客户端 ok..");
//启动客户端去连接服务器端
//关于ChannelFuture要分析,涉及到netty的异步模型
ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 6668).sync();
//给关闭通道进行监听
channelFuture.channel().closeFuture().sync();
} finally {
group.shutdownGracefully();
}
}
}
package com.test.netty.simple;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;
public class NettyClientHandler extends ChannelInboundHandlerAdapter {
//当通道就绪就会触发该方法
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
System.out.println("client " + ctx);
ctx.writeAndFlush(Unpooled.copiedBuffer("hello, server: (>^ω^<)喵",
CharsetUtil.UTF_8));
}
//当通道有读取事件时,会触发
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
ByteBuf buf = (ByteBuf) msg;
System.out.println("服务器回复的消息:" + buf.toString(CharsetUtil.UTF_8));
System.out.println("服务器的地址: " + ctx.channel().remoteAddress());
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
cause.printStackTrace();
ctx.close();
}
}
2.8.6 任务队列中的Task有3种典型使用场景
- 用户程序自定义的普通任务
- 用户自定义定时任务
- 非当前
Reactor
线程调用Channel
的各种方法例如在推送系统的业务线程里面,根据用户的标识,找到对应的Channel
引用,然后调用Write
类方法向该用户推送消息,就会进入到这种场景。最终的Write
会提交到任务队列中后被异步消费
package com.test.netty.simple;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;
import java.util.concurrent.TimeUnit;
/**
* 说明
* 1. 我们自定义一个Handler需要继续netty规定好的某个HandlerAdapter(规范)
* 2. 这时我们自定义一个Handler,才能称为一个handler
*/
public class NettyServerHandler extends ChannelInboundHandlerAdapter {
//读取数据实际(这里我们可以读取客户端发送的消息)
/**
* 1. ChannelHandlerContext ctx:上下文对象,含有管道pipeline,通道channel,地址
* 2. Object msg: 就是客户端发送的数据,默认Object
*/
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
// 比如这里我们有一个非常耗时长的业务-> 异步执行 -> 提交该channel对应的
// NIOEventLoop的taskQueue中,
// 解决方案1:用户程序自定义的普通任务
ctx.channel().eventLoop().execute(() -> {
try {
Thread.sleep(5 * 1000);
ctx.writeAndFlush(Unpooled.copiedBuffer("hello, 客户端~(>^ω^<)喵2",
CharsetUtil.UTF_8));
System.out.println("channel code=" + ctx.channel().hashCode());
} catch (Exception ex) {
System.out.println("发生异常" + ex.getMessage());
}
});
ctx.channel().eventLoop().execute(() -> {
try {
Thread.sleep(5 * 1000);
ctx.writeAndFlush(Unpooled.copiedBuffer("hello, 客户端~(>^ω^<)喵3",
CharsetUtil.UTF_8));
System.out.println("channel code=" + ctx.channel().hashCode());
} catch (Exception ex) {
System.out.println("发生异常" + ex.getMessage());
}
});
//解决方案2:用户自定义定时任务 -》 该任务是提交到scheduleTaskQueue中
ctx.channel().eventLoop().schedule(-> () {
try {
Thread.sleep(5 * 1000);
ctx.writeAndFlush(Unpooled.copiedBuffer("hello, 客户端~(>^ω^<)喵4",
CharsetUtil.UTF_8));
System.out.println("channel code=" + ctx.channel().hashCode());
} catch (Exception ex) {
System.out.println("发生异常" + ex.getMessage());
}
}, 5, TimeUnit.SECONDS);
System.out.println("go on ...");
// System.out.println("服务器读取线程 " + Thread.currentThread().getName()
// + " channle =" + ctx.channel());
// System.out.println("server ctx =" + ctx);
// System.out.println("看看channel 和 pipeline的关系");
// Channel channel = ctx.channel();
// ChannelPipeline pipeline = ctx.pipeline(); //本质是一个双向链接,出站入站
//
// //将 msg 转成一个 ByteBuf
// //ByteBuf 是 Netty 提供的,不是 NIO 的 ByteBuffer.
// ByteBuf buf = (ByteBuf) msg;
// System.out.println("客户端发送消息是:" + buf.toString(CharsetUtil.UTF_8));
// System.out.println("客户端地址:" + channel.remoteAddress());
}
//数据读取完毕
@Override
public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
//writeAndFlush是write + flush
//将数据写入到缓存,并刷新
//一般讲,我们对这个发送的数据进行编码
ctx.writeAndFlush(Unpooled.copiedBuffer("hello, 客户端~(>^ω^<)喵1", CharsetUtil.UTF_8));
}
//处理异常,一般是需要关闭通道
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
ctx.close();
}
}
2.8.7 方案再说明
Netty
抽象出两组线程池,BossGroup
专门负责接收客户端连接,WorkerGroup
专门负责网络读写操作。NioEventLoop
表示一个不断循环执行处理任务的线程,每个NioEventLoop
都有一个Selector
,用于监听绑定在其上的socket
网络通道。NioEventLoop
内部采用串行化设计,从消息的读取->解码->处理->编码->发送,始终由IO
线程NioEventLoop
负责
NioEventLoopGroup
下包含多个NioEventLoop
- 每个
NioEventLoop
中包含有一个Selector
,一个taskQueue
- 每个
NioEventLoop
的Selector
上可以注册监听多个NioChannel
- 每个
NioChannel
只会绑定在唯一的NioEventLoop
上 - 每个
NioChannel
都绑定有一个自己的ChannelPipeline
2.9 异步模型
- 异步的概念和同步相对。当一个异步过程调用发出后,调用者不能立刻得到结果。实际处理这个调用的组件在完成后,通过状态、通知和回调来通知调用者。
Netty
中的I/O
操作是异步的,包括Bind、Write、Connect
等操作会简单的返回一个ChannelFuture
。- 调用者并不能立刻获得结果,而是通过
Future-Listener
机制,用户可以方便的主动获取或者通过通知机制获得IO
操作结果。 Netty
的异步模型是建立在future
和callback
的之上的。callback
就是回调。重点说Future
,它的核心思想是:假设一个方法fun
,计算过程可能非常耗时,等待fun
返回显然不合适。那么可以在调用fun
的时候,立马返回一个Future
,后续可以通过Future
去监控方法fun
的处理过程(即:Future-Listener
机制)
2.9.1 Future说明
- 表示异步的执行结果,可以通过它提供的方法来检测执行是否完成,比如检索计算等等。
ChannelFuture
是一个接口:public interface ChannelFuture extends Future<Void>
我们可以添加监听器,当监听的事件发生时,就会通知到监听器。案例说明
工作原理示意图
说明:
- 在使用
Netty
进行编程时,拦截操作和转换出入站数据只需要您提供callback
或利用future
即可。这使得链式操作简单、高效,并有利于编写可重用的、通用的代码。 Netty
框架的目标就是让你的业务逻辑从网络基础应用编码中分离出来、解脱出来。
2.9.2 Future-Listener机制
- 当
Future
对象刚刚创建时,处于非完成状态,调用者可以通过返回的ChannelFuture
来获取操作执行的状态,注册监听函数来执行完成后的操作。 - 常见有如下操作
- 通过
isDone
方法来判断当前操作是否完成; - 通过
isSuccess
方法来判断已完成的当前操作是否成功; - 通过
getCause
方法来获取已完成的当前操作失败的原因; - 通过
isCancelled
方法来判断已完成的当前操作是否被取消; - 通过
addListener
方法来注册监听器,当操作已完成(isDone
方法返回完成),将会通知指定的监听器;如果Future
对象已完成,则通知指定的监听器
- 通过
演示:绑定端口是异步操作,当绑定操作处理完,将会调用相应的监听器处理逻辑
//绑定一个端口并且同步,生成了一个ChannelFuture对象
//启动服务器(并绑定端口)
ChannelFuture cf = bootstrap.bind(6668).sync();
//给cf注册监听器,监控我们关心的事件
cf.addListener(new ChannelFutureListener() {
@Override
public void operationComplete (ChannelFuture future) throws Exception {
if (cf.isSuccess()) {
System.out.println("监听端口6668成功");
} else {
System.out.println("监听端口6668失败");
}
}
});
2.9.3 快速入门实例 - HTTP服务
package com.test.netty.http;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
public class TestServer {
public static void main(String[] args) throws Exception {
EventLoopGroup bossGroup = new NioEventLoopGroup(1);
EventLoopGroup workerGroup = new NioEventLoopGroup();
try {
ServerBootstrap serverBootstrap = new ServerBootstrap();
serverBootstrap.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class)
.childHandler(new TestServerInitializer());
ChannelFuture channelFuture = serverBootstrap.bind(6668).sync();
channelFuture.channel().closeFuture().sync();
} finally {
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}
}
}
package com.test.netty.http;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.http.HttpServerCodec;
public class TestServerInitializer extends ChannelInitializer<SocketChannel> {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
//向管道加入处理器
//得到管道
ChannelPipeline pipeline = ch.pipeline();
//加入一个netty提供的httpServerCodec codec =>[coder - decoder]
//HttpServerCodec说明
//1. HttpServerCodec是netty提供的处理http的编-解码器
pipeline.addLast("MyHttpServerCodec", new HttpServerCodec());
//2. 增加一个自定义的handler
pipeline.addLast("MyTestHttpServerHandler", new TestHttpServerHandler());
System.out.println("ok~~~~");
}
}
package com.test.netty.http;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.codec.http.*;
import io.netty.util.CharsetUtil;
import java.net.URI;
/**
* 说明
* 1. SimpleChannelInboundHandler是ChannelInboundHandlerAdapter
* 2. HttpObject客户端和服务器端相互通讯的数据被封装成HttpObject
*/
public class TestHttpServerHandler extends SimpleChannelInboundHandler<HttpObject> {
//channelRead0读取客户端数据
@Override
protected void channelRead0(ChannelHandlerContext ctx, HttpObject msg) throws Exception {
System.out.println("对应的channel=" + ctx.channel() + " pipeline=" + ctx
.pipeline() + " 通过pipeline获取channel" + ctx.pipeline().channel());
System.out.println("当前ctx的handler=" + ctx.handler());
//判断msg是不是httpRequest请求
if (msg instanceof HttpRequest) {
System.out.println("ctx类型=" + ctx.getClass());
System.out.println("pipeline hashcode" + ctx.pipeline().hashCode()
+ " TestHttpServerHandler hash=" + this.hashCode());
System.out.println("msg类型=" + msg.getClass());
System.out.println("客户端地址" + ctx.channel().remoteAddress());
//获取到
HttpRequest httpRequest = (HttpRequest) msg;
//获取uri,过滤指定的资源
URI uri = new URI(httpRequest.uri());
if ("/favicon.ico".equals(uri.getPath())) {
System.out.println("请求了favicon.ico,不做响应");
return;
}
//回复信息给浏览器[http协议]
ByteBuf content = Unpooled.copiedBuffer("hello, 我是服务器", CharsetUtil.UTF_8);
//构造一个http的相应,即httpResponse
FullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1,
HttpResponseStatus.OK, content);
response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/plain");
response.headers().set(HttpHeaderNames.CONTENT_LENGTH, content.readableBytes());
//将构建好response返回
ctx.writeAndFlush(response);
}
}
}
三、Netty核心模块组件
3.1 Bootstrap、ServerBootstrap
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 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) | 该方法用于客户端,用来连接服务器端 |
3.2 Future、ChannelFuture
Netty
中所有的IO
操作都是异步的,不能立刻得知消息是否被正确处理。但是可以过一会等它执行完成或者直接注册一个监听,具体的实现就是通过Future
和ChannelFutures
,他们可以注册一个监听,当操作执行成功或失败时监听会自动触发注册的监听事件
常见的方法有
方法名 | 方法介绍 |
---|---|
Channel channel() | 返回当前正在进行IO 操作的通道 |
ChannelFuture sync() | 等待异步操作执行完毕,相当于将阻塞在当前。 |
3.3 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
。
3.4 Selector
Netty
基于Selector
对象实现I/O
多路复用,通过Selector
一个线程可以监听多个连接的Channel
事件。- 当向一个
Selector
中注册Channel
后,Selector
内部的机制就可以自动不断地查询(Select
)这些注册的Channel
是否有已就绪的I/O
事件(例如可读,可写,网络连接完成等),这样程序就可以很简单地使用一个线程高效地管理多个Channel
3.5 ChannelHandler及其实现类
ChannelHandler
是一个接口,处理I/O
事件或拦截I/O
操作,并将其转发到其ChannelPipeline
(业务处理链)中的下一个处理程序。ChannelHandler
本身并没有提供很多方法,因为这个接口有许多的方法需要实现,方便使用期间,可以继承它的子类。
ChannelHandler
及其实现类一览图
- ChannelInboundHandler用于处理入站IO事件
- ChannelOutboundHandler用于处理出站IO操作
//适配器
- ChannelInboundHandlerAdapter用于处理入站IO事件。
- ChannelOutboundHandlerAdapter用于处理出站IO操作。
- ChannelDuplexHandler用于处理入站和出站事件。
我们经常需要自定义一个Handler
类去继承ChannelInboundHandlerAdapter
,然后通过重写相应方法实现业务逻辑,我们接下来看看一般都需要重写哪些方法。
public class ChannelInboundHandlerAdapter extends ChannelHandlerAdapter
implements ChannelInboundHandler {
public ChannelInboundHandlerAdapter(){}
//通道注册事件
@Skip
@Override
public void channelRegistered(ChannelHandlerContext ctx) throws Exception {
ctx.fireChannelRegistered();
}
//通道取消注册事件
@Skip
@Override
public void channelUnregistered(ChannelHandlerContext ctx) throws Exception {
ctx.fireChannelUnregistered();
}
//通道就绪事件
@Skip
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
ctx.fireChannelActive();
}
/**
* Calls {@link ChannelHandlerContext#fireChannelInactive()} to forward
* to the next {@link ChannelInboundHandler} in the {@link ChannelPipeline}.
*
* Sub-classes may override this method to change behavior.
*/
@Skip
@Override
public void channelInactive(ChannelHandlerContext ctx) throws Exception {
ctx.fireChannelInactive();
}
//通道读取数据事件
@Skip
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
ctx.fireChannelRead(msg);
}
//通道数据读取完毕事件
@Skip
@Override
public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
ctx.fireChannelReadComplete();
}
/**
* Calls {@link ChannelHandlerContext#fireUserEventTriggered(Object)} to forward
* to the next {@link ChannelInboundHandler} in the {@link ChannelPipeline}.
*
* Sub-classes may override this method to change behavior.
*/
@Skip
@Override
public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
ctx.fireUserEventTriggered(evt);
}
/**
* Calls {@link ChannelHandlerContext#fireChannelWritabilityChanged()} to forward
* to the next {@link ChannelInboundHandler} in the {@link ChannelPipeline}.
*
* Sub-classes may override this method to change behavior.
*/
@Skip
@Override
public void channelWritabilityChanged(ChannelHandlerContext ctx) throws Exception {
ctx.fireChannelWritabilityChanged();
}
//通道发生异常事件
@Skip
@Override
@SuppressWarnings("deprecation")
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
ctx.fireExceptionCaught(cause);
}
}
3.6 Pipeline和ChannelPipeline
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
互不干扰
常用方法
方法名 | 方法介绍 |
---|---|
ChannelPipeline addFirst(ChannelHandler... handlers) | 把一个业务处理类(handler )添加到链中的第一个位置 |
ChannelPipeline addLast(ChannelHandler… handlers) | 把一个业务处理类(handler )添加到链中的最后一个位置 |
3.7 ChannelHandlerContext
- 保存
Channel
相关的所有上下文信息,同时关联一个ChannelHandler
对象 - 即
ChannelHandlerContext
中包含一个具体的事件处理器ChannelHandler
,同时ChannelHandlerContext
中也绑定了对应的pipeline
和Channel
的信息,方便对ChannelHandler
进行调用。
常用方法
方法名 | 介绍 |
---|---|
ChannelFuture close() | 关闭通道 |
ChannelOutboundInvoker flush() | 刷新 |
ChannelFuture writeAndFlush(Object msg) | 将数据写到ChannelPipeline 中当前ChannelHandler 的下一个 ChannelHandler 开始处理(出站) |
3.8 ChannelOption
Netty
在创建Channel
实例后,一般都需要设置ChannelOption
参数。ChannelOption
参数如下:
ChannelOption.SO_BACKLOG
:对应TCP/IP
协议listen
函数中的backlog
参数,用来初始化服务器可连接队列大小。服务端处理客户端连接请求是顺序处理的,所以同一时间只能处理一个客户端连接。多个客户端的时候,服务端将不能处理的客户端连接请求放在队列中等待处理,backlog
参数指定了队列的大小。ChannelOption.SO_KEEPALIVE
:一直保持连接活动状态
3.9 EventLoopGroup和其实现类NioEventLoopGroup
EventLoopGroup
是一组EventLoop
的抽象,Netty
为了更好的利用多核CPU
资源,一般会有多个EventLoop
同时工作,每个EventLoop
维护着一个Selector
实例。EventLoopGroup
提供next
接口,可以从组里面按照一定规则获取其中一个EventLoop
来处理任务。在Netty
服务器端编程中,我们一般都需要提供两个EventLoopGroup
,例如:BossEventLoopGroup
和WorkerEventLoopGroup
。- 通常一个服务端口即一个
ServerSocketChannel
对应一个Selector
和一个EventLoop
线程。BossEventLoop
负责接收客户端的连接并将SocketChannel
交给WorkerEventLoopGroup
来进行IO
处理,如下图所示
常用方法
方法名 | 介绍 |
---|---|
public NioEventLoopGroup() | 构造方法 |
public Future shutdownGracefully() | 断开连接,关闭线程 |
3.10 Unpooled类
Netty
提供一个专门用来操作缓冲区(即Netty
的数据容器)的工具类- 常用方法如下所示
- 举例说明
Unpooled
获取Netty
的数据容器ByteBuf
的基本使用【案例演示】
案例 1
package com.test.netty.buf;
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 i = 0; i < buffer.capacity(); i++) {
System.out.println(buffer.readByte());
}
System.out.println("执行完毕");
}
}
案例 2
package com.test.netty.buf;
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")));
}
}
}
3.11 Netty应用实例-群聊系统
实例要求:
- 编写一个
Netty
群聊系统,实现服务器端和客户端之间的数据简单通讯(非阻塞) - 实现多人群聊
- 服务器端:可以监测用户上线,离线,并实现消息转发功能
- 客户端:通过
channel
可以无阻塞发送消息给其它所有用户,同时可以接受其它用户发送的消息(有服务器转发得到) - 目的:进一步理解
Netty
非阻塞网络编程机制
代码如下:
package com.test.netty.groupchat;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
public class GroupChatServer {
private int port; //监听端口
public GroupChatServer(int port) {
this.port = port;
}
//编写run方法,处理客户端的请求
public void run() throws Exception {
//创建两个线程组
EventLoopGroup bossGroup = new NioEventLoopGroup(1);
EventLoopGroup workerGroup = new NioEventLoopGroup(); //8个NioEventLoop
try {
ServerBootstrap b = new ServerBootstrap();
b.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)
.option(ChannelOption.SO_BACKLOG, 128)
.childOption(ChannelOption.SO_KEEPALIVE, true)
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
//获取到pipeline
ChannelPipeline pipeline = ch.pipeline();
//向pipeline加入解码器
pipeline.addLast("decoder", new StringDecoder());
//向pipeline加入编码器
pipeline.addLast("encoder", new StringEncoder());
//加入自己的业务处理handler
pipeline.addLast(new GroupChatServerHandler());
}
});
System.out.println("netty服务器启动");
ChannelFuture channelFuture = b.bind(port).sync();
//监听关闭
channelFuture.channel().closeFuture().sync();
} finally {
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}
}
public static void main(String[] args) throws Exception {
new GroupChatServer(7000).run();
}
}
package com.test.netty.groupchat;
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.channel.group.ChannelGroup;
import io.netty.channel.group.DefaultChannelGroup;
import io.netty.util.concurrent.GlobalEventExecutor;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class GroupChatServerHandler extends SimpleChannelInboundHandler<String> {
//public static List<Channel> channels = new ArrayList<Channel>();
//使用一个hashmap管理
//public static Map<String, Channel> channels = new HashMap<String, Channel>();
//定义一个channel组,管理所有的channel
//GlobalEventExecutor.INSTANCE)是全局的事件执行器,是一个单例
private static ChannelGroup channelGroup = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//handlerAdded表示连接建立,一旦连接,第一个被执行
//将当前channel加入到channelGroup
@Override
public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
Channel channel = ctx.channel();
//将该客户加入聊天的信息推送给其它在线的客户端
//该方法会将channelGroup中所有的channel遍历,并发送消息,我们不需要自己遍历
channelGroup.writeAndFlush("[客户端]" + channel.remoteAddress() + " 加入聊天"
+ sdf.format(new java.util.Date()) + " \n");
channelGroup.add(channel);
}
//断开连接,将xx客户离开信息推送给当前在线的客户
@Override
public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
Channel channel = ctx.channel();
channelGroup.writeAndFlush("[客户端]" + channel.remoteAddress() + " 离开了\n");
System.out.println("channelGroup size" + channelGroup.size());
}
//表示channel处于活动状态,提示xx上线
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
System.out.println(ctx.channel().remoteAddress() + " 上线了~");
}
//表示channel处于不活动状态,提示xx离线了
@Override
public void channelInactive(ChannelHandlerContext ctx) throws Exception {
System.out.println(ctx.channel().remoteAddress() + " 离线了~");
}
//读取数据
@Override
protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
//获取到当前channel
Channel channel = ctx.channel();
//这时我们遍历channelGroup,根据不同的情况,回送不同的消息
channelGroup.forEach(ch -> {
if (channel != ch) { //不是当前的channel,转发消息
ch.writeAndFlush("[客户]" + channel.remoteAddress() + " 发送了消息" + msg + "\n");
} else {//回显自己发送的消息给自己
ch.writeAndFlush("[自己]发送了消息" + msg + "\n");
}
});
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
//关闭通道
ctx.close();
}
}
package com.test.netty.groupchat;
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import java.util.Scanner;
public class GroupChatClient {
//属性
private final String host;
private final int port;
public GroupChatClient(String host, int port) {
this.host = host;
this.port = port;
}
public void run() throws Exception {
EventLoopGroup group = new NioEventLoopGroup();
try {
Bootstrap bootstrap = new Bootstrap()
.group(group)
.channel(NioSocketChannel.class)
.handler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
//得到pipeline
ChannelPipeline pipeline = ch.pipeline();
//加入相关handler
pipeline.addLast("decoder", new StringDecoder());
pipeline.addLast("encoder", new StringEncoder());
//加入自定义的handler
pipeline.addLast(new GroupChatClientHandler());
}
});
ChannelFuture channelFuture = bootstrap.connect(host, port).sync();
//得到channel
Channel channel = channelFuture.channel();
System.out.println("-------" + channel.localAddress() + "--------");
//客户端需要输入信息,创建一个扫描器
Scanner scanner = new Scanner(System.in);
while (scanner.hasNextLine()) {
String msg = scanner.nextLine();
//通过channel发送到服务器端
channel.writeAndFlush(msg + "\r\n");
}
} finally {
group.shutdownGracefully();
}
}
public static void main(String[] args) throws Exception {
new GroupChatClient("127.0.0.1", 7000).run();
}
}
package com.test.netty.groupchat;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
public class GroupChatClientHandler extends SimpleChannelInboundHandler<String> {
@Override
protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
System.out.println(msg.trim());
}
}
3.12 Netty心跳检测机制案例
实例要求:
- 编写一个
Netty
心跳检测机制案例,当服务器超过3
秒没有读时,就提示读空闲 - 当服务器超过
5
秒没有写操作时,就提示写空闲 - 实现当服务器超过
7
秒没有读或者写操作时,就提示读写空闲
package com.test.netty.heartbeat;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
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.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
import io.netty.handler.timeout.IdleStateHandler;
import java.util.concurrent.TimeUnit;
public class MyServer {
public static void main(String[] args) throws Exception {
//创建两个线程组
EventLoopGroup bossGroup = new NioEventLoopGroup(1);
EventLoopGroup workerGroup = new NioEventLoopGroup(); //8个NioEventLoop
try {
ServerBootstrap serverBootstrap = new ServerBootstrap();
serverBootstrap.group(bossGroup, workerGroup);
serverBootstrap.channel(NioServerSocketChannel.class);
serverBootstrap.handler(new LoggingHandler(LogLevel.INFO));
serverBootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline pipeline = ch.pipeline();
//加入一个netty提供IdleStateHandler
/*
* 1. IdleStateHandler是netty提供的处理空闲状态的处理器
* 2. long readerIdleTime : 表示多长时间没有读,就会发送一个心跳检测包检测是否连接
* 3. long writerIdleTime : 表示多长时间没有写,就会发送一个心跳检测包检测是否连接
* 4. long allIdleTime : 表示多长时间没有读写,就会发送一个心跳检测包检测是否连接
* 5. 当IdleStateEvent触发后,就会传递给管道的下一个handler去处理,通过调用(触发)下一个
* handler的userEventTiggered,在该方法中去处理IdleStateEvent(读空闲,写空闲,读写空闲)
*/
pipeline.addLast(new IdleStateHandler(7000, 7000, 10, TimeUnit.SECONDS));
//加入一个对空闲检测进一步处理的handler(自定义)
pipeline.addLast(new MyServerHandler());
}
});
//启动服务器,设置为同步模式。
ChannelFuture channelFuture = serverBootstrap.bind(7000).sync();
channelFuture.channel().closeFuture().sync();
} finally {
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}
}
}
package com.test.netty.heartbeat;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.handler.timeout.IdleStateEvent;
public class MyServerHandler extends ChannelInboundHandlerAdapter {
/**
* @param ctx 上下文
* @param evt 事件
* @throws Exception
*/
@Override
public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
if (evt instanceof IdleStateEvent) {
//将evt向下转型IdleStateEvent
IdleStateEvent event = (IdleStateEvent) evt;
String eventType = null;
switch (event.state()) {
case READER_IDLE:
eventType = "读空闲";
break;
case WRITER_IDLE:
eventType = "写空闲";
break;
case ALL_IDLE:
eventType = "读写空闲";
break;
}
System.out.println(ctx.channel().remoteAddress() + "--超时时间--" + eventType);
System.out.println("服务器做相应处理..");
//如果发生空闲,我们关闭通道
// ctx.channel().close();
}
}
}
3.13 Netty通过WebSocket编程实现服务器和客户端长连接
实例要求:
Http
协议是无状态的,浏览器和服务器间的请求响应一次,下一次会重新创建连接。- 要求:实现基于
WebSocket
的长连接的全双工的交互 - 改变
Http
协议多次请求的约束,实现长连接了,服务器可以发送消息给浏览器 - 客户端浏览器和服务器端会相互感知,比如服务器关闭了,浏览器会感知,同样浏览器关闭了,服务器会感知
package com.test.netty.websocket;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
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.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.codec.http.websocketx.WebSocketServerProtocolHandler;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
import io.netty.handler.stream.ChunkedWriteHandler;
public class MyServer {
public static void main(String[] args) throws Exception {
//创建两个线程组
EventLoopGroup bossGroup = new NioEventLoopGroup(1);
EventLoopGroup workerGroup = new NioEventLoopGroup(); //8个NioEventLoop
try {
ServerBootstrap serverBootstrap = new ServerBootstrap();
serverBootstrap.group(bossGroup, workerGroup);
serverBootstrap.channel(NioServerSocketChannel.class);
serverBootstrap.handler(new LoggingHandler(LogLevel.INFO));
serverBootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline pipeline = ch.pipeline();
//因为基于http协议,使用http的编码和解码器
pipeline.addLast(new HttpServerCodec());
//是以块方式写,添加ChunkedWriteHandler处理器
pipeline.addLast(new ChunkedWriteHandler());
/*
* 1. http数据在传输过程中是分段,HttpObjectAggregator,就是可以将多个段聚合
* 2. 这就就是为什么,当浏览器发送大量数据时,就会发出多次http请求
*/
pipeline.addLast(new HttpObjectAggregator(8192));
/*
* 1. 对应websocket,它的数据是以帧(frame)形式传递
* 2. 可以看到WebSocketFrame下面有六个子类
* 3. 浏览器请求时:ws://localhost:7000/hello表示请求的uri
* 4. WebSocketServerProtocolHandler核心功能是将http协议升级为ws协议,保持长连接
* 5. 从Http协议升级到Websocket协议,是通过StatusCode 101(Switching Protocols)来切换。
*/
pipeline.addLast(new WebSocketServerProtocolHandler("/hello2"));
//自定义的handler,处理业务逻辑
pipeline.addLast(new MyTextWebSocketFrameHandler());
}
});
//启动服务器
ChannelFuture channelFuture = serverBootstrap.bind(7000).sync();
channelFuture.channel().closeFuture().sync();
} finally {
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}
}
}
package com.test.netty.websocket;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;
import java.time.LocalDateTime;
//这里TextWebSocketFrame类型,表示一个文本帧(frame)
public class MyTextWebSocketFrameHandler extends SimpleChannelInboundHandler<TextWebSocketFrame> {
@Override
protected void channelRead0(ChannelHandlerContext ctx, TextWebSocketFrame msg) throws Exception {
System.out.println("服务器收到消息" + msg.text());
//回复消息
ctx.channel().writeAndFlush(new TextWebSocketFrame("服务器时间" + LocalDateTime.now()
+ " " + msg.text()));
}
//当web客户端连接后,触发方法
@Override
public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
//id表示唯一的值,LongText是唯一的ShortText不是唯一
System.out.println("handlerAdded 被调用" + ctx.channel().id().asLongText());
System.out.println("handlerAdded 被调用" + ctx.channel().id().asShortText());
}
@Override
public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
System.out.println("handlerRemoved 被调用" + ctx.channel().id().asLongText());
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
System.out.println("异常发生 " + cause.getMessage());
ctx.close(); //关闭连接
}
}
hello.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<script>
var socket;
//判断当前浏览器是否支持websocket
if(window.WebSocket) {
//go on
socket = new WebSocket("ws://localhost:7000/hello2");
//相当于channelReado,ev收到服务器端回送的消息
socket.onmessage = function (ev) {
var rt = document.getElementById("responseText");
rt.value = rt.value + "\n" + ev.data;
}
//相当于连接开启(感知到连接开启)
socket.onopen = function (ev) {
var rt = document.getElementById("responseText");
rt.value = "连接开启了.."
}
//相当于连接关闭(感知到连接关闭)
socket.onclose = function (ev) {
var rt = document.getElementById("responseText");
rt.value = rt.value + "\n" + "连接关闭了.."
}
} else {
alert("当前浏览器不支持websocket")
}
//发送消息到服务器
function send(message) {
if(!window.socket) { //先判断socket是否创建好
return;
}
if(socket.readyState == WebSocket.OPEN) {
//通过socket发送消息
socket.send(message)
} else {
alert("连接没有开启");
}
}
</script>
<form onsubmit="return false">
<textarea name="message" style="height: 300px; width: 300px"></textarea>
<input type="button" value="发生消息" onclick="send(this.form.message.value)">
<textarea id="responseText" style="height: 300px; width: 300px"></textarea>
<input type="button" value="清空内容"
onclick="document.getElementById('responseText').value=''">
</form>
</body>
</html>
启动类:
- 首先初始化两个
NioEventLoopGroup
。其中BossGroup
一般设置线程为1
- 初始化一个
ServerBootStrap
类。并调用它设置很多参数。group()
:服务端设置两个Group
,客户端设置一个Group
chnnel()
:服务端传入NioServerSocketChannel
,客户端传入NioSocketChannel
option()
:服务端给BossGroup
设置SO_BACKLOG
任务队列大小childOption()
:服务端给WorkerGroup
设置连接SO_KEEPALIVE
保持连接状态handler()
:服务端给BossGroup
设置Handler
,客户端设置Handler
childHandler()
:服务端给WorkerGroup
设置Handler
。
- 通过
BootStrap
去绑定端口,监听关闭事件。设置为同步
Handler:
SimpleChannelInboundHandler
:可以继承它来处理很多通信。一般写自己的Handler
继承它就可以了ChannelInboundHandlerAdapter
:这个是上一个的父类,我们在心跳检测的时候通过继承它的userEventTriggered
去判断连接状态。其实通过上面那个simple
也可以继承这个trigger
IdleStateHandler
:在心跳检测时我们要通过这个Handler
去触发上面的trigger
HttpServerCodec
:提供好的用于Http
编码解码,一般用于Http
请求ChunkedWriteHandler
:提供好的Handler
,以块方式写,添加ChunkedWriter
处理器。一般用于发送大文件。HttpObjectAggregator
:将http
数据聚合在一起发送WebSocketServerProtocolHandler
:传入ws
路径,将Http
协议升级成为ws
协议
Handler常用方法:
方法名 | 介绍 |
---|---|
channelRead0(ChannelHandlerContext channelHandlerContext, T t) | 读取数据,并进行消息转发 |
handlerAdded(ChannelHandlerContext ctx) | 连接建立,一旦建立连接,就第一个被执行 |
channelActive(ChannelHandlerContext ctx) | 表示channel 处于活动状态,提示xxx上线 |
channelInactive(ChannelHandlerContext ctx) | 表示channel 处于不活动状态,提示xxx离线 |
handlerRemoved(ChannelHandlerContext ctx) | 表示channel 断开连接,将xx客户离开信息推送给当前在线客户 |
exceptionCaught(ChannelHandlerContext ctx, Throwable cause) | 出现错误如何进行处理 |
userEventTriggered(ChannelHandlerContext ctx, Object evt) | 事件触发器,通过判断evt的类型去判断发生了什么事件, 再通过里面的属性判断事件发生的类型。我们在 IdleStateHandler 后面加上一个触发器,可以检测心跳。 |
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】凌霞软件回馈社区,博客园 & 1Panel & Halo 联合会员上线
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】博客园社区专享云产品让利特惠,阿里云新客6.5折上折
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步
· DeepSeek “源神”启动!「GitHub 热点速览」
· 微软正式发布.NET 10 Preview 1:开启下一代开发框架新篇章
· C# 集成 DeepSeek 模型实现 AI 私有化(本地部署与 API 调用教程)
· DeepSeek R1 简明指南:架构、训练、本地部署及硬件要求
· NetPad:一个.NET开源、跨平台的C#编辑器