Java Academy · Lezione

Gestione delle risposte

BodyHandlers e codici di stato

Gestione delle risposte è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 4 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.

Gestione delle risposte

Ogni chiamata al client HTTP restituisce un HttpResponse<T>. Il tipo generico T è determinato dal BodyHandler passato. Questa lezione illustra gli handler disponibili e come interpretare i codici di stato.

L'API HttpResponse

Metodi principali di HttpResponse:

statusCode() — il codice di stato di tipo int.
body() — il corpo decodificato del tipo T.
headers() — le intestazioni della risposta.
uri() — l'URI finale, dopo i reindirizzamenti.
version() — HTTP/1.1 o HTTP/2.

BodyHandlers.ofString

L'handler più comune decodifica il corpo in una String usando il charset della risposta, con UTF-8 come valore predefinito. Il tipo della risposta è HttpResponse<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 req = HttpRequest.newBuilder()
            .uri(URI.create("https://example.com")).build();
        HttpResponse<String> res =
            client.send(req, HttpResponse.BodyHandlers.ofString());
        System.out.println(res.body().length());
    }
}

BodyHandlers.ofByteArray

Per contenuti binari, come le immagini, usate ofByteArray(). Il tipo del corpo diventa byte[], che potete scrivere su disco o decodificare autonomamente.

public class Main {
    public static void main(String[] args) {
        // ofByteArray() yields HttpResponse<byte[]>
        byte[] simulated = { 1, 2, 3, 4 };
        System.out.println("Bytes received: " + simulated.length);
    }
}

BodyHandlers.ofFile

ofFile(path) trasmette la risposta direttamente su disco e restituisce un HttpResponse<Path>. In questo modo si evita di memorizzare in un buffer un download di grandi dimensioni.

import java.net.URI;
import java.net.http.*;
import java.nio.file.Path;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest req = HttpRequest.newBuilder()
            .uri(URI.create("https://example.com/file.zip")).build();
        HttpResponse<Path> res = client.send(req,
            HttpResponse.BodyHandlers.ofFile(Path.of("out.zip")));
        System.out.println("Saved to: " + res.body());
    }
}

BodyHandlers.discarding

Quando vi interessano solo lo stato e le intestazioni, discarding() scarta il corpo e produce un HttpResponse<Void>. In questo modo si evita il costo del buffering.

Verifica dell'esito positivo

Un helper comune verifica che lo stato rientri nell'intervallo 2xx prima di considerare attendibile il corpo.

public class Main {
    static boolean isSuccess(int code) {
        return code >= 200 && code < 300;
    }
    public static void main(String[] args) {
        System.out.println(isSuccess(204));
        System.out.println(isSuccess(404));
    }
}

Gestione delle categorie di stato

Usate uno switch sulla prima cifra per diramare la logica in base a esiti positivi, reindirizzamenti ed errori.

public class Main {
    static String classify(int code) {
        return switch (code / 100) {
            case 2 -> "Success";
            case 3 -> "Redirect";
            case 4 -> "Client error";
            case 5 -> "Server error";
            default -> "Unknown";
        };
    }
    public static void main(String[] args) {
        System.out.println(classify(503));
        System.out.println(classify(200));
    }
}

Mappatura dei corpi con mapping

BodyHandlers.mapping(upstream, fn) racchiude un altro handler e trasforma il risultato. Ad esempio, consente di analizzare un corpo stringa e convertirlo nella sua lunghezza intera, tutto all'interno dell'handler.

Lettura di un'intestazione specifica

Per leggere il valore di un'intestazione della risposta, usate headers().firstValue(name), che restituisce un Optional<String>. Per ottenere tutti i valori di un'intestazione ripetuta, usate allValues(name).

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        Optional<String> len = Optional.of("1024");
        int contentLength = len.map(Integer::parseInt).orElse(0);
        System.out.println("Content-Length: " + contentLength);
    }
}

Scelta dell'handler

ofString — API testuali e JSON.
ofByteArray — payload binari di piccole dimensioni mantenuti in memoria.
ofFile — download di grandi dimensioni trasmessi su disco.
ofInputStream — elaborazione del corpo come stream.
discarding — richieste per cui interessa solo lo stato.

Verifica rapida

Verifichi la Sua comprensione della gestione delle risposte.

Riepilogo

Ha imparato a interpretare le risposte HTTP:

HttpResponse espone statusCode(), body() e headers().
BodyHandler determina il tipo del corpo: String, byte[], Path, Void o stream.
Utilizzi ofFile per i download di grandi dimensioni, così da evitare un'eccessiva pressione sulla memoria.
Classifichi i codici di stato in base alla prima cifra e verifichi l'intervallo 2xx per controllare l'esito positivo.
Legga le intestazioni con firstValue / allValues.

Domande Frequenti

La lezione «Gestione delle risposte» è gratuita?

Sì — il testo completo di «Gestione delle risposte» è 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 «Gestione delle risposte»?

BodyHandlers e codici di stato 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 4 di 4.

Quanto tempo richiede la lezione «Gestione delle risposte»?

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