0Pricing
Advanced Spring Boot 4: Event-Driven Architecture (Kafka) · Aula

Tratando retornos de envio e confirmações do produtor

Aprenda a reagir ao resultado de envios assíncronos do Kafka usando retornos de chamada, CompletableFuture e a configuração de confirmações para garantir a confiabilidade da entrega.

Tratando retornos de envio e confirmações do produtor é uma aula grátis de Advanced Spring Boot 4: Event-Driven Architecture (Kafka) 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 Advanced Spring Boot 4: Event-Driven Architecture (Kafka), e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Advanced Spring Boot 4: Event-Driven Architecture (Kafka) inclui 4 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

Why Send Results Matter

When you call KafkaTemplate.send(), the message is dispatched asynchronously. The call returns immediately, but the broker may not have stored the record yet.

To build reliable producers you must inspect the result of each send so you can log, retry, or alert on failures.

The CompletableFuture Result

In Spring Kafka, send() returns a CompletableFuture<SendResult<K,V>>.

  • SendResult holds the RecordMetadata (partition, offset, timestamp).
  • You attach a continuation to handle success or failure.
CompletableFuture<SendResult<String,String>> future =
    kafkaTemplate.send("orders", order.getId(), payload);

Attaching whenComplete

Use whenComplete to handle both outcomes in one place. The first argument is the result, the second is the exception (null on success).

future.whenComplete((result, ex) -> {
    if (ex == null) {
        var md = result.getRecordMetadata();
        log.info("Sent to partition {} offset {}", md.partition(), md.offset());
    } else {
        log.error("Send failed", ex);
    }
});

Reading RecordMetadata

On success, RecordMetadata tells you exactly where the record landed.

  • partition() — which partition received it.
  • offset() — its position in that partition.
  • timestamp() — broker-assigned timestamp.
RecordMetadata md = result.getRecordMetadata();
String location = md.topic() + "-" + md.partition() + "@" + md.offset();

Blocking for the Result

Sometimes you need a synchronous guarantee. Call get() with a timeout to block until the broker acknowledges.

Use this sparingly — it kills throughput, but it is useful in tests or critical writes.

SendResult<String,String> result =
    kafkaTemplate.send("orders", payload).get(10, TimeUnit.SECONDS);

The acks Configuration

Acknowledgment durability is controlled by the producer acks setting:

  • acks=0 — fire and forget, no guarantee.
  • acks=1 — leader writes, then acknowledges.
  • acks=all — leader plus all in-sync replicas acknowledge.

Configuring acks in Spring Boot

Set the strongest durability with acks=all in your application.yml.

spring:
  kafka:
    producer:
      acks: all
      properties:
        min.insync.replicas: 2

Trade-off: Latency vs Durability

Stronger acks mean higher latency.

  • acks=0 is fastest but loses data on broker failure.
  • acks=all is safest but waits for replica confirmation.

For financial events choose all; for high-volume metrics 1 may suffice.

Centralizing Callback Logic

Avoid duplicating callback code. Wrap sends in a helper method that always logs metadata and failures consistently.

public void sendTracked(String topic, String key, String value) {
    kafkaTemplate.send(topic, key, value)
        .whenComplete((res, ex) -> {
            if (ex != null) metrics.incrementFailures();
            else metrics.incrementSuccess();
        });
}

Handling Failures Gracefully

In the failure branch you can:

  • Persist the failed payload to a fallback store.
  • Increment a failure metric for alerting.
  • Schedule a retry on a separate executor.

Never swallow the exception silently.

Putting It Together

A robust producer combines acks=all, callback inspection, and failure handling. This gives you observability and delivery guarantees without blocking your main flow.

future.whenComplete((res, ex) -> {
    if (ex != null) deadLetterStore.save(payload);
});

Quick Check

Test your understanding of producer acknowledgments.

Recap

You learned to handle the asynchronous result of Kafka sends.

  • send() returns a CompletableFuture<SendResult>.
  • Use whenComplete to inspect metadata or failures.
  • acks controls the durability vs latency trade-off.
  • Centralize callbacks for consistent reliability handling.

Perguntas Frequentes

A aula “Tratando retornos de envio e confirmações do produtor” é grátis?

Sim — o texto completo de “Tratando retornos de envio e confirmações do produtor” é 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 Advanced Spring Boot 4: Event-Driven Architecture (Kafka), atualize para CoddyKit PRO. O curso de Advanced Spring Boot 4: Event-Driven Architecture (Kafka) inclui 4 aulas no total.

O que vou aprender em “Tratando retornos de envio e confirmações do produtor”?

Aprenda a reagir ao resultado de envios assíncronos do Kafka usando retornos de chamada, CompletableFuture e a configuração de confirmações para garantir a confiabilidade da entrega. Você pratica Advanced Spring Boot 4: Event-Driven Architecture (Kafka) 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 Advanced Spring Boot 4: Event-Driven Architecture (Kafka)?

Nenhuma experiência prévia é necessária. Advanced Spring Boot 4: Event-Driven Architecture (Kafka) 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 “Tratando retornos de envio e confirmações do produtor”?

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 Advanced Spring Boot 4: Event-Driven Architecture (Kafka)?

Sim. Cada aula de Advanced Spring Boot 4: Event-Driven Architecture (Kafka) 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. Integração do Spring Kafka Starter
  2. Envio de mensagens com KafkaTemplate
  3. Personalização das configurações do produtor
  4. Tratando retornos de envio e confirmações do produtor
← Voltar para Advanced Spring Boot 4: Event-Driven Architecture (Kafka)