Java Academy · Lezione

java.net.http.HttpClient

Inviare richieste sincrone

java.net.http.HttpClient è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.

Il client HTTP moderno

A partire da Java 11, il JDK include un client HTTP moderno nel package java.net.http. Sostituisce il vecchio HttpURLConnection con un'API pulita e fluente che supporta HTTP/1.1 e HTTP/2.

I tre tipi fondamentali sono:

HttpClient — invia le richieste e gestisce la configurazione (timeout, proxy, reindirizzamenti).
HttpRequest — una descrizione immutabile di ciò che deve essere inviato.
HttpResponse — il risultato, inclusi stato, intestazioni e corpo.

Creazione di un HttpClient

Si crea un client con il metodo statico newBuilder(). Un singolo client può essere riutilizzato per molte richieste ed è thread-safe.

Qui si configurano HTTP/2 e un timeout di connessione. È disponibile anche newHttpClient() per creare rapidamente un'istanza con i valori predefiniti.

import java.net.http.HttpClient;
import java.time.Duration;

public class Main {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newBuilder()
            .version(HttpClient.Version.HTTP_2)
            .connectTimeout(Duration.ofSeconds(10))
            .build();
        System.out.println("Client version: " + client.version());
    }
}

Creazione di una richiesta

HttpRequest è immutabile e viene creato con un builder fluente. Come minimo, si fornisce un URI; per impostazione predefinita esegue una GET.

Si converte una stringa in un URI con URI.create(...).

import java.net.URI;
import java.net.http.HttpRequest;

public class Main {
    public static void main(String[] args) {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://example.com/data"))
            .GET()
            .build();
        System.out.println("Method: " + request.method());
        System.out.println("URI: " + request.uri());
    }
}

Invio sincrono

Il metodo send blocca il thread chiamante finché non arriva la risposta. Richiede un BodyHandler che indica al client come interpretare il corpo della risposta.

BodyHandlers.ofString() legge il corpo in una String.

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

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://example.com"))
            .build();
        HttpResponse<String> response =
            client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println("Status: " + response.statusCode());
    }
}

Lettura del codice di stato

La risposta espone statusCode() come un int. I codici nell'intervallo 2xx indicano un esito positivo, i codici 3xx sono reindirizzamenti, i codici 4xx sono errori del client e i codici 5xx sono errori del server.

Nota: il client HTTP non genera mai eccezioni per una risposta 4xx/5xx: è necessario controllare personalmente il codice.

public class Main {
    public static void main(String[] args) {
        int status = 404;
        String label;
        if (status >= 200 && status < 300) label = "Success";
        else if (status >= 300 && status < 400) label = "Redirect";
        else if (status >= 400 && status < 500) label = "Client error";
        else label = "Server error";
        System.out.println(status + " -> " + label);
    }
}

Lettura del corpo

Con BodyHandlers.ofString(), response.body() restituisce una String. Esistono altri handler per byte, file e stream, che verranno trattati più avanti.

Questo frammento simula il contenuto del corpo che si riceverebbe.

public class Main {
    public static void main(String[] args) {
        String body = "{\"message\":\"hello\"}";
        System.out.println("Body length: " + body.length());
        System.out.println("Body: " + body);
    }
}

Gestione dei reindirizzamenti

Per impostazione predefinita, il client non segue i reindirizzamenti. È possibile configurarlo nel builder con followRedirects(...).

Le opzioni in HttpClient.Redirect sono NEVER, ALWAYS e NORMAL (segue i reindirizzamenti tranne quelli da HTTPS a HTTP).

import java.net.http.HttpClient;

public class Main {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newBuilder()
            .followRedirects(HttpClient.Redirect.NORMAL)
            .build();
        System.out.println("Redirect policy: " + client.followRedirects());
    }
}

Timeout per richiesta

Il timeout di connessione risiede nel client. Il timeout di una richiesta, ovvero il tempo di attesa della risposta, risiede nella richiesta tramite timeout(...).

Se scade, send genera una HttpTimeoutException.

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

public class Main {
    public static void main(String[] args) {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://example.com"))
            .timeout(Duration.ofSeconds(5))
            .build();
        System.out.println("Timeout set: " + request.timeout().isPresent());
    }
}

Ispezione delle intestazioni della risposta

La risposta contiene un oggetto HttpHeaders, accessibile tramite headers(). Le ricerche nelle intestazioni non distinguono tra maiuscole e minuscole e possono restituire più valori; per questo firstValue(...) restituisce un Optional<String>.

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        // Simulating a header lookup result
        Optional<String> contentType = Optional.of("application/json");
        System.out.println("Content-Type: " + contentType.orElse("unknown"));
    }
}

Eccezioni controllate

Il metodo sincrono send dichiara due eccezioni controllate:

IOException — errore di rete o del protocollo.
InterruptedException — il thread bloccato è stato interrotto.

È necessario catturarle entrambe o dichiararle. Le chiamate asincrone, nella prossima lezione, evitano questo problema restituendo un future.

import java.io.IOException;

public class Main {
    public static void main(String[] args) {
        try {
            // client.send(...) would go here
            throw new IOException("connection refused");
        } catch (IOException e) {
            System.out.println("Network problem: " + e.getMessage());
        }
    }
}

Un client riutilizzabile

Buona pratica: create una sola istanza di HttpClient e riutilizzatela nell'applicazione. Il client gestisce un pool di connessioni ed è completamente thread-safe.

Creare un nuovo client per ogni richiesta spreca risorse e vanifica il multiplexing di HTTP/2.

import java.net.http.HttpClient;

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

    public static void main(String[] args) {
        System.out.println("Shared client ready: " + (SHARED != null));
    }
}

Verifica rapida

Verificate la vostra comprensione del client HTTP sincrono.

Riepilogo

Avete appreso le nozioni di base del client HTTP del JDK:

HttpClient.newBuilder() configura la versione, il timeout e i reindirizzamenti; riutilizzate una sola istanza.
HttpRequest.newBuilder().uri(...).GET() crea una richiesta immutabile.
client.send(request, BodyHandlers.ofString()) blocca e restituisce un HttpResponse<String>.
Leggete i risultati con statusCode(), body() e headers().
I codici diversi da 2xx non generano eccezioni: controllateli personalmente.

Domande Frequenti

La lezione «java.net.http.HttpClient» è gratuita?

Sì — il testo completo di «java.net.http.HttpClient» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.

Cosa imparerò in «java.net.http.HttpClient»?

Inviare richieste sincrone Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Java Academy?

Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «java.net.http.HttpClient»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Java Academy?

Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Java Academy