Java I/O 模型之 NIO

❤️ 个人主页：水滴技术
🚀 支持水滴：点赞👍 + 收藏⭐ + 留言💬
🌸 订阅专栏：Java 教程：从入门到精通

大家好，我是水滴~~

服务端API

创建服务端套接字的通道

服务端通过ServerSocketChannel类的open静态方法，可以创建一个打开的服务端套接字通道。该通道用于监听客户端的连接。虽然该通道已经打开，但还无法接收客户端的连接。

该通道默认为阻塞模式，通过configureBlocking方法设为非阻塞模式，那么其accept方法会是非阻塞方法，这样才可以将该通道的ACCEPT事件注册到选择器中。（如果不设置，accept方法会是阻塞方法，这就和BIO的监听连接一样了）

通过bind方法绑定本地套接字地址，与BIO相同。此时客户端已经可以连接该通道了。

// 在本地打开一个 ServerSocket 通道
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
// 将该通道配置为非阻塞
serverSocketChannel.configureBlocking(false);
// 绑定本地端口
serverSocketChannel.bind(new InetSocketAddress(8080));

创建选择器，并注册Accept事件

通过Selector类的open静态方法，创建一个打开的选择器（多路复用器）。

通过服务端套接字通道的register，将该通道注册到此选择器上，监听ACCEPT事件。

// 打开一个选择器（多路复用）
Selector selector = Selector.open();
// 将该通道的接入事件注册到选择器中
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

通过选择器监听I/O事件

通过选择器的select方法，来获取被注册通道的I/O事件，它是一个阻塞方法，我们应该无限循环来轮询所有准备好的I/O事件。

选择器可以同时接收多个I/O事件，通过selectedKeys方法来获取已接收的I/O事件，再迭代处理所有事件。

// 通过选择器轮询获取该通道上的 I/O 事件。该操作会阻塞
int num = selector.select();
// 获取选择器中所有准备就绪的事件，并进行迭代
Iterator<SelectionKey> it = selector.selectedKeys().iterator();
// 遍历所有准备好的事件
while (it.hasNext()) {
   
    // 获取当前事件
    SelectionKey selectionKey = it.next();
    // 从迭代器中移除当前事件
    it.remove();
    // ...区别不同的事件...
}

处理ACCEPT事件

通过选择器事件的isAcceptable方法，判断是否ACCEPT事件。

通过服务端套接字通道的accept方法，获取该连接的套接字通道SocketChannel。该套接字通道默认是阻塞模式，通过configureBlocking方法设为非阻塞模式，那么该通道的read方法将是个非阻塞方法。

将该通道注册到选择器中，来监听该套接字通道上的READ事件。并且此处可以是单独的选择器。

if (selectionKey.isAcceptable()) {
   
    // 接收事件，表示一个 Socket 连接上来了
    // 获取当前接入的通道
    SocketChannel socketChannel = serverSocketChannel.accept();
    System.out.printf("[%s] - 有一个客户端连上来了 - %s\n", Thread.currentThread().getName(), socketChannel.getRemoteAddress());
    // 将接入的通道设为非阻塞
    socketChannel.configureBlocking(false);
    // 将该接入的通道的读事件注册到选择器中
    socketChannel.register(selector, SelectionKey.OP_READ);
}

处理READ事件

通过选择器事件的isReadable方法，判断是否READ事件。

获取该事件上的通道，并通过read方法，读取客户端写入的数据，并写入ByteBuffer缓冲器中。

读取缓冲器中的数据，首先要将其flip反转，即从写入状态反转为读取状态，方可开始读取。

if (selectionKey.isReadable()) {
   
    // 读取事件，表示有客户端发来消息
    // 获取产生事件的通道
    SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
    // 申请一个1024个字节的缓冲区
    ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
    // 读取该通道的内容至缓冲区（将内容写入缓冲区）
    while (socketChannel.read(byteBuffer) > 0) {
   
        // 将缓冲区进行反转（刚才是写入，反转后变为读取）
        byteBuffer.flip();
        // 读取缓冲区中的内容，并转为字符串
        String content = new String(byteBuffer.array(), 0, byteBuffer.limit());
        System.out.printf("[%s] - 接收客户端发来的内容：%s\n", Thread.currentThread().getName(), content);
        // 清除缓冲区
        byteBuffer.clear();
    }
}

客户端API

创建客户端套接字通道

通过SocketChannel类的open静态方法，可以创建一个客户端套接字通道。通过套接字通道的configureBlocking方法，将该通道设为非阻塞模式，那么该通道的connect和read法将是个非阻塞方法。

// 打开一个 Socket 通道，并绑定指定的服务端地址与端口
SocketChannel socketChannel = SocketChannel.open();
// 将该通道设为非阻塞
socketChannel.configureBlocking(false);

连接服务器端

