Networking & HTTP

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

public class Main {
    public static void main(String[] args) throws Exception {
        int port = 8080;

        // ServerSocket "listens" on a port — like a receptionist waiting for calls.
        ExecutorService pool = Executors.newCachedThreadPool();
        ServerSocket server = new ServerSocket(port);
        pool.submit(() -> {
            try {
                while (!server.isClosed()) {
                    Socket client = server.accept(); // blocks until a client connects
                    pool.submit(() -> handleClient(client));
                }
            } catch (IOException ignored) { /* server was closed */ }
        });
        System.out.println("Server listening on port " + port);

        // A Socket is the phone line connecting client to server.
        // try-with-resources closes the socket + streams automatically.
        try (Socket socket = new Socket("localhost", port);
             PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
             BufferedReader in = new BufferedReader(
                 new InputStreamReader(socket.getInputStream()))) {
            for (String msg : new String[]{"Hello Server!", "Goodbye!"}) {
                out.println(msg);                              // send a line
                System.out.println("Client -> Server: " + msg);
                System.out.println("Server -> Client: " + in.readLine()); // read reply
            }
        }

        server.close();        // free the port
        pool.shutdownNow();    // stop the background threads
    }

    // Each connected client gets its own thread; we echo its lines back.
    static void handleClient(Socket client) {
        try (client;
             BufferedReader in = new BufferedReader(
                 new InputStreamReader(client.getInputStream()));
             PrintWriter out = new PrintWriter(client.getOutputStream(), true)) {
            String line;
            while ((line = in.readLine()) != null) {
                out.println("Echo: " + line);                  // reply to the client
            }
        } catch (IOException ignored) { }
    }
}

Server listening on port 8080
Client -> Server: Hello Server!
Server -> Client: Echo: Hello Server!
Client -> Server: Goodbye!
Server -> Client: Echo: Goodbye!

import java.net.*;
import java.nio.charset.StandardCharsets;

public class Main {
    public static void main(String[] args) throws Exception {
        int port = 9000;

        // UDP is "fire and forget" — no connection, no delivery guarantee.
        // Receiver: bind a DatagramSocket to a port and wait for a packet.
        DatagramSocket receiver = new DatagramSocket(port);
        new Thread(() -> {
            try {
                byte[] buf = new byte[1024];                 // inbox buffer
                DatagramPacket packet = new DatagramPacket(buf, buf.length);
                receiver.receive(packet);                    // blocks for one packet
                String text = new String(
                    packet.getData(), 0, packet.getLength(), StandardCharsets.UTF_8);
                System.out.println("Receiver got: " + text);
            } catch (Exception ignored) { }
        }).start();

        // Sender: wrap bytes in a packet addressed to host:port and send.
        try (DatagramSocket sender = new DatagramSocket()) {
            byte[] data = "ping".getBytes(StandardCharsets.UTF_8);
            InetAddress host = InetAddress.getByName("localhost");
            DatagramPacket packet = new DatagramPacket(data, data.length, host, port);
            sender.send(packet);                             // no handshake, just send
            System.out.println("Sender sent: ping");
        }

        Thread.sleep(200);   // give the receiver a moment
        receiver.close();
    }
}

Sender sent: ping
Receiver got: ping

import java.net.URI;
import java.net.http.*;
import java.time.Duration;

public class Main {
    public static void main(String[] args) throws Exception {
        // Reuse ONE client — it manages a connection pool internally.
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(10))   // cap time to open a connection
            .build();

        // --- GET with a header ---
        HttpRequest getReq = HttpRequest.newBuilder()
            .uri(URI.create("https://httpbin.org/get"))
            .header("Accept", "application/json")     // ask for JSON back
            .timeout(Duration.ofSeconds(30))          // cap the whole request
            .GET()
            .build();
        HttpResponse<String> getRes = client.send(
            getReq, HttpResponse.BodyHandlers.ofString());
        System.out.println("GET  -> status " + getRes.statusCode());

