การจัดการการตอบกลับและการยืนยันการส่งของผู้ผลิต

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.

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.

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

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.

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.

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.

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

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.

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

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.

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

Test your understanding of producer acknowledgments.

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.