Java Academy · Aula

Corpos e cabeçalhos de requisições

Envie dados por POST e defina cabeçalhos.

Corpos e cabeçalhos de requisições é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 3 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.

Corpos de requisições e cabeçalhos

As requisições GET raramente precisam de um corpo, mas POST, PUT e PATCH precisam. O cliente HTTP do JDK usa objetos BodyPublisher para fornecer os corpos das requisições e métodos do construtor para definir cabeçalhos.

Esta lição aborda o envio de dados e o controle de cabeçalhos como Content-Type.

BodyPublishers.ofString

O publicador mais simples envia um corpo de cadeia de caracteres. Passe-o ao método POST(...) do construtor da requisição.

BodyPublishers.noBody() existe para requisições sem corpo.

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

public class Main {
    public static void main(String[] args) {
        String json = "{\"name\":\"Ada\"}";
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://example.com/users"))
            .POST(BodyPublishers.ofString(json))
            .build();
        System.out.println("Method: " + request.method());
    }
}

Definindo um único cabeçalho

Use header(name, value) para adicionar um cabeçalho. Para enviar JSON, quase sempre você define Content-Type.

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

public class Main {
    public static void main(String[] args) {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://example.com/users"))
            .header("Content-Type", "application/json")
            .POST(BodyPublishers.ofString("{}"))
            .build();
        System.out.println("Has Content-Type: " +
            request.headers().firstValue("Content-Type").isPresent());
    }
}

Vários cabeçalhos de uma só vez

headers(name1, value1, name2, value2, ...) define vários cabeçalhos em uma única chamada. A quantidade de argumentos deve ser par; caso contrário, uma IllegalArgumentException será lançada.

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"))
            .headers(
                "Accept", "application/json",
                "Accept-Language", "en-US")
            .GET()
            .build();
        System.out.println(request.headers().map().keySet());
    }
}

Cabeçalhos de autorização

Os tokens de portador são enviados por meio do cabeçalho Authorization. Construa o valor como uma cadeia de caracteres; nunca registre o token bruto.

public class Main {
    public static void main(String[] args) {
        String token = "abc123";
        String headerValue = "Bearer " + token;
        System.out.println("Authorization: Bearer ***");
        System.out.println("Length: " + headerValue.length());
    }
}

PUT e DELETE

O construtor tem métodos dedicados: PUT(publisher), DELETE() e o método genérico method(name, publisher) para qualquer outra finalidade, como PATCH.

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

public class Main {
    public static void main(String[] args) {
        HttpRequest patch = HttpRequest.newBuilder()
            .uri(URI.create("https://example.com/users/1"))
            .method("PATCH", BodyPublishers.ofString("{\"active\":true}"))
            .build();
        System.out.println("Method: " + patch.method());
    }
}

Corpos codificados como formulário

Para dados application/x-www-form-urlencoded, você constrói manualmente a cadeia de caracteres do corpo, codificando cada valor na URL, e depois a publica como uma cadeia de caracteres.

import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;

public class Main {
    public static void main(String[] args) {
        String body = "name=" + URLEncoder.encode("Ada Lovelace", StandardCharsets.UTF_8)
            + "&role=" + URLEncoder.encode("engineer", StandardCharsets.UTF_8);
        System.out.println(body);
    }
}

Enviando um corpo de arquivo

BodyPublishers.ofFile(path) transmite um arquivo como corpo da requisição sem carregá-lo todo na memória — ideal para envios.

import java.net.URI;
import java.net.http.HttpRequest;
import java.net.http.HttpRequest.BodyPublishers;
import java.nio.file.Path;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://example.com/upload"))
            .header("Content-Type", "application/octet-stream")
            .POST(BodyPublishers.ofFile(Path.of("data.bin")))
            .build();
        System.out.println("Upload request built");
    }
}

Corpos de matriz de bytes

Quando você já tem bytes na memória, BodyPublishers.ofByteArray(byte[]) os envia diretamente. Isso é útil para cargas binárias construídas durante a execução.

import java.nio.charset.StandardCharsets;

public class Main {
    public static void main(String[] args) {
        byte[] payload = "raw-bytes".getBytes(StandardCharsets.UTF_8);
        // BodyPublishers.ofByteArray(payload) would wrap these bytes
        System.out.println("Payload size: " + payload.length + " bytes");
    }
}

Cabeçalhos restritos

Por motivos de segurança, o cliente não permite que você defina determinados cabeçalhos, como Host, Content-Length, Connection e Upgrade. Tentar defini-los lança uma IllegalArgumentException — o próprio cliente os gerencia.

Reunindo tudo

Uma solicitação JSON típica com POST combina um publicador de corpo e um cabeçalho de tipo de conteúdo:

.POST(BodyPublishers.ofString(json))
.header("Content-Type", "application/json")
adicione .header("Authorization", "Bearer ...") se necessário

Verificação rápida

Teste sua compreensão dos corpos de requisições e dos cabeçalhos.

Recapitulação

Você aprendeu a enviar dados e controlar cabeçalhos:

BodyPublishers.ofString / ofByteArray / ofFile fornecem os corpos das requisições.
POST / PUT / DELETE / method(...) escolhem o verbo HTTP.
header(...) e headers(...) definem os cabeçalhos das requisições.
Defina Content-Type para JSON e dados de formulário; use Authorization para tokens.
Alguns cabeçalhos (Host, Content-Length) são restritos e gerenciados pelo cliente.

Perguntas Frequentes

A aula “Corpos e cabeçalhos de requisições” é grátis?

Sim — o texto completo de “Corpos e cabeçalhos de requisições” é 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 “Corpos e cabeçalhos de requisições”?

Envie dados por POST e defina cabeçalhos. 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 3 de 4.

Quanto tempo leva a aula “Corpos e cabeçalhos de requisições”?

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