TCP、UDP 与 NIO 基础

import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class UdpServer {
  public static void main(String[] args) throws Exception {
    try (DatagramSocket serverSocket = new DatagramSocket(9001)) {  // 监听 9001 端口
      byte[] buffer = new byte[1024];
      System.out.println("UDP 服务端已启动,监听端口 9001...");
      // 服务端通常循环接收
      while (true) {
        // 准备接收数据报
        DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
        serverSocket.receive(packet);   // 阻塞等待,收到后填充 packet

        String msg = new String(packet.getData(), 0, packet.getLength());
        System.out.println("收到客户端消息: " + msg);

        // 回显: 把收到的数据原样发回给客户端
        DatagramPacket response = new DatagramPacket(
            packet.getData(), packet.getLength(),
            packet.getAddress(), packet.getPort());   // 使用发送方的地址与端口
        serverSocket.send(response);
      }
    }
  }
}

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class UdpClient {
  public static void main(String[] args) throws Exception {
    try (DatagramSocket socket = new DatagramSocket()) {
      InetAddress serverAddr = InetAddress.getByName("localhost");
      String msg = "Hello UDP Server";
      byte[] data = msg.getBytes();

      // 发送数据报给服务端
      DatagramPacket sendPacket = new DatagramPacket(
          data, data.length, serverAddr, 9001);
      socket.send(sendPacket);

      // 接收服务端回显
      byte[] buffer = new byte[1024];
      DatagramPacket recvPacket = new DatagramPacket(buffer, buffer.length);
      socket.receive(recvPacket);

      String reply = new String(recvPacket.getData(), 0, recvPacket.getLength());
      System.out.println("收到服务端回显: " + reply);
    }
  }
}

// 发送方：固定长度消息编码
public void sendFixedLengthMessage(SocketChannel channel, String message) throws IOException {
    // 固定消息长度为 100 字节
    byte[] bytes = message.getBytes(StandardCharsets.UTF_8);
    ByteBuffer buffer = ByteBuffer.allocate(100);
    buffer.put(bytes);
    // 不足部分用空字节填充
    while (buffer.hasRemaining()) {
        buffer.put((byte) 0);
    }
    buffer.flip();
    channel.write(buffer);
}

// 接收方：固定长度消息解码
public String receiveFixedLengthMessage(SocketChannel channel) throws IOException {
    ByteBuffer buffer = ByteBuffer.allocate(100);
    int totalRead = 0;
    while (totalRead < 100) {
        int read = channel.read(buffer);
        if (read == -1) {
            throw new IOException("连接已关闭");
        }
        totalRead += read;
    }
    buffer.flip();
    byte[] bytes = new byte[buffer.remaining()];
    buffer.get(bytes);
    // 去除填充字节
    return new String(bytes, StandardCharsets.UTF_8).trim();
}

public class DelimiterBasedMessage {
    private static final String DELIMITER = "\r\n";

    // 发送方：追加分隔符
    public void sendDelimitedMessage(SocketChannel channel, String message) throws IOException {
        String delimitedMessage = message + DELIMITER;
        ByteBuffer buffer = StandardCharsets.UTF_8.encode(delimitedMessage);
        channel.write(buffer);
    }

    // 接收方：按分隔符切分消息
    public String receiveDelimitedMessage(SocketChannel channel, ByteBuffer readBuffer) throws IOException {
        while (true) {
            int read = channel.read(readBuffer);
            if (read == -1) {
                throw new IOException("连接已关闭");
            }

            readBuffer.flip();
            String data = StandardCharsets.UTF_8.decode(readBuffer).toString();

            int delimiterIndex = data.indexOf(DELIMITER);
            if (delimiterIndex != -1) {
                String message = data.substring(0, delimiterIndex);
                // 保留剩余数据到 readBuffer
                readBuffer.compact();
                return message;
            }

            readBuffer.compact();
        }
    }
}

public class LengthFieldBasedMessage {
    // 消息头:4 字节长度字段 + 消息体

