Java NIO（New IO）是Java 1.4版本中引入的一套全新的IO处理机制，与之前的传统IO相比，NIO具有更高的可扩展性和灵活性，特别是在网络编程和高并发场景下，表现得更为出色。
NIO提供了四个核心组件：Channel、Buffer、Selector和SelectionKey，通过它们的协同配合，实现数据的读写和同步、非同步IO操作。本文将从基础概念、核心组件、使用方法等方面全面详细地介绍Java NIO，总字数约8000字。
一、基础概念
1.1 IO和NIO的区别
Java IO和NIO的主要区别在于两者的处理方式不同。Java IO是面向流（Stream）的，它将输入输出数据直接传输到目标设备或文件中，以流的形式进行读写；而NIO则是面向缓冲区（Buffer）的，它将会使用缓存去管理数据，使得读写操作更加快速和灵活。
特别是在网络编程和高并发场景下，Java NIO表现得更为出色。Java IO在进行网络通信时，每个客户端连接都需要创建一个线程来进行处理，这样会导致系统资源的浪费。Java NIO则只需要一个线程就可以完成对多个客户端连接的处理，大大减少系统资源的占用。
1.2 缓冲区
缓冲区是Java NIO中一个非常重要的概念，它是用来存储IO操作的数据的一段连续区域。缓冲区可以在内存中创建，并可以通过通道（Channel）进行读写操作，也可以作为参数传递给其他方法。除此之外，缓冲区还有特定的类型，例如ByteBuffer、CharBuffer、IntBuffer等。
不同类型的缓冲区都包含以下几个基本属性：
- Capacity：容量，缓冲区中最多可以存储的元素数量；
- Position：当前位置，下一个要被读取或写入的位置；
- Limit：限制，缓冲区中的限制，表示可以读写的元素数量；
- Mark：标记，可以让缓冲区记住一个position或limit的值，通过调用reset()方法来恢复到这些值。
缓冲区的读写操作都会修改position和limit属性，例如在从缓冲区中读取数据时，position属性会自动向后移动，而limit属性则不会更改，因此读取操作只能读取到limit位置之前的数据。
1.3 通道
通道（Channel）是Java NIO中网络或文件IO操作的抽象，它类似于传统IO中的Stream，但是它更加灵活和高效。通道可以和缓冲区一起使用，让数据直接在缓冲区之间进行传输，可以使用Selector选择器实现非阻塞IO操作。
通道主要分为以下四种类型：
- FileChannel：用于文件读写操作；
- DatagramChannel：用于UDP协议的网络通信；
- SocketChannel：用于TCP协议的网络通信；
- ServerSocketChannel：用于监听TCP连接请求。
在使用NIO进行网络编程时，我们常常使用SocketChannel和ServerSocketChannel来实现客户端与服务器之间的通信。使用FileChannel可以完成对本地文件的读写操作，使用DatagramChannel可以发送和接收UDP协议的数据包。
1.4 选择器和选择键
选择器（Selector）和选择键（SelectionKey）是Java NIO提供的另外两个核心组件。选择器用于检测一个或多个通道的状态，并且可以根据通道状态进行非阻塞选择操作。而选择键则是一种将通道和选择器进行关联的机制。
使用选择器可以实现单线程管理多个通道的方式，以此实现高并发IO操作。在选择器的模型中，每个通道都会注册到一个选择器上，并且每个通道都有一个其唯一的选择键对象来代表这个通道。选择键对象包含几个标志位，表示通道的当前状态等信息。
选择器可以监听多个通道的事件，例如连接就绪、读取数据就绪、写入数据就绪等等。当有一个或多个通道的事件就绪时，选择器就会自动返回这些通道的选择键，我们可以通过选择键获取到对应的通道，然后进行相应的操作。
二、核心组件
Java NIO包含了四个核心组件：Channel、Buffer、Selector和SelectionKey。下面我们将分别介绍这四个组件的作用和使用方法。
2.1 Channel
Channel是Java NIO中网络通信和文件IO操作的抽象，类似于传统IO中的Stream。它可以支持双向读写操作，并且可以通过缓冲区来直接进行数据读取或写入。通常情况下，我们会创建一个Channel对象，然后将其绑定到一个Socket、File、Pipe等资源上进行读写操作。
NIO中主要提供了以下几种类型的Channel：
- FileChannel：用于文件读写操作；
- DatagramChannel：用于UDP协议的网络通信；
- SocketChannel：用于TCP协议的网络通信；
- ServerSocketChannel：用于监听TCP连接请求。
我们可以通过调用相应的工厂方法来创建不同类型的Channel。
2.1.1 FileChannel
FileChannel是Java NIO中对本地文件读写操作的封装。正如其名字所示，FileChannel对象是针对文件的Channel，通过FileInputStream或FileOutputStream来获取。通过FileChannel，我们可以实现对文件的读取和写入操作，也可以使用它的position()方法来控制读写位置，并配合Buffer进行数据操作。
下面是一个使用FileChannel读取文件的例子：
public static void main(String[] args) throws IOException {
RandomAccessFile file = new RandomAccessFile("test.txt", "rw");
FileChannel channel = file.getChannel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
int bytesRead = channel.read(buffer);
while (bytesRead != -1) {
buffer.flip();
while (buffer.hasRemaining()) {
System.out.print((char) buffer.get());
}
buffer.clear();
bytesRead = channel.read(buffer);
}
file.close();
}
在这个例子中，我们使用FileChannel读取一个名为test.txt的文本文件。首先，我们获取到了一个文件对象，并通过它的getChannel()方法来获取FileChannel对象；然后，我们创建一个容量为1024的ByteBuffer缓冲区来接收读取到的数据。循环读取数据时，我们将缓冲区的limit和position属性进行调整，以便缓冲区可以正常存储和处理读取到的数据。
2.1.2 DatagramChannel
DatagramChannel是Java NIO中对UDP协议通信的封装。通过DatagramChannel对象，我们可以实现发送和接收UDP数据包。它与TCP协议不同的是，UDP协议没有连接的概念，所以无需像SocketChannel一样先建立连接再开始通信。
下面是一个使用DatagramChannel发送和接收UDP数据包的例子：
public static void main(String[] args) throws IOException {
DatagramChannel channel = DatagramChannel.open();
channel.configureBlocking(false);
ByteBuffer buffer = ByteBuffer.allocate(1024);
Scanner scanner = new Scanner(System.in);
while (scanner.hasNext()) {
String message = scanner.next();
buffer.put(message.getBytes());
buffer.flip();
channel.send(buffer, new InetSocketAddress("127.0.0.1", 8888));
buffer.clear();
channel.receive(buffer);
buffer.flip();
while (buffer.hasRemaining()) {
System.out.print((char) buffer.get());
}
buffer.clear();
}
channel.close();
}
在这个例子中，我们创建了一个DatagramChannel对象，并调用configureBlocking(false)方法将其设置为非阻塞模式。然后，通过Scanner类获取用户输入的消息，将消息存放到ByteBuffer缓冲区中，并使用send()方法将其发送出去。接着，我们调用receive()方法来接收对方发送回来的消息，并将其打印到控制台上。
2.1.3 SocketChannel
SocketChannel是Java NIO中对TCP协议通信的封装。通过SocketChannel对象，我们可以实现对TCP连接的建立和通信交互。与传统的Socket操作不同的是，SocketChannel基于非阻塞IO模式，可以在同一个线程内同时管理多个通信连接，从而提高系统的并发处理能力。
下面是一个使用SocketChannel发送和接收TCP数据的例子：
public static void main(String[] args) throws IOException {
SocketChannel channel = SocketChannel.open();
channel.configureBlocking(false);
channel.connect(new InetSocketAddress("bing.com", 80));
while (!channel.finishConnect()) {
// 等待连接建立完成
}
ByteBuffer buffer = ByteBuffer.allocate(1024);
String requestHeader = "GET / HTTP/1.1\r\n" +
"Host: www.bing.com\r\n" +
"Connection: Keep-Alive\r\n\r\n";
buffer.put(requestHeader.getBytes());
buffer.flip();
while (buffer.hasRemaining()) {
channel.write(buffer);
}
buffer.clear();
while (channel.read(buffer) != -1) {
buffer.flip();
while (buffer.hasRemaining()) {
System.out.print((char) buffer.get());
}
buffer.clear();
}
channel.close();
}
在这个例子中，我们创建了一个SocketChannel对象，并调用configureBlocking(false)方法将其设置为非阻塞模式。然后，我们使用connect()方法来建立与目标主机的TCP连接，并使用finishConnect()方法等待连接的建立完成。
接着，我们构造了一个HTTP请求头部，并将其存放到ByteBuffer缓冲区中，使用write()方法将其发送出去。最后，我们循环读取SocketChannel中的数据，将其打印到控制台上。
2.1.4 ServerSocketChannel
ServerSocketChannel是Java NIO中用于监听TCP连接请求的封装。通过ServerSocketChannel，我们可以监听来自客户端的连接请求，并创建相应的SocketChannel对象进行通信交互。与传统的ServerSocket不同的是，ServerSocketChannel基于非阻塞IO模式，可以在同一个线程内同时管理多个客户端连接请求，从而提高系统的并发处理能力。
下面是一个使用ServerSocketChannel监听TCP连接请求的例子：
public static void main(String[] args) throws IOException {
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.socket().bind(new InetSocketAddress(8888));
serverChannel.configureBlocking(false);
while (true) {
SocketChannel channel = serverChannel.accept();
if (channel != null) {
ByteBuffer buffer = ByteBuffer.allocate(1024);
int bytesRead = channel.read(buffer);
while (bytesRead != -1) {
buffer.flip();
while (buffer.hasRemaining()) {
System.out.print((char) buffer.get());
}
buffer.clear();
bytesRead = channel.read(buffer);
}
channel.close();
}
}
}
在这个例子中，我们创建了一个ServerSocketChannel对象，并通过bind()方法将其绑定到本地的8888端口上。然后，我们使用configureBlocking(false)方法将其设置为非阻塞模式，并启动一个无限循环来接收客户端连接请求。
当一个客户端连接请求到达时，我们调用accept()方法来接收它，并创建一个与客户端通信的SocketChannel对象。接着，我们读取SocketChannel中的数据，并将其打印到控制台上，完成一次客户端请求的处理。
2.2 Buffer
Buffer是Java NIO中用于存储IO操作数据的缓冲区组件，它提供了一种更加高效、可控的数据读写方式。在进行数据读写操作时，我们需要将数据存放到Buffer中，并且使用相应的方法对其进行操作。
NIO中主要提供了以下几种类型的Buffer：
- ByteBuffer：用于存储字节数据；
- CharBuffer：用于存储字符数据；
- ShortBuffer、IntBuffer、LongBuffer、FloatBuffer和DoubleBuffer：用于存储各种基本类型数据。
使用Buffer的方式具有一定的规律性，通常情况下，我们都需要遵循以下几个步骤：
- 创建Buffer对象；
- 存储数据到Buffer中；
- 调用flip()方法将Buffer从写模式切换为读模式；
- 从Buffer中读取数据；
- 调用clear()或compact()方法清空或压缩Buffer。
下面是一个使用ByteBuffer实现文件读取功能的例子：
public static void main(String[] args) throws IOException {
FileInputStream inputStream = new FileInputStream("test.txt");
FileChannel channel = inputStream.getChannel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
int bytesRead = channel.read(buffer);
while (bytesRead != -1) {
buffer.flip();
while (buffer.hasRemaining()) {
System.out.print((char) buffer.get());
}
buffer.clear();
bytesRead = channel.read(buffer);
}
inputStream.close();
}
在这个例子中，我们创建了一个ByteBuffer缓冲区，并调用FileChannel的read()方法将文件中的数据读取到缓冲区中。然后，我们调用flip()方法将缓冲区从写模式切换为读模式，使用get()方法逐个获取缓冲区中的字节数据，并将其转换成字符类型输出到控制台上。
2.3 Selector
Selector是Java NIO中用于网络通信的多路复用器组件，它可以监控多个通道的IO操作状态，并在状态就绪时将其返回给程序处理。使用Selector可以实现单线程管理多个通道的方式，以此实现高并发IO操作。
下面是一个使用Selector进行TCP连接监听的例子：
public static void main(String[] args) throws IOException {
Selector selector = Selector.open();
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.socket().bind(new InetSocketAddress(8888));
serverChannel.configureBlocking(false);
serverChannel.register(selector, SelectionKey.OP_ACCEPT);
ByteBuffer buffer = ByteBuffer.allocate(1024);
while (true) {
int readyCount = selector.select();
if (readyCount == 0) {
continue;
}
Set selectedKeys = selector.selectedKeys();
Iterator keyIterator = selectedKeys.iterator();
while (keyIterator.hasNext()) {
SelectionKey key = keyIterator.next();
if (key.isAcceptable()) {
SocketChannel channel = ((ServerSocketChannel) key.channel()).accept();
channel.configureBlocking(false);
channel.register(selector, SelectionKey.OP_READ);
} else if (key.isReadable()) {
SocketChannel channel = (SocketChannel) key.channel();
int bytesRead = channel.read(buffer);
while (bytesRead != -1) {
buffer.flip();
while (buffer.hasRemaining()) {
System.out.print((char) buffer.get());
}
buffer.clear();
bytesRead = channel.read(buffer);
}
channel.close();
}
keyIterator.remove();
}
}
}
在这个例子中，我们创建了一个Selector对象，并通过ServerSocketChannel的register()方法将其注册到Selector上，监听其连接请求的就绪状态。当有新的客户端连接请求到达时，我们调用accept()方法来接受它，并将其SocketChannel对象注册到Selector上，监听其读取数据的就绪状态。
在进行网络通信时，如果有数据到达，则Selector会检测到其可读性，然后调用对应的处理方法进行数据读取和处理。最后，我们通过调用SelectionKey对象的remove()方法从Selector中移除监听键，以便下次可以再详细说明一下上面的例子：
在while循环中，我们首先调用Selector的select()方法来检测当前是否有通道读写事件就绪。如果没有就绪的事件，则select()方法会阻塞，直到有事件发生为止。
如果有事件就绪，则调用selectedKeys()方法获取所有就绪的SelectionKey对象，并通过迭代器依次处理每个事件。
如果当前事件是连接请求事件，我们使用ServerSocketChannel的accept()方法接受该连接请求，并将其register()到Selector上进行监听读取操作。
如果当前事件是可读事件，我们通过SelectionKey对象获取对应的SocketChannel，并从中读取数据，完成读取后，关闭SocketChannel对象。
最后，我们通过调用SelectionKey对象的remove()方法从Selector中移除监听键，以便下次可以重新注册。
Selector不仅可以监听TCP连接请求，还可以监听其他网络事件，如可读、可写等。通过Selector的多路复用机制，我们可以在单线程内同时管理多个通道的网络IO事件，从而提高系统的并发处理能力。
三. 总结
Java NIO提供了一套灵活高效的IO操作API，可以帮助我们实现高并发、高性能的网络通信功能。其中包括了Channel、Buffer和Selector三大核心组件，它们共同构成了Java NIO的基础框架。
相比传统的IO操作方式，Java NIO具有更高的效率、更低的资源占用和更好的可扩展性。因此，在开发高并发、高性能网络应用时，我们可以考虑使用Java NIO来实现。
以上就是Java NIO中四大核心组件的使用详解的详细内容，更多关于Java NIO的资料请关注脚本之家其它相关文章！