Java Academy · Aula

Requisições assíncronas

sendAsync e CompletableFuture.

Requisições assíncronas é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 2 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.

Requisições assíncronas

Bloquear a cada chamada HTTP desperdiça linhas de execução. O cliente HTTP do JDK oferece sendAsync, que retorna um CompletableFuture imediatamente e realiza o trabalho em um executor em segundo plano.

Isso permite iniciar muitas requisições simultaneamente e combinar seus resultados sem gerenciar linhas de execução manualmente.

send em comparação com sendAsync

As assinaturas diferem no que retornam:

send retorna HttpResponse<T> e bloqueia, declarando IOException e InterruptedException.
sendAsync retorna CompletableFuture<HttpResponse<T>> e nunca bloqueia; os erros são disponibilizados por meio do futuro.

Uma chamada básica de sendAsync

sendAsync recebe a mesma requisição e o mesmo BodyHandler que send. O futuro retornado é concluído quando a resposta está pronta.

import java.net.URI;
import java.net.http.*;
import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://example.com"))
            .build();
        CompletableFuture<HttpResponse<String>> future =
            client.sendAsync(request, HttpResponse.BodyHandlers.ofString());
        System.out.println("Request sent, future created");
    }
}

Transformando com thenApply

Use thenApply para transformar o resultado assim que ele chegar — por exemplo, extraindo o corpo da resposta.

Isso é executado de forma síncrona na linha de execução que concluiu o estágio anterior.

import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) throws Exception {
        CompletableFuture<String> future =
            CompletableFuture.completedFuture("OK 200")
                .thenApply(body -> "Length=" + body.length());
        System.out.println(future.get());
    }
}

Consumindo com thenAccept

Quando você quer apenas um efeito colateral e nenhum valor de retorno, use thenAccept. Ele recebe um Consumer e produz um CompletableFuture<Void>.

import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) throws Exception {
        CompletableFuture<Void> done =
            CompletableFuture.completedFuture("payload")
                .thenAccept(b -> System.out.println("Received: " + b));
        done.get();
    }
}

Bloqueando com join

Para aguardar um resultado assíncrono a partir de main, chame join() (não verificado) ou get() (verificado). Em um servidor real, você encadearia os estágios em vez de bloquear.

join() envolve as falhas em uma CompletionException não verificada.

import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) {
        CompletableFuture<Integer> f =
            CompletableFuture.supplyAsync(() -> 21).thenApply(n -> n * 2);
        int result = f.join();
        System.out.println("Result: " + result);
    }
}

Lidando com erros com exceptionally

exceptionally fornece um valor alternativo quando um estágio falha, recuperando o fluxo.

É assim que você impede que um fluxo HTTP assíncrono seja interrompido por um erro de rede.

import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) {
        CompletableFuture<String> f = CompletableFuture
            .<String>supplyAsync(() -> { throw new RuntimeException("boom"); })
            .exceptionally(ex -> "fallback: " + ex.getMessage());
        System.out.println(f.join());
    }
}

Combinando duas requisições

thenCombine aguarda dois futuros independentes e combina seus resultados. Com HTTP assíncrono, isso busca dados de dois pontos de extremidade em paralelo e combina os corpos.

import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) {
        CompletableFuture<String> a = CompletableFuture.supplyAsync(() -> "Hello");
        CompletableFuture<String> b = CompletableFuture.supplyAsync(() -> "World");
        String combined = a.thenCombine(b, (x, y) -> x + " " + y).join();
        System.out.println(combined);
    }
}

Iniciando muitas requisições em paralelo

Para executar um conjunto de requisições, reúna cada futuro em uma lista e use CompletableFuture.allOf(...) para aguardar todas elas.

allOf retorna CompletableFuture<Void>; depois, você lê os resultados individuais.

import java.util.*;
import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) {
        List<CompletableFuture<Integer>> futures = new ArrayList<>();
        for (int i = 1; i <= 3; i++) {
            int n = i;
            futures.add(CompletableFuture.supplyAsync(() -> n * n));
        }
        CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();
        for (var f : futures) System.out.println(f.join());
    }
}

Resumo do padrão assíncrono

Um fluxo HTTP assíncrono típico é semelhante a este:

client.sendAsync(req, BodyHandlers.ofString())
.thenApply(HttpResponse::body) para obter o corpo
.thenAccept(System.out::println) para consumi-lo
.exceptionally(ex -> ...) para se recuperar

Nenhuma linha de execução é bloqueada enquanto aguarda a rede.

Quando usar o modo assíncrono

Escolha sendAsync quando fizer muitas chamadas simultâneas, distribuir requisições entre vários serviços ou executar dentro de um servidor reativo e não bloqueante. Escolha send para scripts simples e chamadas pontuais em que bloquear não é um problema.

Verificação rápida

Verifique sua compreensão das requisições assíncronas.

Recapitulação

Você aprendeu a fazer chamadas HTTP não bloqueantes:

sendAsync retorna um CompletableFuture em vez de bloquear.
thenApply / thenAccept transformam e consomem o resultado.
exceptionally fornece uma alternativa em caso de falha.
thenCombine combina duas chamadas paralelas; allOf aguarda um conjunto de chamadas.
O modo assíncrono é adequado para servidores reativos e com alta concorrência; o modo síncrono é adequado para scripts simples.

Perguntas Frequentes

A aula “Requisições assíncronas” é grátis?

Sim — o texto completo de “Requisições assíncronas” é 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 “Requisições assíncronas”?

sendAsync e CompletableFuture. 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 2 de 4.

Quanto tempo leva a aula “Requisições assíncronas”?

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