// BIO服务器示例
ServerSocket serverSocket = new ServerSocket(8080);
while (true) {
    // 阻塞直到有客户端连接
    Socket clientSocket = serverSocket.accept();
    // 为每个客户端创建一个新线程
    new Thread(() -> {
        try (InputStream in = clientSocket.getInputStream()) {
            // 读取数据（阻塞操作）
            byte[] buffer = new byte[1024];
            int len;
            while ((len = in.read(buffer)) != -1) {
                System.out.println(new String(buffer, 0, len));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }).start();
}

// NIO服务器示例
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.bind(new InetSocketAddress(8080));
serverChannel.configureBlocking(false);

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

while (true) {
    // 非阻塞或阻塞较短时间
    selector.select();
    
    Iterator<SelectionKey> keyIterator = selector.selectedKeys().iterator();
    while (keyIterator.hasNext()) {
        SelectionKey key = keyIterator.next();
        keyIterator.remove();
        
        if (key.isAcceptable()) {
            // 处理新连接
            ServerSocketChannel server = (ServerSocketChannel) key.channel();
            SocketChannel client = server.accept();
            client.configureBlocking(false);
            client.register(selector, SelectionKey.OP_READ);
        } else if (key.isReadable()) {
            // 处理读事件
            SocketChannel client = (SocketChannel) key.channel();
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            int bytesRead = client.read(buffer);
            if (bytesRead > 0) {
                buffer.flip();
                System.out.println(new String(buffer.array(), 0, buffer.limit()));
            }
        }
    }
}

// AIO服务器示例
AsynchronousServerSocketChannel serverChannel = AsynchronousServerSocketChannel.open();
serverChannel.bind(new InetSocketAddress(8080));

serverChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Void>() {
    @Override
    public void completed(AsynchronousSocketChannel client, Void attachment) {
        // 继续接受下一个连接
        serverChannel.accept(null, this);
        
        // 处理当前连接
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        client.read(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
            @Override
            public void completed(Integer bytesRead, ByteBuffer buffer) {
                if (bytesRead > 0) {
                    buffer.flip();
                    System.out.println(new String(buffer.array(), 0, buffer.limit()));
                    // 可以继续读取或执行其他操作
                }
            }
            
            @Override
            public void failed(Throwable exc, ByteBuffer attachment) {
                exc.printStackTrace();
            }
        });
    }
    
    @Override
    public void failed(Throwable exc, Void attachment) {
        exc.printStackTrace();
    }
});

public Object invoke(Object obj, Object... args)
        throws IllegalAccessException, IllegalArgumentException,
        InvocationTargetException {
    // 如果方法不允许被覆盖，进行权限检查
    if (!override) {
        if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
            Class<?> caller = Reflection.getCallerClass();
            // 检查调用者是否具有访问权限
            checkAccess(caller, clazz, obj, modifiers);
        }
    }
    // 获取方法访问器（从 volatile 变量中读取）
    MethodAccessor ma = methodAccessor;
    if (ma == null) {
        // 如果访问器为空，尝试获取方法访问器
        ma = acquireMethodAccessor();
    }
    // 使用方法访问器调用方法，并返回结果
    return ma.invoke(obj, args);
}

package client;

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

public class Client {
    private Socket socket;
    private DataOutputStream outputStream;
    private PrintWriter out;
    private BufferedReader in;
    private String serverAddress;
    private int port;
    private String username;
    private OnMessageReceivedListener listener;

    public Client(String serverAddress, int port, String username, OnMessageReceivedListener listener) throws IOException {
        this.serverAddress = serverAddress;
        this.port = port;
        this.username = username;
        this.listener = listener;
        initConnection();
    }



    private void initConnection() throws IOException {
        if (socket != null && !socket.isClosed()) {
            return;
        }
        socket = new Socket(serverAddress, port);
        outputStream = new DataOutputStream(socket.getOutputStream());
        out = new PrintWriter(new OutputStreamWriter(socket.getOutputStream(), "UTF-8"), true);
        in = new BufferedReader(new InputStreamReader(socket.getInputStream(), "UTF-8"));
    }

