Java NIO使用案例和说明

最新推荐文章于 2025-04-19 20:03:32 发布

诸葛小猿

最新推荐文章于 2025-04-19 20:03:32 发布

阅读量996

点赞数 24

分类专栏：网络协议文章标签： nio socket java

本文链接：https://blog.youkuaiyun.com/wuxiaolongah/article/details/144749920

版权

网络协议专栏收录该内容

8 篇文章

订阅专栏

Java NIO（New Input/Output）和传统的 Java Socket 编程提供了不同的方法来处理网络通信。Java NIO 引入了非阻塞 I/O 和多路复用的概念，这使得它在处理大量并发连接时比传统的阻塞式 Socket 更加高效。

传统 Java Socket 编程有几个特点：

阻塞式 I/O：传统的 Socket 类是阻塞式的，意味着当你调用 accept(), read(), 或 write() 方法时，线程会一直等待直到操作完成。
一对一模型：每个连接都需要一个独立的线程来处理客户端请求，这在面对大量并发连接时可能导致资源耗尽。
简单易用：API 相对简单，适合初学者或小型应用。

Java NIO是 JDK1.4开始提供的一套新的 I/O API，旨在提供更高效的非阻塞 I/O 操作和更灵活的缓冲区管理。NIO 与传统的 Java I/O API 相比，提供了更好的性能和可扩展性，特别是在处理大量并发连接时。对于需要处理大量并发连接的应用程序，Java NIO 明显优于传统的 Socket 编程。由于它可以使用单个线程管理多个连接，因此减少了线程切换带来的开销。以下是关于 Java NIO 的详细介绍。

Java NIO 的主要特性

缓冲区（Buffer）：
- 概念：Buffer 是一个容器对象，用于存储基本数据类型的值。它提供了一种机制来操作字节、字符等数据。
- 类型：常见的 Buffer 类型包括 ByteBuffer, CharBuffer, ShortBuffer, IntBuffer, LongBuffer, FloatBuffer, 和 DoubleBuffer。
- 方法：Buffer 提供了诸如 put(), get(), flip(), clear() 等方法来操作数据。
通道（Channel）：
- 概念：Channel 是一个能够进行 I/O 操作的对象。与传统的流不同，Channel 可以同时进行读写操作，并且可以是非阻塞的。
- 类型：常见的 Channel 类型包括 FileChannel, SocketChannel, ServerSocketChannel, 和 DatagramChannel。
- 操作：Channel 可以通过 read() 和 write() 方法与 Buffer 进行数据交换。
选择器（Selector）：
- 概念：Selector 允许单个线程管理多个 Channel，从而实现非阻塞 I/O。这对于处理大量并发连接非常有用。
- 注册：Channel 需要注册到 Selector 上，并指定感兴趣的事件类型（如读、写）。
- 选择：通过 select() 方法，Selector 会等待直到至少有一个 Channel 准备好进行 I/O 操作。

下面是一个完整的 Java NIO 客户端和服务端示例。我们将创建一个简单的回显服务器（Echo Server），它接收客户端发送的消息并将其回显给客户端。这个例子将展示如何使用 Selector 来管理多个客户端连接，以及如何通过非阻塞 I/O 进行通信。

服务端代码

package com.wuxiaolong.socket.nio;

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.nio.charset.StandardCharsets;
import java.util.Iterator;

public class EchoServer {
    private static final int PORT = 8080; // 服务器监听的端口号
    private Selector selector; // 选择器用于管理多个通道

    /**
     * 构造函数：初始化选择器并设置服务器通道。
     */
    public EchoServer() throws IOException {
        // 打开选择器，用于多路复用 I/O 操作
        selector = Selector.open();

        // 打开服务器通道，并绑定到指定端口
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.socket().bind(new InetSocketAddress(PORT));
        serverChannel.configureBlocking(false); // 设置为非阻塞模式

        // 注册选择器，监听连接事件（OP_ACCEPT）
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);

