Java Academy · Aula

Lidando com respostas

BodyHandlers e códigos de status.

Lidando com respostas é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

Lidando com respostas

Cada chamada ao cliente HTTP retorna um HttpResponse<T>. O tipo genérico T é definido pelo BodyHandler que você fornece. Esta lição explora os manipuladores disponíveis e como interpretar os códigos de status.

A API HttpResponse

Métodos importantes de HttpResponse:

statusCode() — o status do tipo inteiro.
body() — o corpo decodificado do tipo T.
headers() — os cabeçalhos da resposta.
uri() — a URI final, após os redirecionamentos.
version() — HTTP/1.1 ou HTTP/2.

BodyHandlers.ofString

O manipulador mais comum decodifica o corpo em uma String usando o conjunto de caracteres da resposta, com UTF-8 como padrão. O tipo da resposta é 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

Para conteúdo binário, como imagens, use ofByteArray(). O tipo do corpo se torna byte[], que você pode gravar no disco ou decodificar por conta própria.

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) transmite a resposta diretamente para o disco e fornece um HttpResponse<Path>. Isso evita armazenar um download grande na memória.

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 você só se importa com o status e os cabeçalhos, discarding() descarta o corpo, produzindo um HttpResponse<Void>. Isso evita o custo de armazená-lo em um buffer.

Verificando o sucesso

Um auxiliar comum verifica se o status está na faixa 2xx antes de confiar no 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));
    }
}

Reagindo às categorias de status

Examine o primeiro dígito para direcionar sua lógica de acordo com sucessos, redirecionamentos e erros.

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));
    }
}

Mapeando corpos com mapping

BodyHandlers.mapping(upstream, fn) envolve outro manipulador e transforma o resultado dele. Por exemplo, analise um corpo de cadeia de caracteres em um tamanho inteiro, tudo dentro do manipulador.

Lendo um cabeçalho específico

Para ler o valor de um cabeçalho da resposta, use headers().firstValue(name), que retorna um Optional<String>. Para obter todos os valores de um cabeçalho repetido, use 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);
    }
}

Escolhendo um manipulador

ofString — APIs de texto e JSON.
ofByteArray — pequenas cargas binárias mantidas na memória.
ofFile — downloads grandes transmitidos para o disco.
ofInputStream — processa o corpo como um fluxo.
discarding — requisições que só precisam do status.

Verificação rápida

Teste sua compreensão sobre o tratamento de respostas.

Recapitulação

Você aprendeu a interpretar respostas HTTP:

HttpResponse expõe statusCode(), body() e headers().
BodyHandler determina o tipo do corpo: String, byte[], caminho, vazio ou fluxo.
Use ofFile para downloads grandes e evite sobrecarregar a memória.
Classifique os códigos de status pelo primeiro dígito e verifique o intervalo 2xx para confirmar o sucesso.
Leia os cabeçalhos com firstValue / allValues.

Perguntas Frequentes

A aula “Lidando com respostas” é grátis?

Sim — o texto completo de “Lidando com respostas” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “Lidando com respostas”?

BodyHandlers e códigos de status. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Lidando com respostas”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Java Academy