skills.rest
taipt1504
taipt1504COMMUNITY
Explore all skills by this author →
GitHub

messaging-patterns

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
One-click install
npx skills add https://github.com/taipt1504/agent-skills --skill messaging-patterns-taipt1504
Or copy as Structured Prompt for Agent▼
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.

Related Skills

Explore More Software Engineering Skills→
dallaydallay
1

spring-boot-messaging

Guide event-driven messaging and reactive integration in Spring Boot 4 applications.

Official
Advanced
mariotoffiamariotoffia

setup-observability

Standardize logs, metrics, and distributed tracing across microservices.

Community
Advanced
olehsvyrydovolehsvyrydov
13

spring-kafka-integration

Configure Spring Kafka producers, consumers, and Dead Letter Topics in Spring Boot applications.

Community
Advanced
giuseppe-trisciuogliogiuseppe-trisciuoglio
322

spring-boot-event-driven-patterns

Implement event-driven patterns in Spring Boot with Kafka and transactional listeners.

Community
Advanced