Java Socket Programming: สร้างแอป Chat แบบ Client-Server ตั้งแต่ศูนย์

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.StandardCharsets;

public class SimpleServer {
    public static void main(String[] args) throws IOException {
        try (ServerSocket serverSocket = new ServerSocket(5050)) {
            System.out.println("Waiting for clients on port 5050...");
            while (true) {
                try (Socket socket = serverSocket.accept();
                     BufferedReader in = new BufferedReader(
                             new InputStreamReader(socket.getInputStream(), StandardCharsets.UTF_8))) {
                    String line;
                    while ((line = in.readLine()) != null) {   // null = client closed the connection
                        System.out.println(socket.getRemoteSocketAddress() + " says: " + line);
                    }
                }
            }
        }
    }
}

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

public class SimpleClient {
    public static void main(String[] args) throws IOException {
        String host = args.length > 0 ? args[0] : "127.0.0.1";
        try (Socket socket = new Socket(host, 5050);
             PrintWriter out = new PrintWriter(
                     new OutputStreamWriter(socket.getOutputStream(), StandardCharsets.UTF_8), true)) {
            out.println("Hello from the client");
            out.println("สวัสดีครับ");
        }
    }
}

import java.io.Serializable;
import java.time.Instant;

public record ChatMessage(String sender, String text, Instant sentAt) implements Serializable {
}

import java.io.EOFException;
import java.io.IOException;
import java.io.ObjectInputFilter;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.time.Instant;
import java.util.Set;
import java.util.concurrent.CopyOnWriteArraySet;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ChatServer {
    static final int PORT = 5050;

    // Only these classes may be deserialized; everything else is rejected.
    private static final ObjectInputFilter FILTER = ObjectInputFilter.Config.createFilter(
            "maxdepth=5;ChatMessage;java.time.Instant;java.time.Ser;!*");

    private final Set<ClientHandler> clients = new CopyOnWriteArraySet<>();

    public static void main(String[] args) throws IOException {
        new ChatServer().start();
    }

    void start() throws IOException {
        ExecutorService pool = Executors.newCachedThreadPool();
        try (ServerSocket serverSocket = new ServerSocket(PORT)) {
            System.out.println("Chat server listening on port " + PORT);
            while (true) {
                Socket socket = serverSocket.accept();      // blocks until a client connects
                pool.execute(new ClientHandler(socket));    // one thread per client
            }
        } finally {
            pool.shutdownNow();
        }
    }

    void broadcast(ChatMessage message) {
        for (ClientHandler client : clients) {
            client.send(message);
        }
    }

    static ObjectOutputStream openOutput(Socket socket) throws IOException {
        ObjectOutputStream out = new ObjectOutputStream(socket.getOutputStream());
        out.flush(); // push the stream header now so the peer's ObjectInputStream can start
        return out;
    }

    private class ClientHandler implements Runnable {
        private final Socket socket;
        private ObjectOutputStream out;

        ClientHandler(Socket socket) {
            this.socket = socket;
        }

        @Override
        public void run() {
            try (socket;
                 ObjectOutputStream out = openOutput(socket);
                 ObjectInputStream in = new ObjectInputStream(socket.getInputStream())) {
                in.setObjectInputFilter(FILTER);
                this.out = out;
                clients.add(this);
                broadcast(new ChatMessage("server", socket.getRemoteSocketAddress() + " joined", Instant.now()));

                while (true) {
                    if (in.readObject() instanceof ChatMessage message) {
                        broadcast(message);
                    }
                }
            } catch (EOFException e) {
                // the client closed the connection normally
            } catch (IOException | ClassNotFoundException e) {
                System.err.println("Client error: " + e.getMessage());
            } finally {
                clients.remove(this);
            }
        }

        synchronized void send(ChatMessage message) {
            try {
                out.writeObject(message);
                out.reset();   // forget previously written objects so memory does not grow
                out.flush();
            } catch (IOException e) {
                clients.remove(this);
            }
        }
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.time.Instant;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;

public class ChatClient {
    private static final DateTimeFormatter TIME =
            DateTimeFormatter.ofPattern("HH:mm").withZone(ZoneId.systemDefault());

    public static void main(String[] args) throws IOException {
        String host = args.length > 0 ? args[0] : "127.0.0.1";
        String name = args.length > 1 ? args[1] : "guest";

        try (Socket socket = new Socket(host, 5050);
             ObjectOutputStream out = openOutput(socket);
             ObjectInputStream in = new ObjectInputStream(socket.getInputStream())) {

            Thread reader = new Thread(() -> {
                try {
                    while (true) {
                        if (in.readObject() instanceof ChatMessage m) {
                            System.out.printf("[%s] %s: %s%n", TIME.format(m.sentAt()), m.sender(), m.text());
                        }
                    }
                } catch (IOException | ClassNotFoundException e) {
                    System.out.println("Disconnected from server.");
                }
            });
            reader.setDaemon(true);
            reader.start();

            BufferedReader console = new BufferedReader(new InputStreamReader(System.in));
            String line;
            while ((line = console.readLine()) != null && !line.equals("/quit")) {
                out.writeObject(new ChatMessage(name, line, Instant.now()));
                out.reset();
                out.flush();
            }
        }
    }

    private static ObjectOutputStream openOutput(Socket socket) throws IOException {
        ObjectOutputStream out = new ObjectOutputStream(socket.getOutputStream());
        out.flush();
        return out;
    }
}

javac ChatMessage.java ChatServer.java ChatClient.java
java ChatServer                      # terminal 1
java ChatClient 127.0.0.1 alice      # terminal 2
java ChatClient 127.0.0.1 bob        # terminal 3