spring-boot-event-driven-patterns
Implement event-driven architecture in Spring Boot 3.x using domain events, ApplicationEventPublisher, and Kafka for distributed messaging. This skill covers designing immutable domain events, publishing from aggregate roots, handling events transactionally with @TransactionalEventListener, configuring Kafka producers and consumers, and implementing the outbox pattern for guaranteed event delivery.
Spring Boot Event-Driven Patterns helps you build event-driven systems using domain events, Kafka messaging, and the transactional outbox pattern.
AI-generated summary based on this skill's SKILL.md
Decision gist · record as of 2026-06-22
Spring Boot Event-Driven Patterns helps you build event-driven systems using domain events, Kafka messaging, and the transactional outbox pattern. Implement event-driven architecture in Spring Boot 3.x using domain events, ApplicationEventPublisher, and Kafka for distributed messaging. This skill covers designing immutable domain events, publishing from aggregate roots, handling events transactionally with @TransactionalEventListener, configuring Kafka producers and consumers, and implementing the outbox pattern for guaranteed event delivery.
Use it when
- spring-boot-event-driven-patterns covers the transactional outbox pattern for guaranteed event delivery.
- spring-boot-event-driven-patterns shows how to use @TransactionalEventListener to handle events only after the current transaction commits.
Verify before relying
Read SKILL.md below before installing (11 files). Open directory: indexed for reading, not audited.
Install
giuseppe-trisciuoglio/developer-kit/spring-boot-event-driven-patterns · repository language: Python
Open directory. Skills are indexed for reading, not audited. Review a skill's body before installing it.
Frequently asked questions
AI-generated answers based on this skill's SKILL.md and metadata
How do I implement domain events in Spring Boot?
spring-boot-event-driven-patterns teaches you to design immutable domain events and publish them from aggregate roots using ApplicationEventPublisher. Domain events capture state changes within your domain model. You create event classes representing business occurrences, then publish them when aggregates change state. Spring Boot's event infrastructure ensures listeners respond to these events, enabling loose coupling between domain logic and side effects like sending notifications or updating read models.
What is the transactional outbox pattern in Spring Boot?
spring-boot-event-driven-patterns covers the transactional outbox pattern for guaranteed event delivery. This pattern stores events in an outbox table within the same database transaction as your business logic, ensuring atomicity. A separate process polls the outbox and publishes events to Kafka. This prevents message loss if your service crashes between saving data and publishing events, making it essential for reliable distributed systems.
How to set up transactional event listeners and reliable event publishing?
spring-boot-event-driven-patterns shows how to use @TransactionalEventListener to handle events only after the current transaction commits. This prevents processing events from rolled-back transactions. Configure listeners with phase=AFTER_COMMIT to ensure reliability. Combine this with Kafka producers for distributed messaging and implement idempotent handlers to tolerate duplicate deliveries, creating a robust event-driven system.
How do I configure Kafka producers and consumers in Spring Boot?
spring-boot-event-driven-patterns demonstrates Kafka setup using Spring Kafka. Configure producers with KafkaTemplate for publishing events to topics. Use @KafkaListener annotations on consumer methods to subscribe to topics and handle messages. Spring Cloud Stream provides higher-level abstractions for binding producers and consumers to Kafka topics. Configure serialization, error handling, and consumer groups to build scalable distributed messaging.
How can I refactor synchronous microservices to event-driven async?
spring-boot-event-driven-patterns guides refactoring from synchronous REST calls to asynchronous event-driven communication. Replace direct service calls with domain events published to Kafka topics. Services subscribe to relevant events and react independently, improving resilience and scalability. Implement event correlation and tracing to track workflows across services. This decouples services, enables parallel processing, and makes systems more responsive to failures.
What are event-driven microservices best practices in Spring Boot?
spring-boot-event-driven-patterns covers best practices including designing immutable, versioned events; implementing idempotent handlers to tolerate duplicates; using dead letter queues for failed messages; adding correlation IDs for tracing; and applying the outbox pattern for reliability. Handle events transactionally with @TransactionalEventListener, configure appropriate timeouts and retries, and monitor event flow across your distributed system.
SKILL.md
Rendered from the published skill. Quoted content, verbatim.
Spring Boot Event-Driven Patterns
Overview
Implement Event-Driven Architecture (EDA) patterns in Spring Boot 3.x using domain events, ApplicationEventPublisher, @TransactionalEventListener, and distributed messaging with Kafka and Spring Cloud Stream.
When to Use
- Implementing event-driven microservices with Kafka messaging
- Publishing domain events from aggregate roots in DDD architectures
- Setting up transactional event listeners that fire after database commits
- Adding async messaging with producers and consumers via Spring Kafka
- Ensuring reliable event delivery using the transactional
(truncated - see the full file via the links below)
File tree — 11 files
plugins/developer-kit-java/skills/spring-boot-event-driven-patterns/SKILL.md
plugins/developer-kit-java/skills/spring-boot-event-driven-patterns/references/aggregate-root-patterns.md
plugins/developer-kit-java/skills/spring-boot-event-driven-patterns/references/configuration.md
plugins/developer-kit-java/skills/spring-boot-event-driven-patterns/references/dependency-setup.md
plugins/developer-kit-java/skills/spring-boot-event-driven-patterns/references/domain-events-design.md
plugins/developer-kit-java/skills/spring-boot-event-driven-patterns/references/event-driven-patterns-reference.md
plugins/developer-kit-java/skills/spring-boot-event-driven-patterns/references/event-handling.md
plugins/developer-kit-java/skills/spring-boot-event-driven-patterns/references/event-publishing.md
plugins/developer-kit-java/skills/spring-boot-event-driven-patterns/references/examples.md
plugins/developer-kit-java/skills/spring-boot-event-driven-patterns/references/outbox-pattern.md
plugins/developer-kit-java/skills/spring-boot-event-driven-patterns/references/testing-strategies.md
Let your AI agent find skills like this
Example. Real query, live index.
You found this page by searching. An agent finds it by wishing: SkillFed indexes 56,283 agent skills by what they can do, searchable in plain language.
wish › “Implement event-driven architecture in Spring Boot with Kafka and domain events”
Give your agent the search over MCP, or paste the wish link into any chat. No install? Search from any chat →
Related skills
Master asynchronous system design through message brokers, event sourcing, and distributed transaction patterns. This skill covers Kafka, RabbitMQ, SQS/SNS integration alongside CQRS, saga orchestration, idempotency strategies, and failure handling with dead letter queues—everything needed to build resilient, decoupled microservice architectures.
Design and deploy production-ready microservices using Spring Cloud components like service discovery, API Gateway, and load balancing. Learn resilience patterns including circuit breakers, retries, and bulkhead isolation to handle failures gracefully. Implement event-driven communication with Kafka and Spring Cloud Stream, plus observability through distributed tracing and metrics.
Master architectural patterns for building distributed systems through service decomposition, inter-service communication strategies, and fault tolerance techniques. Covers synchronous and asynchronous messaging, database ownership models, and resilience patterns like circuit breakers and bulkheads.
Learn to architect microservices by decomposing monoliths into independent services, managing inter-service communication through synchronous and asynchronous patterns, and implementing resilience strategies like circuit breakers and sagas. This skill covers service decomposition strategies, data management across distributed systems, and practical patterns for building fault-tolerant distributed architectures.
Master the core patterns for building distributed systems that scale independently. This skill covers service boundaries, asynchronous event communication, saga-based transactions with compensation logic, API gateway configuration, and health monitoring strategies. Includes anti-patterns to avoid and a practical checklist for implementation.
Master real-time data pipelines and event streaming architectures using modern message brokers and processors. This skill covers Kafka, Pulsar, Redpanda, Flink, and Spark across TypeScript, Python, Go, and Java, with patterns for producer/consumer coordination, delivery guarantees, event sourcing, and change data capture.
More skills spring-boot-crud-patterns (MIT) · unit-test-application-events (MIT)