0Pricing
Java Academy · Aula

Tratamento de Erros e Pipeline HTTP Assíncrono

Trate erros com exceptionally, handle e whenComplete e depois construa um pipeline assíncrono de cliente HTTP.

Tratamento de Erros e Pipeline HTTP Assíncrono é 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.

Por que o tratamento de erros assíncronos é importante

Em fluxos assíncronos, as exceções não se propagam da mesma forma que no código síncrono. Você deve tratar os erros explicitamente usando exceptionally, handle ou whenComplete.

exceptionally: Recuperação de Erros

exceptionally(Function<Throwable, T>) só é chamado se o futuro for concluído com uma exceção. Ele fornece um valor alternativo, mantendo o fluxo ativo.

CompletableFuture<String> safe = fetchUser(id)
    .thenApply(User::getName)
    .exceptionally(ex -> {
        log.warn("Fetch failed: " + ex.getMessage());
        return "Anonymous";
    });
System.out.println(safe.join()); // "Anonymous" if fetch failed

handle: Transformação de Sucesso e Falha

handle(BiFunction<T, Throwable, U>) é chamado tanto em caso de sucesso quanto de falha. Um dos dois argumentos será nulo.

fetchUser(id).handle((user, ex) -> {
    if (ex != null) return UserDto.empty();
    return UserDto.from(user);
}).thenAccept(dto -> sendResponse(dto));

whenComplete: Efeito Colateral Após Qualquer Resultado

whenComplete(BiConsumer) é chamado após a conclusão, independentemente do resultado. Ele não altera o resultado — use-o para registro, métricas ou limpeza.

fetchUser(id)
    .whenComplete((user, ex) -> {
        if (ex != null) metrics.increment("user.fetch.error");
        else            metrics.increment("user.fetch.success");
    })
    .thenAccept(u -> sendResponse(u));

Repetição de Futuros com Falha

Implemente a lógica de novas tentativas chamando recursivamente a operação em caso de falha, até atingir um número máximo de tentativas.

CompletableFuture<String> withRetry(Supplier<CompletableFuture<String>> task, int retries) {
    return task.get().exceptionallyCompose(ex -> {
        if (retries > 0) {
            System.out.println("Retrying... " + retries);
            return withRetry(task, retries - 1);
        }
        return CompletableFuture.failedFuture(ex);
    });
}

Java 11 HttpClient: GET Assíncrono

O Java 11 HttpClient fornece HTTP totalmente assíncrono por meio de sendAsync(), retornando um CompletableFuture<HttpResponse<String>>.

HttpClient client = HttpClient.newHttpClient();
HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.example.com/users/1"))
    .build();
CompletableFuture<String> body = client
    .sendAsync(req, HttpResponse.BodyHandlers.ofString())
    .thenApply(HttpResponse::body);

Encadeando Várias Chamadas HTTP

Use thenCompose para encadear chamadas HTTP dependentes: primeiro obtenha o usuário e depois use o ID do usuário para obter seus pedidos.

client.sendAsync(userReq, HttpResponse.BodyHandlers.ofString())
    .thenApply(r -> parseUser(r.body()))
    .thenCompose(user -> client.sendAsync(
        buildOrdersRequest(user.getId()),
        HttpResponse.BodyHandlers.ofString()))
    .thenApply(r -> parseOrders(r.body()))
    .thenAccept(orders -> System.out.println("Orders: " + orders.size()));

Chamadas HTTP Paralelas com allOf

Envie solicitações a vários endpoints em paralelo e depois reúna todas as respostas quando tudo for concluído.

List<URI> endpoints = List.of(uri1, uri2, uri3);
List<CompletableFuture<String>> requests = endpoints.stream()
    .map(uri -> client.sendAsync(
            HttpRequest.newBuilder(uri).build(),
            HttpResponse.BodyHandlers.ofString())
        .thenApply(HttpResponse::body))
    .collect(Collectors.toList());
List<String> responses = CompletableFuture
    .allOf(requests.toArray(new CompletableFuture[0]))
    .thenApply(v -> requests.stream().map(CompletableFuture::join).collect(Collectors.toList()))
    .join();

Tempo Limite em Chamadas HTTP

Aplique orTimeout diretamente à chamada HTTP assíncrona para cancelá-la se o servidor demorar demais.

CompletableFuture<String> result = client
    .sendAsync(req, HttpResponse.BodyHandlers.ofString())
    .orTimeout(5, TimeUnit.SECONDS)
    .thenApply(HttpResponse::body)
    .exceptionally(ex -> "timeout or error");

Validação do Código de Status no Fluxo

Use thenApply para verificar o código de status HTTP e lançar uma exceção de domínio se ele indicar um erro, mantendo consistente o tratamento de erros do fluxo.

.thenApply(response -> {
    if (response.statusCode() != 200)
        throw new HttpResponseException(response.statusCode());
    return response.body();
})

Combinando Recuperação de Erros e Registro

Use whenComplete para registro e exceptionally para recuperação no mesmo fluxo — eles se compõem de forma simples.

fetchData()
    .whenComplete((r, ex) -> { if (ex != null) log.error("Failed", ex); })
    .exceptionally(ex -> fallback())
    .thenAccept(result -> process(result));

Verificação Rápida

Qual método de CompletableFuture é chamado ONLY quando o futuro falha?

Recapitulação

Use exceptionally para valores alternativos, handle para transformar ambos os resultados e whenComplete para efeitos colaterais. Crie fluxos HTTP assíncronos com Java 11 HttpClient + thenCompose + allOf.

Perguntas Frequentes

A aula “Tratamento de Erros e Pipeline HTTP Assíncrono” é grátis?

Sim — o texto completo de “Tratamento de Erros e Pipeline HTTP Assíncrono” é 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 “Tratamento de Erros e Pipeline HTTP Assíncrono”?

Trate erros com exceptionally, handle e whenComplete e depois construa um pipeline assíncrono de cliente HTTP. 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 “Tratamento de Erros e Pipeline HTTP Assíncrono”?

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

  1. Criação e Conclusão de CompletableFutures
  2. Encadeamento com thenApply e thenCompose
  3. Combinação de Futures: allOf e anyOf
  4. Tratamento de Erros e Pipeline HTTP Assíncrono
← Voltar para Java Academy