Prosty serwer HTTP bez frameworka

import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpServer;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.URI;
import java.net.URLDecoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.time.Duration;

/**
 * Minimalny serwer HTTP z biblioteki standardowej — skryptyJAVA.pl
 * Zapisz jako: ProstySerwerHttp.java
 */
public class ProstySerwerHttp {

    /** Tworzy serwer na wskazanym porcie; wartość 0 oznacza automatyczny wybór wolnego portu. */
    public static HttpServer utworz(int port) throws IOException {
        // 127.0.0.1 ogranicza dostęp do tego komputera i jest bezpiecznym ustawieniem demonstracyjnym.
        HttpServer serwer = HttpServer.create(new InetSocketAddress("127.0.0.1", port), 0);
        serwer.createContext("/", ProstySerwerHttp::stronaGlowna);
        serwer.createContext("/powitanie", ProstySerwerHttp::powitanie);
        return serwer;
    }

    private static void stronaGlowna(HttpExchange wymiana) throws IOException {
        // Kontekst "/" jest prefiksem awaryjnym, więc sam rozróżniamy stronę główną od 404.
        if (!wymiana.getRequestURI().getPath().equals("/")) {
            odpowiedz(wymiana, 404, "text/plain", "Nie znaleziono takiej strony.");
            return;
        }
        if (!tylkoOdczyt(wymiana)) { return; }
        String html = """
                <!doctype html>
                <html lang="pl"><meta charset="UTF-8"><title>Serwer Java</title>
                <body><h1>Serwer działa</h1><p>Wypróbuj /powitanie?imie=Ola</p></body></html>
                """;
        odpowiedz(wymiana, 200, "text/html", html);
    }

    private static void powitanie(HttpExchange wymiana) throws IOException {
        // Konteksty HttpServer działają prefiksowo: /powitanie/inne też trafiłoby do tej metody.
        if (!wymiana.getRequestURI().getPath().equals("/powitanie")) {
            odpowiedz(wymiana, 404, "text/plain", "Nie znaleziono takiej strony.");
            return;
        }
        if (!tylkoOdczyt(wymiana)) { return; }
        // Adres z błędnym zapisem procentowym (np. %ZZ) HttpServer odrzuca sam, kodem 400.
        String imie = parametr(wymiana.getRequestURI(), "imie");
        if (imie == null || imie.isBlank()) { imie = "świecie"; }
        odpowiedz(wymiana, 200, "text/plain", "Cześć, " + imie.strip() + "!");
    }

    /** Przepuszcza GET i HEAD, a inne metody odrzuca z nagłówkiem dozwolonych metod. */
    private static boolean tylkoOdczyt(HttpExchange wymiana) throws IOException {
        String metoda = wymiana.getRequestMethod();
        if (metoda.equalsIgnoreCase("GET") || metoda.equalsIgnoreCase("HEAD")) { return true; }
        wymiana.getResponseHeaders().set("Allow", "GET, HEAD");
        odpowiedz(wymiana, 405, "text/plain", "Dozwolone są tylko metody GET i HEAD.");
        return false;
    }

    /** Odczytuje pojedynczy parametr query string i dekoduje zapis procentowy oraz znak +. */
    private static String parametr(URI adres, String szukanaNazwa) {
        String zapytanie = adres.getRawQuery();
        if (zapytanie == null) { return null; }
        for (String para : zapytanie.split("&")) {
            String[] czesci = para.split("=", 2);
            String nazwa = URLDecoder.decode(czesci[0], StandardCharsets.UTF_8);
            if (nazwa.equals(szukanaNazwa)) {
                return czesci.length == 2
                        ? URLDecoder.decode(czesci[1], StandardCharsets.UTF_8) : "";
            }
        }
        return null;
    }

    /** Wysyła odpowiedź UTF-8 i domyka jej strumień; dla HEAD wysyła same nagłówki. */
    private static void odpowiedz(HttpExchange wymiana, int status, String typ, String tresc)
            throws IOException {
        byte[] bajty = tresc.getBytes(StandardCharsets.UTF_8);
        wymiana.getResponseHeaders().set("Content-Type", typ + "; charset=UTF-8");
        wymiana.getResponseHeaders().set("X-Content-Type-Options", "nosniff");
        if (wymiana.getRequestMethod().equalsIgnoreCase("HEAD")) {
            wymiana.sendResponseHeaders(status, -1); // HEAD wymaga długości -1, inaczej JDK ostrzega
            wymiana.close();
            return;
        }
        wymiana.sendResponseHeaders(status, bajty.length);
        try (var wyjscie = wymiana.getResponseBody()) {
            wyjscie.write(bajty);
        }
    }

    // ── PRZYKŁADY ───────────────────────────────────────────
    public static void main(String[] args) throws Exception {
        HttpServer serwer = utworz(0);
        serwer.start();
        int port = serwer.getAddress().getPort();
        System.out.println("Serwer działa lokalnie na porcie " + port);

        try {
            HttpClient klient = HttpClient.newBuilder()
                    .connectTimeout(Duration.ofSeconds(2)).build();
            HttpRequest zadanie = HttpRequest.newBuilder(
                            URI.create("http://127.0.0.1:" + port + "/powitanie?imie=Ola%20Nowak"))
                    .timeout(Duration.ofSeconds(3)).GET().build();
            HttpResponse<String> wynik = klient.send(
                    zadanie, HttpResponse.BodyHandlers.ofString(StandardCharsets.UTF_8));
            System.out.println("HTTP " + wynik.statusCode() + ": " + wynik.body());
        } finally {
            serwer.stop(0); // zatrzymanie jest konieczne, bo serwer utrzymuje wątek procesu
            System.out.println("Serwer zatrzymany.");
        }
    }
}