java 60 lines · 9 steps

Dead-letter recovery with Spring AMQP

A Spring component consumes dead-lettered orders, tracks retry attempts, and either re-queues with backoff or escalates.

Explained by highlit

Spring Advanced dead-letter-queue retry exponential-backoff message-driven escalation

1@Component
2public class OrderRecoveryHandler {
3 
  private final RabbitTemplate rabbitTemplate;
  private final RecoveryAttemptRepository attempts;
  private final AlertService alertService;
7 
  public OrderRecoveryHandler(RabbitTemplate rabbitTemplate,
                              RecoveryAttemptRepository attempts,
                              AlertService alertService) {
      this.rabbitTemplate = rabbitTemplate;
      this.attempts = attempts;
      this.alertService = alertService;
  }
15 
  @RabbitListener(queues = "orders.payment.dlq")
  public void onPaymentFailure(FailedOrderMessage message,
                               @Header("x-death") List<Map<String, ?>> death) {
      recover(message, RecoverySource.PAYMENT, deathCount(death));
  }
21 
  @RabbitListener(queues = "orders.fulfillment.dlq")
  public void onFulfillmentFailure(FailedOrderMessage message,
                                   @Header("x-death") List<Map<String, ?>> death) {
      recover(message, RecoverySource.FULFILLMENT, deathCount(death));
  }
27 
  private void recover(FailedOrderMessage message, RecoverySource source, long deaths) {
      RecoveryAttempt attempt = attempts.findByOrderId(message.orderId())
              .orElseGet(() -> new RecoveryAttempt(message.orderId()));
      attempt.record(source, message.reason());
32 
      if (deaths >= 3 || attempt.hasFailedIn(RecoverySource.PAYMENT, RecoverySource.FULFILLMENT)) {
          attempt.escalate();
          attempts.save(attempt);
          alertService.pageOnCall(message.orderId(), attempt.summary());
          return;
      }
39 
      attempts.save(attempt);
      rabbitTemplate.convertAndSend(
              "orders.retry.exchange",
              source.routingKey(),
              message,
              m -> {
                  m.getMessageProperties().setDelayLong(backoffMillis(deaths));
                  return m;
              });
  }
50 
  private long deathCount(List<Map<String, ?>> death) {
      return death == null || death.isEmpty()
              ? 1L
              : ((Number) death.get(0).getOrDefault("count", 1L)).longValue();
  }
56 
  private long backoffMillis(long deaths) {
      return Math.min(Duration.ofMinutes(5).toMillis(), 2000L * (1L << deaths));
  }
60}

01 / 01

STEP 01

Walkthrough

Space play ←→ step click any line

Three takeaways

1Dead-letter queues plus a persisted attempt record let you retry failures safely without losing track of history.
2Capping exponential backoff prevents retry delays from growing unbounded while still spacing out attempts.
3Escalation rules based on death count and cross-source failure stop poison messages from retrying forever.

Related explainers

java

@Component
public class CorrelationIdWebFilter implements WebFilter, Ordered {
 
    public static final String CORRELATION_ID_HEADER = "X-Correlation-Id";

Correlation IDs in a Spring WebFlux filter

reactive web filter correlation id

Advanced 7 steps

java

public final class DeepCopier {
 
    private static final ObjectMapper MAPPER = new ObjectMapper()
            .registerModule(new JavaTimeModule())

Deep-copying objects via Jackson serialization

serialization deep-copy generics

Intermediate 7 steps

java

package com.example.time;
 
import java.time.Duration;
import java.time.Instant;

Adding ISO-8601 durations across time zones in Java

date-time iso-8601 parsing

Intermediate 7 steps

java

@Component
public class InventoryReconciliationJob {
 
    private static final Logger log = LoggerFactory.getLogger(InventoryReconciliationJob.class);

Distributed scheduled jobs with Spring locks

distributed-locking scheduling concurrency

Advanced 8 steps

java

import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.regex.Pattern;

Ranking the most frequent words in Java

streams regex grouping

Intermediate 7 steps

java

public final class HttpHeaders {
 
    private final NavigableMap<String, List<String>> values =
            new TreeMap<>(String.CASE_INSENSITIVE_ORDER);