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

Menangani Callback Pengiriman Produsen dan Pengakuan

Pelajari cara merespons hasil pengiriman Kafka asinkron menggunakan callback, CompletableFuture, dan konfigurasi acks untuk menjamin keandalan pengiriman.

Menangani Callback Pengiriman Produsen dan Pengakuan adalah pelajaran Advanced Spring Boot 4: Event-Driven Architecture (Kafka) gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Advanced Spring Boot 4: Event-Driven Architecture (Kafka), dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Advanced Spring Boot 4: Event-Driven Architecture (Kafka) mencakup 4 pelajaran total.

Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.

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.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Menangani Callback Pengiriman Produsen dan Pengakuan” gratis?

Ya — teks lengkap “Menangani Callback Pengiriman Produsen dan Pengakuan” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Advanced Spring Boot 4: Event-Driven Architecture (Kafka), upgrade ke CoddyKit PRO. Kursus Advanced Spring Boot 4: Event-Driven Architecture (Kafka) mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Menangani Callback Pengiriman Produsen dan Pengakuan”?

Pelajari cara merespons hasil pengiriman Kafka asinkron menggunakan callback, CompletableFuture, dan konfigurasi acks untuk menjamin keandalan pengiriman. Kamu berlatih Advanced Spring Boot 4: Event-Driven Architecture (Kafka) dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Advanced Spring Boot 4: Event-Driven Architecture (Kafka)?

Tidak diperlukan pengalaman sebelumnya. Advanced Spring Boot 4: Event-Driven Architecture (Kafka) di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “Menangani Callback Pengiriman Produsen dan Pengakuan” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Advanced Spring Boot 4: Event-Driven Architecture (Kafka) ini?

Ya. Setiap pelajaran Advanced Spring Boot 4: Event-Driven Architecture (Kafka) menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Mengintegrasikan Spring Kafka Starter
  2. Mengirim Pesan dengan KafkaTemplate
  3. Menyesuaikan Konfigurasi Produsen
  4. Menangani Callback Pengiriman Produsen dan Pengakuan
← Kembali ke Advanced Spring Boot 4: Event-Driven Architecture (Kafka)