    public void sendMessage(String message) {
        if (outputStream != null && !socket.isClosed()) {
            try {
                out.println(message);
                out.flush();
            } catch (Exception e) {
                handleSendError(e);
            }
        } else {
            System.err.println("Socket is not properly initialized or is closed.");
        }
    }

    public void sendPrivateMessage(String recipient, String message) {
        sendMessage("/pm " + recipient + " " + message);
    }

    private void handleSendError(Exception e) {
        e.printStackTrace();
        try {
            socket.close();
        } catch (IOException closeException) {
            closeException.printStackTrace();
        }
        listener.onConnectionLost();
    }

    public void connect() {
        try {
            initConnection();
            sendMessage(username); // 发送用户名以登录

            Thread readerThread = new Thread(() -> {
                String message;
                try {
                    while ((message = in.readLine()) != null) {
                        listener.onMessageReceived(message);
                    }
                } catch (IOException e) {
                    listener.onConnectionLost();
                    e.printStackTrace();
                } finally {
                    try {
                        socket.close();
                    } catch (IOException ex) {
                        ex.printStackTrace();
                    }
                }
            });
            readerThread.start();
        } catch (UnknownHostException e) {
            System.err.println("Server not found: " + e.getMessage());
            listener.onConnectionLost();
        } catch (IOException e) {
            System.err.println("Error connecting to server: " + e.getMessage());
            listener.onConnectionLost();
        }
    }

