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

Dead-Letter-Topics (DLT) implementieren

Konfigurieren Sie Dead-Letter-Topics, um Nachrichten zu erfassen und zu speichern, deren Verarbeitung wiederholt fehlschlägt, sodass sie später analysiert und erneut verarbeitet werden können.

Dead-Letter-Topics (DLT) implementieren ist eine kostenlose Advanced Spring Boot 4: Event-Driven Architecture (Kafka)-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Advanced Spring Boot 4: Event-Driven Architecture (Kafka)-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Advanced Spring Boot 4: Event-Driven Architecture (Kafka)-Kurs umfasst insgesamt 4 Lektionen.

Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.

Why Dead Letter Topics?

In event-driven systems, consumers sometimes fail to process messages due to transient errors (e.g., database unavailable) or permanent issues (e.g., malformed data).

  • What happens to these failed messages?
  • Do we retry them indefinitely, blocking the queue?
  • Or do we discard them, potentially losing critical data?

This is where Dead Letter Topics (DLTs) come in!

What is a Dead Letter Topic?

A Dead Letter Topic (DLT) is a dedicated Kafka topic where messages that repeatedly fail processing are sent.

  • It acts as a 'quarantine' for problematic messages.
  • Instead of blocking the main consumer or losing data, messages are moved to the DLT.
  • This allows the main consumer to continue processing new messages.

Messages in a DLT can then be inspected, manually corrected, or reprocessed later.

Spring Kafka's DLT Support

Spring for Apache Kafka provides excellent support for DLTs through its error handling mechanisms.

The key component is the DefaultErrorHandler, which can be configured to publish failed messages to a DLT after a certain number of retries.

It uses a DeadLetterPublishingRecoverer internally to perform the actual publishing.

Basic DLT Configuration

To enable DLT for a @KafkaListener, you can configure the DefaultErrorHandler with a DeadLetterPublishingRecoverer. This example sets up a simple DLT after 3 delivery attempts.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.listener.DeadLetterPublishingRecoverer;
import org.springframework.kafka.listener.DefaultErrorHandler;
import org.springframework.util.backoff.FixedBackOff;

@SpringBootApplication
public class DltApplication {

  public static void main(String[] args) {
    SpringApplication.run(DltApplication.class, args);
  }

  @Bean
  public DefaultErrorHandler errorHandler(KafkaTemplate<?, ?> kafkaTemplate) {
    // Publish to DLT after 3 delivery attempts
    // FixedBackOff(interval, maxAttempts) -> interval is ignored for DLT after retries
    return new DefaultErrorHandler(new DeadLetterPublishingRecoverer(kafkaTemplate),
                                   new FixedBackOff(0L, 2L)); // 0L interval, 2 retries = 3 attempts total
  }

  @KafkaListener(topics = "my-main-topic", groupId = "my-group", errorHandler = "errorHandler")
  public void listen(String message) {
    System.out.println("Received: " + message);
    if (message.contains("fail")) {
      throw new RuntimeException("Simulating processing failure!");
    }
  }

  // To send messages for testing (not part of DLT config itself)
  // @Autowired
  // private KafkaTemplate<String, String> template;
  // @EventListener(ApplicationReadyEvent.class)
  // public void sendMessage() {
  //   template.send("my-main-topic", "Hello");
  //   template.send("my-main-topic", "This will fail");
  // }
}

Understanding DLT Topic Names

By default, Spring Kafka names the DLT topic by appending .DLT to the original topic name. For example, if your main topic is my-main-topic, the DLT will be my-main-topic.DLT.

  • You can customize this behavior.
  • The DeadLetterPublishingRecoverer constructor can take a BiFunction to determine the DLT topic and partition.
  • This allows for more flexible naming conventions or routing failed messages to different DLTs based on criteria.

Message Headers in DLT

When a message is sent to a DLT, Spring Kafka adds several useful headers to it. These headers provide context about why the message ended up in the DLT:

  • dlt_exception-fqcn: Fully qualified class name of the exception.
  • dlt_exception-message: Message from the exception.
  • dlt_exception-stacktrace: Full stack trace.
  • dlt_original-topic: The topic the message came from.
  • dlt_original-partition: The original partition.
  • dlt_original-offset: The original offset.

These headers are invaluable for debugging and reprocessing.

Customizing DLT Publishing

You can provide a custom DeadLetterPublishingRecoverer to gain fine-grained control over how messages are published to the DLT. This allows you to modify headers, filter messages, or even prevent certain messages from going to the DLT.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.listener.DeadLetterPublishingRecoverer;
import org.springframework.kafka.listener.DefaultErrorHandler;
import org.springframework.kafka.support.KafkaHeaders;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.util.backoff.FixedBackOff;

@SpringBootApplication
public class CustomDltApplication {

  public static void main(String[] args) {
    SpringApplication.run(CustomDltApplication.class, args);
  }

  @Bean
  public DefaultErrorHandler customErrorHandler(KafkaTemplate<Object, Object> kafkaTemplate) {
    DeadLetterPublishingRecoverer customRecoverer = new DeadLetterPublishingRecoverer(kafkaTemplate,
      (record, exception) -> { // Custom DLT topic/partition resolver
        System.out.println("Sending to DLT: " + record.topic() + ".custom.dlt");
        return new DeadLetterPublishingRecoverer.HeaderNames(record.topic() + ".custom.dlt", null);
      });
    return new DefaultErrorHandler(customRecoverer, new FixedBackOff(0L, 1L)); // 1 retry = 2 attempts total
  }