通过套接字通道的connect方法来连接服务端。在非阻塞模式下，如果连接能立即建立，会返回一个true；否则该方法将返回一个false，稍后可以通过finishConnect方法来确认是否连接成功。

// 连接远程地址
socketChannel.connect(new InetSocketAddress("127.0.0.1", 8080));

写入数据

在服务端已经介绍过读取数据了，在这里说下写数据。先将数据放入缓冲器ByteBuffer中，通过套接字通道的write方法，将缓冲器中数据写入该通道中。

// 申请一个1024字节的缓冲区
ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
// 将内容写入缓冲区
byteBuffer.put(content.getBytes());
// 反转缓冲区
byteBuffer.flip();
// 将缓冲区中的内容写入到 Socket 通道中
socketChannel.write(byteBuffer);
// 清除缓冲区
byteBuffer.clear();

示例代码

服务端示例代码

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.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;

/**
 * @author 码农StayUp
 * @date 2021/4/16 0016
 */
public class NioServer {
   

    private static final int PORT = 8080;

    public static void main(String[] args) throws IOException {
   

        // 在本地打开一个 ServerSocket 通道
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        // 将该通道配置为非阻塞
        serverSocketChannel.configureBlocking(false);
        // 绑定本地端口
        serverSocketChannel.bind(new InetSocketAddress(PORT));
        System.out.printf("[%s] - 服务端启动了，端口为：%s\n", Thread.currentThread().getName(), PORT);

        // 打开一个选择器（多路复用）
        Selector selector = Selector.open();
        // 将该通道的接入事件注册到选择器中
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        // 通过选择器轮询获取该通道上的 I/O 事件。该操作会阻塞
        while (selector.select() > 0) {
   
            // 获取选择器中所有准备就绪的事件，并进行迭代
            Iterator<SelectionKey> it = selector.selectedKeys().iterator();
            // 遍历所有准备好的事件
            while (it.hasNext()) {
   
                // 获取当前事件
                SelectionKey selectionKey = it.next();
                // 从迭代器中移除当前事件
                it.remove();
                // 根据不同的事件，做不同的操作
                if (selectionKey.isAcceptable()) {
   
                    // 接收事件，表示一个 Socket 连接上来了
                    // 获取当前接入的通道
                    SocketChannel socketChannel = serverSocketChannel.accept();
                    System.out.printf("[%s] - 有一个客户端连上来了 - %s\n", Thread.currentThread().getName(), socketChannel.getRemoteAddress());
                    // 将接入的通道设为非阻塞
                    socketChannel.configureBlocking(false);
                    // 将该接入的通道的读事件注册到选择器中
                    socketChannel.register(selector, SelectionKey.OP_READ);
                } else if (selectionKey.isReadable()) {
   
                    // 读取事件，表示有客户端发来消息
                    // 获取产生事件的通道
                    socketHandler((SocketChannel) selectionKey.channel());
                }
            }
        }
    }

    /**
     * 处理 Socket 通道
     * @param socketChannel
     * @throws IOException
     */
    private static void socketHandler(SocketChannel socketChannel) throws IOException {
   
        // 申请一个1024个字节的缓冲区
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        // 读取该通道的内容至缓冲区（将内容写入缓冲区）
        while (socketChannel.read(byteBuffer) > 0) {
   
            // 将缓冲区进行反转（刚才是写入，反转后变为读取）
            byteBuffer.flip();
            // 读取缓冲区中的内容，并转为字符串
            String content = new String(byteBuffer.array(), 0, byteBuffer.limit());
            System.out.printf("[%s] - 接收客户端发来的内容：%s\n", Thread.currentThread().getName(), content);
            // 清除缓冲区
            byteBuffer.clear();
        }
    }
}

客户端示例代码

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.util.Scanner;

/**
 * @author 码农StayUp
 * @date 2021/4/16 0016
 */
public class NioClient {
   

    private static final String HOST = "127.0.0.1";
    private static final int PORT = 8080;

    public static void main(String[] args) throws IOException {
   

        // 打开一个 Socket 通道，并绑定指定的服务端地址与端口
        SocketChannel socketChannel = SocketChannel.open();
        // 将该通道设为非阻塞
        socketChannel.configureBlocking(false);
        // 连接远程地址
        socketChannel.connect(new InetSocketAddress(HOST, PORT));

        // 申请一个1024字节的缓冲区
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        // 获取控制台输入内容
        Scanner scanner = new Scanner(System.in);
        while (true) {
   
            System.out.print("请输入：");
            String content = scanner.nextLine();
            if ("quit".equals(content)) {
   
                break;
            }
            // 将控制台输入的内容写入缓冲区
            byteBuffer.put(content.getBytes());
            // 反转缓冲区（从写入变为读取）
            byteBuffer.flip();
            // 将缓冲区中的内容写入到 Socket 通道中
            socketChannel.write(byteBuffer);
            // 清除缓冲区
            byteBuffer.clear();
        }
        scanner.close();
        socketChannel.close();
    }
}