public class userAggRoot {
    private Integer userId; //userId是这个实体中的一个值对象。
    private String name; //name也是一个值对象。

    public UserAggRoot getUserInfo(Integer userId) {
        // 获取用户实体的信息
    }

    public void updateUserName(String name) {
        // 更新用户名称
    }

    //getter和setter....
}

public class buyEvent {

    public void buy() {
        // 组装事件信息并且发送事件
    }
}

public class shopAggRoot {
    private Integer shopId; // 商品id值对象
    private String shopName; //商品名称值对象
    private PriceVO price; //价格值对象
    private InventoryVO inventory; //库存值对象

    public void subInventory() {
        // 扣减库存
        // 1. 创建新的库存值对象

        // 2. 替换inventory属性
        // 。。。。
    }
}

public class priceVO{
    private BigDecimal originalPrice; //原价格
    private BigDecimal currentPrice; //当前价格，可能是优惠后的价格等等
}

public class inventoryVO{
    private Long inventory; //库存
}

FileInputStream inputStream = null;
try {
    inputStream = new FileInputStream("example.txt");
    // 读取文件内容
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (inputStream != null) {
        try {
            inputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

FileInputStream inputStream = new FileInputStream("example.txt");
// 使用inputStream读取文件内容
inputStream.close(); // 如果这里抛出异常，资源可能无法正确关闭

FileInputStream inputStream = null;
try {
    inputStream = new FileInputStream("example.txt");
    // 读取文件内容，可能抛出异常
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (inputStream != null) {
        try {
            inputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

try (资源声明) {
    // 使用资源
} catch (异常类型 异常变量) {
    // 处理异常
}

try (FileInputStream inputStream = new FileInputStream("example.txt")) {
    // 使用inputStream读取文件内容
} catch (IOException e) {
    e.printStackTrace();
}

try (FileInputStream inputStream = new FileInputStream("input.txt");
     FileOutputStream outputStream = new FileOutputStream("output.txt")) {
    // 使用inputStream读取文件内容并写入outputStream
} catch (IOException e) {
    e.printStackTrace();
}

public class MyResource implements AutoCloseable {
    @Override
    public void close() throws Exception {
        System.out.println("资源已关闭");
    }
}

try (MyResource myResource = new MyResource()) {
    // 使用myResource
} catch (Exception e) {
    e.printStackTrace();
}

// 伪代码：Flink实时处理用户滑动事件  
DataStream<UserAction> actions = env.addSource(kafkaSource);  
actions  
  .keyBy(userId)  
  .process(new UpdateProfileFunction()) // 实时更新画像  
  .addSink(recommendSink); // 触发推荐计算  

// 伪代码：缓存击穿防护  
RLock lock = redisson.getLock("VIDEO:123");  
if (lock.tryLock()) {  
    try {  
        data = db.getVideo(123);  
        redis.set("VIDEO:123", data, 60);  
    } finally {  
        lock.unlock();  
    }  
}  

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class SocketServer {

    private static final String FILE_PATH = "HelloWorld.java";
    private static String readFileAsString(String filePath) throws IOException {
        StringBuilder contentBuilder = new StringBuilder();
        try (BufferedReader br = new BufferedReader(new FileReader(filePath))) {
            String currentLine;
            while ((currentLine = br.readLine()) != null) {
                System.out.println(currentLine); // 打印读取的每一行
                contentBuilder.append(currentLine).append("\n");
            }
        }
        return contentBuilder.toString();
    }
    public static void main(String[] args) {
        int port = 8888; // 服务器监听的端口号
        try {
            // 创建服务器端的ServerSocket，绑定端口号
            ServerSocket serverSocket = new ServerSocket(port);
            System.out.println("Server is running and listening on port " + port);

            // 服务器无限循环，等待客户端连接
            while (true) {
                // 服务器调用accept()方法，阻塞并等待客户端连接
                Socket clientSocket = serverSocket.accept();
                System.out.println("Client connected.");

                try {
                    // 读取HTTP请求
                    BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
                    String inputLine;
                    StringBuilder request = new StringBuilder();
                    while ((inputLine = in.readLine()) != null && !inputLine.isEmpty()) {
                        request.append(inputLine).append("\n");
                    }
                    
                    // 发送HTTP响应
                    PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
                    String fileContent = readFileAsString(FILE_PATH);
                    long contentLength = fileContent.getBytes().length;
                    String response = "HTTP/1.1 200 OK\r\n" +
                            "Content-Type: application/json\r\n" +
                            "Content-Length: " + contentLength + "\r\n" +
                            "Connection: close\r\n" +
                            "\r\n" +
                            fileContent;
                    out.println(response);

                    // 关闭连接
                    clientSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                System.out.println("Client says: hello world!");

                // 关闭连接
                clientSocket.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public ServerSocket(int port) throws IOException {
    //调用了另外一个构造函数
    this(port, 50, null);
}

public ServerSocket(int port, int backlog, InetAddress bindAddr) throws IOException {
  // 参数检测
  if (port < 0 || port > 0xFFFF)
      throw new IllegalArgumentException("Port value out of range: " + port);
  if (backlog < 1)
      backlog = 50;

  // 创建了一个实现类
  this.impl = createImpl();
  try {
      // 调用了bind方法
      bind(new InetSocketAddress(bindAddr, port), backlog);
  } catch (IOException | SecurityException e) {
      close();
      throw e;
  }
}

/**
 * 将服务器Socket绑定到指定的端点地址并设置监听队列长度
 * 此方法确保Socket未关闭且未绑定，并验证端点地址和backlog参数的合法性
 * 如果满足所有条件，则进行绑定和监听设置
 * 
 * @param endpoint 要绑定的端点地址，如果为null，则创建一个未指定端口的InetSocketAddress实例
 * @param backlog 监听队列的长度，如果小于1，则使用默认值50
 * @throws IOException 如果绑定或监听过程中发生I/O错误
 * @throws SocketException 如果Socket已关闭、已绑定、地址未解析或不支持的地址类型
 * @throws IllegalArgumentException 如果端点地址类型不受支持
 */
public void bind(SocketAddress endpoint, int backlog) throws IOException {
    // 检查Socket是否已关闭
    if (isClosed())
        throw new SocketException("Socket is closed");
    // 检查Socket是否已绑定
    if (isBound())
        throw new SocketException("Already bound");
    // 如果未指定端点地址，则创建一个未指定端口的InetSocketAddress实例
    if (endpoint == null)
        endpoint = new InetSocketAddress(0);
    // 检查端点地址是否为InetSocketAddress类型
    if (!(endpoint instanceof InetSocketAddress epoint))
        throw new IllegalArgumentException("Unsupported address type");
    // 检查端点地址是否已解析
    if (epoint.isUnresolved())
        throw new SocketException("Unresolved address");
    // 检查backlog参数是否合法
    if (backlog < 1)
        backlog = 50;

    // 安全检查，确保有权限监听指定端口
    @SuppressWarnings("removal")
    SecurityManager security = System.getSecurityManager();
    if (security != null)
        security.checkListen(epoint.getPort());

    // 同步块，确保线程安全
    synchronized (stateLock) {
        // 再次检查Socket是否已关闭或绑定
        if (closed)
            throw new SocketException("Socket is closed");
        if (bound)
            throw new SocketException("Already bound");
        // 调用实现类的方法进行实际的绑定和监听设置
        getImpl().bind(epoint.getAddress(), epoint.getPort());
        getImpl().listen(backlog);
        // 设置绑定状态为true
        bound = true;
    }
}

import java.io.*;
import java.net.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SimpleHttpServer {
    private static final int PORT = 8888;
    private static final String FILE_PATH = "HelloWorld.java";

    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newFixedThreadPool(10);
        try (ServerSocket serverSocket = new ServerSocket(PORT)) {
            System.out.println("Server is running at http://localhost:" + PORT);

            while (true) {
                Socket clientSocket = serverSocket.accept();
                threadPool.execute(new ClientHandler(clientSocket));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static class ClientHandler implements Runnable {
        private final Socket clientSocket;

        public ClientHandler(Socket clientSocket) {
            this.clientSocket = clientSocket;
        }

        @Override
        public void run() {
            try {
                // 读取HTTP请求
                BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
                String inputLine;
                StringBuilder request = new StringBuilder();
                while ((inputLine = in.readLine()) != null && !inputLine.isEmpty()) {
                    request.append(inputLine).append("\n");
                }

                // 发送HTTP响应
                PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
                String fileContent = readFileAsString(FILE_PATH);
                long contentLength = fileContent.getBytes().length;
                    String response = "HTTP/1.1 200 OK\r\n" +
                            "Content-Type: application/json\r\n" +
                            "Content-Length: " + contentLength + "\r\n" +
                            "Connection: close\r\n" +
                            "\r\n" +
                            fileContent;
                    out.println(response);

                // 关闭连接
                clientSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        private String readFileAsString(String filePath) throws IOException {
            StringBuilder contentBuilder = new StringBuilder();
            try (BufferedReader br = new BufferedReader(new FileReader(filePath))) {
                String currentLine;
                while ((currentLine = br.readLine()) != null) {
                    System.out.println(currentLine); // 打印读取的每一行
                    contentBuilder.append(currentLine).append("\n");
                }
            }
            return contentBuilder.toString();
        }
    }
}

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.nio.file.*;
import java.util.Iterator;
import java.util.Set;

public class NIOHttpServer {

    private static final int PORT = 8888;
    private static final String FILE_TO_SERVE = "HelloWorld.java";

    public static void main(String[] args) {
        try {
            // 1. 打开一个 Selector，用于管理多个通道的 I/O 事件
            Selector selector = Selector.open();

            // 2. 打开一个 ServerSocketChannel，用于监听客户端连接
            ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();

            // 3. 绑定到指定端口，并配置为非阻塞模式
            serverSocketChannel.bind(new java.net.InetSocketAddress(PORT));
            serverSocketChannel.configureBlocking(false);

            // 4. 将 ServerSocketChannel 注册到 Selector，监听 ACCEPT 事件
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

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

            while (true) {
                // 5. 阻塞等待事件发生（或超时返回）
                selector.select();

                // 6. 获取所有准备好的事件
                Set<SelectionKey> selectedKeys = selector.selectedKeys();
                Iterator<SelectionKey> iterator = selectedKeys.iterator();

                while (iterator.hasNext()) {
                    SelectionKey key = iterator.next();
                    iterator.remove(); // 移除已处理的事件

                    if (key.isAcceptable()) {
                        // 处理新的客户端连接
                        handleAccept(key);
                    } else if (key.isReadable()) {
                        // 处理客户端请求
                        handleRead(key);
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 接受客户端连接
    private static void handleAccept(SelectionKey key) throws IOException {
        ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel();
        SocketChannel clientChannel = serverSocketChannel.accept();
        clientChannel.configureBlocking(false);
        // 注册客户端通道到 Selector，监听 READ 事件
        clientChannel.register(key.selector(), SelectionKey.OP_READ);
        System.out.println("Accepted new connection from " + clientChannel.getRemoteAddress());
    }

    // 读取客户端请求并响应
    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) {
            // 客户端关闭连接
            clientChannel.close();
            return;
        }

        buffer.flip();
        byte[] requestData = new byte[buffer.remaining()];
        buffer.get(requestData);
        String request = new String(requestData);
        System.out.println("Received request:\n" + request);

        // 读取 HelloWorld.java 文件内容
        String fileContent;
        try {
            fileContent = Files.readString(Paths.get(FILE_TO_SERVE));
            System.out.println("Read file content:\n" + fileContent);
        } catch (IOException e) {
            fileContent = "Error reading file: " + e.getMessage();
            System.err.println(fileContent);
        }

        // 构造 HTTP 响应
        String response = "HTTP/1.1 200 OK\r\n" +
                "Content-Type: application/json\r\n" +
                "Content-Length: " + fileContent.length() + "\r\n" +
                "\r\n" +
                fileContent;

        // 将响应写入客户端
        ByteBuffer responseBuffer = ByteBuffer.wrap(response.getBytes());
        clientChannel.write(responseBuffer);
        clientChannel.close(); // 响应完成后关闭连接
    }
}

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Iterator;
import java.util.Set;

public class NIOHttpServer {

    private static final int PORT = 8888;
    private static final String FILE_PATH = "HelloWorld.java";

    public static void main(String[] args) {
        try {
            new NIOHttpServer().start();
        } catch (IOException e) {
            System.err.println("Server error: " + e.getMessage());
            e.printStackTrace();
        }
    }

    public void start() throws IOException {
        Selector selector = Selector.open();
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.bind(new java.net.InetSocketAddress(PORT));
        serverChannel.configureBlocking(false);
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);

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

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

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

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

    private 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("Accepted connection from " + clientChannel.getRemoteAddress());
    }

    private void handleRead(SelectionKey key) {
        SocketChannel clientChannel = (SocketChannel) key.channel();
        ByteBuffer buffer = ByteBuffer.allocate(1024);

        try {
            int bytesRead = clientChannel.read(buffer);
            if (bytesRead == -1) {
                clientChannel.close();
                return;
            }

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

            String fileContent = readFileContent(FILE_PATH);
            String response = constructHttpResponse(fileContent);
            ByteBuffer responseBuffer = ByteBuffer.wrap(response.getBytes());

            while (responseBuffer.hasRemaining()) {
                clientChannel.write(responseBuffer);
            }

            clientChannel.close();
        } catch (IOException e) {
            System.err.println("Error handling client request: " + e.getMessage());
            try {
                clientChannel.close();
            } catch (IOException ex) {
                System.err.println("Error closing client connection: " + ex.getMessage());
            }
        }
    }

    private String constructHttpResponse(String bodyContent) {
        String headers = constructHttpHeaders(bodyContent.length());
        return headers + bodyContent;
    }

    private String constructHttpHeaders(int contentLength) {
        return "HTTP/1.1 200 OK\r\n" +
                "Content-Type: text/plain\r\n" +
                "Content-Length: " + contentLength + "\r\n" +
                "\r\n";
    }

    private String readFileContent(String filePath) {
        try {
            Path path = Paths.get(filePath);
            return Files.readString(path);
        } catch (IOException e) {
            System.err.println("Error reading file: " + e.getMessage());
            return "File not found or error reading file.";
        }
    }
}

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Iterator;
import java.util.Set;

public class NIOZeroCopyHttpServer {

    private static final int PORT = 8888;
    private static final String FILE_PATH = "HelloWorld.java";

    public static void main(String[] args) {
        try {
            new NIOZeroCopyHttpServer().start();
        } catch (IOException e) {
            System.err.println("Server error: " + e.getMessage());
            e.printStackTrace();
        }
    }

    public void start() throws IOException {
        Selector selector = Selector.open();
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.bind(new java.net.InetSocketAddress(PORT));
        serverChannel.configureBlocking(false);
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);

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

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

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

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

    private 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("Accepted connection from " + clientChannel.getRemoteAddress());
    }

    private void handleRead(SelectionKey key) {
        SocketChannel clientChannel = (SocketChannel) key.channel();
        ByteBuffer buffer = ByteBuffer.allocate(1024);

        try {
            int bytesRead = clientChannel.read(buffer);
            if (bytesRead == -1) {
                clientChannel.close();
                return;
            }

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

            sendFileUsingZeroCopy(clientChannel, FILE_PATH);
        } catch (IOException e) {
            System.err.println("Error handling client request: " + e.getMessage());
            try {
                clientChannel.close();
            } catch (IOException ex) {
                System.err.println("Error closing client connection: " + ex.getMessage());
            }
        }
    }

    private void sendFileUsingZeroCopy(SocketChannel clientChannel, String filePath) {
        try (FileChannel fileChannel = FileChannel.open(Paths.get(filePath))) {
            long fileSize = fileChannel.size();
            String headers = constructHttpHeaders(fileSize);
            ByteBuffer headerBuffer = ByteBuffer.wrap(headers.getBytes());

            // Write headers first
            while (headerBuffer.hasRemaining()) {
                clientChannel.write(headerBuffer);
            }

            // 零拷贝
            long position = 0;
            while (position < fileSize) {
                position += fileChannel.transferTo(position, fileSize - position, clientChannel);
            }

            clientChannel.close();
        } catch (IOException e) {
            System.err.println("Error sending file: " + e.getMessage());
        }
    }

    private String constructHttpHeaders(long contentLength) {
        return "HTTP/1.1 200 OK\r\n" +
                "Content-Type: text/plain\r\n" +
                "Content-Length: " + contentLength + "\r\n" +
                "Connection: close\r\n" +
                "\r\n";
    }
}

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.nio.file.Paths;
import java.util.Iterator;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class NIOThreadZeroCopyHttpServer {

    private static final int PORT = 8888;
    private static final String FILE_PATH = "HelloWorld.java";
    private static final int THREAD_POOL_SIZE = 10;

    private final ExecutorService threadPool = Executors.newFixedThreadPool(THREAD_POOL_SIZE);

    public static void main(String[] args) {
        try {
            new NIOThreadZeroCopyHttpServer().start();
        } catch (IOException e) {
            System.err.println("Server error: " + e.getMessage());
            e.printStackTrace();
        }
    }

    public void start() throws IOException {
        Selector selector = Selector.open();
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.bind(new java.net.InetSocketAddress(PORT));
        serverChannel.configureBlocking(false);
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);

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

        while (true) {
            selector.select(); // Block until events are available
            Set<SelectionKey> selectedKeys = selector.selectedKeys();
            Iterator<SelectionKey> keyIterator = selectedKeys.iterator();

            while (keyIterator.hasNext()) {
                SelectionKey key = keyIterator.next();
                keyIterator.remove(); // Ensure key is removed to prevent re-processing

                if (!key.isValid()) {
                    continue; // Skip invalid keys
                }

                try {
                    if (key.isAcceptable()) {
                        handleAccept(key, selector);
                    }
                } catch (CancelledKeyException e) {
                    System.err.println("CancelledKeyException: " + e.getMessage());
                }
            }
        }
    }

    private void handleAccept(SelectionKey key, Selector selector) throws IOException {
        ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
        SocketChannel clientChannel = serverChannel.accept();
        clientChannel.configureBlocking(false);
        clientChannel.setOption(java.net.StandardSocketOptions.TCP_NODELAY, true);
        clientChannel.register(selector, SelectionKey.OP_READ);

        System.out.println("Accepted connection from " + clientChannel.getRemoteAddress());

        // Submit task to thread pool for processing
        threadPool.submit(() -> handleRequest(clientChannel));
    }

    private void handleRequest(SocketChannel clientChannel) {
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        try {
            int bytesRead = clientChannel.read(buffer);
            if (bytesRead == -1) {
                clientChannel.close();
                return;
            }

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

            sendFileUsingZeroCopy(clientChannel, FILE_PATH);
        } catch (IOException e) {
            System.err.println("Error handling client request: " + e.getMessage());
            try {
                clientChannel.close();
            } catch (IOException ex) {
                System.err.println("Error closing client connection: " + ex.getMessage());
            }
        }
    }

    private void sendFileUsingZeroCopy(SocketChannel clientChannel, String filePath) {
        try (FileChannel fileChannel = FileChannel.open(Paths.get(filePath))) {
            long fileSize = fileChannel.size();
            String headers = constructHttpHeaders(fileSize);
            ByteBuffer headerBuffer = ByteBuffer.wrap(headers.getBytes());

            // Write headers first
            while (headerBuffer.hasRemaining()) {
                clientChannel.write(headerBuffer);
            }

            // Use zero-copy to send file content
            long position = 0;
            while (position < fileSize) {
                position += fileChannel.transferTo(position, fileSize - position, clientChannel);
            }

            clientChannel.close();
        } catch (IOException e) {
            System.err.println("Error sending file: " + e.getMessage());
        }
    }

    private String constructHttpHeaders(long contentLength) {
        return "HTTP/1.1 200 OK\r\n" +
                "Content-Type: text/plain\r\n" +
                "Content-Length: " + contentLength + "\r\n" +
                "Connection: close\r\n" +
                "\r\n";
    }
}

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.nio.file.Paths;
import java.util.Iterator;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class NIOBossWorkerHttpServer {
    private static final int PORT = 8888;
    private static final int BUFFER_SIZE = 1024;
    private static final int BOSS_THREAD_COUNT = 1;  // Boss 线程数
    private static final int WORKER_THREAD_COUNT = 10; // Worker 线程数
    private static final String FILE_PATH = "HelloWorld.java";

    public static void main(String[] args) throws IOException {
        // Boss 线程池
        ExecutorService bossThreadPool = Executors.newFixedThreadPool(BOSS_THREAD_COUNT);
        // Worker 线程池
        ExecutorService workerThreadPool = Executors.newFixedThreadPool(WORKER_THREAD_COUNT);

        // 创建一个主选择器（Boss Selector）
        Selector bossSelector = Selector.open();
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.configureBlocking(false);
        serverChannel.bind(new InetSocketAddress(PORT));
        serverChannel.register(bossSelector, SelectionKey.OP_ACCEPT);

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

        // Boss 线程负责分发连接
        bossThreadPool.submit(() -> {
            try {
                while (true) {
                    bossSelector.select(); // 等待事件
                    Iterator<SelectionKey> iterator = bossSelector.selectedKeys().iterator();

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

                        if (key.isAcceptable()) {
                            SocketChannel clientChannel = serverChannel.accept();
                            clientChannel.configureBlocking(false);
                            System.out.println("Accepted new connection: " + clientChannel.getRemoteAddress());

                            // 将新连接交给 Worker 线程池处理
                            workerThreadPool.submit(() -> handleClient(clientChannel));
                        }
                    }
                }
            } catch (IOException e) {
                System.err.println("Error in Boss thread: " + e.getMessage());
            }
        });
    }

    /**
     * Worker 线程处理客户端连接的读写操作
     */
    private static void handleClient(SocketChannel clientChannel) {
        try (Selector workerSelector = Selector.open()) {
            clientChannel.register(workerSelector, SelectionKey.OP_READ);
            ByteBuffer buffer = ByteBuffer.allocate(BUFFER_SIZE);

            while (clientChannel.isOpen()) {
                workerSelector.select(); // 等待事件
                Iterator<SelectionKey> iterator = workerSelector.selectedKeys().iterator();

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

                    if (key.isReadable()) {
                        SocketChannel channel = (SocketChannel) key.channel();
                        buffer.clear();
                        int bytesRead = channel.read(buffer);
                        if (bytesRead == -1) {
                            closeChannel(channel);
                            return;
                        }

                        // 请求解析 (这里只简单返回文件内容作为响应)
                        buffer.flip();
                        sendFile(channel, FILE_PATH);
                    }
                }
            }
        } catch (IOException e) {
            System.err.println("Error in Worker thread: " + e.getMessage());
        } finally {
            closeChannel(clientChannel);
        }
    }

    /**
     * 使用零拷贝技术发送文件
     */
    private static void sendFile(SocketChannel clientChannel, String filePath) {
        try (FileChannel fileChannel = FileChannel.open(Paths.get(filePath))) {
            long fileSize = fileChannel.size();

            // 构造 HTTP 响应头
            String headers = "HTTP/1.1 200 OK\r\n" +
                    "Content-Type: text/plain\r\n" +
                    "Content-Length: " + fileSize + "\r\n" +
                    "\r\n";
            ByteBuffer headerBuffer = ByteBuffer.wrap(headers.getBytes());

            // 发送响应头
            while (headerBuffer.hasRemaining()) {
                clientChannel.write(headerBuffer);
            }

            // 使用零拷贝发送文件内容
            long position = 0;
            while (position < fileSize) {
                position += fileChannel.transferTo(position, fileSize - position, clientChannel);
            }
            System.out.println("File sent successfully to: " + clientChannel.getRemoteAddress());
        } catch (IOException e) {
            System.err.println("Error sending file: " + e.getMessage());
        }
    }

    /**
     * 关闭通道
     */
    private static void closeChannel(Channel channel) {
        if (channel != null && channel.isOpen()) {
            try {
                channel.close();
                System.out.println("Channel closed.");
            } catch (IOException e) {
                System.err.println("Error closing channel: " + e.getMessage());
            }
        }
    }
}