Tagged articles
Dead Letter Queue
45 articles · Page 1 of 1
A comprehensive guide covering message queue reliability patterns using SpringBoot with RabbitMQ and RocketMQ, including a real production incident analysis, core concepts, complete code implementation for reliable delivery, idempotent consumption with Redis SET NX, ordered processing, dead letter queues, and production-ready configurations.
Dead Letter QueueIdempotent ConsumptionMessage Queue
0 likes · 33 min read

This comprehensive guide covers Spring Boot RabbitMQ integration for production reliability, detailing three message-loss scenarios, the three-layer exchange/queue/binding model, publisher confirms and returns, manual acknowledgment modes, local vs requeue retry strategies, dead letter queue triggers, and practical patterns for idempotency, ordering, and backlog handling with code examples.
Dead Letter QueueIdempotencyManual Acknowledgment
0 likes · 19 min read


java1234Oct 26, 2026 · Backend Development
Kafka 4.2 introduces Share Groups (KIP-932) allowing multiple consumers to process records from the same partition concurrently using fetch locks and explicit acknowledgments (ACCEPT, RELEASE, REJECT, RENEW), while Kafka Streams gains server-side rebalancing (KIP-1071) and dead-letter queues (KIP-1034); version 4.2.2 adds 33 fixes including exactly-once checkpoint cleanup, deadlock resolution, and latency metric corrections.
Dead Letter QueueKIP-1034KIP-1071
0 likes · 17 min read

This article analyzes three production failures with local message tables in e-commerce systems — non-atomic writes losing messages, retry storms overwhelming databases, and missing idempotency causing duplicate operations — and provides a six-point production review checklist covering atomic writes, exponential backoff retries, idempotency keys, distributed scheduler locks, table archiving, and dead-letter alerting.
Dead Letter QueueIdempotencySeata
0 likes · 13 min read

This guide details Spring Boot RabbitMQ configuration for reliable message delivery and consumer concurrency, covering publisher confirms, returns, prefetch tuning, acknowledgment modes, channel caching, and a production-ready template with compensation strategies.
Dead Letter QueueIdempotencyMessage Queue
0 likes · 13 min read

A real-world case study demonstrates a six-step SOP using shadow consumer groups and fallback consumers to resolve a 1.2 million message Kafka backlog in 11 minutes while maintaining data consistency and preventing downstream database overload.
Dead Letter QueueIdempotencyKafka
0 likes · 21 min read

This tutorial explains RabbitMQ core concepts including message routing via exchanges and queues, details four exchange types (Direct, Fanout, Topic, Headers), provides Spring Boot integration code examples, covers reliability patterns like publisher confirms and manual acknowledgments, and lists common pitfalls with solutions.
AMQPDead Letter QueueExchange Types
0 likes · 12 min read

This comprehensive guide covers RocketMQ production operations including cluster deployment with NameServer and Broker configurations, message retry mechanisms with backoff strategies, dead letter queue handling and reprocessing, monitoring with Prometheus alerts, and troubleshooting procedures for common issues like message accumulation, disk full, and broker failures.
Cluster DeploymentDead Letter QueueMessage Queue
0 likes · 67 min read

This guide demonstrates building a reliable message queue with Spring Boot and Redis Stream, covering persistence, consumer group rebalancing, idempotency, dead-letter handling, and operational monitoring, with practical code examples and comparisons to Kafka and RabbitMQ.
Consumer GroupDead Letter QueueIdempotency
0 likes · 23 min read

This article shares real-world RocketMQ production lessons from an e-commerce platform, covering message sending reliability, idempotent consumption, backlog handling, dead letter queues, and configuration best practices with code examples.
Dead Letter QueueIdempotencyJava
0 likes · 18 min read

When a Kafka topic’s consumer lag suddenly spiked to over one million messages, the author traced the issue to improper acknowledgment handling, implemented emergency scaling, corrected exception processing, added a dead‑letter queue, and created a reusable checklist to prevent future backlogs.
Consumer LagDead Letter QueueKafka
0 likes · 7 min read