    public void disconnect() {
        try {
            if (socket != null) {
                socket.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public String getUsername() {
        return username;
    }

    public interface OnMessageReceivedListener {
        void onMessageReceived(String message);
        void onConnectionLost();
        void onUpdateOnlineUsers(String userListData);
        void onForceLogout();
    }
}

package client;

import javax.swing.*;
import java.awt.*;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;

public class ClientGUI extends Component {
    private JTextField serverAddressField, portField, usernameField, messageField;
    private JButton connectButton, sendButton;
    private JTextArea chatArea;
    private JList<String> onlineList;
    private DefaultListModel<String> onlineListModel;
    private Client client;

    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> new ClientGUI().initializeUI());
    }

    private void initializeUI() {
        JFrame frame = new JFrame("Chat Client");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(800, 600);

        chatArea = new JTextArea();
        chatArea.setEditable(false);
        JScrollPane scrollPane = new JScrollPane(chatArea);
        frame.add(scrollPane, BorderLayout.CENTER);

        JPanel southPanel = new JPanel();
        southPanel.setLayout(new BorderLayout());

        JPanel inputPanel = new JPanel();
        inputPanel.setLayout(new FlowLayout(FlowLayout.LEFT));
        messageField = new JTextField(30);
        sendButton = new JButton("Send");
        inputPanel.add(messageField);
        inputPanel.add(sendButton);
        southPanel.add(inputPanel, BorderLayout.CENTER);

        JPanel connectPanel = new JPanel();
        connectPanel.setLayout(new FlowLayout(FlowLayout.LEFT));
        serverAddressField = new JTextField("localhost", 10);
        portField = new JTextField("12345", 5);
        usernameField = new JTextField("User", 10);
        connectButton = new JButton("Connect");
        connectPanel.add(new JLabel("Server: "));
        connectPanel.add(serverAddressField);
        connectPanel.add(new JLabel(" Port: "));
        connectPanel.add(portField);
        connectPanel.add(new JLabel(" Username: "));
        connectPanel.add(usernameField);
        connectPanel.add(connectButton);
        southPanel.add(connectPanel, BorderLayout.SOUTH);

        frame.add(southPanel, BorderLayout.SOUTH);

        onlineListModel = new DefaultListModel<>();
        onlineList = new JList<>(onlineListModel);
        JScrollPane onlineScrollPane = new JScrollPane(onlineList);
        onlineScrollPane.setPreferredSize(new Dimension(150, 0));
        frame.add(onlineScrollPane, BorderLayout.EAST);

        createEvents();

        frame.setVisible(true);
    }

    private void createEvents() {
        connectButton.addActionListener(e -> {
            String serverAddress = serverAddressField.getText();
            int port = Integer.parseInt(portField.getText());
            String username = usernameField.getText();
            connectButton.setEnabled(false);
            try {
                client = new Client(serverAddress, port, username, new GUIListener());
                client.connect();
            } catch (Exception ex) {
                JOptionPane.showMessageDialog(this, "连接失败，请检查输入信息。", "连接错误", JOptionPane.ERROR_MESSAGE);
                connectButton.setEnabled(true);
            }
        });

        sendButton.addActionListener(e -> {
            String message = messageField.getText();
            if (!message.isEmpty()) {
                client.sendMessage(message);
                displaySentMessage(message);
                messageField.setText("");
            }
        });

        onlineList.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseClicked(MouseEvent e) {
                if (e.getClickCount() == 2) {
                    String selectedUser = onlineList.getSelectedValue();
                    if (selectedUser != null && client != null) {
                        String privateMessage = JOptionPane.showInputDialog(ClientGUI.this,
                                "输入要发送给 " + selectedUser + " 的消息:", "发送私信", JOptionPane.PLAIN_MESSAGE);
                        if (privateMessage != null && !privateMessage.trim().isEmpty()) {
                            client.sendPrivateMessage(selectedUser, privateMessage);
                            displaySentMessage("[私信给 " + selectedUser + "]: " + privateMessage); // 显示发送的私聊消息
                        }
                    }
                }
            }
        });
    }

    private void displaySentMessage(String message) {
        SwingUtilities.invokeLater(() -> {
            chatArea.append(client.getUsername() + ": " + message + "\n");
            chatArea.setCaretPosition(chatArea.getDocument().getLength());
        });
    }

    private class GUIListener implements Client.OnMessageReceivedListener {
        @Override
        public void onMessageReceived(String message) {
            SwingUtilities.invokeLater(() -> {
                if (message.startsWith("/users ")) { // 检查消息是否以/users开头
                    onUpdateOnlineUsers(message.substring(7)); // 去掉"/users "前缀，然后更新在线用户列表
                }else if(message.equals("/forceLogout")){
                    onForceLogout();
                }else if(message.equals("/server/ERROR: 用户名已被占用，请选择其他用户名。")){
                    JOptionPane.showMessageDialog(ClientGUI.this, "用户名已被占用，请选择其他用户名。", "连接错误", JOptionPane.ERROR_MESSAGE);
                    connectButton.setEnabled(true);
                    client.disconnect();
                }else if(message.equals("/server/SUCCESS: 连接成功")){
                    JOptionPane.showMessageDialog(ClientGUI.this, "连接成功", "连接状态", JOptionPane.INFORMATION_MESSAGE);
                }
                else {
                    chatArea.append(message + "\n");
                    chatArea.setCaretPosition(chatArea.getDocument().getLength());
                }
            });
        }

        @Override
        public void onConnectionLost() {
            SwingUtilities.invokeLater(() -> {
                JOptionPane.showMessageDialog(ClientGUI.this, "连接丢失，请检查网络或重新登录。", "连接错误", JOptionPane.ERROR_MESSAGE);
                connectButton.setEnabled(true);
            });
        }

        @Override
        public void onUpdateOnlineUsers(String userListData) {
            SwingUtilities.invokeLater(() -> {
                String[] usernames = userListData.split(","); // 假设用户列表是以逗号分隔的用户名
                onlineListModel.clear(); // 清空现有在线用户列表
                for (String username : usernames) {
                    onlineListModel.addElement(username.trim()); // 添加每个用户名到在线用户列表模型中
                }
            });
        }

        @Override
        public void onForceLogout(){
            SwingUtilities.invokeLater(() -> {
                JOptionPane.showMessageDialog(null, "抱歉！您已被服务器强制下线！", "强制下线", JOptionPane.WARNING_MESSAGE);
                System.exit(0); // 关闭客户端程序
            });
        }
    }
}