    // 发送方：先写长度再写消息体
    public void sendMessage(SocketChannel channel, String message) throws IOException {
        byte[] body = message.getBytes(StandardCharsets.UTF_8);
        int length = body.length;

        ByteBuffer buffer = ByteBuffer.allocate(4 + length);
        buffer.putInt(length);  // 长度字段
        buffer.put(body);       // 消息体
        buffer.flip();

        channel.write(buffer);
    }

    // 接收方：先读长度再按长度读消息体
    public String receiveMessage(SocketChannel channel, ByteBuffer readBuffer) throws IOException {
        while (true) {
            int read = channel.read(readBuffer);
            if (read == -1) {
                throw new IOException("连接已关闭");
            }

            readBuffer.flip();

            // 至少要有 4 字节才能读取长度
            if (readBuffer.remaining() < 4) {
                readBuffer.compact();
                continue;
            }

            // 读取长度字段
            int length = readBuffer.getInt();

            // 检查是否收到完整的消息体
            if (readBuffer.remaining() < length) {
                readBuffer.rewind();  // 重置 position
                readBuffer.compact();
                continue;
            }

            // 读取消息体
            byte[] body = new byte[length];
            readBuffer.get(body);

            readBuffer.compact();
            return new String(body, StandardCharsets.UTF_8);
        }
    }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class BioServer {

    public static void main(String[] args) throws Exception {
        ServerSocket serverSocket = new ServerSocket(8080);
        System.out.println("BIO 服务端已启动,端口:8080");

        // 使用线程池避免无限创建线程
        ExecutorService threadPool = Executors.newFixedThreadPool(100);

        while (true) {
            Socket socket = serverSocket.accept(); // 阻塞等待连接
            System.out.println("客户端连接:" + socket.getRemoteSocketAddress());
            threadPool.submit(() -> handleClient(socket));
        }
    }

    private static void handleClient(Socket socket) {
        try (
            Socket clientSocket = socket;
            BufferedReader reader = new BufferedReader(
                new InputStreamReader(clientSocket.getInputStream(), StandardCharsets.UTF_8));
            PrintWriter writer = new PrintWriter(
                new OutputStreamWriter(clientSocket.getOutputStream(), StandardCharsets.UTF_8), true)
        ) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println("收到请求:" + line);
                writer.println("服务端响应:" + line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println("客户端断开:" + socket.getRemoteSocketAddress());
        }
    }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;
import java.nio.charset.StandardCharsets;

public class BioClient {

    public static void main(String[] args) throws Exception {
        Socket socket = new Socket("localhost", 8080);

        try (
            BufferedReader reader = new BufferedReader(
                new InputStreamReader(socket.getInputStream(), StandardCharsets.UTF_8));
            PrintWriter writer = new PrintWriter(
                new OutputStreamWriter(socket.getOutputStream(), StandardCharsets.UTF_8), true);
            BufferedReader consoleReader = new BufferedReader(
                new InputStreamReader(System.in))
        ) {
            System.out.println("已连接到服务端,输入消息(输入 quit 退出):");

            String input;
            while ((input = consoleReader.readLine()) != null) {
                if ("quit".equals(input)) {
                    break;
                }

                writer.println(input);
                String response = reader.readLine();
                System.out.println("服务端响应:" + response);
            }
        }
    }
}

// ServerSocketChannel 使用示例
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.configureBlocking(false); // 设置为非阻塞模式
serverChannel.bind(new InetSocketAddress(8080));

// SocketChannel 使用示例
SocketChannel socketChannel = SocketChannel.open();
socketChannel.configureBlocking(false); // 设置为非阻塞模式
socketChannel.connect(new InetSocketAddress("localhost", 8080));

ByteBuffer buffer = ByteBuffer.allocate(1024); // 分配缓冲区

// 写入数据到缓冲区
buffer.put("Hello".getBytes(StandardCharsets.UTF_8));

// 切换到读模式
buffer.flip();

// 从缓冲区读取数据
byte[] data = new byte[buffer.remaining()];
buffer.get(data);

// 清空缓冲区,准备下次写入
buffer.clear();

// compact():保留未读数据,将 position 移到未读数据之后
buffer.compact();

// Selector 使用示例
Selector selector = Selector.open();

// 将 Channel 注册到 Selector
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.configureBlocking(false);
serverChannel.bind(new InetSocketAddress(8080));
serverChannel.register(selector, SelectionKey.OP_ACCEPT);

// 事件循环
while (true) {
    int readyChannels = selector.select(); // 阻塞等待就绪事件
    if (readyChannels == 0) continue;

    Set<SelectionKey> selectedKeys = selector.selectedKeys();
    Iterator<SelectionKey> iterator = selectedKeys.iterator();

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

        if (key.isAcceptable()) {
            // 处理连接
        } else if (key.isReadable()) {
            // 处理读
        } else if (key.isWritable()) {
            // 处理写
        }
    }
}

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.nio.charset.StandardCharsets;
import java.util.Iterator;
import java.util.Set;

public class NioServer {

