JAVA：网络编程 Socket 的技术指南

1、简述

Java NIO（Non-blocking I/O）是一种基于通道（Channel）和缓冲区（Buffer）的 I/O 模型，支持非阻塞通信和多路复用，适合高并发场景。相比传统的阻塞 I/O（BIO），NIO 更高效，因为它避免了线程被阻塞，降低了系统资源消耗。

代码样例：https://gitee.com/lhdxhl/springboot-example.git

核心组件：

• Channel（通道）：数据读写的双向通道。
• Buffer（缓冲区）：存储读写数据。
• Selector（选择器）：用于多路复用管理多个通道。

2、核心原理

NIO 的非阻塞特性通过 Selector 实现：

• Selector 通过轮询管理多个通道。
• 每个通道注册一个事件（如连接建立、数据到达）。
• 当事件就绪时，Selector 通知相应的通道进行处理。

NIO 常见的应用场景：

• 高并发服务器，如聊天系统、游戏服务器、即时通讯应用。
• 网络爬虫，需同时处理大量连接。
• 高吞吐量场景，如日志处理系统。

3、实践样例

3.1 Socket 通信

下面以简单的 NIO Socket 服务器 和 客户端 实现为例，展示如何使用 NIO 处理网络通信。

服务端代码

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;

public class NioServer {
    public static void main(String[] args) throws IOException {
        // 1. 创建 ServerSocketChannel
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.bind(new InetSocketAddress(8080));
        serverChannel.configureBlocking(false); // 设置为非阻塞模式

        // 2. 创建 Selector
        Selector selector = Selector.open();
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);

        System.out.println("NIO Server started on port 8080...");

        while (true) {
            selector.select(); // 阻塞等待事件发生
            Iterator<SelectionKey> keys = selector.selectedKeys().iterator();

            while (keys.hasNext()) {
                SelectionKey key = keys.next();
                keys.remove();

                if (key.isAcceptable()) { // 处理连接事件
                    handleAccept(key);
                } else if (key.isReadable()) { // 处理读事件
                    handleRead(key);
                }
            }
        }
    }

    private static void handleAccept(SelectionKey key) throws IOException {
        ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
        SocketChannel clientChannel = serverChannel.accept();
        clientChannel.configureBlocking(false);

        System.out.println("Connected to client: " + clientChannel.getRemoteAddress());
        clientChannel.register(key.selector(), SelectionKey.OP_READ);
    }

    private static void handleRead(SelectionKey key) throws IOException {
        SocketChannel clientChannel = (SocketChannel) key.channel();
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        int bytesRead = clientChannel.read(buffer);

        if (bytesRead == -1) {
            System.out.println("Client disconnected: " + clientChannel.getRemoteAddress());
            clientChannel.close();
            key.cancel();
            return;
        }

        buffer.flip();
        String message = new String(buffer.array(), 0, buffer.limit());
        System.out.println("Received: " + message);

        // 回显消息
        clientChannel.write(ByteBuffer.wrap(("Echo: " + message).getBytes()));
    }
}

客户端代码

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

public class NioClient {
    public static void main(String[] args) {
        try {
            // 1. 创建 SocketChannel
            SocketChannel socketChannel = SocketChannel.open();
            socketChannel.configureBlocking(false);

            // 2. 连接服务器
            if (!socketChannel.connect(new InetSocketAddress("localhost", 8080))) {
                while (!socketChannel.finishConnect()) {
                    System.out.println("Connecting to server...");
                }
            }

            System.out.println("Connected to server!");

            // 3. 发送数据
            String message = "Hello NIO Server!";
            ByteBuffer buffer = ByteBuffer.wrap(message.getBytes());
            socketChannel.write(buffer);

            // 4. 接收服务器响应
            buffer.clear();
            socketChannel.read(buffer);
            buffer.flip();
            System.out.println("Received from server: " + new String(buffer.array(), 0, buffer.limit()));

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

3.2 广播消息服务（简易聊天室）

服务端维护多个客户端连接，并实现消息广播。

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 NioChatServer {
    private static final int PORT = 8082;

    public static void main(String[] args) throws IOException {
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.bind(new InetSocketAddress(PORT));
        serverChannel.configureBlocking(false);

        Selector selector = Selector.open();
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);

        System.out.println("Chat Server started on port " + PORT);

        while (true) {
            selector.select();
            Iterator<SelectionKey> keys = selector.selectedKeys().iterator();

            while (keys.hasNext()) {
                SelectionKey key = keys.next();
                keys.remove();

                if (key.isAcceptable()) {
                    handleAccept(key, selector);
                } else if (key.isReadable()) {
                    handleRead(key, selector);
                }
            }
        }
    }

    private static void handleAccept(SelectionKey key, Selector selector) throws IOException {
        ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
        SocketChannel clientChannel = serverChannel.accept();
        clientChannel.configureBlocking(false);
        clientChannel.register(selector, SelectionKey.OP_READ);
        System.out.println("Client connected: " + clientChannel.getRemoteAddress());
    }

    private static void handleRead(SelectionKey key, Selector selector) throws IOException {
        SocketChannel clientChannel = (SocketChannel) key.channel();
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        int bytesRead = clientChannel.read(buffer);

        if (bytesRead == -1) {
            System.out.println("Client disconnected: " + clientChannel.getRemoteAddress());
            clientChannel.close();
            key.cancel();
            return;
        }

        buffer.flip();
        String message = new String(buffer.array(), 0, buffer.limit());
        System.out.println("Received: " + message);

        // 广播消息
        broadcastMessage(selector, clientChannel, message);
    }

    private static void broadcastMessage(Selector selector, SocketChannel sender, String message) throws IOException {
        Set<SelectionKey> keys = selector.keys();
        for (SelectionKey key : keys) {
            if (key.channel() instanceof SocketChannel && key.channel() != sender) {
                SocketChannel clientChannel = (SocketChannel) key.channel();
                clientChannel.write(ByteBuffer.wrap(message.getBytes()));
            }
        }
    }
}

3.3 心跳检测

服务器实现定时心跳检测，断开空闲连接。

private static void handleHeartbeat(Selector selector) {
    Set<SelectionKey> keys = selector.keys();
    for (SelectionKey key : keys) {
        if (key.channel() instanceof SocketChannel) {
            SocketChannel clientChannel = (SocketChannel) key.channel();
            try {
                clientChannel.write(ByteBuffer.wrap("HEARTBEAT".getBytes()));
            } catch (IOException e) {
                try {
                    clientChannel.close();
                    key.cancel();
                    System.out.println("Disconnected idle client.");
                } catch (IOException ex) {
                    ex.printStackTrace();
                }
            }
        }
    }
}

4、NIO 的优缺点

优点：

• 高效的非阻塞 I/O，支持高并发。
• 通过 Selector 实现多路复用，减少线程开销。

缺点：

• 编码复杂度高。
• 对小数据量通信优化效果不明显

改进和扩展

• 线程池化：使用线程池处理业务逻辑，避免单线程处理瓶颈。
• 协议支持：结合 Netty 等框架实现高效通信协议支持。
• 连接管理：实现连接超时管理和心跳检测，提升可靠性。

5、总结

NIO 提供了一种高效的非阻塞 I/O 解决方案，在高并发场景中表现出色。通过实践样例，我们可以快速构建高效的网络通信服务。同时，NIO 的复杂性要求我们在实际开发中关注编码质量与扩展性。