package common;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class Message {
    private String sender;
    private String recipient;
    private String content;
    private LocalDateTime timestamp;

    // 构造函数
    public Message(String sender, String recipient, String content) {
        this.sender = sender;
        this.recipient = recipient;
        this.content = content;
        this.timestamp = LocalDateTime.now(); // 当前时间作为发送时间
    }

    public Message(String sender, String content) {
        this(sender, "Everyone", content);
    }

    // Getter 和 Setter 方法
    public String getSender() {
        return sender;
    }

    public void setSender(String sender) {
        this.sender = sender;
    }

    public String getRecipient() {
        return recipient;
    }

    public void setRecipient(String recipient) {
        this.recipient = recipient;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public LocalDateTime getTimestamp() {
        return timestamp;
    }

    // 格式化时间戳的字符串表示
    public String getFormattedTimestamp() {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        return timestamp.format(formatter);
    }

    // 重写toString方法，便于打印或显示消息详情
    @Override
    public String toString() {
        return String.format("[%s] %s -> %s: %s",
                getFormattedTimestamp(),
                sender,
                recipient,
                content);
    }
}

package server;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
import common.Message;


public class Server {
    private static final int PORT = 12345; // 服务器端口
    private final List<ServerThread> clients = new ArrayList<>(); // 存储所有连接的客户端线程
    private ServerGUI gui;

    public Server(ServerGUI gui) {
        this.gui = gui;
    }
    public static void main(String[] args) {
        ServerGUI gui = new ServerGUI();
        Server server = new Server(gui);
        gui.setServer(server);
        server.startServer();
    }

    public void startServer() {
        try (ServerSocket serverSocket = new ServerSocket(PORT)) {
            System.out.println("服务器启动，正在监听端口: " + PORT);

            while (true) {
                Socket socket = serverSocket.accept(); // 阻塞等待客户端连接
                ServerThread serverThread = new ServerThread(socket, this);
                serverThread.start(); // 启动线程处理客户端请求
                System.out.println("新客户端连接: " + socket.getInetAddress());
            }
        } catch (IOException e) {
            e.printStackTrace();
            System.err.println("服务器启动失败");
        }
    }

    public synchronized void addClient(ServerThread client) {
        clients.add(client);
        updateOnlineUsers();
        gui.updateUserList(clients);
    }

    public synchronized boolean removeClient(ServerThread client) {
        boolean removed = clients.remove(client);
        if (removed) {
            updateOnlineUsers();
            gui.updateUserList(clients);
        }
        return removed;
    }

    public synchronized void broadcast(Message message, ServerThread excludeClient) {
        for (ServerThread client : clients) {
            if (client != excludeClient) {
                client.send(message);
            }
        }
    }

    public synchronized void updateOnlineUsers() {
        StringBuilder userList = new StringBuilder("/users ");
        for (ServerThread client : clients) {
            userList.append(client.getUsername()).append(",");
        }
        String userListMessage = userList.toString();
        if (userListMessage.endsWith(",")) {
            userListMessage = userListMessage.substring(0, userListMessage.length() - 1);
        }
        for (ServerThread client : clients) {
            client.sendRawMessage(userListMessage);
        }
    }

    public List<ServerThread> getClients() {
        return clients;
    }

    public void forceLogout(String username) {
        for (ServerThread client : clients) {
            if (client.getUsername().equals(username)) {
                client.interrupt(); // 中断客户端线程以强制下线
                removeClient(client); // 从列表中移除客户端
                client.forceLogout();
                gui.updateUserList(clients);
                break;
            }
        }
    }
    public synchronized boolean isUsernameTaken(String username) {
        for (ServerThread client : clients) {
            if (client.getUsername().equals(username)) {
                return true;
            }
        }
        return false;
    }

    public synchronized void sendSystemMessage(String content) {
        Message systemMessage = new Message("Server", "Everyone", content);
        broadcast(systemMessage, null);
    }
}

package server;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.List;

public class ServerGUI extends JFrame {
    private JList<String> userList;
    private DefaultListModel<String> userListModel;
    private Server server;

    public ServerGUI() {
        setTitle("Chat Server");
        setSize(400, 300);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLocationRelativeTo(null);

        userListModel = new DefaultListModel<>();
        userList = new JList<>(userListModel);
        JScrollPane scrollPane = new JScrollPane(userList);

        JButton forceLogoutButton = new JButton("Force Logout");
        forceLogoutButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String selectedUser = userList.getSelectedValue();
                if (selectedUser != null) {
                    server.forceLogout(selectedUser);
                }
            }
        });

        // 系统消息输入框和发送按钮
        JTextField systemMessageField = new JTextField();
        JButton sendSystemMessageButton = new JButton("发送系统消息");
        sendSystemMessageButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String message = systemMessageField.getText();
                if (message != null && !message.trim().isEmpty()) {
                    server.sendSystemMessage(message);
                    systemMessageField.setText(""); // 清空输入框
                }
            }
        });

        JPanel panel = new JPanel(new BorderLayout());

        panel.add(scrollPane, BorderLayout.CENTER);
        panel.add(forceLogoutButton, BorderLayout.SOUTH);

        // 系统消息面板
        JPanel systemMessagePanel = new JPanel(new BorderLayout());
        systemMessagePanel.add(systemMessageField, BorderLayout.CENTER);
        systemMessagePanel.add(sendSystemMessageButton, BorderLayout.EAST);

        // 添加到主窗口
        add(panel, BorderLayout.CENTER);
        add(systemMessagePanel, BorderLayout.SOUTH);

        setVisible(true);
    }

    public void updateUserList(List<ServerThread> clients) {
        SwingUtilities.invokeLater(() -> {
            userListModel.clear();
            for (ServerThread client : clients) {
                userListModel.addElement(client.getUsername());
            }
        });
    }

    public void setServer(Server server) {
        this.server = server;
    }
}

