Netty学习笔记（一）
一、Netty的简介
👍 Netty的官网
- Netty 是由 JBOSS 提供的一个 java 开源框架，现为 Github 上的独立项目。
- Netty 提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。
- Netty 是一个 NIO 客户端服务器框架，它支持协议服务器和客户端等网络应用程序的快速、简便开发。它极大地简化了网络编程，如 TCP 和 UDP 套接字服务器。
- Netty 主要针对在 TCP 协议下，面向 Client 端的高并发应用，或者 Peer-to-Peer 场景下的大量数据持续传输的应用。
- 要透彻理解 Netty，需要先学习 NIO，这样我们才能阅读 Netty 的源码。
简单体系图：
应用场景：
6. 互联网行业：在分布式系统中，各个节点之间需要远程服务调用，高性能的 RPC 框架必不可少，Netty 作为异步高性能的通信框架，往往作为基础通信组件被这些 RPC 框架使用。
典型应用：阿里分布式服务框架 Dubbo 的 RPC 框架使用 Dubbo 协议进行节点间通信，Dubbo 协议默认使用 Netty 作为基础通信组件，用于实现各进程节点之间的内部通信。
- 游戏行业：无论是手游服务端还是大型的网络游戏，Java 语言得到了越来越广泛的应用；地图服务器之间可以方便的通过 Netty 进行高性能的通信；Netty 作为高性能的基础通信组件，提供了 TCP/UDP 和 HTTP 协议栈，方便定制和开发私有协议栈，账号登录服务器。
- 大数据领域：经典的 Hadoop 的高性能通信和序列化组件 Avro(实现数据文件的共享) 的 RPC 框架，默认采用 Netty 进行跨界点通信；Avro 它的 Netty Service 基于 Netty 框架二次封装实现。
- 其它开源项目使用到 Netty：https://netty.io/wiki/related-projects.html
二、Java BIO 编程
2.1、I/O 模型
- I/O 模型简单的理解：就是用什么样的通道进行数据的发送和接收，很大程度上决定了程序通信的性能。
- Java 共支持 3 种网络编程模型 I/O 模式：BIO、NIO、AIO。
- Java BIO：同步并阻塞（传统阻塞型），服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销。【简单示意图】
- Java NIO：同步非阻塞，服务器实现模式为一个线程处理多个请求（连接），即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有 I/O 请求就进行处理。【简单示意图】
- Java AIO(NIO.2)：异步非阻塞，AIO 引入异步通道的概念，采用了 Proactor 模式，简化了程序编写，有效的请求才启动线程，它的特点是先由操作系统完成后才通知服务端程序启动线程去处理，一般适用于连接数较多且连接时间较长的应用。
2.2、BIO、NIO、AIO 适用场景分析
- BIO 方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4 以前的唯一选择，但程序简单易理解。
- NIO 方式适用于连接数目多且连接比较短（轻操作）的架构，比如聊天服务器，弹幕系统，服务器间通讯等。编程比较复杂，JDK1.4 开始支持。
- AIO 方式使用于连接数目多且连接比较长（重操作）的架构，比如相册服务器，充分调用 OS 参与并发操作，编程比较复杂，JDK7 开始支持。
2.3、Java BIO 基本介绍
- Java BIO 就是传统的 Java I/O 编程，其相关的类和接口在 java.io。
- BIO(Blocking I/O)：同步阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，可以通过线程池机制改善（实现多个客户连接服务器）。
- BIO 方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4 以前的唯一选择，程序简单易理解。
2.4、Java BIO 工作流程
- 服务器端启动一个 ServerSocket。
- 客户端启动 Socket 对服务器进行通信，默认情况下服务器端需要对每个客户建立一个线程与之通讯。
- 客户端发出请求后，先咨询服务器是否有线程响应，如果没有则会等待，或者被拒绝。
- 如果有响应，客户端线程会等待请求结束后，再继续执行。
2.5、Java 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;
/**
* @Description 同步阻塞实例
* @Author ZWP
* @Date 2022/9/28 17:54
*/
public class BIOServer {
public static void main(String[] args) throws Exception {
/*
* 线程池机制
* 思路
* 1. 创建一个线程池
* 2. 如果有客户连接，就创建一个线程，与之通讯（单独写一个方法）
*/
// 创建线程池
ExecutorService threadPool = 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("等待连接....");
// 会阻塞在accept()
final Socket socket = serverSocket.accept();
System.out.println("连接到了一个客户端！");
// 创建一个线程，与之通讯（单独写一个方法）
threadPool.execute(new Runnable() {
public void run() { // 重写run()方法
// 可以和客户端通讯
handler(socket);
}
});
}
}
// 编写一个handler方法，和客户端通讯
public static void handler(Socket socket) {
System.out.println("线程信息: id = " + Thread.currentThread().getId() + "; 名字 = " + Thread.currentThread().getName());
try {
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....");
// 会阻塞在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();
}
}
}
}
- 问题分析：
- 每个请求都需要创建独立的线程，与对应的客户端进行数据 Read，业务处理，数据 Write。
- 当并发数较大时，需要创建大量线程来处理连接，系统资源占用较大。
- 连接建立后，如果当前线程暂时没有数据可读，则线程就阻塞在 Read 操作上，造成线程资源浪费。
三、Java NIO 编程
3.1、Java NIO 基本介绍
- Java NIO 全称 Java non-blocking IO，是指 JDK 提供的新 API。从 JDK1.4 开始，Java 提供了一系列改进的输入/输出的新特性，被统称为 NIO（即 NewIO），是同步非阻塞的。
- NIO 相关类都被放在
java.nio包及子包下，并且对原 java.io 包中的很多类进行改写。 - NIO 有三大核心部分：Channel（通道）、Buffer（缓冲区）、Selector（选择器）。
- NIO 是面向缓冲区，或者面向块编程的。数据读取到一个它稍后处理的缓冲区，需要时可在缓冲区中前后移动，这就增加了处理过程中的灵活性，使用它可以提供非阻塞式的高伸缩性网络。
- Java NIO 的非阻塞模式，使一个线程从某通道发送请求或者读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取，而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。非阻塞写也是如此，一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。【后面有案例说明】
- 通俗理解：NIO 是可以做到用一个线程来处理多个操作的。假设有 10000 个请求过来，根据实际情况，可以分配 50 或者 100 个线程来处理。不像之前的阻塞 IO 那样，非得分配 10000 个。
- HTTP 2.0 使用了多路复用的技术，做到同一个连接并发处理多个请求，而且并发请求的数量比 HTTP 1.1 大了好几个数量级。
- 案例说明 NIO 的 Buffer：
import java.nio.IntBuffer;
/**
* @Description 基本缓冲区
* @Author ZWP
* @Date 2022/9/29 15:16
*/
public class BasicBuffer {
public static void main(String[] args) {
// 举例说明Buffer的使用（简单）
// 创建一个Buffer，大小为5，即可以存放5个int
IntBuffer intBuffer = IntBuffer.allocate(5);
// 向bugger中存放数据
for (int i = 0; i < intBuffer.capacity(); i++) {
intBuffer.put(i * 2);
}
// 如何从buffer中读取数据
// 将buffer转换，读写切换(!!!)
intBuffer.flip();
while (intBuffer.hasRemaining()) {
// 在此缓冲区的当前位置读取 int，然后递增该位置。
System.out.println(intBuffer.get());
}
}
}
3.2、NIO 和 BIO 的比较
- BIO 以流的方式处理数据，而 NIO 以块的方式处理数据，块 I/O 的效率比流 I/O 高很多。
- BIO 是阻塞的，NIO 则是非阻塞的。
- BIO 基于字节流和字符流进行操作，而 NIO 基于 Channel（通道）和 Buffer（缓冲区）进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。Selector（选择器）用于监听多个通道的事件（比如：连接请求，数据到达等），因此使用单个线程就可以监听多个客户端通道。
- Buffer 和 Channel 之间的数据流向是双向的
3.3、NIO 三大核心原理示意图
一张图描述 NIO 的 Selector、Channel 和 Buffer 的关系。
Selector、Channel 和 Buffer 关系图（简单版）
关系图的说明:
- 每个
Channel都会对应一个Buffer。 Selector对应一个线程，一个线程对应多个Channel（连接）。- 该图反应了有三个
Channel注册到该Selector - 程序切换到哪个
Channel是由事件决定的，Event就是一个重要的概念。 Selector会根据不同的事件，在各个通道上切换。Buffer就是一个内存块，底层是有一个数组。- 数据的读取/写入是通过
Buffer，这个和 BIO 是不同的，BIO 中要么是输入流，或者是输出流，不能双向，但是 NIO 的Buffer是可以读也可以写，需要flip方法切换。 Channel是双向的，可以返回底层操作系统的情况，比如 Linux，底层的操作系统通道就是双向的。
3.4、缓冲区（Buffer）
3.4.1、基本介绍
缓冲区（Buffer）：缓冲区本质上是一个可以读写数据的内存块，可以理解成是一个容器对象（含数组），该对象提供了一组方法，可以更轻松地使用内存块，缓冲区对象内置了一些机制，能够跟踪和记录缓冲区的状态变化情况。Channel 提供从文件、网络读取数据的渠道，但是读取或写入的数据都必须经由 Buffer，如图：
3.4.2、Buffer 类及其子类
- 在 NIO 中，
Buffer是一个顶层父类，它是一个抽象类，类的层级关系图：
Buffer类定义了所有的缓冲区都具有的四个属性来提供关于其所包含的数据元素的信息：
Buffer类相关方法一览
3.4.3、ByteBuffer
从前面可以看出对于 Java 中的基本数据类型（boolean 除外），都有一个 Buffer 类型与之相对应，最常用的自然是 ByteBuffer 类（二进制数据），该类的主要方法如下：
3.5、通道（Channel）
3.5.1、基本介绍
NIO的通道类似于流，但有些区别如下：- 通道可以同时进行读写，而流只能读或者只能写
- 通道可以实现异步读写数据
- 通道可以从缓冲读数据，也可以写数据到缓冲:
BIO中的Stream是单向的，例如FileInputStream对象只能进行读取数据的操作，而NIO中的通道（Channel）是双向的，可以读操作，也可以写操作。Channel在NIO中是一个接口public interface Channel extends Closeable{}- 常用的
Channel类有：FileChannel、DatagramChannel、ServerSocketChannel和SocketChannel。【ServerSocketChanne类似ServerSocket、SocketChannel类似Socket】 FileChannel用于文件的数据读写，DatagramChannel用于UDP的数据读写，ServerSocketChannel和SocketChannel用于TCP的数据读写。- 结构：
3.5.2、FileChannel 类
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)，把数据从当前通道复制给目标通道
3.5.3、应用实例1 - 本地文件写数据
实例要求：
- 使用前面学习到的
ByteBuffer（缓冲）和FileChannel（通道），将 “hello,尚硅谷” 写入到file01.txt中 - 文件不存在就创建
- 代码演示
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
/**
* @Description FileChannel应用实例01
* @Author ZWP
* @Date 2022/9/30 14:12
*/
public class NIOFileChannel01 {
public static void main(String[] args) throws Exception {
String str = "hello,尚硅谷";
// 创建一个输出流->channel
FileOutputStream fileOutputStream = new FileOutputStream("d:\\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();
}
}
3.5.4、应用实例2 - 本地文件读数据
实例要求：
- 使用前面学习后的
ByteBuffer（缓冲）和FileChannel（通道），将file01.txt中的数据读入到程序，并显示在控制台屏幕 - 假定文件已经存在
- 代码演示
import java.io.File;
import java.io.FileInputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
/**
* @Description FileChannel应用实例02-本地文件读数据
* @Author ZWP
* @Date 2022/9/30 14:39
*/
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.5.5、应用实例3 - 使用一个 Buffer 完成文件读取、写入
实例要求：
- 使用
FileChannel（通道）和方法read、write，完成文件的拷贝 - 拷贝一个文本文件
1.txt，放在项目下即可 - 代码演示
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
/**
* @Description 应用实例3 - 使用一个 Buffer 完成文件读取、写入
* @Author ZWP
* @Date 2022/9/30 15:03
*/
public class NIOFileChannel03 {
public static void main(String[] args) throws Exception {
// 创建文件输入输出流，并创建输入输出Channel
FileInputStream fileInputStream = new FileInputStream("1.txt");
FileChannel inputStreamChannel = fileInputStream.getChannel();
FileOutputStream fileOutputStream = new FileOutputStream("2.txt");
FileChannel outputStreamChannel = fileOutputStream.getChannel();
// 创建ByteBuffer
ByteBuffer byteBuffer = ByteBuffer.allocate(512);
// 循环读取
while (true) {
//这里有一个重要的操作，一定不要忘了
/*public final Buffer clear() {
position = 0;
limit = capacity;
mark = -1;
return this;
}*/
byteBuffer.clear(); // 清空buffer
int read = inputStreamChannel.read(byteBuffer);
System.out.println("read = " + read);
if (read == -1) { // 表示读完了
break;
}
// 将 buffer 中的数据写入到 outputStreamChannel
byteBuffer.flip();
outputStreamChannel.write(byteBuffer);
}
// 关闭输入输出流
fileOutputStream.close();
fileInputStream.close();
}
}
3.5.6、应用实例4 - 拷贝文件 transferFrom 方法
实例要求：
- 使用
FileChannel（通道）和方法transferFrom，完成文件的拷贝 - 拷贝一张图片
- 代码演示
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.channels.FileChannel;
/**
* @Description 应用实例4 - 拷贝文件 transferFrom 方法
* @Author ZWP
* @Date 2022/9/30 15:30
*/
public class NIOFileChannel04 {
public static void main(String[] args) throws Exception {
// 创建输入输出流
FileInputStream fileInputStream = new FileInputStream("d:\\a.jpg");
FileOutputStream fileOutputStream = new FileOutputStream("d:\\b.jpg");
// 获取对应的通道channel
FileChannel sourceChannel = fileInputStream.getChannel();
FileChannel targetChannel = fileOutputStream.getChannel();
// 使用 transferFrom 完成拷贝
targetChannel.transferFrom(sourceChannel, 0, sourceChannel.size());
// 关闭通道channel和流stream
sourceChannel.close();
targetChannel.close();
fileOutputStream.close();
fileInputStream.close();
}
}
3.5.7、关于 Buffer 和 Channel 的注意事项和细节
ByteBuffer支持类型化的put和get，put放入的是什么数据类型，get就应该使用相应的数据类型来取出，否则可能有BufferUnderflowException异常。
public class NIOByteBufferPutGet {
public static void main(String[] args) {
// 创建一个buffer
ByteBuffer buffer = ByteBuffer.allocate(64);
// 类型化方式放入数据
buffer.putInt(100);
buffer.putLong(9L);
buffer.putChar('尚');
buffer.putShort((short) 4);
// 取出
buffer.flip();
System.out.println(buffer.getInt());
System.out.println(buffer.getLong());
System.out.println(buffer.getChar());
System.out.println(buffer.getShort());
}
}
- 可以将一个普通
Buffer转成只读Buffer。
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());
}
// 因为只读，所以抛出异常ReadOnlyBufferException
readOnlyBuffer.put((byte) 100);
}
}
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 fileChannel = randomAccessFile.getChannel();
/**
* 参数 1: FileChannel.MapMode.READ_WRITE 使用的读写模式
* 参数 2: 0: 可以直接修改的起始位置
* 参数 3: 5: 是映射到内存的大小（不是索引位置），即将 1.txt 的多少个字节映射到内存
* 可以直接修改的范围就是 0-5
* 实际类型 DirectByteBuffer
*/
MappedByteBuffer mappedByteBuffer = fileChannel.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);
}
}
}
扫一扫
1088
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
