TCP vs UDP Explained: When to Use Each Protocol and Why It Matters

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

/**
 * A minimal TCP echo server that demonstrates reliable, ordered delivery.
 * Run TcpEchoServer first, then run TcpEchoClient in a separate terminal.
 */
public class TcpEchoServer {

    private static final int PORT = 9090;

    public static void main(String[] args) throws IOException {

        // ServerSocket binds to a port and listens for incoming TCP connections.
        // The OS completes the three-way handshake before accept() returns —
        // by the time we get a Socket object, the connection is already established.
        try (ServerSocket serverSocket = new ServerSocket(PORT)) {

            System.out.println("[Server] Listening on port " + PORT + " (TCP)");

            // accept() blocks until a client connects. Each call returns one
            // dedicated Socket for that client — full duplex, stream-oriented.
            try (Socket clientSocket = serverSocket.accept()) {

                System.out.println("[Server] Client connected from: "
                        + clientSocket.getInetAddress());

                // Wrap the raw byte stream in readers/writers for convenience.
                // The underlying stream guarantees every byte arrives in order.
                BufferedReader inFromClient = new BufferedReader(
                        new InputStreamReader(clientSocket.getInputStream()));
                PrintWriter outToClient = new PrintWriter(
                        clientSocket.getOutputStream(), true); // autoFlush = true

                String receivedMessage;
                // Read lines until the client closes the connection (readLine returns null).
                while ((receivedMessage = inFromClient.readLine()) != null) {
                    System.out.println("[Server] Received: " + receivedMessage);

                    // Echo the message back in uppercase so we can visibly confirm
                    // it made the round trip intact.
                    String response = "ECHO: " + receivedMessage.toUpperCase();
                    outToClient.println(response);
                    System.out.println("[Server] Sent back: " + response);
                }

                System.out.println("[Server] Client disconnected.");
            }
        }
    }
}

import java.net.*;

/**
 * A UDP echo server. Notice there is NO accept(), NO handshake, NO connection.
 * The server just sits and waits for datagrams to land in its socket buffer.
 * Run UdpEchoServer first, then run UdpEchoClient in a separate terminal.
 */
public class UdpEchoServer {

    private static final int PORT = 9091;
    // Max UDP payload that safely avoids IP fragmentation on most networks.
    private static final int MAX_PACKET_SIZE = 1024;

    public static void main(String[] args) throws Exception {

        // DatagramSocket is connectionless — no client needs to connect first.
        // It simply listens on a port for any datagram that arrives.
        try (DatagramSocket serverSocket = new DatagramSocket(PORT)) {

            System.out.println("[Server] Listening on port " + PORT + " (UDP)");

            byte[] receiveBuffer = new byte[MAX_PACKET_SIZE];

            // UDP servers typically loop forever, processing one datagram at a time.
            while (true) {

                // DatagramPacket is both the envelope and the letter —
                // it carries the data AND the sender's address/port.
                DatagramPacket incomingPacket =
                        new DatagramPacket(receiveBuffer, receiveBuffer.length);

                // receive() blocks until a datagram arrives. Unlike TCP's readLine(),
                // each call here processes exactly one independent packet.
                serverSocket.receive(incomingPacket);

                String receivedMessage = new String(
                        incomingPacket.getData(),
                        0,
                        incomingPacket.getLength() // IMPORTANT: use actual length, not buffer length
                );

                System.out.println("[Server] Received datagram from "
                        + incomingPacket.getAddress() + ":" + incomingPacket.getPort()
                        + " — Message: " + receivedMessage);

                // To reply, we need the sender's address and port from the incoming packet.
                // There is no persistent connection object — we manually address each reply.
                String responseMessage = "ECHO: " + receivedMessage.toUpperCase();
                byte[] responseBytes = responseMessage.getBytes();

                DatagramPacket replyPacket = new DatagramPacket(
                        responseBytes,
                        responseBytes.length,
                        incomingPacket.getAddress(), // send back to whoever sent to us
                        incomingPacket.getPort()
                );

                serverSocket.send(replyPacket);
                System.out.println("[Server] Replied: " + responseMessage);
            }
        }
    }
}

import java.net.*;

/**
 * Companion client for UdpEchoServer.
 * Demonstrates fire-and-forget sending and how to read a reply.
 * Also shows that if the server is down, send() returns immediately —
 * there is NO error thrown. That's the fundamental nature of UDP.
 */
public class UdpEchoClient {

    private static final String SERVER_HOST = "localhost";
    private static final int SERVER_PORT = 9091;
    private static final int TIMEOUT_MS = 3000; // how long to wait for a reply
    private static final int MAX_PACKET_SIZE = 1024;

    public static void main(String[] args) throws Exception {

        // A client DatagramSocket with no arguments lets the OS pick a free port.
        // Unlike TCP, this does NOT send anything to the server — no handshake.
        try (DatagramSocket clientSocket = new DatagramSocket()) {

            // Set a timeout on receive() so we don't block forever if the reply is lost.
            // This is manual reliability — something TCP does for you automatically.
            clientSocket.setSoTimeout(TIMEOUT_MS);

            InetAddress serverAddress = InetAddress.getByName(SERVER_HOST);
            String messageToSend = "hello from udp client";
            byte[] sendBuffer = messageToSend.getBytes();

            // Construct the datagram with the data AND the destination baked in.
            DatagramPacket sendPacket = new DatagramPacket(
                    sendBuffer,
                    sendBuffer.length,
                    serverAddress,
                    SERVER_PORT
            );

            // send() dispatches the packet and returns immediately.
            // If the server isn't running, this line still succeeds with no exception —
            // the packet just disappears into the network. This is UDP's core behaviour.
            clientSocket.send(sendPacket);
            System.out.println("[Client] Sent: " + messageToSend);

            // Prepare a buffer to receive the server's echo reply.
            byte[] receiveBuffer = new byte[MAX_PACKET_SIZE];
            DatagramPacket replyPacket = new DatagramPacket(receiveBuffer, receiveBuffer.length);

            try {
                // receive() will block until a datagram arrives OR the timeout fires.
                clientSocket.receive(replyPacket);
                String reply = new String(replyPacket.getData(), 0, replyPacket.getLength());
                System.out.println("[Client] Received reply: " + reply);

            } catch (SocketTimeoutException timeoutEx) {
                // This is how UDP 'reliability' works at the app layer —
                // you catch the timeout and decide: retry, fail, or move on.
                System.out.println("[Client] No reply within " + TIMEOUT_MS + "ms — packet may be lost.");
            }
        }
    }
}