The article explains why messages can be lost in RocketMQ at the producer, broker, or consumer level and provides concrete strategies—including synchronous sending, async retries, synchronous disk flush, synchronous replication, and manual consumer acknowledgment with dead‑letter monitoring—to ensure reliable delivery.
Asynchronous SendBroker ConfigurationConsumer Acknowledgment
0 likes · 9 min read


liandkAug 8, 2026 · Backend Development
The article explains how to build a production‑grade MQ architecture by addressing the four critical pitfalls—message loss, duplicate consumption, backlog, and out‑of‑order delivery—through producer ACK retries, persistent storage, manual ACKs, idempotent business logic, dead‑letter queues, consumer scaling, and partitioned ordering.
Dead Letter QueueIdempotencyMQ
0 likes · 7 min read

This article explains MQ consumption failure retry mechanisms in depth, using a courier analogy, detailing ACK modes, Spring Boot RabbitMQ and Kafka configurations, local vs MQ re‑delivery strategies, dead‑letter queue setup, retry interval policies, exception handling, monitoring tips, and common FAQs.
ACKDead Letter QueueKafka
0 likes · 16 min read

This article details production-hardened patterns for building reliable message-driven systems with Spring Boot, covering MQ selection, producer confirmations, local message tables, manual acknowledgment, retry with backoff, dead-letter queues, idempotency strategies, backlog monitoring, ordered messaging, distributed tracing, and JVM/OS tuning parameters.
Backpressure HandlingDead Letter QueueDistributed Tracing
0 likes · 20 min read

The article explains two ways to implement a 30‑minute order auto‑cancellation in RabbitMQ—using the classic TTL + dead‑letter exchange pattern (with its head‑blocking pitfall) and the newer delayed‑message‑exchange plugin—provides Spring Boot configuration examples, compares their trade‑offs, and offers interview tips on when to choose each solution.
Dead Letter QueueDelayed Message PluginInterview
0 likes · 12 min read

In ultra‑high‑throughput systems, dead‑letter handling must evolve from a basic discard queue to a comprehensive lifecycle that includes monitoring, attribution, replay, archiving, and dashboards, turning failure messages into actionable system health assets.
Dead Letter QueueKafkaRetry
0 likes · 19 min read

This article explains the concept of RabbitMQ dead‑letter queues, the three conditions that turn a message into a dead letter, how to configure DLX and routing keys in Spring Boot, common pitfalls, a classic order‑timeout use case, and typical interview follow‑up questions.
Dead Letter QueueJava InterviewRabbitMQ
0 likes · 11 min read

This article explains why message ordering is critical for order‑state flows, demonstrates how to use RocketMQ's ordered messaging and dead‑letter queue features in a Spring Cloud project, shows the full project structure, provides runnable code, testing steps, performance numbers, and common pitfalls.
Dead Letter QueueMessage RetryOrdered Messages
0 likes · 21 min read

The article explains why delayed messaging is a common requirement in modern applications, compares the native dead‑letter‑queue TTL method with the RabbitMQ x‑delayed‑message plugin, and provides step‑by‑step SpringBoot integration, configuration, producer/consumer code, testing instructions, and practical cautions.
Dead Letter QueueRabbitMQSpringBoot
0 likes · 13 min read

The article breaks down RabbitMQ's three‑stage message flow—producer to broker, broker persistence, and broker to consumer—detailing how Publisher Confirm, durable exchanges/queues/messages, and manual consumer acknowledgments together guarantee reliability while discussing performance trade‑offs, high‑availability clustering, and common interview follow‑up questions.
Dead Letter QueueMessage ReliabilityPublisher Confirm
0 likes · 14 min read

This article explains how to use dead‑letter queues (DLX) to isolate failed messages in distributed SpringBoot applications, compares RabbitMQ and RocketMQ support, and presents a complete compensation framework with design principles, code examples, best‑practice guidelines, and a real‑world case study showing a 96% reduction in dead‑letter traffic.
Dead Letter QueueMessage RetryRabbitMQ
0 likes · 23 min read

