使用 Java NIO 实现简单的 TCP 服务器

Java NIO（New Input/Output）提供了一种非阻塞 I/O 模型，适合高效处理多个客户端连接。它基于 Channels、Buffers 和 Selector 组件，能显著提升服务器性能。下面我将从绑定端口到处理客户端连接，逐步解释完整流程，并提供一个可运行的代码示例。流程包括：创建通道、绑定端口、设置非阻塞模式、注册事件、循环处理连接和数据传输。

完整流程步骤

1. 创建 ServerSocketChannel 并绑定端口：

   • 使用 ServerSocketChannel.open() 创建服务器通道。
   • 调用 bind() 方法绑定到指定端口（如 8080），并配置选项（如重用地址）。
   • 设置通道为非阻塞模式（configureBlocking(false)）。

2. 创建 Selector 并注册事件：

   • 使用 Selector.open() 创建选择器。
   • 将 ServerSocketChannel 注册到选择器，监听 SelectionKey.OP_ACCEPT 事件（表示新连接请求）。

3. 事件循环处理：

   • 在无限循环中调用 selector.select() 等待事件（如新连接或数据到达）。
   • 遍历已就绪的键（selectedKeys），处理不同类型事件：
     • ACCEPT 事件：接受客户端连接，创建 SocketChannel，并注册到选择器监听 SelectionKey.OP_READ（数据读取）。
     • READ 事件：读取客户端数据，处理业务逻辑（如回显消息）。
     • WRITE 事件（可选）：向客户端写入数据。
   • 移除已处理的键，避免重复。

4. 处理客户端连接和数据：

   • 对于每个 READ 事件，使用 ByteBuffer 读取数据，并解析字节流。
   • 实现简单业务逻辑（如将数据回显给客户端）。
   • 关闭通道时释放资源（使用 try-with-resources 或 finally 块）。

5. 资源清理：

   • 服务器结束时关闭选择器和通道。

完整代码示例

以下是一个简单的 TCP 服务器实现，监听端口 8080，接受客户端连接，并将收到的消息回显给客户端。代码使用 Java 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.util.Iterator;
import java.util.Set;

public class SimpleNioTcpServer {
    public static void main(String[] args) {
        // 1. 创建 ServerSocketChannel 并绑定端口
        try (ServerSocketChannel serverChannel = ServerSocketChannel.open();
             Selector selector = Selector.open()) {
            
            serverChannel.bind(new InetSocketAddress(8080)); // 绑定到端口 8080
            serverChannel.configureBlocking(false); // 设置为非阻塞模式
            
            // 2. 注册 ACCEPT 事件到选择器
            serverChannel.register(selector, SelectionKey.OP_ACCEPT);
            System.out.println("服务器启动，监听端口 8080...");
            
            // 3. 事件循环处理
            while (true) {
                selector.select(); // 阻塞等待事件
                Set<SelectionKey> selectedKeys = selector.selectedKeys();
                Iterator<SelectionKey> keyIterator = selectedKeys.iterator();
                
                while (keyIterator.hasNext()) {
                    SelectionKey key = keyIterator.next();
                    keyIterator.remove(); // 移除键，避免重复处理
                    
                    try {
                        if (key.isAcceptable()) {
                            // 处理 ACCEPT 事件：接受新连接
                            ServerSocketChannel server = (ServerSocketChannel) key.channel();
                            SocketChannel clientChannel = server.accept();
                            clientChannel.configureBlocking(false);
                            clientChannel.register(selector, SelectionKey.OP_READ); // 注册 READ 事件
                            System.out.println("客户端连接: " + clientChannel.getRemoteAddress());
                        } else if (key.isReadable()) {
                            // 处理 READ 事件：读取数据并回显
                            SocketChannel clientChannel = (SocketChannel) key.channel();
                            ByteBuffer buffer = ByteBuffer.allocate(1024); // 创建缓冲区
                            int bytesRead = clientChannel.read(buffer);
                            
                            if (bytesRead > 0) {
                                buffer.flip(); // 切换为读模式
                                byte[] data = new byte[buffer.remaining()];
                                buffer.get(data);
                                String message = new String(data);
                                System.out.println("收到消息: " + message);
                                
                                // 回显消息给客户端
                                ByteBuffer response = ByteBuffer.wrap(("回显: " + message).getBytes());
                                clientChannel.write(response);
                            } else if (bytesRead == -1) {
                                // 客户端关闭连接
                                System.out.println("客户端断开连接");
                                clientChannel.close();
                            }
                        }
                    } catch (IOException e) {
                        System.err.println("处理事件错误: " + e.getMessage());
                        key.cancel(); // 取消键，避免无效操作
                        if (key.channel() != null) {
                            key.channel().close();
                        }
                    }
                }
            }
        } catch (IOException e) {
            System.err.println("服务器异常: " + e.getMessage());
        }
    }
}

关键点解释

• 绑定端口：serverChannel.bind(new InetSocketAddress(8080)) 将服务器绑定到端口 8080。configureBlocking(false) 确保非阻塞模式。
• 事件注册：serverChannel.register(selector, SelectionKey.OP_ACCEPT) 注册 ACCEPT 事件。当新连接到来时，Selector 会通知。
• 事件循环：selector.select() 阻塞直到事件发生。遍历 selectedKeys 处理事件，使用 keyIterator.remove() 防止重复。
• 处理连接：在 ACCEPT 事件中，server.accept() 接受连接，创建 SocketChannel，并注册 READ 事件。
• 读取数据：在 READ 事件中，使用 ByteBuffer 读取数据。buffer.flip() 切换缓冲区模式，便于处理字节。
• 回显逻辑：示例中简单地将消息回显给客户端（clientChannel.write(response)）。您可以根据需求修改业务逻辑。
• 资源管理：try-with-resources 自动关闭通道和选择器。异常处理确保服务器稳定。

优点和注意事项

• 优点：NIO 模型高效处理多连接，资源占用低（单线程即可）。适合高并发场景。
• 注意事项：
  • 本示例是基础版本，实际中需添加更多错误处理（如端口占用、缓冲区溢出）。
  • 对于复杂业务，考虑使用线程池处理耗时操作，避免阻塞事件循环。
  • 测试时，使用 Telnet 或 Netcat 工具连接 localhost:8080 发送消息。

通过以上步骤，您能快速构建一个简单的 TCP 服务器。Java NIO 提供了灵活性，但需要理解事件驱动模型。如果有特定需求（如自定义协议），可以扩展此框架。