文章目录
1 Netty
1.1 Netty介绍
- Netty 是由 JBOSS 提供的一个 Java 开源框架
- Netty 是一个异步的、基于事件驱动的网络应用框架，用以快速开发高性能、高可靠性的网络IO程序
- Netty 主要针对在 TCP 协议下，面向 Clients 端的高并发应用，或者 Peer-to-Peer 场景下的大量数据持续传输的应用
- Netty 本质是一个 NIO 框架，适用于服务器通讯相关的多种应用场景
1.2 Netty应用场景
互联网行业
- 互联网行业：在分布式系统中，各个节点之间需要远程服务调用，高性能的 RPC 框架必不可少，Netty作为异步高性能的通信框架，往往作为基础通信组件被这些 RPC 框架使用
- 典型的应用有：阿里分布式服务框架 Dubbo 的 RPC 框架使用 Dubbo 协议进行节点间通信，Dubbo协议默认使用 Netty 作为基础通信组件，用于实现各进程节点之间的内部通信
游戏行业
- Netty 作为高性能的基础通信组件，提供了 TCP/UDP 和 HTTP 协议栈，方便定制和开发私有协议栈，账号登录服务器
- 地图服务器之间可以方便的通过 Netty 进行高性能的通信
大数据行业
- 经典的 Hadoop 的高性能通信和序列化组件 Avro 的 RPC 框架，默认采用 Netty 进行跨界点通信
- 它的 Netty Service 基于 Netty 框架二次封装实现。
2 Java BIO编程
2.1 IO模型
Java 共支持 3 种网络编程模型/IO 模式：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 BIO
BIO基本介绍
-
Java BIO 就是传统的 java io 编程，其相关的类和接口在 java.io
-
BIO(blocking I/O) ： 同步阻塞，服务器实现模式为一个连接一个线程
- 即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，可以通过线程池机制改善(实现多个客户连接服务器)
-
BIO 方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4以前的唯一选择，程序简单易理解
BIO 工作机制
BIO编程梳理
- 服务器端启动一个 ServerSocket
- 客户端启动 Socket 对服务器进行通信，默认情况下服务器端需要对每个客户 建立一个线程与之通讯
- 客户端发出请求后, 先咨询服务器是否有线程响应，如果没有则会等待，或者被拒绝
- 如果有响应，客户端线程会等待请求结束后，在继续执行
应用实例
需求
- 使用 BIO 模型编写一个服务器端，监听 6666 端口，当有客户端连接时，就启动一个线程与之通讯
- 要求使用线程池机制改善，可以连接多个客户端
- 服务器端可以接收客户端发送的数据(telnet 方式即可)
编码
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();
}
}
}
}
分析
- 每个请求都需要创建独立的线程，与对应的客户端进行数据 Read，业务处理数据 Write
- 当并发数较大时，需要创建大量线程来处理连接，系统资源占用较大
- 连接建立后，如果当前线程暂时没有数据可读，则线程就阻塞在 Read 操作上，造成线程资源浪费
3 Java NIO编程
3.1 NIO基本介绍
- Java NIO 全称 java non-blocking IO，是指 JDK 提供的新 API
- 从 JDK1.4 开始，Java 提供了一系列改进的输入/输出的新特性，被统称为 NIO(即 New IO)，是同步非阻塞的
- NIO 相关类都被放在 java.nio 包及子包下，并且对原 java.io 包中的很多类进行改写
- IO 有三大核心部分：Channel(通道)，Buffer(缓冲区), Selector(选择器)
- NIO 是面向缓冲区 ，或者面向块编程的。数据读取到一个它稍后处理的缓冲区，需要时可在缓冲区中前后移动，这就增加了处理过程中的灵活性，使用它可以提供非阻塞式的高伸缩性网络
- Java NIO 的非阻塞模式，使一个线程从某通道发送请求或者读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取，而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。 非阻塞写也是如此，一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情
- HTTP2.0 使用了多路复用的技术，做到同一个连接并发处理多个请求，而且并发请求的数量比HTTP1.1大了好几个数量级
3.2 NIO和BIO的比较
- BIO 以流的方式处理数据，而 NIO 以块的方式处理数据，块 I/O 的效率比流 I/O 高很多
- BIO 是阻塞的，NIO 则是非阻塞的
- BIO 基于字节流和字符流进行操作，而 NIO **基于 Channel(通道)和 Buffer(缓冲区)**进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。Selector(选择器)用于监听多个通道的事件（比如：连接请求，数据到达等），因此使用单个线程就可以监听多个客户端通道
3.3 NIO三大核心原理
Selector 、 Channel 和 Buffer 的关系图
- 每个 channel 都会对应一个 Buffer
- Selector 对应一个线程， 一个线程对应多个 channel(连接)
- 该图反应了有三个 channel 注册到该 selector //程序
- 程序切换到哪个 channel 是有事件决定的，Event 就是一个重要的概念
- Selector 会根据不同的事件，在各个通道上切换
- Buffer 就是一个内存块 ， 底层是有一个数组
- 数据的读取写入是通过 Buffer，这个和 BIO ，BIO 中要么是输入流，或者是输出流，不能双向，但是 NIO 的 Buffer 是可以读也可以写，需要 flip 方法切换 channel 是双向的，可以返回底层操作系统的情况，比如 Linux，底层的操作系统通道就是双向的
3.4 缓冲区Buffer
基本介绍
缓冲区本质上是一个可以读写数据的内存块，可以理解成是一个容器对象(含数组)，该对象提供了一组方法，可以更轻松地使用内存块，缓冲区对象内置了一些机制，能够跟踪和记录缓冲区的状态变化情况。Channel 提供从文件、网络读取数据的渠道，但是读取或写入的数据都必须经由Buffer
Buffer类及其子类
-
在 NIO 中，Buffer 是一个顶层父类，它是一个抽象类
-
Buffer 类定义了所有的缓冲区都具有的四个属性来提供关于其所包含的数据元素的信息:
private int mark = -1; private int position = 0; private int limit; private int capacity;属性 描述 Capacity 容量，即可以容纳的最大数据量；在缓冲区创建时被设定并且不能改变 Limit 表示缓冲区的当前终点，不能对缓冲区超过极限的位置进行读写操作。且极限是可以修改的 Position 位置，下一个要被读或写的元素的索引每次读写缓冲区数据时都会改变改值，为下次读写作准备 Mark 标记 -
Buffer 类相关方法
ByteBuffer
3.5 通道（Channel）
-
通道与流的区别
- 通道可以同时进行读写，而流只能读或者只能写
- 通道可以实现异步读写数据
- 通道可以从缓冲读数据，也可以写数据到缓冲
-
BIO 中的 stream 是单向的，而NIO 中的通道(Channel)是双向的，可以读操作，也可以写操作
-
Channel 在 NIO 中是一个接口
public interface Channel extends Closeable{} -
常 用 的 Channel 类 有 ： FileChannel 、 DatagramChannel 、 ServerSocketChannel 和SocketChannel 。【ServerSocketChanne 类似 ServerSocket , SocketChannel 类似 Socket】
-
FileChannel 用于文件的数据读写，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);// 把数据从当前通道复制给目标通道
Channel应用实例1–本地文件写数据
需求：使用ByteBuffer(缓冲) 和 FileChannel(通道)， 将 “hello,world” 写入到file.txt 中，文件不存在则创建
public class NIOFileChannel01 {
public static void main(String[] args) throws Exception{
String str = "hello,world";
// 创建一个输出流->channel
FileOutputStream fileOutputStream = new FileOutputStream("d:\\file.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();
}
}
Channel应用实例2–本地文件读数据
需求：使用ByteBuffer(缓冲) 和 FileChannel(通道)， 将 file.txt 中的数据读入到程序，并显示在控制台屏幕 (假定文件已经存在)
public class NIOFileChannel02 {
public static void main(String[] args) throws Exception {
// 创建文件的输入流
File file = new File("d:\\file.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();
}
}
Channel应用实例 3–使用一个 Buffer 完成文件读取、写入
需求：使用 FileChannel(通道) 和 方法 read , write，完成文件的拷贝
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();
}
}
Channel应用实例 4–拷贝文件 transferFrom 方法
需求：使用 FileChannel(通道) 和 方法 transferFrom ，完成文件的拷贝
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();
}
}
3.6 Selector 选择器
基本介绍
- Java 的 NIO，用非阻塞的 IO 方式。可以用一个线程，处理多个的客户端连接，就会使用到Selector
- Selector 能够检测多个注册的通道上是否有事件发生
- 注意:多个 Channel 以事件的方式可以注册到同一个Selector
- 如果有事件发生，便获取事件然后针对每个事件进行相应的处理。这样就可以只用一个单线程去管理多个通道，也就是管理多个连接和请求
- 只有在 连接/通道 真正有读写事件发生时，才会进行读写，就大大地减少了系统开销，并且不必为每个连接都创建一个线程，不用去维护多个线程
- 避免了多线程之间的上下文切换导致的开销
Selector示意图
- Netty 的 IO 线程 NioEventLoop 聚合了 Selector(选择器，也叫多路复用器)，可以同时并发处理成百上千个客户端连接
- 当线程从某客户端 Socket 通道进行读写数据时，若没有数据可用时，该线程可以进行其他任务
- 线程通常将非阻塞 IO 的空闲时间用于在其他通道上执行 IO 操作，所以单独的线程可以管理多个输入和输出通道
- 由于读写操作都是非阻塞的，这就可以充分提升 IO 线程的运行效率，避免由于频繁I/O 阻塞导致的线程挂起
- 一个 I/O 线程可以并发处理 N 个客户端连接和读写操作，这从根本上解决了传统同步阻塞I/O一连接一线程模型，架构的性能、弹性伸缩能力和可靠性都得到了极大的提升
API
3.7 NIO非阻塞网络编程原理
Selector、SelectionKey、ServerScoketChannel 和 SocketChannel 关系梳理
- 客户端连接时，会通过 ServerSocketChannel 得到 SocketChannel
- Selector 进行监听 select 方法, 返回有事件发生的通道的个数
- 将 socketChannel 注册到 Selector 上, register(Selector sel, int ops), 一个 selector 上可以注册多个SocketChannel
- 注册后返回一个 SelectionKey, 会和该 Selector 关联(集合)
- 进一步得到各个 SelectionKey (有事件发生)
- 在通过 SelectionKey 反向获取 SocketChannel , 方法 channel()
- 可以通过 得到的 channel , 完成业务处理
需求：
- 编写一个 NIO 案例，实现服务器端和客户端之间的数据简单通讯（非阻塞）
- 目的：理解 NIO 非阻塞网络编程机制
public class NIOServer {
public static void main(String[] args) throws Exception{
// 创建 ServerSocketChannel -> ServerSocket
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
// 得到一个 Selecor 对象
Selector selector = Selector.open();
// 绑定一个端口 6666, 在服务器端监听
serverSocketChannel.socket().bind(new InetSocketAddress(6666));
// 设置为非阻塞
serverSocketChannel.configureBlocking(false);
// 把 serverSocketChannel 注册到 selector 关系事件为 OP_ACCEPT
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
// 循环等待客户端连接
while (true) {
// 等待1秒，如果没有事件发生, 返回
if(selector.select(1000) == 0) { // 没有事件发生
System.out.println("服务器等待了 1 秒，无连接");
continue;
}
// 如果返回的>0, 就获取到相关的 selectionKey 集合
// 1.如果返回的>0， 表示已经获取到关注的事件
// 2. selector.selectedKeys() 返回关注事件的集合
// 通过 selectionKeys 反向获取通道
Set<SelectionKey> selectionKeys = selector.selectedKeys();
// 遍历 Set<SelectionKey>, 使用迭代器遍历
Iterator<SelectionKey> keyIterator = selectionKeys.iterator();
while (keyIterator.hasNext()) {
// 获取到 SelectionKey
SelectionKey key = keyIterator.next();
// 根据 key 对应的通道发生的事件做相应处理
if(key.isAcceptable()) { // 如果是 OP_ACCEPT, 有新的客户端连接
// 该该客户端生成一个 SocketChannel
SocketChannel socketChannel = serverSocketChannel.accept();
System.out.println(" 客 户 端 连 接 成 功 生 成 了 一个socketChannel "+socketChannel.hashCode());
// 将 SocketChannel 设置为非阻塞
socketChannel.configureBlocking(false);
// 将 socketChannel 注册到 selector, 关注事件为 OP_READ， 同时给socketChannel
// 关联一个 Buffer
socketChannel.register(selector, SelectionKey.OP_READ, ByteBuffer.allocate(1024));
}
if(key.isReadable()) { // 发生 OP_READ
// 通过 key 反向获取到对应 channel
SocketChannel channel = (SocketChannel)key.channel();
// 获取到该 channel 关联的 buffer
ByteBuffer buffer = (ByteBuffer)key.attachment();
channel.read(buffer);
System.out.println("form 客户端 " + new String(buffer.array()));
}
// 手动从集合中移动当前的 selectionKey, 防止重复操作
keyIterator.remove();
}
}
}
public class NIOClient {
public static void main(String[] args) throws Exception{
// 得到一个网络通道
SocketChannel socketChannel = SocketChannel.open();
// 设置非阻塞
socketChannel.configureBlocking(false);
// 提供服务器端的 ip 和 端口
InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 6666);
// 连接服务器
if (!socketChannel.connect(inetSocketAddress)) {
while (!socketChannel.finishConnect()) {
System.out.println("因为连接需要时间，客户端不会阻塞，可以做其它工作..");
}
}
// ...如果连接成功，就发送数据
String str = "hello, 尚硅谷~";
// Wraps a byte array into a buffer
ByteBuffer buffer = ByteBuffer.wrap(str.getBytes());
// 发送数据，将 buffer 数据写入 channel
socketChannel.write(buffer);
System.in.read();
}
}
3.8 SelectionKey
SelectionKey，表示 Selector 和网络通道的注册关系, 共四种
int OP_ACCEPT：有新的网络连接可以 accept，值为 16
int OP_CONNECT：代表连接已经建立，值为 8
int OP_READ：代表读操作，值为 1
int OP_WRITE：代表写操作，值为 4
public static final int OP_READ = 1 << 0;
public static final int OP_WRITE = 1 << 2;
public static final int OP_CONNECT = 1 << 3;
public static final int OP_ACCEPT = 1 << 4;
3.9 ServerSocketChannel
ServerSocketChannel 在服务器端监听新的客户端 Socket 连接
3.10 SocketChannel
SocketChannel，网络 IO 通道，具体负责进行读写操作。NIO 把缓冲区的数据写入通道，或者把通道里的数据读到缓冲区
3.11 NIO网络编程应用–搭建群聊系统
需求
- 编写一个 NIO 群聊系统，实现服务器端和客户端之间的数据简单通讯（非阻塞）
- 实现多人群聊
- 服务器端：可以监测用户上线，离线，并实现消息转发功能
- 客户端：通过 channel 可以无阻塞发送消息给其它所有用户，同时可以接受其它用户发送的消息(有服务器转发得到)
- 目的：进一步理解 NIO 非阻塞网络编程机制
思路：
- 先编写服务器端
- 服务器端自动监听 6667
- 服务器接受客户端信息，并实现转发[处理上线和离线]
- 然后编写客户端
- 连接服务器
- 发送消息
- 接受服务器消息
package com.cyan.nio.chatonline;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
/**
* Server
*
* @author Cyan Chau
* @create 2022-12-18
*/
public class GroupChatServer {
private Selector selector;
private ServerSocketChannel listenChannel;
private static final int PORT = 6667;
public GroupChatServer() {
try {
// 选择器
selector = Selector.open();
listenChannel = ServerSocketChannel.open();
// 绑定端口
listenChannel.socket().bind(new InetSocketAddress(PORT));
// 设置非阻塞模式
listenChannel.configureBlocking(false);
// 将channel注册到selector
listenChannel.register(selector, SelectionKey.OP_ACCEPT);
} catch (IOException e) {
e.printStackTrace();
}
}
// 监听
public void listen() {
try {
// 循环处理
while (true) {
int count = selector.select(2000);
if (count > 0) { // 有事件处理
// SelectionKey集合
Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
while (iterator.hasNext()) {
SelectionKey key = iterator.next();
// 监听到accept
if (key.isAcceptable()) {
SocketChannel socketChannel = listenChannel.accept();
// 将socketChannel注册到selector
socketChannel.register(selector, SelectionKey.OP_READ);
// 提示
System.out.println(socketChannel.getRemoteAddress() + "上线");
}
if (key.isReadable()) { // 通道发送 read 事件，即通道是可读的状态//处理读 (专门写方法..)
readData(key);
}
// 当前的 key 删除，防止重复处理
iterator.remove();
}
} else {
System.out.println("等待....");
}
}
} catch (Exception e) {
e.printStackTrace();
} finally {
}
}
// 读取客户端消息
private void readData(SelectionKey key) {
// 取到关联的 channle
SocketChannel channel = null;
try {
// 得到 channel
channel = (SocketChannel) key.channel();
// 创建 buffer
ByteBuffer buffer = ByteBuffer.allocate(1024);
int count = channel.read(buffer);
// 根据 count 的值做处理
if (count > 0) {
// 把缓存区的数据转成字符串
String msg = new String(buffer.array());
// 输出该消息
System.out.println("form 客户端: " + msg);
// 向其它的客户端转发消息(去掉自己), 专门写一个方法来处理
sendInfoToOtherClients(msg, channel);
}
} catch (IOException e) {
try {
System.out.println(channel.getRemoteAddress() + " 离线了..");
// 取消注册
key.cancel();
// 关闭通道
channel.close();
} catch (IOException e2) {
e2.printStackTrace();
}
}
}
// 转发消息给其它客户(通道)
private void sendInfoToOtherClients(String msg, SocketChannel self) throws IOException {
System.out.println("服务器转发消息中...");
// 遍历 所有注册到 selector 上的 SocketChannel,并排除 self
for (SelectionKey key : selector.keys()) {
// 通过 key 取出对应的 SocketChannel
Channel targetChannel = key.channel();
// 排除自己
if (targetChannel instanceof SocketChannel && targetChannel != self) {
// 转型
SocketChannel dest = (SocketChannel) targetChannel;
// 将 msg 存储到 buffer
ByteBuffer buffer = ByteBuffer.wrap(msg.getBytes());
}
}
}
public static void main(String[] args) {
// 创建服务器对象
GroupChatServer groupChatServer = new GroupChatServer();
groupChatServer.listen();
}
}
package com.cyan.nio.chatonline;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Scanner;
/**
* Client
*
* @author Cyan Chau
* @create 2022-12-18
*/
public class GroupChatClient {
private final String HOST = "127.0.0.1"; // 服务器的 ip
private final int PORT = 6667; //服务器端口
private Selector selector;
private SocketChannel socketChannel;
private String username;
// 构造器, 完成初始化工作
public GroupChatClient() throws IOException {
selector = Selector.open();
// 连接服务器
socketChannel = socketChannel.open(new InetSocketAddress("127.0.0.1", PORT));
// 设置非阻塞
socketChannel.configureBlocking(false);
// 将 channel 注册到 selector
socketChannel.register(selector, SelectionKey.OP_READ);
// 得到 username
username = socketChannel.getLocalAddress().toString().substring(1);
System.out.println(username + " is ok...");
}
// 向服务器发送消息
public void sendInfo(String info) {
info = username + " 说：" + info;
try {
socketChannel.write(ByteBuffer.wrap(info.getBytes()));
} catch (IOException e) {
e.printStackTrace();
}
}
// 读取从服务器端回复的消息
public void readInfo() {
try {
int readChannels = selector.select();
if (readChannels > 0) {// 有可以用的通道
Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
while (iterator.hasNext()) {
SelectionKey key = iterator.next();
if (key.isReadable()) {
// 得到相关的通道
SocketChannel sc = (SocketChannel) key.channel();
// 得到一个 Buffer
ByteBuffer buffer = ByteBuffer.allocate(1024);
// 读取
sc.read(buffer);
// 把读到的缓冲区的数据转成字符串
String msg = new String(buffer.array());
System.out.println(msg.trim());
}
}
iterator.remove(); // 删除当前的 selectionKey, 防止重复操作
} else {
// System.out.println("没有可以用的通道...");
}
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws Exception{
// 启动我们客户端
GroupChatClient chatClient = new GroupChatClient();
// 启动一个线程, 每个 3 秒，读取从服务器发送数据
new Thread() {
public void run() {
while (true) {
chatClient.readInfo();
try {
Thread.currentThread().sleep(3000);
}catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}.start();
// 发送数据给服务器端
Scanner scanner = new Scanner(System.in);
while (scanner.hasNextLine()) {
String s = scanner.nextLine();
chatClient.sendInfo(s);
}
}
}
3.12 零拷贝
传统IO模型
read ：磁盘–>内核缓冲区–>用户缓冲区
write：socket缓冲区–>网卡设备
-
用户空间的应用程序通过
read()函数，向操作系统发起IO调用，上下文从用户态到切换到内核态，然后再通过 DMA 控制器将数据从磁盘文件中读取到内核缓冲区 -
接着CPU将内核空间缓冲区的数据拷贝到用户空间的数据缓冲区，然后read系统调用返回，而系统调用的返回又会导致上下文从内核态切换到用户态
-
用户空间的应用程序通过
write()函数向操作系统发起IO调用，上下文再次从用户态切换到内核态；接着CPU将数据从用户缓冲区复制到内核空间的 socket 缓冲区（也是内核缓冲区，只不过是给socket使用），然后write系统调用返回，再次触发上下文切换 -
最后异步传输socket缓冲区的数据到网卡，也就是说write系统调用的返回并不保证数据被传输到网卡
在传统的数据 IO 模式中，读取一个磁盘文件，并发送到远程端的服务，就共有四次用户空间与内核空间的上下文切换，四次数据复制，包括两次 CPU 数据复制，两次 DMA 数据复制
但两次 CPU 数据复制才是最消耗资源和时间的，这个过程还需要内核态和用户态之间的来回切换，而CPU资源十分宝贵，要拷贝大量的数据，还要处理大量的任务
解决思路：
如果能把 CPU 的这两次拷贝给去除掉，既能节省CPU资源，还可以避免内核态和用户态之间的切换。而零拷贝技术就是为了解决这个问题
零拷贝概念
零拷贝指在进行数据 IO 时，数据在用户态下经历了零次 CPU 拷贝，并非不拷贝数据。
通过减少数据传输过程中内核缓冲区和用户进程缓冲区间不必要的CPU数据拷贝与用户态和内核态的上下文切换次数，降低 CPU 在这两方面的开销，释放 CPU 执行其他任务，更有效的利用系统资源，提高传输效率，同时还减少了内存的占用，也提升应用程序的性能。
缺点： 不允许进程对文件内容作一些加工再发送，比如数据压缩后再发送。
零拷贝演化
mmap+write实现的零拷贝
#include <sys/mman.h>
void *mmap(void *start, size_t length, int prot, int flags, int fd, off_t offset)
-
在传统 IO 模式的4次内存拷贝中，与物理设备相关的2次拷贝（把磁盘数据拷贝到内存 以及 把数据从内存拷贝到网卡）是必不可少的。
-
但与用户缓冲区相关的2次拷贝都不是必需的
-
如果内核在读取文件后，直接把内核缓冲区中的内容拷贝到 Socket 缓冲区，待到网卡发送完毕后，再通知进程，这样就可以减少一次 CPU 数据拷贝
内存映射mmp实现方式
它的核心就是操作系统把内核缓冲区与应用程序共享，将一段用户空间内存映射到内核空间，当映射成功后，用户对这段内存区域的修改可以直接反映到内核空间；同样地，内核空间对这段区域的修改也直接反映用户空间。正因为有这样的映射关系, 就不需要在用户态与内核态之间拷贝数据， 提高了数据传输的效率，这就是内存直接映射技术
-
应用程序通过 mmap() 向操作系统发起 IO调用，上下文从用户态切换到内核态；然后通过 DMA 将数据从磁盘中复制到内核空间缓冲区
-
mmap 系统调用返回，上下文从内核态切换回用户态（这里不需要将数据从内核空间复制到用户空间，因为用户空间和内核空间共享了这个缓冲区）
-
用户应用程序通过 write() 向操作系统发起 IO调用，上下文再次从用户态切换到内核态。接着 CPU 将数据从内核空间缓冲区复制到内核空间 socket 缓冲区；write 系统调用返回，导致内核空间到用户空间的上下文切换
-
DMA 异步将 socket 缓冲区中的数据拷贝到网卡
mmap 的零拷贝 I/O 进行了4次用户空间与内核空间的上下文切换，以及3次数据拷贝；其中3次数据拷贝中包括了2次 DMA 拷贝和1次 CPU 拷贝。所以 mmap 通过内存地址映射的方式，节省了数据IO过程中的一次CPU数据拷贝以及一半的内存空间
sendfile实现的零拷贝 LInux2.1版本
只要我们的代码执行 read 或者 write 这样的系统调用，一定会发生 2 次上下文切换：首先从用户态切换到内核态，当内核执行完任务后，再切换回用户态交由进程代码执行
因此，如果想减少上下文切换次数，就一定要减少系统调用的次数
解决方案
把 read、write 两次系统调用合并成一次，在内核中完成磁盘与网卡的数据交换。
- 用户应用程序发出 sendfile 系统调用，上下文从用户态切换到内核态；然后通过 DMA 控制器将数据从磁盘中复制到内核缓冲区中
- 然后CPU将数据从内核空间缓冲区复制到 socket 缓冲区
- sendfile 系统调用返回，上下文从内核态切换到用户态
- DMA 异步将内核空间 socket 缓冲区中的数据传递到网卡
通过 sendfile 实现的零拷贝I/O使用了2次用户空间与内核空间的上下文切换，以及3次数据的拷贝。其中3次数据拷贝中包括了2次DMA拷贝和1次CPU拷贝
带 DMA 收集拷贝功能的 sendfile 实现的零拷贝 Linux2.4版本
引入了 SG-DMA技术，其实就是对DMA拷贝加入 scatter/gather 操作，它可以直接从内核空间缓冲区中将数据读取到网卡，无需将内核空间缓冲区的数据再复制一份到 socket 缓冲区，从而省去一次 CPU拷贝。
- 用户应用程序发出 sendfile 系统调用，上下文从用户态切换到内核态；然后通过 DMA 控制器将数据从磁盘中复制到内核缓冲区中
- 接下来不需要CPU将数据复制到 socket 缓冲区，而是将相应的文件描述符信息复制到 socket 缓冲区，该描述符包含了两种的信息：①内核缓冲区的内存地址、②内核缓冲区的偏移量
- sendfile 系统调用返回，上下文从内核态切换到用户态
- DMA 根据 socket 缓冲区中描述符提供的地址和偏移量直接将内核缓冲区中的数据复制到网卡
带有 DMA 收集拷贝功能的 sendfile 实现的 I/O 使用了2次用户空间与内核空间的上下文切换，以及2次数据的拷贝，而且这2次的数据拷贝都是非CPU拷贝
mmap 和 sendFile 的区别
- mmap 适合小数据量读写，sendFile 适合大文件传输
- mmap 需要 4 次上下文切换，3 次数据拷贝；sendFile 需要 3 次上下文切换，最少2 次数据拷贝
- sendFile 可以利用 DMA 方式，减少 CPU 拷贝，mmap 则不能（必须从内核拷贝到Socket 缓冲区）
应用场景
NIO：mmap + write 的零拷贝方式
FileChannel 的 map() 方法产生的 MappedByteBuffer：FileChannel 提供 map() 方法，该方法可以在一个打开的文件和 MappedByteBuffer 之间建立一个虚拟内存映射，MappedByteBuffer 继承于 ByteBuffer；该缓冲器的内存是一个文件的内存映射区域。
map() 方法底层是通过 mmap 实现的，因此将文件内存从磁盘读取到内核缓冲区后，用户空间和内核空间共享该缓冲区
FileChannel readChannel = FileChannel.open(Paths.get("./jay.txt"), StandardOpenOption.READ);
MappedByteBuffer data = readChannel.map(FileChannel.MapMode.READ_ONLY, 0, 1024 * 1024 * 40);
FileChannel writeChannel = FileChannel.open(Paths.get("./siting.txt"), StandardOpenOption.WRITE, StandardOpenOption.CREATE);
// 数据传输
writeChannel.write(data);
readChannel.close();
writeChannel.close();
NIO： sendfile 的零拷贝方式：
FileChannel 的 transferTo、transferFrom 如果操作系统底层支持的话，transferTo、transferFrom也会使用 sendfile 零拷贝技术来实现数据的传输
@Override
public long transferFrom(FileChannel fileChannel, long position, long count) throws IOException {
return fileChannel.transferTo(position, count, socketChannel);
}
FileChannel readChannel = FileChannel.open(Paths.get("./jay.txt"), StandardOpenOption.READ);
long len = readChannel.size();
long position = readChannel.position();
FileChannel writeChannel = FileChannel.open(Paths.get("./siting.txt"), StandardOpenOption.WRITE, StandardOpenOption.CREATE);
//数据传输
readChannel.transferTo(position, len, writeChannel);
readChannel.close();
writeChannel.close();
Netty
在网络通信上，Netty 的接收和发送 ByteBuffer 采用直接内存，使用堆外直接内存进行 Socket 读写，不需要进行字节缓冲区的二次拷贝。如果使用传统的堆内存进行 Socket 读写，JVM 会将堆内存 Buffer 拷贝一份到直接内存中（为什么拷贝？因为 JVM 会发生 GC 垃圾回收，数据的内存地址会发生变化，直接将堆内的内存地址传给内核，内存地址一旦变了就内核读不到数据了），然后才写入 Socket 中。相比于堆外直接内存，消息在发送过程中多了一次缓冲区的内存拷贝。
在文件传输上，Netty 的通过 FileRegion 包装的 FileChannel.tranferTo 实现文件传输，它可以直接将文件缓冲区的数据发送到目标 Channel，避免了传统通过循环 write 方式导致的内存拷贝问题。
在缓存操作上，Netty 提供了CompositeByteBuf 类，它可以将多个 ByteBuf 合并为一个逻辑上的 ByteBuf，避免了各个 ByteBuf 之间的拷贝
通过 wrap 操作，我们可以将byte[]数组、ByteBuf、ByteBuffer等包装成一个Netty ByteBuf对象，进而避免了拷贝操作 ByteBuf 支持 slice 操作，因此可以将 ByteBuf 分解为多个共享同一个存储区域的 ByteBuf，避免了内存的拷贝。
ByteBuf 支持 slice 操作，因此可以将 ByteBuf 分解为多个共享同一个存储区域的 ByteBuf，避免了内存的拷贝
3.13 AIO
- JDK 7 引入了 Asynchronous I/O，即 AIO。在进行 I/O 编程中，常用到两种模式：Reactor 和Proactor。Java的NIO 就是 Reactor，当有事件触发时，服务器端得到通知，进行相应的处理
- AIO 即 NIO2.0，叫做异步不阻塞的 IO。AIO 引入异步通道的概念，采用了 Proactor 模式，简化了程序编写，有效的请求才启动线程，它的特点是先由操作系统完成后才通知服务端程序启动线程去处理，一般适用于连接数较多且连接时间较长的应用
3.14 BIO、NIO、AIO对比
| BIO | NIO | AIO | |
|---|---|---|---|
| IO模型 | 同步阻塞 | 同步非阻塞（多路复用） | 异步非阻塞 |
| 编程难度 | 简单 | 复杂 | 复杂 |
| 可靠性 | 差 | 好 | 好 |
| 吞吐量 | 低 | 高 | 高 |
4 Netty概述
Netty 对 JDK 自带的 NIO 的 API 进行了封装
-
设计优雅
- 适用于各种传输类型的统一 API 阻塞和非阻塞 Socket
- 基于灵活且可扩展的事件模型，可以清晰地分离关注点
- 高度可定制的线程模型 - 单线程，一个或多个线程池.
-
使用方便
- 详细记录的 Javadoc，用户指南和示例
- 没有其他依赖项
-
性能、吞吐量更高
- 延迟更低；减少资源消耗
- 最小化不必要的内存复制。
-
安全
- 完整的 SSL/TLS 和 StartTLS 支持
5 Netty高性能架构设计
目前线程模型
传统阻塞IO服务模型
Reactor模式
- 单 Reactor 单线程
- 单 Reactor 多线程
- 主从 Reactor 多线程
5.1 传统阻塞I/O服务模型
模型特点
- 采用阻塞 IO 模式获取输入的数据
- 每个连接都需要独立的线程完成数据的输入，业务处理, 数据返回
存在问题
- 当并发数很大，就会创建大量的线程，占用很大系统资源
- 连接创建后，如果当前线程暂时没有数据可读，该线程 会阻塞在 read 操作，造成线程资源浪费
5.2 Reactor模式
针对传统阻塞 I/O 服务模型的 2 个缺点，解决方案：
- 基于 I/O 复用模型
- 多个连接共用一个阻塞对象，应用程序只需要在一个阻塞对象等待，无需阻塞等待所有连接。
- 当某个连接有新的数据可以处理时，操作系统通知应用程序，线程从阻塞状态返回，开始进行业务处理
- 基于线程池复用线程资源
- 不必再为每个连接创建线程，将连接完成后的业务处理任务分配给线程进行处理，一个线程可以处理多个连接的业务。
复用结合线程池，就是 Reactor 模式基本设计思想
- Reactor 模式，通过一个或多个输入同时传递给服务处理器的模式(基于事件驱动)
- 服务器端程序处理传入的多个请求，并将它们同步分派到相应的处理线程， 因此Reactor 模式也叫Dispatcher模式
- Reactor 模式使用 IO 复用监听事件，收到事件后，分发给某个线程(进程),，这点就是网络服务器高并发处理关键
Reactor 模式中 核心组成
Reactor：
在一个单独的线程中运行，负责监听和分发事件，分发给适当的处理程序来对IO事件做出反应。
Handlers：
处理程序执行 I/O 事件要完成的实际事件，Reactor通过调度适当的处理程序来响应 I/O 事件，处理程序执行非阻塞操作。
5.3 单 Reactor 单线程
解释：
- Select 是前面 I/O 复用模型介绍的标准网络编程 API，可以实现应用程序通过一个阻塞对象监听多路连接请求
- Reactor 对象通过 Select 监控客户端请求事件，收到事件后通过 Dispatch 进行分发
- 如果是建立连接请求事件，则由 Acceptor 通过 Accept 处理连接请求，然后创建一个Handler 对象处理连接完成后的后续业务处理
- 如果不是建立连接事件，则 Reactor 会分发调用连接对应的 Handler 来响应
- Handler 会完成 Read→业务处理→Send 的完整业务流程
优点
模型简单，没有多线程、进程通信、竞争的问题，全部都在一个线程中完成
缺点
- 性能问题，只有一个线程，无法完全发挥多核 CPU 的性能。Handler 在处理某个连接上的业务时，整个进程无法处理其他连接事件，很容易导致性能瓶颈
- 可靠性问题，线程意外终止，或者进入死循环，会导致整个系统通信模块不可用，不能接收和处理外部消息，造成节点故障
使用场景
客户端的数量有限，业务处理非常快速，比如 Redis 在业务处理的时间复杂度O(1) 的情况
5.4 单 Reactor 多线程
解释
- Reactor 对象通过 select 监控客户端请求 事件，收到事件后，通过 dispatch 进行分发
- 如果建立连接请求, 则右 Acceptor 通过 accept 处理连接请求, 然后创建一个 Handler 对象处理完成连接后的各种事件
- 如果不是连接请求，则由 reactor 分发调用连接对应的 handler 来处理
- handler 只负责响应事件，不做具体的业务处理，通过 read 读取数据后，会分发给后面的worker 线程池的某个线程处理业务
- worker 线程池会分配独立线程完成真正的业务，并将结果返回给 handler
- handler 收到响应后，通过 send 将结果返回给 client
优点
充分利用多核 cpu 的处理能力
缺点
多线程数据共享和访问比较复杂， reactor 处理所有的事件的监听和响应，在单线程运行，在高并发场景容易出现性能瓶颈
5.5 主从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
优点
- 父线程与子线程的数据交互简单职责明确，父线程只需要接收新连接，子线程完成后续的业务处理
- 父线程与子线程的数据交互简单，Reactor 主线程只需要把新连接传给子线程，子线程无需返回数据
缺点
- 编程复杂度较高
总结
Reactor模式优点
- 响应快，不必为单个同步时间所阻塞，虽然 Reactor 本身依然是同步的
- 可以最大程度的避免复杂的多线程及同步问题，并且避免了多线程/进程的切换开销
- 扩展性好，可以方便的通过增加 Reactor 实例个数来充分利用 CPU 资源
- 复用性好，Reactor 模型本身与具体事件处理逻辑无关，具有很高的复用性
5.6 Netty模型
工作原理
-
Netty 抽象出两组线程池 BossGroup 专门负责接收客户端的连接, WorkerGroup 专门负责网络的读写
- BossGroup 和 WorkerGroup 类型都是NioEventLoopGroup
- NioEventLoopGroup 相当于一个事件循环组，这个组中含有多个事件循环 ，每一个事件循环是NioEventLoop
- NioEventLoopGroup 可以有多个线程，即可以含有多个 NioEventLoop
-
NioEventLoop 表示一个不断循环的执行处理任务的线程， 每个 NioEventLoop 都有一个selector ，用于监听绑定在其上的 socket 的网络通讯
-
每个 Boss NioEventLoop 循环执行的步骤
-
A. 轮询accept事件
-
B. 处理 accept 事件，与 client 建立连接，生成 NioScocketChannel，并将其注册到某个worker NIOEventLoop上的 selector
-
C. 处理任务队列的任务 ， 即 runAllTasks
-
-
每个 Worker NIOEventLoop 循环执行的步骤
- A. 轮询 read/write 事件
- B. 处理 i/o 事件， 即 read/write 事件，在对应 NioScocketChannel 处理
- C. 处理任务队列的任务 ， 即 runAllTasks
-
每个Worker NIOEventLoop 处理业务时，会使用pipeline(管道)，pipeline 中包含了channel，即通过pipeline可以获取到对应通道，管道中维护了很多的 处理器
快速入门
案例：
- Netty 服务器在 6668 端口监听，客户端能发送消息给服务器 “hello, 服务器~”
- 服务器可以回复消息给客户端 “hello, 客户端~”
服务端
NettyServer
public class NettyServer {
public static void main(String[] args) throws InterruptedException {
// 创建BossGroup和WorkGroup
/*
* 1. 创建两个线程组BossGroup和WorkGroup
* 2. BossGroup仅处理连接请求，WorkGroup处理业务
* 3. 两个都是无线循环
*/
EventLoopGroup bossGroup = new NioEventLoopGroup();
EventLoopGroup workGroup = new NioEventLoopGroup();
try {
// 创建服务器的启动对象
ServerBootstrap bootstrap = new ServerBootstrap();
// 配置参数
bootstrap.group(bossGroup, workGroup) // 设置线程组
.channel(NioServerSocketChannel.class) // 使用NioSocketChannel作为服务器的通道实现
.option(ChannelOption.SO_BACKLOG, 128) // 设置线程队列等待连接个数
.childOption(ChannelOption.SO_KEEPALIVE, true) // 设置保持活动连接状态
.childHandler(new ChannelInitializer<SocketChannel>() { // 通道初始化对象
// 给通道设置处理器
@Override
protected void initChannel(SocketChannel socketChannel) {
socketChannel.pipeline().addLast(new NettyServerHandler());
}
}); // 给workGroup的EventGroup对应的管道设置处理器
System.out.println("服务器已经准备就绪");
ChannelFuture channelFuture = bootstrap.bind(6668).sync();
channelFuture.channel().closeFuture().sync();
} finally {
bossGroup.shutdownGracefully();
workGroup.shutdownGracefully();
}
}
}
NettyServerHandler
public class NettyServerHandler extends ChannelInboundHandlerAdapter {
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
System.out.println("server ctx = " + ctx);
ByteBuf buf = (ByteBuf)msg;
System.out.println("客户端发送消息是: " + buf.toString(CharsetUtil.UTF_8));
System.out.println("客户端地址: " + ctx.channel().remoteAddress());
}
@Override
public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
ctx.writeAndFlush(Unpooled.copiedBuffer("hello，客户端~", CharsetUtil.UTF_8));
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
ctx.close();
}
}
客户端
NettyClient
public class NettyClient {
public static void main(String[] args) throws InterruptedException {
// 事件循环组
EventLoopGroup eventExecutors = new NioEventLoopGroup();
try {
// 客户端启动对象
Bootstrap bootstrap = new Bootstrap();
// 设置参数
bootstrap.group(eventExecutors) // 设置线程组
.channel(NioSocketChannel.class) // 设置客户端通道的实现类
.handler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel socketChannel) {
socketChannel.pipeline().addLast(new NettyClientHandler());
}
});
System.out.println("客户端接受到了");
ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 6668).sync();
channelFuture.channel().closeFuture().sync();
} finally {
eventExecutors.shutdownGracefully();
}
}
}
NettyClientHandler
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();
}
}
任务队列三种典型使用场景
用户程序自定义的普通任务
用户自定义定时任务
非当前Reactor线程调用Channel的各种方法
5.7 异步模型
基本介绍
-
当一个异步过程调用发出后，调用者不能立刻得到结果。实际处理这个调用的组件在完成后，通过状态、通知和回调来通知调用者
-
Netty 中的 I/O 操作是异步的，包括 Bind、Write、Connect 等操作会简单的返回一个ChannelFuture。
-
调用者并不能立刻获得结果，而是通过 Future-Listener 机制，用户可以方便的主动获取或者通过通知机制获得IO 操作结果
-
Netty 的异步模型是建立在 future 和 callback 的之上的
- 假设一个方法 fun，计算过程可能非常耗时，等待 fun 返回显然不合适。那么可以在调用fun 的时候，立马返回一个 Future，后续可以通过 Future 去监控方法 fun 的处理过程
Future
-
Future表示异步的执行结果，可以通过它提供的方法来检测执行是否完成，比如检索计算等等
-
ChannelFuture 是一个接口
public interface ChannelFuture extends Future
工作原理
-
在使用 Netty 进行编程时，拦截操作和转换出入站数据只需要您提供 callback 或利用future 即可。这使得链式操作简单、高效, 并有利于编写可重用的、通用的代码
-
Netty 框架的目标就是让你的业务逻辑从网络基础应用编码中分离出来、解脱出来
Future-Listener 机制
当 Future 对象刚刚创建时，处于非完成状态，调用者可以通过返回的 ChannelFuture 来获取操作执行的状态，注册监听函数来执行完成后的操作
| 方法 | 说明 |
|---|---|
| isDone | 判断当前操作是否完成 |
| isSuccess | 判断已完成的当前操作是否成功 |
| getCause | 获取已完成的当前操作失败的原因 |
| isCancelled | 判断已完成的当前操作是否被取消 |
| addListener | 来注册监听器，当操作已完成(isDone 方法返回完成)，将会通知指定的监听器；如果Future 对象已完成，则通知指定的监听器 |
快速入门
实例要求：
- Netty 服务器在 6668 端口监听，浏览器发出请求 "http://localhost:6668/ "
- 服务器可以回复消息给客户端 "Hello! 我是服务器 5 " , 并对特定请求资源进行过滤.
- 目的： Netty 可以做 Http 服务开发，并且理解 Handler 实例和客户端及其请求的关系.
TestServer
public class TestServer {
public static void main(String[] args) throws InterruptedException {
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();
}
}
}
TestServerInitializer
public class TestServerInitializer extends ChannelInitializer<SocketChannel> {
@Override
protected void initChannel(SocketChannel socketChannel) {
// 向管道加入处理器
// 得到管道
ChannelPipeline pipeline = socketChannel.pipeline();
// 加入一个 netty 提供的 httpServerCodec codec =>[coder - decoder]
// HttpServerCodec 说明
// 1. HttpServerCodec 是 netty 提供的处理 http 的 编-解码器
pipeline.addLast("MyHttpServerCodec", new HttpServerCodec());
//2 . 增加一个自定义的 handler
pipeline.addLast("MyTestHttpServerHandler", new TestHttpServerHandler());
}
}
TestHttpServerHandler
/*
说明
1. SimpleChannelInboundHandler 是 ChannelInboundHandlerAdapter
2. HttpObject 客户端和服务器端相互通讯的数据被封装成 HttpObject
*/
public class TestHttpServerHandler extends SimpleChannelInboundHandler<HttpObject> {
@Override
protected void channelRead0(ChannelHandlerContext ctx, HttpObject msg) throws URISyntaxException {
// 判断 msg 是不是 httprequest 请求
if(msg instanceof HttpRequest) {
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);
}
}
}
扫一扫
2460
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