        System.out.println("服务器已启动，监听端口 " + PORT);
    }

    /**
     * 启动服务器并进入主循环，处理客户端连接和消息。
     */
    public void start() throws IOException {
        while (true) {
            // 选择已就绪的键（有新连接或可读取的数据）  如果没有事件响应  这里会阻塞
            selector.select();

            // 获取已就绪的键集合，并迭代处理每个键
            Iterator<SelectionKey> selectedKeys = selector.selectedKeys().iterator();
            while (selectedKeys.hasNext()) {
                SelectionKey key = selectedKeys.next();
                selectedKeys.remove(); // 从集合中移除已处理的键

                if (!key.isValid()) { // 如果键无效，跳过
                    continue;
                }

                try {
                    if (key.isAcceptable()) {
                        // 处理新的客户端连接
                        ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
                        SocketChannel clientChannel = serverChannel.accept();
                        if (clientChannel != null) {
                            clientChannel.configureBlocking(false); // 设置为非阻塞模式
                            clientChannel.register(selector, SelectionKey.OP_READ); // 注册读取事件
                            System.out.println("新客户端连接: " + clientChannel.getRemoteAddress());
                        }
                    } else if (key.isReadable()) {
                        // 读取客户端消息
                        SocketChannel clientChannel = (SocketChannel) key.channel();
//                        ByteBuffer readBuffer = ByteBuffer.allocate(256); // 堆上创建缓冲区
                        ByteBuffer readBuffer = ByteBuffer.allocateDirect(256); // 直接内存上创建缓冲区
                        int readBytes = clientChannel.read(readBuffer); // 从通道读取数据到缓冲区


                        if (readBytes == -1) {
                            // 客户端关闭连接
                            clientChannel.close();
                            System.out.println("客户端断开连接");
                        } else if (readBytes > 0) {
                            // 准备回显数据
                            readBuffer.flip(); // 切换缓冲区为读取模式

                            byte[] messageBytes = new byte[readBuffer.remaining()];
                            readBuffer.get(messageBytes);
                            String message = new String(messageBytes, StandardCharsets.UTF_8);
                            System.out.println("收到消息: " + message);

                            // 创建一个新的缓冲区来存储回显数据
                            ByteBuffer writerBuffer = ByteBuffer.wrap(message.getBytes(StandardCharsets.UTF_8));
                            // 回显消息给客户端
                            while (writerBuffer.hasRemaining()) {
                                clientChannel.write(writerBuffer); // 将缓冲区中的数据写回客户端
                            }

                            writerBuffer.clear(); // 清空原始缓冲区以备下次使用
                        }
                    }
                } catch (IOException e) {
                    // 捕获并处理 I/O 异常，确保通道关闭
                    key.cancel();
                    if (key.channel() != null) {
                        try {
                            key.channel().close();
                        } catch (IOException ex) {
                            ex.printStackTrace();
                        }
                    }
                }
            }
        }
    }

    /**
     * 主方法：创建并启动服务器。
     */
    public static void main(String[] args) throws IOException {
        new EchoServer().start();
    }
}

客户端代码

package com.wuxiaolong.socket.nio;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;

public class EchoClient {
    private static final String SERVER_HOST = "localhost"; // 服务器主机地址
    private static final int SERVER_PORT = 8080; // 服务器监听的端口号
    private SocketChannel socketChannel; // 客户端通道

    /**
     * 构造函数：初始化客户端通道并连接到服务器。
     */
    public EchoClient() throws IOException {
        // 打开客户端通道并尝试连接到服务器
        socketChannel = SocketChannel.open();
        socketChannel.connect(new InetSocketAddress(SERVER_HOST, SERVER_PORT));
        socketChannel.configureBlocking(false); // 设置为非阻塞模式
        System.out.println("已连接到服务器 " + SERVER_HOST + ":" + SERVER_PORT);
    }

    /**
     * 发送消息给服务器并接收回显消息。
     *
     * @param message 要发送的消息字符串
     */
    public void sendMessage(String message) throws IOException {
        // 发送消息到服务器
        ByteBuffer writeBuffer = ByteBuffer.wrap(message.getBytes(StandardCharsets.UTF_8));
        socketChannel.write(writeBuffer);

        // 等待服务器回显
        writeBuffer.clear(); // 清空缓冲区
        // 不断读取直到没有更多数据
        while (true){
            ByteBuffer readBuffer = ByteBuffer.allocate(256);
            int bytesRead = socketChannel.read(readBuffer);
            if (bytesRead > 0) {
                readBuffer.flip(); // 切换缓冲区为读取模式
                byte[] responseBytes = new byte[readBuffer.remaining()];
                readBuffer.get(responseBytes);
                String resp = new String(responseBytes, StandardCharsets.UTF_8);
                readBuffer.clear(); // 清空缓冲区以备下次读取
                System.out.println("服务器回显: " + resp);
                break;
            }
        }

    }

    /**
     * 关闭客户端通道。
     */
    public void close() throws IOException {
        socketChannel.close();
        System.out.println("客户端已断开连接");
    }

    /**
     * 主方法：创建客户端并允许用户通过命令行输入消息。
     */
    public static void main(String[] args) {
        try{
            EchoClient client = new EchoClient();
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入要发送的消息（输入 'exit' 退出）：");

            while (true) {
                System.out.print("您: ");
                String message = scanner.nextLine();
                if ("exit".equalsIgnoreCase(message)) {
                    break;
                }
                client.sendMessage(message);
            }

            scanner.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}