This article walks through Kafka’s core architecture, explains why it achieves massive throughput, and provides a step‑by‑step SpringBoot integration—including environment setup, Maven dependencies, configuration, producer and consumer code, advanced features like transactions and dead‑letter queues, plus performance monitoring and tuning tips.
ConsumerDead Letter QueueJava
0 likes · 11 min read

Discover the three stages where MQ messages can be lost and explore five practical solutions—including producer confirmations, message persistence, consumer acknowledgments, transactional messaging, and retry with dead‑letter queues—complete with code examples and guidance on selecting the right approach for different scenarios.
Dead Letter QueueKafkaMessage Queue
0 likes · 14 min read

This article explains what message queue backlog is, why it harms system latency, and provides practical, step‑by‑step strategies—including temporary consumer scaling, prioritizing core messages, queue splitting, root‑cause analysis, performance tuning, message design, dead‑letter handling, traffic control, capacity planning, and monitoring—to eliminate backlog and ensure reliable asynchronous processing.
Dead Letter QueueMessage Queuebacklog
0 likes · 21 min read

This article explains why Kafka’s at‑least‑once delivery can cause duplicate message processing, outlines the business risks of such duplicates, and presents four practical solutions—including idempotent design, manual offset commits, exactly‑once semantics, and dead‑letter queues—to ensure reliable consumption.
Dead Letter QueueIdempotencyKafka
0 likes · 6 min read

This article deeply explores Apache RocketMQ's retry mechanisms, detailing producer and consumer retry strategies, flow control handling, dead‑letter queue management, advanced configurations, best practices, and comparisons with Kafka and RabbitMQ, providing practical code examples and monitoring recommendations for building highly reliable distributed systems.
Dead Letter QueueIdempotencyMessage Queue
0 likes · 8 min read

This article explains what delayed queues are, details two RabbitMQ implementations using TTL with dead‑letter exchanges and the rabbitmq‑delayed‑message‑exchange plugin, provides full Java configuration and producer/consumer code examples, and outlines common use‑cases such as order timeout and refund processing.
Dead Letter QueueJavaRabbitMQ
0 likes · 13 min read

This article explains the concepts of RabbitMQ dead‑letter exchanges and queues, outlines why messages become dead letters, and provides complete Java code examples for configuring exchanges, publishing messages with TTL, and consuming both normal and dead‑letter queues.
Dead Letter QueueJavaMessage Queue
0 likes · 12 min read

This guide explains why RocketMQ consumer retries can be slow under HTTP, outlines the retry mechanism and limits, and provides step‑by‑step instructions with screenshots for manually resending messages via the console to troubleshoot system anomalies.
Dead Letter QueueHTTP ProtocolManual Message Resend
0 likes · 4 min read

Effective software resilience requires strategies such as dead‑letter queues, feature toggles, robust design patterns like bulkhead and circuit breaker, loose coupling, and sidecar containers, enabling developers to isolate failures, reduce impact, and maintain performance in distributed, cloud‑native systems.
Dead Letter Queuecloud-nativedesign patterns
0 likes · 10 min read

This article explains what dead letters are in RabbitMQ, outlines their common causes, and provides a complete Spring Boot configuration and code examples for setting up dead‑letter exchanges, queues, TTL handling, message rejection, and consumer processing to reliably manage undeliverable messages.
Dead Letter QueueMessage RejectionRabbitMQ
0 likes · 8 min read

This article explains what a Message Queue (MQ) is, why it is used for traffic shaping, system decoupling, and asynchronous processing, reviews popular MQ products such as Kafka, ActiveMQ, RocketMQ and RabbitMQ, and details RabbitMQ's core concepts and advanced features like dead‑letter, delayed, idempotent, priority, and lazy queues.
Asynchronous ProcessingDead Letter QueueKafka
0 likes · 13 min read