    private Selector selector;
    private ServerSocketChannel serverChannel;
    private static final int BUFFER_SIZE = 1024;

    public static void main(String[] args) throws Exception {
        NioServer server = new NioServer();
        server.start(8080);
    }

    public void start(int port) throws Exception {
        // 1. 打开 Selector
        selector = Selector.open();

        // 2. 创建 ServerSocketChannel
        serverChannel = ServerSocketChannel.open();
        serverChannel.configureBlocking(false);
        serverChannel.bind(new InetSocketAddress(port));

        // 3. 注册 ACCEPT 事件
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);

        System.out.println("NIO 服务端已启动,端口:" + port);

        // 4. 事件循环
        while (true) {
            int readyChannels = selector.select();
            if (readyChannels == 0) continue;

            Set<SelectionKey> selectedKeys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = selectedKeys.iterator();

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

                try {
                    if (key.isAcceptable()) {
                        handleAccept(key);
                    } else if (key.isReadable()) {
                        handleRead(key);
                    } else if (key.isWritable()) {
                        handleWrite(key);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                    closeChannel(key);
                }
            }
        }
    }

    private void handleAccept(SelectionKey key) throws Exception {
        ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
        SocketChannel socketChannel = serverChannel.accept();
        socketChannel.configureBlocking(false);

        // 注册 READ 事件,并附加一个 Buffer
        socketChannel.register(selector, SelectionKey.OP_READ, ByteBuffer.allocate(BUFFER_SIZE));
        System.out.println("客户端已连接:" + socketChannel.getRemoteAddress());
    }

    private void handleRead(SelectionKey key) throws Exception {
        SocketChannel socketChannel = (SocketChannel) key.channel();
        ByteBuffer buffer = (ByteBuffer) key.attachment();
        buffer.clear();

        int readBytes = socketChannel.read(buffer);
        if (readBytes == -1) {
            // 客户端关闭连接
            System.out.println("客户端断开:" + socketChannel.getRemoteAddress());
            closeChannel(key);
            return;
        }

        if (readBytes > 0) {
            buffer.flip();
            String message = StandardCharsets.UTF_8.decode(buffer).toString();
            System.out.println("收到消息[" + socketChannel.getRemoteAddress() + "]:" + message);

            // 发送响应
            buffer.clear();
            buffer.put(("服务端响应:" + message).getBytes(StandardCharsets.UTF_8));
            buffer.flip();
            socketChannel.write(buffer);
        }
    }

    private void handleWrite(SelectionKey key) throws Exception {
        SocketChannel socketChannel = (SocketChannel) key.channel();
        // 写操作通常在 read 处理中完成
        // 如果写缓冲区满,才需要注册 OP_WRITE 事件
        key.interestOps(SelectionKey.OP_READ);
    }

