messaging-patterns

Name: messaging-patterns
Availability: InStock
Author: taipt1504

Implement Kafka and RabbitMQ messaging patterns in Spring Boot applications.

3|2|Updated Jan 16, 2026

Search Tags:#kafka #spring-boot #idempotency #dead-letter #rabbitmq #schema-registry #messaging-patterns

Ready to run

npx skills add https://github.com/taipt1504/agent-skills --skill messaging-patterns-taipt1504

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: messaging-patterns
Source: https://github.com/taipt1504/agent-skills/tree/main/skills/messaging-patterns
Command: npx skills add https://github.com/taipt1504/agent-skills --skill messaging-patterns-taipt1504

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Kafka and RabbitMQ patterns provide battle-tested messaging strategies for Spring Boot microservices, reducing reliability risks and boilerplate.

Core Features & Use Cases

Producer/Consumer reliability patterns for Kafka and RabbitMQ in Spring Boot (idempotent sends, acks, transactional publishing)
Dead-letter handling and error flows (retries, DLQ/DLX routing for resilient event processing)
Schema registry integration and reactive messaging support (Avro/JSON) for non-blocking event streams Use Case: End-to-end order processing across services (OrderCreated -> Payment -> Inventory).

Quick Start

Configure Spring Boot services to publish and consume events using Kafka and RabbitMQ patterns.

Frequently Asked Questions about messaging-patterns

High-intent search queries and answers about installing and using this skill.

FAQPage Schema

How do I implement reliable Kafka producer and consumer patterns in Spring Boot?▼

Reliable Kafka messaging patterns in Spring Boot use idempotent sends, manual acknowledgments, and transactional publishing to ensure event delivery. This approach provides structured end-to-end reliability for producer and consumer flows across microservices.

What is the best way to handle Dead Letter Queue routing for RabbitMQ in Spring Boot?▼

Dead-letter handling patterns for RabbitMQ in Spring Boot manage error flows through automated retries and DLQ routing. This structured approach routes failed messages to a dead-letter exchange, ensuring resilient event processing without data loss.

How do I integrate a schema registry with Spring Boot reactive messaging?▼

Schema registry integration with Spring Boot reactive messaging supports Avro and JSON formats for non-blocking event streams. This pattern validates message schemas across services, ensuring contract compatibility during event consumption.

Does this messaging pattern approach support manual acknowledgment and failure handling?▼

Yes, the messaging patterns approach explicitly fulfills requirements for manual acknowledgment and failure handling. It exposes structured error flows and acknowledgment strategies to maintain reliability during event processing.

How do I build end-to-end order processing across services using Kafka and RabbitMQ?▼

End-to-end order processing across services uses messaging patterns to chain events like OrderCreated to Payment to Inventory. This structured approach coordinates producer and consumer reliability across Kafka and RabbitMQ in Spring Boot applications.