        // --- POST a JSON body ---
        HttpRequest postReq = HttpRequest.newBuilder()
            .uri(URI.create("https://httpbin.org/post"))
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString("{\"name\":\"Charlie\"}"))
            .build();
        HttpResponse<String> postRes = client.send(
            postReq, HttpResponse.BodyHandlers.ofString());
        System.out.println("POST -> status " + postRes.statusCode());

        // ALWAYS check the status before trusting the body. 2xx = success.
        if (getRes.statusCode() == 200) {
            String body = getRes.body();
            System.out.println("Body starts: "
                + body.substring(0, Math.min(40, body.length())));
        } else {
            System.out.println("Request failed: " + getRes.statusCode());
        }
    }
}

GET  -> status 200
POST -> status 200
Body starts: {
  "args": {},
  "headers": {
    "Acc

import java.net.URI;
import java.net.http.*;
import java.util.List;
import java.util.concurrent.CompletableFuture;

public class Main {
    static final HttpClient client = HttpClient.newHttpClient();

    public static void main(String[] args) throws Exception {
        // sendAsync returns immediately with a CompletableFuture — the main
        // thread is NOT blocked, so all three requests run in parallel.
        List<String> urls = List.of(
            "https://httpbin.org/get",
            "https://httpbin.org/headers",
            "https://httpbin.org/ip");

        List<CompletableFuture<Integer>> futures = urls.stream()
            .map(u -> HttpRequest.newBuilder(URI.create(u)).build())
            .map(req -> client
                .sendAsync(req, HttpResponse.BodyHandlers.ofString())
                .thenApply(HttpResponse::statusCode))   // map response -> status
            .toList();

        // Wait for every future to finish, then read each status code.
        CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();
        for (int i = 0; i < urls.size(); i++) {
            System.out.println(urls.get(i) + " -> " + futures.get(i).join());
        }
    }
}

https://httpbin.org/get -> 200
https://httpbin.org/headers -> 200
https://httpbin.org/ip -> 200

import java.net.URI;
import java.net.http.*;

public class Main {
    public static void main(String[] args) throws Exception {
        // 🎯 YOUR TURN — finish this GET request (fill in the ___ blanks)
        HttpClient client = HttpClient.newHttpClient();

        // 1) Build a request to https://httpbin.org/get
        HttpRequest req = HttpRequest.newBuilder()
            .uri(URI.create(___))   // 👉 put the URL string in here
            .GET()
            .build();

        // 2) Send it synchronously and capture the response as a String
        HttpResponse<String> res = client.send(
            req, HttpResponse.BodyHandlers.___());   // 👉 use ofString

        // 3) Print the status code (a number like 200)
        System.out.println("Status: " + res.___());  // 👉 the method is statusCode

        // ✅ Expected output:
        // Status: 200
    }
}

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

public class Main {
    public static void main(String[] args) throws Exception {
        int port = 7000;

        // A tiny server thread that sends one greeting, then closes.
        new Thread(() -> {
            try (ServerSocket server = new ServerSocket(port);
                 Socket client = server.accept();
                 PrintWriter out = new PrintWriter(client.getOutputStream(), true)) {
                out.println("Welcome!");
            } catch (IOException ignored) { }
        }).start();

        Thread.sleep(100); // let the server start listening

        // 🎯 YOUR TURN — connect and read the one line the server sends
        // 1) Open a Socket to "localhost" on the port above
        try (Socket socket = new Socket("localhost", ___);   // 👉 which port?
             BufferedReader in = new BufferedReader(
                 new InputStreamReader(socket.getInputStream()))) {

            // 2) Read a single line from the server and print it
            String line = in.___();   // 👉 the method that reads one line
            System.out.println("Server said: " + line);
        }
        // Note: try-with-resources closes the socket for you — no leak.

        // ✅ Expected output:
        // Server said: Welcome!
    }
}

import java.net.URI;
import java.net.http.*;

public class Main {
    public static void main(String[] args) throws Exception {
        // 🎯 MINI-CHALLENGE: POST JSON and report success/failure
        // 1. Create ONE HttpClient (reuse it)
        // 2. Build a POST request to https://httpbin.org/post
        //    - set header "Content-Type" to "application/json"
        //    - body: BodyPublishers.ofString("{\"city\":\"London\"}")
        // 3. Send it synchronously (BodyHandlers.ofString)
        // 4. If statusCode() is 200, print "Saved!" — otherwise print
        //    "Failed: " followed by the status code
        //
        // ✅ Expected output (httpbin returns 200):
        // Saved!

        // your code here
    }
}