    private void closeChannel(SelectionKey key) {
        try {
            key.channel().close();
            key.cancel();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.nio.charset.StandardCharsets;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Set;

public class NioClient {

    private Selector selector;
    private SocketChannel socketChannel;
    private static final int BUFFER_SIZE = 1024;

    public static void main(String[] args) throws Exception {
        NioClient client = new NioClient();
        client.start("localhost", 8080);
    }

    public void start(String host, int port) throws Exception {
        // 1. 打开 Selector
        selector = Selector.open();

        // 2. 创建 SocketChannel
        socketChannel = SocketChannel.open();
        socketChannel.configureBlocking(false);

        // 3. 连接服务端
        boolean connected = socketChannel.connect(new InetSocketAddress(host, port));

        if (connected) {
            // 连接成功,注册 READ 事件
            socketChannel.register(selector, SelectionKey.OP_READ, ByteBuffer.allocate(BUFFER_SIZE));
            System.out.println("已连接到服务端");
        } else {
            // 连接中,注册 CONNECT 事件
            socketChannel.register(selector, SelectionKey.OP_CONNECT);
        }

        // 4. 启动读线程
        new Thread(this::readFromServer).start();

        // 5. 主线程处理用户输入
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextLine()) {
            String message = scanner.nextLine();
            if ("quit".equals(message)) {
                break;
            }
            sendMessage(message);
        }

        socketChannel.close();
        selector.close();
    }

    private void readFromServer() {
        try {
            while (true) {
                int readyChannels = selector.select();
                if (readyChannels == 0) continue;

                Set<SelectionKey> selectedKeys = selector.selectedKeys();
                Iterator<SelectionKey> iterator = selectedKeys.iterator();

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

                    if (key.isConnectable()) {
                        handleConnect(key);
                    } else if (key.isReadable()) {
                        handleRead(key);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private void handleConnect(SelectionKey key) throws Exception {
        SocketChannel socketChannel = (SocketChannel) key.channel();
        if (socketChannel.isConnectionPending()) {
            socketChannel.finishConnect();
        }
        socketChannel.register(selector, SelectionKey.OP_READ, ByteBuffer.allocate(BUFFER_SIZE));
        System.out.println("已连接到服务端");
    }

    private void handleRead(SelectionKey key) throws Exception {
        SocketChannel socketChannel = (SocketChannel) key.channel();
        ByteBuffer buffer = (ByteBuffer) key.attachment();
        buffer.clear();

        int readBytes = socketChannel.read(buffer);
        if (readBytes == -1) {
            System.out.println("服务端关闭连接");
            socketChannel.close();
            return;
        }

        if (readBytes > 0) {
            buffer.flip();
            String message = StandardCharsets.UTF_8.decode(buffer).toString();
            System.out.println("服务端响应:" + message);
        }
    }

    private void sendMessage(String message) throws Exception {
        ByteBuffer buffer = ByteBuffer.wrap(message.getBytes(StandardCharsets.UTF_8));
        while (buffer.hasRemaining()) {
            socketChannel.write(buffer);
        }
    }
}

// EPollSelectorImpl.doSelect() 核心逻辑（简化版）
protected int doSelect(SelectorImpl selector, long timeout) throws IOException {
    // ... 省略中断和唤醒检查 ...

    try {
        // 调用操作系统 epoll_wait
        // pollArray 是存放就绪事件的本地内存区域
        int updated = epollWait(pollArray.address(), NUM_EPOLLEVENTS, timeout, epfd);
        // ... 省略 ...
    } finally {
        // ... 省略 ...
    }

    // 处理就绪事件
    processEvents();
    return selectedKeys.size();
}

// processEvents() 遍历就绪 fd
private void processEvents() {
    for (int i = 0; i < updated; i++) {
        // 从 pollArray 读取就绪的 fd 和事件
        long event = pollArray.getEvent(i);
        int fd = pollArray.getDescriptor(i);
        // 根据 fd 找到对应的 SelectionKey
        SelectionKeyImpl ski = fdToKey.get(fd);
        if (ski != null) {
            // 更新 readyOps
            int ops = eventOps(event);
            ski.channel.translateAndSetReadyOps(ops, ski);
            // 将 ski 加入 selectedKeys 集合
            selectedKeys.add(ski);
        }
    }
}

// Netty NioEventLoop 的修复逻辑（简化版）
int selectCnt = 0; // 空轮询计数器

for (;;) {
    int selectedKeys = selector.select(timeoutMillis);
    selectCnt++;

    // 如果 select 返回了事件,或者被唤醒,或者有定时任务,重置计数器
    if (selectedKeys != 0 || oldWakenUp || wakenUp || hasTasks()) {
        selectCnt = 0; // 正常情况,重置计数器
    }
    // 如果空轮询次数超过阈值（默认 512）
    else if (selectCnt >= SELECTOR_AUTO_REBUILD_THRESHOLD) {
        // 重建 Selector:创建新的 Selector,将所有 Channel 迁移过去
        selector = selectRebuildSelector(selectCnt);
        selectCnt = 0; // 重置计数器
    }

    // 处理事件和任务...
}

// Netty 重建 Selector 的核心逻辑（简化版）
private Selector selectRebuildSelector(int selectCnt) {
    // 1. 创建新的 Selector
    Selector newSelector = Selector.open();

    // 2. 将所有注册在旧 Selector 上的 Channel 迁移到新 Selector
    for (SelectionKey key : oldSelector.keys()) {
        if (!key.isValid()) continue;

        // 获取 Channel 和兴趣事件
        SelectableChannel channel = key.channel();
        int interestOps = key.interestOps();
        Object attachment = key.attachment();

        // 取消旧 Selector 上的注册
        key.cancel();

        // 注册到新 Selector
        channel.register(newSelector, interestOps, attachment);
    }

    // 3. 关闭旧 Selector
    oldSelector.close();

    return newSelector;
}

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
import java.nio.charset.StandardCharsets;

public class AioServer {

    public static void main(String[] args) throws Exception {
        AsynchronousServerSocketChannel serverChannel = AsynchronousServerSocketChannel.open();
        serverChannel.bind(new InetSocketAddress(8080));
        System.out.println("AIO 服务端已启动,端口:8080");

        // 异步接收连接
        serverChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Void>() {
            @Override
            public void completed(AsynchronousSocketChannel clientChannel, Void attachment) {
                // 继续接收下一个连接
                serverChannel.accept(null, this);

                // 处理客户端连接
                handleClient(clientChannel);
            }

            @Override
            public void failed(Throwable exc, Void attachment) {
                exc.printStackTrace();
            }
        });

        // 防止主线程退出
        Thread.sleep(Long.MAX_VALUE);
    }

    private static void handleClient(AsynchronousSocketChannel clientChannel) {
        ByteBuffer buffer = ByteBuffer.allocate(1024);

        clientChannel.read(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
            @Override
            public void completed(Integer result, ByteBuffer attachment) {
                if (result == -1) {
                    try {
                        clientChannel.close();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    return;
                }

                attachment.flip();
                String message = StandardCharsets.UTF_8.decode(attachment).toString();
                System.out.println("收到消息:" + message);

                // 发送响应
                ByteBuffer responseBuffer = StandardCharsets.UTF_8.encode("服务端响应:" + message);
                clientChannel.write(responseBuffer);

                // 继续读取下一条消息
                attachment.clear();
                clientChannel.read(attachment, attachment, this);
            }

            @Override
            public void failed(Throwable exc, ByteBuffer attachment) {
                exc.printStackTrace();
                try {
                    clientChannel.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }
}

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.nio.charset.StandardCharsets;
import java.util.*;

public class ChatServer {

    private Selector selector;
    private ServerSocketChannel serverChannel;
    private static final int BUFFER_SIZE = 1024;
    private Map<SocketChannel, String> clientNames = new HashMap<>();

    public static void main(String[] args) throws Exception {
        ChatServer server = new ChatServer();
        server.start(8080);
    }

    public void start(int port) throws Exception {
        selector = Selector.open();
        serverChannel = ServerSocketChannel.open();
        serverChannel.configureBlocking(false);
        serverChannel.bind(new InetSocketAddress(port));
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);

        System.out.println("聊天室服务端已启动,端口:" + port);

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

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

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

    private void handleAccept(SelectionKey key) throws Exception {
        ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
        SocketChannel socketChannel = serverChannel.accept();
        socketChannel.configureBlocking(false);
        socketChannel.register(selector, SelectionKey.OP_READ, ByteBuffer.allocate(BUFFER_SIZE));

        String clientName = "用户" + System.currentTimeMillis();
        clientNames.put(socketChannel, clientName);

        System.out.println(clientName + " 已加入聊天室");
        broadcast(clientName + " 已加入聊天室", socketChannel);
    }

    private void handleRead(SelectionKey key) throws Exception {
        SocketChannel socketChannel = (SocketChannel) key.channel();
        ByteBuffer buffer = (ByteBuffer) key.attachment();
        buffer.clear();

        int readBytes = socketChannel.read(buffer);
        if (readBytes == -1) {
            String clientName = clientNames.remove(socketChannel);
            System.out.println(clientName + " 已离开聊天室");
            broadcast(clientName + " 已离开聊天室", socketChannel);
            socketChannel.close();
            return;
        }

        if (readBytes > 0) {
            buffer.flip();
            String message = StandardCharsets.UTF_8.decode(buffer).toString();
            String clientName = clientNames.get(socketChannel);

            System.out.println(clientName + ":" + message);
            broadcast(clientName + ":" + message, socketChannel);
        }
    }

    private void broadcast(String message, SocketChannel excludeChannel) throws Exception {
        ByteBuffer buffer = StandardCharsets.UTF_8.encode(message);

        for (SelectionKey key : selector.keys()) {
            if (key.isValid() && key.channel() instanceof SocketChannel) {
                SocketChannel clientChannel = (SocketChannel) key.channel();
                if (clientChannel != excludeChannel) {
                    buffer.rewind();
                    clientChannel.write(buffer);
                }
            }
        }
    }
}

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.nio.charset.StandardCharsets;
import java.util.Iterator;

public class SimpleHttpServer {

    public static void main(String[] args) throws Exception {
        Selector selector = Selector.open();
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.configureBlocking(false);
        serverChannel.bind(new InetSocketAddress(8080));
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);

        System.out.println("HTTP 服务器已启动,端口:8080");

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

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

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

    private static void handleAccept(Selector selector, SelectionKey key) throws Exception {
        ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
        SocketChannel socketChannel = serverChannel.accept();
        socketChannel.configureBlocking(false);
        socketChannel.register(selector, SelectionKey.OP_READ);
    }

    private static void handleHttpRequest(SelectionKey key) throws Exception {
        SocketChannel socketChannel = (SocketChannel) key.channel();
        ByteBuffer buffer = ByteBuffer.allocate(4096);
        int readBytes = socketChannel.read(buffer);

        if (readBytes == -1) {
            socketChannel.close();
            return;
        }

        if (readBytes > 0) {
            buffer.flip();
            String request = StandardCharsets.UTF_8.decode(buffer).toString();

            // 解析 HTTP 请求
            String[] lines = request.split("\r\n");
            if (lines.length > 0) {
                String[] requestLine = lines[0].split(" ");
                if (requestLine.length >= 2) {
                    String method = requestLine[0];
                    String path = requestLine[1];

                    System.out.println("收到请求:" + method + " " + path);

                    // 构造 HTTP 响应
                    String responseBody = "<html><body><h1>Hello from NIO Server</h1></body></html>";
                    String response = "HTTP/1.1 200 OK\r\n" +
                                     "Content-Type: text/html; charset=UTF-8\r\n" +
                                     "Content-Length: " + responseBody.getBytes(StandardCharsets.UTF_8).length + "\r\n" +
                                     "\r\n" +
                                     responseBody;

                    ByteBuffer responseBuffer = StandardCharsets.UTF_8.encode(response);
                    socketChannel.write(responseBuffer);
                }
            }

            socketChannel.close();
        }
    }
}

// 错误示例:未关闭 Channel
private void handleRead(SelectionKey key) {
    SocketChannel socketChannel = (SocketChannel) key.channel();
    try {
        // 读取数据
    } catch (IOException e) {
        // 异常后未关闭 Channel,导致资源泄漏
        e.printStackTrace();
    }
}

// 正确示例:异常时关闭 Channel
private void handleRead(SelectionKey key) {
    SocketChannel socketChannel = (SocketChannel) key.channel();
    try {
        // 读取数据
    } catch (IOException e) {
        e.printStackTrace();
        try {
            socketChannel.close();
            key.cancel();
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }
}