Netty 概述
本文章学习要求
- 本文章不适用于 0 基础的学员
- 要求已经掌握了 Java 编程， 主要技术构成： Java OOP 编程、Java 多线程编程、Java IO 编程 、Java 网 络编程、常用的 Java 设计模式(比如 观察者模式 ，命令模式，职责链模式 )、常用的数据结构(比如 链表)
- 最好有项目开发和阅读源码的经历
Netty 的介绍
- Netty 是由 JBOSS 提供的一个 Java 开源框架，现为 Github 上的独立项目。
- Netty 是一个异步的、基于事件驱动的网络应用框架，用以快速开发高性能、高可靠性的网络 IO 程序。
- Netty 主要针对在 TCP 协议下，面向 Clients 端的高并发应用，或者 Peer-to-Peer(P2P) 场景下的大量数据持续传输的 应用。
- Netty 本质是一个 NIO 框架，适用于服务器通讯相关的多种应用场景
- 要透彻理解 Netty ， 需要先学习 NIO ， 这样我们才能阅读 Netty 的源码。
Netty 的应用场景
互联网行业
- 互联网行业：在分布式系统中，各个节点之间需要远程服务调用，高性能的 RPC 框架必不可少，Netty 作为 异步高性能的通信框架，往往作为基础通信组件被这些 RPC 框架使用。
- 典型的应用有：阿里分布式服务框架 Dubbo 的 RPC 框架使用 Dubbo 协议进行节点间通信，Dubbo 协议默 认使用 Netty 作为基础通信组件，用于实现各进程节点之间的内部通信
游戏行业
- 无论是手游服务端还是大型的网络游戏，Java 语言得到了越来越广泛的应用
- Netty 作为高性能的基础通信组件，提供了 TCP/UDP 和 HTTP 协议栈，方便定制和开发私有协议栈，账号登 录服务器
- 地图服务器之间可以方便的通过 Netty 进行高性能的通信
大数据领域
- 经典的 Hadoop 的高性能通信和序列化组件 Avro 的 RPC 框架，默认采用 Netty 进行跨界点通信
- 它的 Netty Service 基于 Netty 框架二次封装实现。
哪些项目用 Netty
下面我放出一张缩略图，详情请点击这里
Java BIO 编程
I/O 模型基本说明
I/O 模型简单的理解：就是用什么样的通道进行数据的发送和接收，很大程度上决定了程序通信的性能
Java 共支持 3 种网络编程模型/IO 模式：BIO、NIO、AIO
Java BIO ： 同步并阻塞(传统阻塞型)，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器 端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销 【简单示意图】
Java NIO ： 同步非阻塞，服务器实现模式为一个线程处理多个请求(连接)，即客户端发送的连接请求都会注 册到多路复用器上，多路复用器轮询到连接有 I/O 请求就进行处理 【简单示意图】
Java AIO(NIO.2) (这个暂时没广泛使用)： 异步非阻塞，AIO 引入异步通道的概念，采用了 Proactor 模式，简化了程序编写，有效 的请求才启动线程，它的特点是先由操作系统完成后才通知服务端程序启动线程去处理，一般适用于连接数较 多且连接时间较长的应用
我们依次展开讲解
IO 适用场景分析
- BIO 方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4 以前的唯一选择，但程序简单易理解。
- NIO 方式适用于连接数目多且连接比较短（轻操作）的架构，比如聊天服务器，弹幕系统，服务器间通讯等。 编程比较复杂，JDK1.4 开始支持。
- AIO 方式使用于连接数目多且连接比较长（重操作）的架构，比如相册服务器，充分调用 OS 参与并发操作， 编程比较复杂，JDK7 开始支持。
Java BIO 基本介绍
- Java BIO 就是传统的 java io 编程，其相关的类和接口在 java.io
- BIO(blocking I/O) ： 同步阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需 要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，可以通过线程池机制改善(实 现多个客户连接服务器)。 【后有实例】
- BIO 方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4 以前的唯一选择，程序简单易理解
Java BIO 工作机制
对 BIO 编程流程的梳理
- 服务器端启动一个 ServerSocket
- 客户端启动 Socket 对服务器进行通信，默认情况下服务器端需要对每个客户 建立一个线程与之通讯
- 客户端发出请求后, 先咨询服务器是否有线程响应，如果没有则会等待，或者被拒绝
- 如果有响应，客户端线程会等待请求结束后，再继续执行
Java BIO 实例
实例说明：
- 使用 BIO 模型编写一个服务器端，监听 6666 端口，当有客户端连接时，就启动一个线程与之通讯。
- 要求使用线程池机制改善，可以连接多个客户端.
- 服务器端可以接收客户端发送的数据(telnet 方式即可,点击查看教程)。
- 代码演示流程走向,主线程按照顺序走到
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91import 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)
{
break;
}
//输出客户端发送的数据
System.out.println(new String(bytes, 0, read));
}
} catch (Exception e)
{
e.printStackTrace();
} finally
{
System.out.println("关闭和client的连接");
try
{
socket.close();
} catch (Exception e)
{
e.printStackTrace();
}
}
}
}final Socket socket = serverSocket.accept();不会往下走了,
直到有连接进入(也就是我们使用的telnet进行连接),有连接进入就会使用线程池新执行一个线程,进到handler(socket);方法中进行通讯,
这里读取数据之后,还会走到int read = inputStream.read(bytes);而不往下走,进行接收数据.
Java BIO 问题分析
- 每个请求都需要创建独立的线程，与对应的客户端进行数据 Read，业务处理，数据 Write 。
- 当并发数较大时，需要创建大量线程来处理连接，系统资源占用较大。
- 连接建立后，如果当前线程暂时没有数据可读，则线程就阻塞在 Read 操作上，造成线程资源浪费
- read（返回 -1，表示读到 eof 结束了，如果没有数据可读时，它将会阻塞。因为它不确定有没有人会继续往这条流里面发送数据。）
- accept（会阻塞，需要一直等着，直到有连接进来）
这两个方法是一个阻塞式的方法，也就是死皮赖脸型的。我向你要数据，你说什么？没有！没有我就不走了，我就在这等着，其他人也给我一边候着，只有等我要到了东西才有你们说话的份。
Java NIO 编程
Java NIO 基本介绍
- Java NIO 全称 java non-blocking IO，是指 JDK 提供的新 API。从 JDK1.4 开始，Java 提供了一系列改进的 输入/输出的新特性，被统称为 NIO(即 New IO)，是同步非阻塞的
- NIO 相关类都被放在 java.nio 包及子包下，并且对原 java.io 包中的很多类进行改写。【基本案例】
- NIO 有三大核心部分：*Channel(通道)，Buffer(缓冲区), Selector(选择器) *
- NIO 是 面向缓冲区 ，或者面向 块 编程的。数据读取到一个它稍后处理的缓冲区，需要时可在缓冲区中前后 移动，这就增加了处理过程中的灵活性，使用它可以提供非阻塞式的高伸缩性网络
- Java NIO 的非阻塞模式，使一个线程从某通道发送请求或者读取数据，但是它仅能得到目前可用的数据，如果 目前没有数据可用时，就什么都不会获取，而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可 以继续做其他的事情。 非阻塞写也是如此，一个线程请求写入一些数据到某通道，但不需要等待它完全写入， 这个线程同时可以去做别的事情。【后面有案例说明】
- 通俗理解：NIO 是可以做到用一个线程来处理多个操作的。假设有 10000 个请求过来,根据实际情况，可以分配 50 或者 100 个线程来处理。不像之前的阻塞 IO 那样，非得分配 10000 个。
- HTTP2.0 使用了多路复用的技术，做到同一个连接并发处理多个请求，而且并发请求的数量比 HTTP1.1 大了好 几个数量级
- 案例说明 NIO 的 Buffer
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44import 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转换，读写切换(!!!)
/*
public final Buffer flip() {
limit = position; //读数据不能超过5
position = 0;
mark = -1;
return this;
}
*/
intBuffer.flip();
intBuffer.position(1);/*从下标1开始读,读到limit为止,但不包含limit那个位置*/
System.out.println(intBuffer.get());
intBuffer.limit(3);/*限制到3,此时position=1,limit=3,可以读取下标1,2两个位置*/
/*是否还有数据可读`return position < limit;`*/
while (intBuffer.hasRemaining())
{
System.out.println(intBuffer.get());
}
}
}
NIO 和 BIO 的比较
- BIO 以流的方式处理数据,而 NIO 以块的方式处理数据,块 I/O 的效率比流 I/O 高很多
- BIO 是阻塞的，NIO 则是非阻塞的
- BIO 基于字节流和字符流进行操作，而 NIO 基于 Channel(通道)和 Buffer(缓冲区)进行操作，数据总是从通道 读取到缓冲区中，或者从缓冲区写入到通道中。Selector(选择器)用于监听多个通道的事件（比如：连接请求， 数据到达等），因此使用单个线程就可以监听多个客户端通道
NIO 三大核心原理示意图
一张图描述 NIO 的 Selector 、 Channel 和 Buffer 的关系
Selector 、 Channel 和 Buffer 的关系图(简单版)
关系图的说明:
- 每个 channel 都会对应一个 Buffer
- Selector 对应一个线程， 一个线程对应多个 channel(连接)
- 该图反应了有三个 channel 注册到 该 selector
- 程序切换到哪个 channel 是有事件决定的, Event 就是一个重要的概念
- Selector 会根据不同的事件，在各个通道上切换
- Buffer 就是一个内存块 ， 底层是有一个数组
- 数据的读取写入是通过 Buffer, 这个和 BIO 有所不同, BIO 中要么是输入流，或者是 输出流, 不能双向，但是 NIO 的 Buffer 是可以读也可以写, 需要 flip 方法切换。
缓冲区(Buffer)
基本介绍
缓冲区（Buffer）：缓冲区本质上是一个可以读写数据的内存块，可以理解成是一个容器对象(含数组)，
该对 象提供了一组方法，可以更轻松地使用内存块，缓冲区对象内置了一些机制，能够跟踪和记录缓冲区的状态变化情况。
Channel 提供从文件、网络读取数据的渠道，但是读取或写入的数据都必须经由 Buffer，如图: 【后面举 例说明】
Buffer 类及其子类
- 在 NIO 中，Buffer 是一个顶层父类，它是一个抽象类, 类的层级关系图:
- Buffer 类定义了所有的缓冲区都具有的四个属性来提供关于其所包含的数据元素的信息:
- Buffer 类相关方法一览
ByteBuffer
从前面可以看出对于 Java 中的基本数据类型(boolean 除外)，都有一个 Buffer 类型与之相对应，最常用的自 然是 ByteBuffer 类（二进制数据），该类的主要方法如下：
通道(Channel)
基本介绍
- NIO 的通道类似于流，但有些区别如下：
- 通道可以同时进行读写，而流只能读或者只能写
- 通道可以实现异步读写数据
- 通道可以从缓冲读数据，也可以写数据到缓冲:
2. BIO 中的 stream 是单向的，例如 FileInputStream 对象只能进行读取数据的操作，而 NIO 中的通道(Channel) 是双向的，可以读操作，也可以写操作。
3. Channel 在 NIO 中是一个接口 public interface Channel extends Closeable{}
4. 常 用 的 Channel 类 有 ： FileChannel 、 DatagramChannel 、 ServerSocketChannel 和 SocketChannel 。 【ServerSocketChanne 类似 ServerSocket , SocketChannel 类似 Socket】
5. FileChannel 用于文件的数据读写，DatagramChannel 用于 UDP 的数据读写，ServerSocketChannel 和 SocketChannel 用于 TCP 的数据读写。
6. 图示
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)，把数据从当前通道复制给目标通道
案例1 写入
实例要求:
- 使用前面学习后的 ByteBuffer(缓冲) 和 FileChannel(通道)， 将 “Hello,mother fucker…” 写入到 a.txt 中
- 文件不存在就创建
- 代码演示
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32import 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,mother fucker...";
//创建一个输出流->channel
FileOutputStream fileOutputStream = new FileOutputStream("D:\\a.txt");
//通过 fileOutputStream 获取 对应的 FileChannel
//这个 fileChannel 真实 类型是 FileChannelImpl
FileChannel fileChannel = fileOutputStream.getChannel();
//创建一个缓冲区 ByteBuffer，容量1024
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(通道)， 将 a.txt 中的数据读入到程序，并显示在控制台屏幕
- 假定文件已经存在
- 代码演示
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29import 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:\\a.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 读写转换
实例要求:
- 使用 FileChannel(通道) 和 方法 read , write，完成文件的拷贝
- 拷贝一个文本文件 a.txt
- 代码演示
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45import 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 inputStream = new FileInputStream("D:\\a.txt");
FileChannel channel01 = inputStream.getChannel();
FileOutputStream outputStream = new FileOutputStream("D:\\a.bak.txt");
FileChannel channel02 = outputStream.getChannel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
while (true)//循环读取
{
/*从channel读取数据,写入到buffer
* 没往buffer写之前,position=0,limit=1024
* 写之后,position=22,limit=1024,因为这时候写到22,就不能往下写了,因为channel中只有22个字节(byte)的数据*/
int read = channel01.read(buffer);
if (read == -1)//表示读完
{
break;
}
/*因为buffer从上面的写入模式要变为下面的读取模式,
执行了这个之后,position=0,因为要从第一个字节进行读取,limit变为之前的position,也就是22,因为只能读取22的字节*/
buffer.flip();
/*从buffer中读取数据,写入到channel,读取之后,position变为limit,因为它读取到第limit字节时,就不能往下读取了,没数据可读了,不能超出limit限制*/
channel02.write(buffer);
/*如果不clean的话,此时的position和limit一样大,进行下一次read时,就不能往下读取数据,也就是读取到的数据是0字节,永远不为-1,死循环*/
buffer.clear();//清空buffer
}
/*如果不执行`outputStream.flush();`
* 执行它的close()方法也会把数据刷新到文件中去*/
//关闭相关的流
outputStream.close();
inputStream.close();
}
}
案例4 拷贝
1) 实例要求:
2) 使用 FileChannel(通道) 和 方法 transferFrom ，完成文件的拷贝
3) 拷贝一张图片
4) 代码演示
1 | import java.io.FileInputStream; |
注意细节
数据存取
ByteBuffer 支持类型化的 put 和 get, put 放入的是什么数据类型，get 就应该使用相应的数据类型来取出，否 则可能有 BufferUnderflowException 异常。
1 | import java.nio.ByteBuffer; |
只读buffer
可以将一个普通 Buffer 转成只读 Buffer
1 | import java.nio.ByteBuffer; |
mmap
NIO 还提供了 MappedByteBuffer（映射字节缓冲区）， 可以让文件直接在内存（堆外的内存）中进行修改， 也就是mmap技术，而如何同步到文件 由 NIO 来完成。
1 | import java.io.RandomAccessFile; |
多个buffer
前面我们讲的读写操作，都是通过一个 Buffer 完成的，NIO 还支持 通过多个 Buffer (即 Buffer 数组) 完成读 写操作，即 Scattering 和 Gathering
1 | import java.net.InetSocketAddress; |
Selector(选择器)
基本介绍
- Java 的 NIO，用非阻塞的 IO 方式。可以用一个线程，处理多个的客户端连接，就会使用到 Selector(选择器)
- Selector 能够检测多个注册的通道上是否有事件发生(注意:多个 Channel 以事件的方式可以注册到同一个 Selector)，如果有事件发生，便获取事件然后针对每个事件进行相应的处理。这样就可以只用一个单线程去管 理多个通道，也就是管理多个连接和请求。【示意图】
- 只有在 连接/通道 真正有读写事件发生时，才会进行读写，就大大地减少了系统开销，并且不必为每个连接都 创建一个线程，不用去维护多个线程
- 避免了多线程之间的上下文切换导致的开销
Selector 特点说明
- Netty 的 IO 线程 NioEventLoop(NIO事件循环) 聚合了 Selector(选择器，也叫多路复用器)，可以同时并发处理成百上千个客户端连接。
- 当线程从某客户端 Socket 通道进行读写数据时，若没有数据可用时，该线程可以进行其他任务。
- 线程通常将非阻塞 IO 的空闲时间用于在其他通道上执行 IO 操作，所以单独的线程可以管理多个输入和输出 通道。
- 由于读写操作都是非阻塞的，这就可以充分提升 IO 线程的运行效率，避免由于频繁 I/O 阻塞导致的线程挂起。
- 一个 I/O 线程可以并发处理多个客户端连接和读写操作，这从根本上解决了传统同步阻塞 I/O 一连接一线 程模型，架构的性能、弹性伸缩能力和可靠性都得到了极大的提升。
Selector 类、方法
Selector 类是一个抽象类, 常用方法和说明如下:
1 | public abstract class Selector implements Closeable { |
Selector 注意事项
- NIO 中的 ServerSocketChannel 功能类似 ServerSocket，SocketChannel 功能类似 Socket
- selector 相关方法说明（个人理解）
Set<SelectionKey> keys();返回注册的SelectionKey的集合Set<SelectionKey> selectedKeys();返回注册的SelectionKey并且发生了对应绑定事件的集合，可以根据key来获取到对应的channel和buffer，它里面保存了要操作的事件，进行remove之后，是为了防止事件重复操作int select() throws IOException;它的返回值等同于selectedKeys().size()。阻塞，直到注册进的key有事件发生，也就是select()>0才会返回。- 关于keys，selectedKeys，select举例说明：假设k1,k2,k3都注册进了Selector，但是只要k2发生了对应的事件，此时keys().size()=3，selectedKeys().size()=1，select()=1
int select(long timeout) throws IOException;如果没有事件发生，阻塞n毫秒，再进行返回。可能返回0。如果传入0毫秒，等同于select()方法。不能传负数。int selectNow() throws IOException;不阻塞，立马返回，可能为0Selector wakeup();唤醒 selector。连续执行多次和执行一次是同样的效果。
NIO 网络编程原理分析
NIO 非阻塞 网络编程相关的(Selector、SelectionKey、ServerScoketChannel 和 SocketChannel) 关系梳理图
对上图的说明:
- 当客户端连接时，会通过 ServerSocketChannel 得到 SocketChannel
- Selector 进行监听 select 方法, 返回有事件发生的通道的个数.
- 将 serverSocketChannel，socketChannel 注册到 Selector 上, register(Selector sel, int ops), 一个 selector 上可以注册多个 SocketChannel
- 注册后返回一个 SelectionKey, 会和该 Selector 关联(集合)
- 有事件发生的情况下,进一步得到各个 SelectionKey
- 在通过 SelectionKey 反向获取 SocketChannel , 方法 channel()
- 可以通过 得到的 channel , 完成业务处理
- 可根据下面配合代码来理解…
NIO 网络编程入门
案例要求:
- 编写一个 NIO 入门案例，实现服务器端和客户端之间的数据简单通讯（非阻塞）
- 目的：理解 NIO 非阻塞网络编程机制
- 看代码演示
NIOServer1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
import java.util.Set;
public class NIOServer
{
public static void main(String[] args) throws Exception
{
//创建ServerSocketChannel -> ServerSocket
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
//绑定一个端口6666, 在服务器端监听
serverSocketChannel.socket().bind(new InetSocketAddress("127.0.0.1", 6666));
//设置为非阻塞
serverSocketChannel.configureBlocking(false);
//得到一个Selecor对象
Selector selector = Selector.open();
//把 serverSocketChannel 注册到 selector , 关注事件为 OP_ACCEPT
// 也就是说 serverSocketChannel 绑定的地址有新连接时就会注册
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
System.out.println("注册后的selectionkey 数量=" + selector.keys().size()); // 1
while (true) //循环等待客户端连接
{
System.out.println("选择器中需要操作事件的数量是: " + selector.selectedKeys().size());
//如果没有事件发生，这里我们等待1秒，再返回
if (selector.select(1000) == 0)
{ //没有事件发生
System.out.println("服务器等待了1秒，无连接");
continue;
}
//如果返回的>0, 就获取到相关的 selectionKey集合
//1. 如果返回的>0， 表示已经获取到关注的事件
//2. selector.selectedKeys() 返回关注事件的集合
// 通过 selectionKeys 反向获取通道
Set<SelectionKey> selectionKeys = selector.selectedKeys();
System.out.println("发生事件的selectionKeys 数量 = " + selectionKeys.size());
//遍历 Set<SelectionKey>, 使用迭代器遍历
Iterator<SelectionKey> keyIterator = selectionKeys.iterator();
while (keyIterator.hasNext())
{
//获取到SelectionKey
SelectionKey key = keyIterator.next();
//根据key 对应的通道发生的事件做相应处理
//如果是 OP_ACCEPT, 有新的客户端连接
if (key.isAcceptable())
{
//该该客户端生成一个 SocketChannel
//本身accept是会阻塞的,但是这里进来的条件就是有新连接进来,所以在这里是不会阻塞的.
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));
System.out.println("客户端连接后 ，注册的selectionkey 数量=" + selector.keys().size()); //2,3,4.. 需要看有多少连接
}
//发生 OP_READ
if (key.isReadable())
{
//通过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();
}
}
}
}NIOClient1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
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);
//连接服务器,连接之后会触发select不为0,并且触发`key.isAcceptable()`为true
if (!socketChannel.connect(inetSocketAddress))
{
while (!socketChannel.finishConnect())
{
System.out.println("因为连接需要时间，客户端不会阻塞，可以做其它工作..");
}
}
//如果连接成功，就发送数据
String str = "Hello,mother fucker...";
//Wraps a byte array into a buffer
ByteBuffer buffer = ByteBuffer.wrap(str.getBytes());
//发送数据，将 buffer 数据写入 channel
//发送完成会触发`key.isReadable()`为true
socketChannel.write(buffer);
System.in.read();
}
}
下面进行流程梳理
NIOServer类先创建ServerSocketChannel通道,并给这个通道绑定ip个端口进行监听连接,并且设置为非阻塞,- 创建
Selector选择器,并且往里面注册一个ServerSocketChannel通道,设置监听事件为OP_ACCEPT,这时候就会输出selectionkey的数量是1 - 这时通道监听的ip和端口还没有进入新的连接,所以这时选择器的
select方法会一直返回0,隔一秒打印一次”服务器等待了1秒，无连接” - 这时候执行
NIOClient执行了socketChannel.connect(inetSocketAddress)这一行时,才会把通道和那个ip,端口进行连接起来,有了新的连接,上面我们监听的那个OP_ACCEPT事件发生了,选择器中的key有事件发生的时候,我们的选择器的select方法就不返回0了,继续往下走, - 这时候,判断是
key.isAcceptable()为true,进行往选择器里面注册,注册一个新的通道,并关联一个buffer,注册的监听事件为OP_READ,也就是读,这时选择器里面有两个key了,打印数量2, - 往下走不能发生可读事情,移除当前的key(注册操作的那个key),继续往下走,重新进入循环,判断
select是否不为0,我们知道了当有事件发生的时候才会不为0,我们NIOClient执行了write方法时,会触发OP_READ事件, - 也就是此时
select不为0,但是这时isAcceptable判断为false,isReadable判断为true,因为它是可读的,从key中获取通道和buffer,读取数据,移除当前的key再进行监听.
SelectionKey
- SelectionKey，表示 Selector 和网络通道的注册关系, 共四种:
int OP_ACCEPT：有新的网络连接可以 accept，值为 16int OP_CONNECT：代表连接已经建立，值为 8int OP_READ：代表读操作，值为 1int OP_WRITE：代表写操作，值为 4
源码中：1
2
3
4public 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; - SelectionKey 相关方法
1
2
3
4
5
6
7
8
9
10
11public abstract class SelectionKey {
public abstract Selector selector();//得到与之关联的 Selector 对象
public abstract SelectableChannel channel();//得到与之关联的通道
public final Object attachment();//得到与之关联的共享数据,例如关联的buffer
public abstract SelectionKey interestOps(int ops);//设置或改变监听事件
public abstract void cancel();//取消注册,通常用于处理客户端退出的catch块中操作
public final boolean isAcceptable();//是否可以 accept
public final boolean isReadable();//是否可以读
public final boolean isWritable();//是否可以写
}
ServerSocketChannel
- ServerSocketChannel 在服务器端监听新的客户端 Socket 连接
- 相关方法如下
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19public abstract class ServerSocketChannel
extends AbstractSelectableChannel
implements NetworkChannel{
//得到一个 ServerSocketChannel 通道
public static ServerSocketChannel open();
//设置服务器端 主机名+端口号
public final ServerSocketChannel bind(SocketAddress local)
//设置阻塞或非阻塞模式，取值 false 表示采用非阻塞模式
public final SelectableChannel configureBlocking(boolean block)
//接受一个连接，返回代表这个连接的通道对象
//在`isAcceptable()`时使用
public SocketChannel accept()
//注册一个选择器并设置监听事件
public final SelectionKey register(Selector sel, int ops)
}
SocketChannel
1) SocketChannel，网络 IO 通道，具体负责进行读写操作。NIO 把缓冲区的数据写入通道，或者把通道里的数 据读到缓冲区。
2) 相关方法如下
1 | public abstract class SocketChannel |
案例_群聊系统
要求
1 | 1. 编写一个 NIO 群聊系统，实现服务器端和客户端之间的数据简单通讯（非阻塞） |
步骤
1 | * 服务器 |
结果
源码
GroupChatServer.java
1 | import java.net.InetSocketAddress; |
GroupChatClient.java
1 | import java.net.InetSocketAddress; |