  @KafkaListener(topics = "another-topic", groupId = "my-custom-group", errorHandler = "customErrorHandler")
  public void listenWithCustomDlt(String message) {
    System.out.println("Received (custom DLT): " + message);
    if (message.contains("fail")) {
      throw new RuntimeException("Simulating custom DLT failure!");
    }
  }
}

Consuming DLT Messages

Once messages are in a DLT, you'll need another consumer to process them. This DLT consumer can be designed to:

  • Log the error and notify administrators.
  • Store the message in a database for manual review.
  • Attempt to reprocess the message after a delay or transformation.

It's just another @KafkaListener, but configured to listen to the DLT topic.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.listener.DeadLetterPublishingRecoverer;
import org.springframework.kafka.listener.DefaultErrorHandler;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.kafka.support.KafkaHeaders;
import org.springframework.util.backoff.FixedBackOff;

@SpringBootApplication
public class DltConsumerApplication {

  public static void main(String[] args) {
    SpringApplication.run(DltConsumerApplication.class, args);
  }

  @Bean
  public DefaultErrorHandler errorHandler(KafkaTemplate<?, ?> kafkaTemplate) {
    return new DefaultErrorHandler(new DeadLetterPublishingRecoverer(kafkaTemplate),
                                   new FixedBackOff(0L, 2L));
  }

  @KafkaListener(topics = "my-main-topic", groupId = "my-group", errorHandler = "errorHandler")
  public void listenMain(String message) {
    System.out.println("Main Listener Received: " + message);
    if (message.contains("fail")) {
      throw new RuntimeException("Main processing failure!");
    }
  }

  @KafkaListener(topics = "my-main-topic.DLT", groupId = "dlt-group")
  public void listenDlt(String message,
                        @Header(KafkaHeaders.RECEIVED_TOPIC) String receivedTopic,
                        @Header(KafkaHeaders.ORIGINAL_OFFSET) Long originalOffset,
                        @Header(KafkaHeaders.EXCEPTION_MESSAGE) String exceptionMessage) {
    System.out.println("DLT Listener Received: " + message);
    System.out.println("  From Topic: " + receivedTopic);
    System.out.println("  Original Offset: " + originalOffset);
    System.out.println("  Exception: " + exceptionMessage);
    // Here you would implement logic to store, alert, or reprocess
  }
}

DLT Best Practices

To effectively use DLTs, consider these best practices:

  • Monitor DLTs: Set up alerts for messages appearing in DLTs, as they indicate persistent issues.
  • Process DLTs: Don't let DLTs grow indefinitely. Have a plan to consume and handle these messages.
  • Idempotency: Ensure your DLT reprocessing logic is idempotent to avoid duplicate processing issues.
  • Separate Concerns: Keep DLT consumers separate from your main application logic for clearer responsibilities.
  • Schema Evolution: Be mindful of schema changes when reprocessing old DLT messages.

DLT Quick Check

Which of the following is the primary benefit of using a Dead Letter Topic (DLT) in a Kafka consumer application?

Recap: DLT for Robustness

You've learned how Dead Letter Topics are a crucial component for building robust and resilient Kafka consumer applications.

  • DLTs quarantine messages that fail repeated processing.
  • Spring Kafka's DefaultErrorHandler and DeadLetterPublishingRecoverer simplify DLT integration.
  • Messages sent to DLTs include useful headers for debugging.
  • DLTs require a separate consumer to handle the failed messages.

By implementing DLTs, you ensure your consumers can gracefully handle errors, prevent data loss, and maintain steady message flow.

Häufig gestellte Fragen

Ist die Lektion „Dead-Letter-Topics (DLT) implementieren“ kostenlos?

Ja — der vollständige Text von „Dead-Letter-Topics (DLT) implementieren“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Advanced Spring Boot 4: Event-Driven Architecture (Kafka)-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Advanced Spring Boot 4: Event-Driven Architecture (Kafka)-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Dead-Letter-Topics (DLT) implementieren“?

Konfigurieren Sie Dead-Letter-Topics, um Nachrichten zu erfassen und zu speichern, deren Verarbeitung wiederholt fehlschlägt, sodass sie später analysiert und erneut verarbeitet werden können. Du übst Advanced Spring Boot 4: Event-Driven Architecture (Kafka) mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Advanced Spring Boot 4: Event-Driven Architecture (Kafka) zu starten?

Keine Vorkenntnisse erforderlich. Advanced Spring Boot 4: Event-Driven Architecture (Kafka) auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Dead-Letter-Topics (DLT) implementieren“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Advanced Spring Boot 4: Event-Driven Architecture (Kafka)-Lektion Code schreiben und ausführen?

Ja. Jede Advanced Spring Boot 4: Event-Driven Architecture (Kafka)-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Ausnahmen bei Consumern behandeln
  2. Retry-Mechanismen mit Spring Retry
  3. Dead-Letter-Topics (DLT) implementieren
  4. Nicht blockierende Wiederholungen mit Retry Topics
← Zurück zu Advanced Spring Boot 4: Event-Driven Architecture (Kafka)