This article explains the purpose of message queues, outlines RabbitMQ's architecture, describes common MQ patterns such as simple, work, fan‑out, direct, and topic, and discusses reliability features like transactions, confirms, dead‑letter queues, TTL, clustering, and ordering guarantees.
Asynchronous ProcessingDead Letter QueueMessage Queue
0 likes · 22 min read


JavaEdgeDec 24, 2021 · Backend Development
This article explains RabbitMQ's advanced reliability features, including how to prevent message loss with confirmCallback and returnCallback, configure TTL and dead‑letter queues, and provides practical code samples and interview‑style Q&A for backend developers.
BackendConfirmCallbackDead Letter Queue
0 likes · 10 min read

This article explains the concept of RabbitMQ dead letter queues, outlines the conditions that generate dead letters, provides step‑by‑step configuration instructions, and includes Go code examples for publishing messages with TTL and consuming from the dead‑letter queue to implement delayed processing.
Dead Letter QueueGoMessage Queue
0 likes · 5 min read

This guide explains RabbitMQ dead‑letter queues, covering the conditions that turn messages into dead letters, how to configure exchanges and queues with x‑dead‑letter‑exchange, TTL, and max‑length, and provides step‑by‑step Spring Boot code examples for testing each scenario.
BackendDead Letter QueueMessage Queue
0 likes · 7 min read

This article analyzes common Kafka consumer failure scenarios, explains why naïve retry‑topic or message‑skip approaches can break ordering and data consistency, and presents practical patterns—including error classification, in‑consumer backoff, hidden topics, and DLQ handling—to design resilient asynchronous microservice communication.
Dead Letter QueueKafkaMessage Failure
0 likes · 21 min read

This guide explains RabbitMQ dead-letter queues, detailing the conditions that cause messages to become dead letters, how to configure exchanges and queues with x-dead-letter parameters, and demonstrates three testing methods—reject/nack, TTL expiration, and max-length overflow—using Spring Boot code examples.
Dead Letter QueueMessage QueuingRabbitMQ
0 likes · 7 min read

This article explains why consumer‑side flow control is needed in RabbitMQ, demonstrates how to use the QoS API and basicQos settings, shows practical Java code for limiting consumption, and covers TTL and dead‑letter queue configurations to improve message reliability and system stability.
Consumer Rate LimitingDead Letter QueueJava
0 likes · 15 min read

This article explains why and how to throttle RabbitMQ consumers using QoS settings, demonstrates practical Java code for consumer‑side flow control, explores message and queue TTL configurations, and details the setup of dead‑letter exchanges and queues to handle undelivered messages.
Dead Letter QueueJavaMessage Queue
0 likes · 13 min read

This article explains how to implement consumer-side flow control in RabbitMQ using QoS settings, demonstrates configuring prefetch limits, shows how to set message and queue TTLs, and provides step‑by‑step code examples for creating producers, consumers, and dead‑letter queues to manage message overload and expiration.
Dead Letter QueueJavaQoS
0 likes · 15 min read

This article explains how using message queues for asynchronous communication decouples services, improves fault tolerance, and enhances performance, illustrated with a real‑world early‑education app case and a guide to employing dead‑letter queues for handling failed messages.
Dead Letter QueueDecouplingMessage Queue
0 likes · 9 min read

This article explains how to configure Kafka Connect error handling options—including stopping on failure, silently ignoring malformed messages, and routing failed records to a dead‑letter queue—while providing practical examples, monitoring techniques, and code snippets for robust data pipelines.
ConfigurationDead Letter Queueerror-handling
0 likes · 21 min read

This article provides a comprehensive guide to RabbitMQ, covering the fundamentals of message middleware, the P2P and Pub/Sub models, a comparison with Kafka and RocketMQ, detailed explanations of exchanges, queues, channels, and advanced features such as mandatory routing, backup exchanges, TTL, dead‑letter queues, delayed queues, priority queues, and RPC implementations for reliable distributed systems.
Dead Letter QueueMessage QueueMessaging Patterns
0 likes · 23 min read
