Netty 学习手册
1.Netty 简介
(1)Netty
是由 JBOSS
提供的一个 Java
开源框架,现为 Github
上的独立项目。
(2)Netty
是一个异步的、基于事件驱动的网络应用框架,用以快速开发高性能、高可靠性的网络 IO
程序。
(3)Netty
主要针对在 TCP
协议下,面向 Client
端的高并发应用,或者 Peer-to-Peer
场景下的大量数据持续传输的应用。
(4)Netty
本质是一个 NIO
框架,适用于服务器通讯相关的多种应用场景。
(5)要透彻理解 Netty
,需要先学习 NIO
,这样我们才能阅读 Netty
的源码。
2 I/O 模型
2.1 模型基本说明
(1)I/O
模型简单的理解:就是用什么样的通道进行数据的发送和接收,很大程度上决定了程序通信的性能。
(2)Java
共支持 3
种网络编程模型 I/O
模式:BIO
、NIO
、AIO
。
(3)Java BIO
:同步并阻塞(传统阻塞型),服务器实现模式为一个连接一个线程,即客户端有连接请求时服务器端就需要启动一个线程进行处理,如果这个连接不做任何事情会造成不必要的线程开销。【简单示意图】
(4)Java NIO
:同步非阻塞,服务器实现模式为一个线程处理多个请求(连接),即客户端发送的连接请求都会注册到多路复用器上,多路复用器轮询到连接有 I/O
请求就进行处理。【简单示意图】
(5)Java AIO(NIO.2)
:异步非阻塞,AIO
引入异步通道的概念,采用了 Proactor
模式,简化了程序编写,有效的请求才启动线程,它的特点是先由操作系统完成后才通知服务端程序启动线程去处理,一般适用于连接数较多且连接时间较长的应用。
2.2 各I/O 使用场景
(1)BIO
方式适用于连接数目比较小且固定的架构,这种方式对服务器资源要求比较高,并发局限于应用中,JDK1.4
以前的唯一选择,但程序简单易理解。
(2)NIO
方式适用于连接数目多且连接比较短(轻操作)的架构,比如聊天服务器,弹幕系统,服务器间通讯等。编程比较复杂,JDK1.4
开始支持。
(3)AIO
方式使用于连接数目多且连接比较长(重操作)的架构,比如相册服务器,充分调用 OS
参与并发操作,编程比较复杂,JDK7
开始支持。
3. Java BIO 编程
3.1 BIO基本介绍
(1)Java BIO
就是传统的 Java I/O
编程,其相关的类和接口在 java.io
。
(2)BIO(BlockingI/O)
:同步阻塞,服务器实现模式为一个连接一个线程,即客户端有连接请求时服务器端就需要启动一个线程进行处理,如果这个连接不做任何事情会造成不必要的线程开销,可以通过线程池机制改善(实现多个客户连接服务器)。【后有应用实例】
(3)BIO
方式适用于连接数目比较小且固定的架构,这种方式对服务器资源要求比较高,并发局限于应用中,JDK1.4
以前的唯一选择,程序简单易理解。
3.2 BIO工作机制
对 BIO
编程流程的梳理
- 服务器端启动一个
ServerSocket
。 - 客户端启动
Socket
对服务器进行通信,默认情况下服务器端需要对每个客户建立一个线程与之通讯。 - 客户端发出请求后,先咨询服务器是否有线程响应,如果没有则会等待,或者被拒绝。
- 如果有响应,客户端线程会等待请求结束后,在继续执行。
3.3 BIO应用实例
实例说明:
- 使用
BIO
模型编写一个服务器端,监听6666
端口,当有客户端连接时,就启动一个线程与之通讯。 - 要求使用线程池机制改善,可以连接多个客户端。
- 服务器端可以接收客户端发送的数据(
telnet
方式即可)。 - 代码演示:
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class BIOServer {
public static void main(String[] args) throws Exception {
//线程池机制 //思路
//1. 创建一个线程池
//2. 如果有客户端连接,就创建一个线程,与之通讯(单独写一个方法)
ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
//创建ServerSocket
ServerSocket serverSocket = new ServerSocket(6666);
System.out.println("服务器启动了");
while (true) {
System.out.println("线程信息id = " + Thread.currentThread().getId() + "名字 = " + Thread.currentThread().getName());
//监听,等待客户端连接
System.out.println("等待连接....");
final Socket socket = serverSocket.accept();
System.out.println("连接到一个客户端");
//就创建一个线程,与之通讯(单独写一个方法)
newCachedThreadPool.execute(new Runnable() {
public void run() {//我们重写
//可以和客户端通讯
handler(socket);
}
});
}
}
//编写一个handler方法,和客户端通讯
public static void handler(Socket socket) {
try {
System.out.println("线程信息id = " + Thread.currentThread().getId() + "名字 = " + Thread.currentThread().getName());
byte[] bytes = new byte[1024];
//通过socket获取输入流
InputStream inputStream = socket.getInputStream();
//循环的读取客户端发送的数据
while (true) {
System.out.println("线程信息id = " + Thread.currentThread().getId() + "名字 = " + Thread.currentThread().getName());
System.out.println("read....");
int read = inputStream.read(bytes);
if (read != -1) {
System.out.println(new String(bytes, 0, read));//输出客户端发送的数据
} else {
break;
}
}
} catch (Exception e) {
e.printStackTrace();
} finally {
System.out.println("关闭和client的连接");
try {
socket.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
3.4 BIO 问题
- 每个请求都需要创建独立的线程,与对应的客户端进行数据
Read
,业务处理,数据Write
。 - 当并发数较大时,需要创建大量线程来处理连接,系统资源占用较大。
- 连接建立后,如果当前线程暂时没有数据可读,则线程就阻塞在
Read
操作上,造成线程资源浪费。
4.Java NIO 编程
4.1 NIO 基本介绍
(1)Java NIO
全称 Java non-blocking IO
,是指 JDK
提供的新 API
。从 JDK1.4
开始,Java
提供了一系列改进的输入/输出的新特性,被统称为 NIO
(即 NewIO
),是同步非阻塞的。
(2)NIO
相关类都被放在 java.nio
包及子包下,并且对原 java.io
包中的很多类进行改写。【基本案例】
(3)NIO
有三大核心部分: Channel
(通道)、Buffer
(缓冲区)、Selector
(选择器) 。
(4)NIO
是面向缓冲区,或者面向块编程的。数据读取到一个它稍后处理的缓冲区,需要时可在缓冲区中前后移动,这就增加了处理过程中的灵活性,使用它可以提供非阻塞式的高伸缩性网络。
(5)Java NIO
的非阻塞模式,使一个线程从某通道发送请求或者读取数据,但是它仅能得到目前可用的数据,如果目前没有数据可用时,就什么都不会获取,而不是保持线程阻塞,所以直至数据变的可以读取之前,该线程可以继续做其他的事情。非阻塞写也是如此,一个线程请求写入一些数据到某通道,但不需要等待它完全写入,这个线程同时可以去做别的事情。【后面有案例说明】
(6)通俗理解:NIO
是可以做到用一个线程来处理多个操作的。假设有 10000
个请求过来,根据实际情况,可以分配 50
或者 100
个线程来处理。不像之前的阻塞 IO
那样,非得分配 10000
个。
(7)HTTP 2.0
使用了多路复用的技术,做到同一个连接并发处理多个请求,而且并发请求的数量比 HTTP 1.1
大了好几个数量级。
(8)案例说明 NIO
的 Buffer
import java.nio.IntBuffer;
public class BasicBuffer {
public static void main(String[] args) {
//举例说明 Buffer 的使用(简单说明)
//创建一个 Buffer,大小为 5,即可以存放 5 个 int
IntBuffer intBuffer = IntBuffer.allocate(5);
//向buffer存放数据
//intBuffer.put(10);
//intBuffer.put(11);
//intBuffer.put(12);
//intBuffer.put(13);
//intBuffer.put(14);
for (int i = 0; i < intBuffer.capacity(); i++) {
intBuffer.put(i * 2);
}
//如何从 buffer 读取数据
//将 buffer 转换,读写切换(!!!)
intBuffer.flip();
while (intBuffer.hasRemaining()) {
System.out.println(intBuffer.get());
}
}
}
4.2 NIO 和 BIO 的比较
BIO
以流的方式处理数据,而NIO
以块的方式处理数据,块I/O
的效率比流I/O
高很多。BIO
是阻塞的,NIO
则是非阻塞的。BIO
基于字节流和字符流进行操作,而NIO
基于Channel
(通道)和Buffer
(缓冲区)进行操作,数据总是从通道读取到缓冲区中,或者从缓冲区写入到通道中。Selector
(选择器)用于监听多个通道的事件(比如:连接请求,数据到达等),因此使用单个线程就可以监听多个客户端通道。
4.3 NIO 三大核心
一张图描述 NIO
的 Selector
、Channel
和 Buffer
的关系。
(1)每个 Channel
都会对应一个 Buffer
。
(2)Selector
对应一个线程,一个线程对应多个 Channel
(连接)。
(3)该图反应了有三个 Channel
注册到该 Selector
//程序
(4)程序切换到哪个 Channel
是由事件决定的,Event
就是一个重要的概念。
(5)Selector
会根据不同的事件,在各个通道上切换。
(6)Buffer
就是一个内存块,底层是有一个数组。
(7)数据的读取写入是通过 Buffer
,这个和 BIO
,BIO
中要么是输入流,或者是输出流,不能双向,但是 NIO
的 Buffer
是可以读也可以写,需要 flip
方法切换 Channel
是双向的,可以返回底层操作系统的情况,比如 Linux
,底层的操作系统通道就是双向的。
4.3.1 Buffer
- 基本原理
缓冲区(Buffer
):缓冲区本质上是一个可以读写数据的内存块,可以理解成是一个容器对象(含数组),该对象提供了一组方法,可以更轻松地使用内存块,缓冲区对象内置了一些机制,能够跟踪和记录缓冲区的状态变化情况。Channel
提供从文件、网络读取数据的渠道,但是读取或写入的数据都必须经由 Buffer
,如图:
- 类与方法说明
(1)在 NIO
中,Buffer
是一个顶层父类,它是一个抽象类,类的层级关系图:
![img](https://img-blog.csdnimg.cn/img_convert/6d2061174f5e5f8c8b3fa79fbf04340a.png)
(2)Buffer
类定义了所有的缓冲区都具有的四个属性来提供关于其所包含的数据元素的信息:
(3)Buffer
类相关方法一览
![img](https://img-blog.csdnimg.cn/img_convert/c721491bed38e6404cb62ba55ac79186.png)
(4)ByteBuffer
类
从前面可以看出对于 Java
中的基本数据类型(boolean
除外),都有一个 Buffer
类型与之相对应,最常用的自然是 ByteBuffer
类(二进制数据),该类的主要方法如下:
![img](https://img-blog.csdnimg.cn/img_convert/83d84dcc7faba51309a1dddfb2513650.png)
4.3.2 Channel
- 基本原理
(1)NIO
的通道类似于流,但有些区别如下:
通道可以同时进行读写,而流只能读或者只能写
通道可以实现异步读写数据
通道可以从缓冲读数据,也可以写数据到缓冲:
(2)BIO
中的 Stream
是单向的,例如 FileInputStream
对象只能进行读取数据的操作,而 NIO
中的通道(Channel
)是双向的,可以读操作,也可写操作。
(3)Channel
在 NIO
中是一个接口 public interface Channel extends Closeable{}
- 类与方法说明
常用的 Channel
类有: FileChannel
、DatagramChannel
、ServerSocketChannel
和 SocketChannel
【
ServerSocketChanne
类似ServerSocket
、SocketChannel
类似Socket
】
![img](https://img-blog.csdnimg.cn/img_convert/c90a61eea858ccc55fbe9afb9cf0a0c5.png)
DatagramChannel
用于 UDP
的数据读写,ServerSocketChannel
和 SocketChannel
用于 TCP
的数据读写
FileChannel
类:主要用来对文件数据进行 IO
操作,常见的方法有
public int read(ByteBuffer dst)
,从通道读取数据并放到缓冲区中public int write(ByteBuffer src)
,把缓冲区的数据写到通道中public long transferFrom(ReadableByteChannel src, long position, long count)
,从目标通道中复制数据到当前通道public long transferTo(long position, long count, WritableByteChannel target)
,把数据从当前通道复制给目标通道
4.3.3 Selector
-
基本原理
(1)
Java
的NIO
,用非阻塞的IO
方式。可以用一个线程,处理多个的客户端连接,就会使用到Selector
(选择器)。(2)
Selector
能够检测多个注册的通道上是否有事件发生(注意:多个Channel
以事件的方式可以注册到同一个Selector
),如果有事件发生,便获取事件然后针对每个事件进行相应的处理。这样就可以只用一个单线程去管理多个通道,也就是管理多个连接和请求。【示意图】(3)只有在连接/通道真正有读写事件发生时,才会进行读写,就大大地减少了系统开销,并且不必为每个连接都创建一个线程,不用去维护多个线程。
(4)避免了多线程之间的上下文切换导致的开销。
详细说明如下:
(1)
Netty
的IO
线程NioEventLoop
聚合了Selector
(选择器,也叫多路复用器),可以同时并发处理成百上千个客户端连接。(2)当线程从某客户端
Socket
通道进行读写数据时,若没有数据可用时,该线程可以进行其他任务。(3)线程通常将非阻塞
IO
的空闲时间用于在其他通道上执行IO
操作,所以单独的线程可以管理多个输入和输出通道。(4)由于读写操作都是非阻塞的,这就可以充分提升
IO
线程的运行效率,避免由于频繁I/O
阻塞导致的线程挂起。(5)一个
I/O
线程可以并发处理N
个客户端连接和读写操作,这从根本上解决了传统同步阻塞I/O
一连接一线程模型,架构的性能、弹性伸缩能力和可靠性都得到了极大的提升。 -
类与方法 说明
注意事项:
NIO
中的ServerSocketChannel
功能类似ServerSocket
、SocketChannel
功能类似Socket
。
Selector
相关方法说明
selector.select();
//阻塞selector.select(1000);
//阻塞 1000 毫秒,在 1000 毫秒后返回selector.wakeup();
//唤醒 selectorselector.selectNow();
//不阻塞,立马返还
(1) SelectionKey
表示Selector和网络通道的注册关系,共四种:
int OP_ACCEPT
:有新的网络连接可以accept
,值为16
int OP_CONNECT
:代表连接已经建立,值为8
int OP_READ
:代表读操作,值为1
int OP_WRITE
:代表写操作,值为4
4.4 NIO应用实例
应用实例1:本地文件写数据
实例要求:
- 使用前面学习后的
ByteBuffer
(缓冲)和FileChannel
(通道),将 “hello!!!” 写入到file01.txt
中 - 文件不存在就创建
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
public class NIOFileChannel01 {
public static void main(String[] args) throws Exception {
String str = "hello!!!";
//创建一个输出流 -> channel
FileOutputStream fileOutputStream = new FileOutputStream("data/file/file01.txt");
//通过 fileOutputStream 获取对应的 FileChannel
//这个 fileChannel 真实类型是 FileChannelImpl
FileChannel fileChannel = fileOutputStream.getChannel();
//创建一个缓冲区 ByteBuffer
ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
//将 str 放入 byteBuffer
byteBuffer.put(str.getBytes());
//对 byteBuffer 进行 flip
byteBuffer.flip();
//将 byteBuffer 数据写入到 fileChannel
fileChannel.write(byteBuffer);
fileOutputStream.close();
}
}
应用实例2:本地文件读数据
实例要求:
- 使用前面学习后的
ByteBuffer
(缓冲)和FileChannel
(通道),将file01.txt
中的数据读入到程序,并显示在控制台屏幕 - 假定文件已经存在
import java.io.File;
import java.io.FileInputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
public class NIOFileChannel02 {
public static void main(String[] args) throws Exception {
//创建文件的输入流
File file = new File("d:\\file01.txt");
FileInputStream fileInputStream = new FileInputStream(file);
//通过 fileInputStream 获取对应的 FileChannel -> 实际类型 FileChannelImpl
FileChannel fileChannel = fileInputStream.getChannel();
//创建缓冲区
ByteBuffer byteBuffer = ByteBuffer.allocate((int)file.length());
//将通道的数据读入到 Buffer
fileChannel.read(byteBuffer);
//将 byteBuffer 的字节数据转成 String
System.out.println(new String(byteBuffer.array()));
fileInputStream.close();
}
}
应用实例3:用一个 Buffer 完成文件读、写
实例要求:
-
使用
FileChannel
(通道)和方法read、write
,完成文件的拷贝 -
拷贝一个文本文件
1.txt
,放在项目下即可
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
public class NIOFileChannel03 {
public static void main(String[] args) throws Exception {
FileInputStream fileInputStream = new FileInputStream("1.txt");
FileChannel fileChannel01 = fileInputStream.getChannel();
FileOutputStream fileOutputStream = new FileOutputStream("2.txt");
FileChannel fileChannel02 = fileOutputStream.getChannel();
ByteBuffer byteBuffer = ByteBuffer.allocate(512);
while (true) { //循环读取
//这里有一个重要的操作,一定不要忘了
/*
public final Buffer clear() {
position = 0;
limit = capacity;
mark = -1;
return this;
}
*/
byteBuffer.clear(); //清空 buffer
int read = fileChannel01.read(byteBuffer);
System.out.println("read = " + read);
if (read == -1) { //表示读完
break;
}
//将 buffer 中的数据写入到 fileChannel02--2.txt
byteBuffer.flip();
fileChannel02.write(byteBuffer);
}
//关闭相关的流
fileInputStream.close();
fileOutputStream.close();
}
}
应用实例4: transferFrom 方法实现拷贝文件
实例要求:
- 使用
FileChannel
(通道)和方法transferFrom
,完成文件的拷贝 - 拷贝一张图片
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.channels.FileChannel;
public class NIOFileChannel04 {
public static void main(String[] args) throws Exception {
//创建相关流
FileInputStream fileInputStream = new FileInputStream("d:\\a.jpg");
FileOutputStream fileOutputStream = new FileOutputStream("d:\\a2.jpg");
//获取各个流对应的 FileChannel
FileChannel sourceCh = fileInputStream.getChannel();
FileChannel destCh = fileOutputStream.getChannel();
//使用 transferForm 完成拷贝
destCh.transferFrom(sourceCh, 0, sourceCh.size());
//关闭相关通道和流
sourceCh.close();
destCh.close();
fileInputStream.close();
fileOutputStream.close();
}
}
4.5 关于 Buffer 和 Channel 注意事项和细节
ByteBuffer
支持类型化的put
和get
,put
放入的是什么数据类型,get
就应该使用相应的数据类型来取出,否则可能有BufferUnderflowException
异常。【举例说明】
import java.nio.ByteBuffer;
public class NIOByteBufferPutGet {
public static void main(String[] args) {
//创建一个 Buffer
ByteBuffer buffer = ByteBuffer.allocate(64);
//类型化方式放入数据
buffer.putInt(100);
buffer.putLong(9);
buffer.putChar('char');
buffer.putShort((short) 4);
//取出
buffer.flip();
System.out.println();
System.out.println(buffer.getInt());
System.out.println(buffer.getLong());
System.out.println(buffer.getChar());
System.out.println(buffer.getShort());
}
}
- 可以将一个普通
Buffer
转成只读Buffer
【举例说明】
import java.nio.ByteBuffer;
public class ReadOnlyBuffer {
public static void main(String[] args) {
//创建一个 buffer
ByteBuffer buffer = ByteBuffer.allocate(64);
for (int i = 0; i < 64; i++) {
buffer.put((byte) i);
}
//读取
buffer.flip();
//得到一个只读的 Buffer
ByteBuffer readOnlyBuffer = buffer.asReadOnlyBuffer();
System.out.println(readOnlyBuffer.getClass());
//读取
while (readOnlyBuffer.hasRemaining()) {
System.out.println(readOnlyBuffer.get());
}
readOnlyBuffer.put((byte) 100); //ReadOnlyBufferException
}
}
NIO
还提供了MappedByteBuffer
,可以让文件直接在内存(堆外的内存)中进行修改,而如何同步到文件由NIO
来完成。【举例说明】
import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
/*说明 1.MappedByteBuffer 可让文件直接在内存(堆外内存)修改,操作系统不需要拷贝一次*/
public class MappedByteBufferTest {
public static void main(String[] args) throws Exception {
RandomAccessFile randomAccessFile = new RandomAccessFile("1.txt", "rw");
//获取对应的通道
FileChannel channel = randomAccessFile.getChannel();
/**
* 参数 1:FileChannel.MapMode.READ_WRITE 使用的读写模式
* 参数 2:0:可以直接修改的起始位置
* 参数 3:5: 是映射到内存的大小(不是索引位置),即将 1.txt 的多少个字节映射到内存
* 可以直接修改的范围就是 0-5
* 实际类型 DirectByteBuffer
*/
MappedByteBuffer mappedByteBuffer = channel.map(FileChannel.MapMode.READ_WRITE, 0, 5);
mappedByteBuffer.put(0, (byte) 'H');
mappedByteBuffer.put(3, (byte) '9');
mappedByteBuffer.put(5, (byte) 'Y');//IndexOutOfBoundsException
randomAccessFile.close();
System.out.println("修改成功~~");
}
}
- 之前读写操作都是通过一个
Buffer
完成的,NIO
还支持通过多个Buffer
(即Buffer
数组)完成读写操作,即Scattering
和Gathering
【举例说明】
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Arrays;
/**
* Scattering:将数据写入到 buffer 时,可以采用 buffer 数组,依次写入 [分散]
* Gathering:从 buffer 读取数据时,可以采用 buffer 数组,依次读
*/
public class ScatteringAndGatheringTest {
public static void main(String[] args) throws Exception {
//使用 ServerSocketChannel 和 SocketChannel 网络
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
InetSocketAddress inetSocketAddress = new InetSocketAddress(7000);
//绑定端口到 socket,并启动
serverSocketChannel.socket().bind(inetSocketAddress);
//创建 buffer 数组
ByteBuffer[] byteBuffers = new ByteBuffer[2];
byteBuffers[0] = ByteBuffer.allocate(5);
byteBuffers[1] = ByteBuffer.allocate(3);
//等客户端连接 (telnet)
SocketChannel socketChannel = serverSocketChannel.accept();
int messageLength = 8; //假定从客户端接收 8 个字节
//循环的读取
while (true) {
int byteRead = 0;
while (byteRead < messageLength) {
long l = socketChannel.read(byteBuffers);
byteRead += l; //累计读取的字节数
System.out.println("byteRead = " + byteRead);
//使用流打印,看看当前的这个 buffer 的 position 和 limit
Arrays.asList(byteBuffers).stream().map(buffer -> "position = " + buffer.position() + ", limit = " + buffer.limit()).forEach(System.out::println);
}
//将所有的 buffer 进行 flip
Arrays.asList(byteBuffers).forEach(buffer -> buffer.flip());
//将数据读出显示到客户端
long byteWirte = 0;
while (byteWirte < messageLength) {
long l = socketChannel.write(byteBuffers);//
byteWirte += l;
}
//将所有的buffer进行clear
Arrays.asList(byteBuffers).forEach(buffer -> {
buffer.clear();
});
System.out.println("byteRead = " + byteRead + ", byteWrite = " + byteWirte + ", messagelength = " + messageLength);
}
}
}