Java Socket实现简易在线聊天室：从单客户端到群聊的完整教程

项目目标与核心难点

我们的目标是开发一个基于C/S（客户端/服务器）架构的简易聊天系统。实现过程分为以下几个关键阶段：

1. 基础连接：使用AWT组件构建简单的GUI窗口，实现单一客户端与服务端之间的持续消息发送。
2. 并发处理：引入多线程技术，使服务端能够同时监听和处理多个客户端的连接，解决单线程循环导致的阻塞问题。
3. 消息转发：在服务端维护已连接客户端列表，将任一客户端发出的消息广播至所有其他在线用户，实现真正的群聊功能。
4. 增强体验：为每个客户端生成随机用户名，并在界面中清晰展示消息来源。

主要难点在于理解Socket的数据流操作、事件监听机制以及多线程环境下的资源管理。

第一步：实现基础连接与单客户端交互

首先，我们需要建立一个简单的TCP连接。这一步主要验证数据能否从客户端正确发送到服务端并读取。

1.1 启动服务端监听

服务端通过 ServerSocket 绑定特定端口（如8888），并使用 accept() 方法等待客户端连接。当连接建立后，获取输入流以读取客户端发送的数据。

package chat.chat;

import java.io.DataInputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class ChatServer {
    public static void main(String[] args) {
        ServerSocket ss = null;
        Socket socket = null;
        try {
            // 启动服务器，监听8888端口
            ss = new ServerSocket(8888);
            System.out.println("服务端已启动");
            
            while (true) {
                socket = ss.accept(); // 阻塞直到有客户端连接
                System.out.println("一个新客户端连接");
                
                DataInputStream dataInputStream = new DataInputStream(socket.getInputStream());
                String message = dataInputStream.readUTF();
                System.out.println("客户端说：" + message);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

完成状态判断：控制台打印“服务端已启动”后，运行客户端可看到“一个新客户端连接”及接收到的文字消息。

1.2 编写基础客户端界面

使用Java AWT库创建一个包含文本输入框和文本域显示区的窗口。监听输入框的回车事件，触发数据发送。

package chat.chat;

import java.awt.BorderLayout;
import java.awt.Frame;
import java.awt.TextArea;
import java.awt.TextField;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;

public class ChatClient extends Frame {
    private TextField tfTxt = new TextField();
    private TextArea tarea = new TextArea();
    private Socket socket = null;
    private DataOutputStream dataOutputStream = null;

    public static void main(String[] args) {
        new ChatClient().launcFrame();
    }

    public void launcFrame() {
        setLocation(300, 200);
        this.setSize(400, 300);
        add(tfTxt, BorderLayout.SOUTH);
        add(tarea, BorderLayout.NORTH);
        pack();
        
        // 添加关闭窗口监听
        this.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                disConnect();
                System.exit(0);
            }
        });
        
        // 监听回车键
        tfTxt.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                String text = tfTxt.getText().trim();
                if (!text.isEmpty()) {
                    sendMessage(text);
                    tarea.setText(tarea.getText() + "\n我说: " + text);
                    tfTxt.setText("");
                }
            }
        });
        
        setVisible(true);
        connect();
    }

    public void connect() {
        try {
            socket = new Socket("127.0.0.1", 8888);
            dataOutputStream = new DataOutputStream(socket.getOutputStream());
            System.out.println("连上服务端");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private void sendMessage(String text) {
        try {
            dataOutputStream.writeUTF(text);
            dataOutputStream.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

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

注意：此版本客户端只能发送消息，无法接收其他用户的消息，因为主线程被用于监听本地UI事件且阻塞式地尝试读取服务端响应（若直接读取会阻塞UI）。在实际群聊实现中，需要分离接收逻辑。

第二步：引入多线程实现多客户端并发

当多个客户端尝试连接时，单线程服务端会因阻塞在 accept() 或之前的 readUTF() 而无法处理后续连接。解决方案是每当有新的客户端接入，就为其分配一个新的线程来处理该客户端的数据读写。

2.1 改造服务端逻辑

服务端不再在主线程中直接读取数据，而是创建一个内部类 Client 实现 Runnable 接口。主线程只负责接受连接并启动新线程。

package chat.chat;

import java.io.DataInputStream;
import java.io.EOFException;
import java.io.IOException;
import java.net.BindException;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;

public class ChatServer {
    private boolean isStart = false;
    private ServerSocket ss = null;

    public void start() {
        try {
            ss = new ServerSocket(8888);
            isStart = true;
        } catch (BindException e) {
            System.out.println("端口已被占用");
            System.exit(0);
        } catch (IOException e) {
            e.printStackTrace();
        }

        while (isStart) {
            try {
                Socket socket = ss.accept();
                System.out.println("一个客户端上线了！");
                // 启动新线程处理该客户端
                new Thread(new Client(socket)).start();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    class Client implements Runnable {
        private Socket socket;
        private DataInputStream dataInputStream;
        private boolean isConnect = true;

        public Client(Socket socket) {
            this.socket = socket;
            try {
                dataInputStream = new DataInputStream(socket.getInputStream());
            } catch (IOException e) {
                e.printStackTrace();
                isConnect = false;
            }
        }

        @Override
        public void run() {
            while (isConnect) {
                try {
                    String message = dataInputStream.readUTF();
                    System.out.println(message);
                } catch (EOFException e) {
                    System.out.println(