package server;

import common.Message;

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

public class ServerThread extends Thread {
    private Socket socket;
    private PrintWriter out;
    private BufferedReader in;
    private String username;
    private Server server;
    private volatile boolean running = true;

    public ServerThread(Socket socket, Server server) {
        this.socket = socket;
        this.server = server;
        try {
            out = new PrintWriter(socket.getOutputStream(), true);
            in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        } catch (IOException e) {
            e.printStackTrace();
            System.err.println("Error initializing streams for client: " + e.getMessage());
        }
    }

    @Override
    public void run() {
        try {
            this.username = in.readLine();
            if (server.isUsernameTaken(this.username)) {
                sendRawMessage("/server/ERROR: 用户名已被占用，请选择其他用户名。");
                socket.close();
                return;
            }

            sendRawMessage("/server/SUCCESS: 连接成功");
            System.out.println("账号" + this.username + "已经登录");
            server.addClient(this);  // 注意不要在构造函数中重复调用 addClient
            server.broadcast(new Message(username, "Server", username + " has joined the chat!"), this);

            String inputLine;
            while (running && (inputLine = in.readLine()) != null) {
                if (inputLine.startsWith("/pm ")) {
                    handlePrivateMessage(inputLine);
                }
                else {
                    server.broadcast(new Message(username, "Everyone", inputLine), this);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            boolean removed = server.removeClient(this);
            if (removed) {
                server.broadcast(new Message(username, "Server", username + " has left the chat!"), null);
            }
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public void send(Message message) {
        if (out != null && !out.checkError()) {
            out.println(message.toString());
            out.flush();
        }
    }

    public void sendRawMessage(String message) {
        try {
            if (out != null && !out.checkError()) {
                out.println(message);
                out.flush();
            } else {
                System.err.println("Output stream is closed, cannot send message.");
            }
        } catch (Exception e) {
            e.printStackTrace();
            System.err.println("Error sending message: " + e.getMessage());
        }
    }

    private void handlePrivateMessage(String inputLine) {
        int firstSpace = inputLine.indexOf(" ");
        int secondSpace = inputLine.indexOf(" ", firstSpace + 1);
        if (secondSpace != -1) {
            String recipient = inputLine.substring(firstSpace + 1, secondSpace);
            String message = inputLine.substring(secondSpace + 1);
            for (ServerThread client : server.getClients()) {
                if (client.getUsername().equals(recipient)) {
                    client.send(new Message(username, recipient, message));
                    break;
                }
            }
        }
    }

    public String getUsername() {
        return username;
    }
    public void forceLogout() {
        running = false; // 停止主循环
        sendRawMessage("/forceLogout");
        try {
            socket.close(); // 关闭Socket以触发IOException并停止线程
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}