Java Academy · Aula

java.net.http.HttpClient

Envie requisições síncronas.

java.net.http.HttpClient é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 1 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.

O cliente HTTP moderno

Desde o Java 11, o JDK fornece um cliente HTTP moderno no pacote java.net.http. Ele substitui o antigo HttpURLConnection por uma API limpa e fluente que oferece suporte a HTTP/1.1 e HTTP/2.

Os três tipos centrais são:

HttpClient — envia solicitações e gerencia a configuração (tempos limite, servidores proxy e redirecionamentos).
HttpRequest — uma descrição imutável do que enviar.
HttpResponse — o resultado, incluindo código de status, cabeçalhos e corpo.

Criando um HttpClient

Você cria um cliente com o método estático newBuilder(). Um único cliente pode ser reutilizado para muitas solicitações e é seguro para uso concorrente.

Aqui configuramos HTTP/2 e um tempo limite de conexão. newHttpClient() também está disponível para criar rapidamente uma instância padrão.

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

Construindo uma requisição

HttpRequest é imutável e é construído com um construtor fluente. No mínimo, você fornece uma URI; por padrão, ele executa um GET.

Você converte uma cadeia de caracteres em uma URI com 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());
    }
}

Enviando de forma síncrona

O método send bloqueia a linha de execução chamadora até a chegada da resposta. Ele precisa de um BodyHandler que informe ao cliente como interpretar o corpo da resposta.

BodyHandlers.ofString() lê o corpo em uma 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());
    }
}

Lendo o código de status

A resposta expõe statusCode() como um int. Os códigos na faixa 2xx indicam sucesso, 3xx indicam redirecionamentos, 4xx indicam erros do cliente e 5xx indicam erros do servidor.

Observação: o cliente HTTP nunca lança uma exceção para uma resposta 4xx/5xx — você precisa verificar o código por conta própria.

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

Lendo o corpo

Com BodyHandlers.ofString(), response.body() retorna uma String. Existem outros manipuladores para bytes, arquivos e fluxos, que serão abordados mais adiante.

Este trecho simula o conteúdo do corpo que você receberia.

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

Lidando com redirecionamentos

Por padrão, o cliente não segue redirecionamentos. Configure esse comportamento no construtor com followRedirects(...).

As opções em HttpClient.Redirect são NEVER, ALWAYS e NORMAL (segue redirecionamentos, exceto em rebaixamentos de HTTPS para 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());
    }
}

Tempos limite por requisição

O tempo limite de conexão é definido no cliente. Um tempo limite de requisição (por quanto tempo aguardar uma resposta) é definido na requisição por meio de timeout(...).

Se ele expirar, send lançará uma 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());
    }
}

Inspecionando os cabeçalhos da resposta

A resposta contém um objeto HttpHeaders acessível por meio de headers(). As consultas aos cabeçalhos não diferenciam maiúsculas de minúsculas e podem retornar vários valores; por isso, firstValue(...) retorna um 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"));
    }
}

Exceções verificadas

O send síncrono declara duas exceções verificadas:

IOException — falha de rede ou de protocolo.
InterruptedException — a linha de execução bloqueada foi interrompida.

Você precisa capturar ou declarar ambas. As chamadas assíncronas (na próxima lição) evitam isso ao retornar um futuro.

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

Um cliente reutilizável

Boa prática: crie um HttpClient e reutilize-o em toda a aplicação. Ele mantém um conjunto de conexões e é totalmente seguro para uso por várias linhas de execução.

Criar um novo cliente para cada requisição desperdiça recursos e impede o uso da multiplexação do 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ção rápida

Teste sua compreensão do cliente HTTP síncrono.

Recapitulação

Você aprendeu os fundamentos do cliente HTTP do JDK:

HttpClient.newBuilder() configura a versão, o tempo limite e os redirecionamentos; reutilize uma única instância.
HttpRequest.newBuilder().uri(...).GET() constrói uma requisição imutável.
client.send(request, BodyHandlers.ofString()) bloqueia e retorna um HttpResponse<String>.
Leia os resultados com statusCode(), body() e headers().
Códigos diferentes de 2xx não lançam exceções — verifique-os por conta própria.

Perguntas Frequentes

A aula “java.net.http.HttpClient” é grátis?

Sim — o texto completo de “java.net.http.HttpClient” é 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 “java.net.http.HttpClient”?

Envie requisições síncronas. 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 1 de 4.

Quanto tempo leva a aula “java.net.http.HttpClient”?

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