{"enrichment":{"faq":[{"a":"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.","q":"How do I implement domain events in Spring Boot?"},{"a":"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.","q":"What is the transactional outbox pattern in Spring Boot?"},{"a":"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.","q":"How to set up transactional event listeners and reliable event publishing?"},{"a":"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.","q":"How do I configure Kafka producers and consumers in Spring Boot?"},{"a":"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.","q":"How can I refactor synchronous microservices to event-driven async?"},{"a":"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.","q":"What are event-driven microservices best practices in Spring Boot?"}],"shadow_tags":["async-messaging","distributed-systems","event-sourcing","microservices-architecture","message-broker","transaction-safety","domain-driven-design","reliability-patterns","event-streaming","spring-ecosystem"],"summary_rewrite":"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."},"files":[{"bytes":9244,"path":"plugins/developer-kit-java/skills/spring-boot-event-driven-patterns/SKILL.md","sha256":"27b7433250498e6020e233f9aeac6818e6d1c137c82e57f4410d1f02fdf1b455","url":"https://skillfed.io/files/giuseppe-trisciuoglio/developer-kit/spring-boot-event-driven-patterns/0ad6da91/SKILL.md"}],"id":"giuseppe-trisciuoglio/developer-kit/spring-boot-event-driven-patterns","links":{"html":"https://skillfed.io/giuseppe-trisciuoglio/developer-kit/spring-boot-event-driven-patterns","md":"https://skillfed.io/giuseppe-trisciuoglio/developer-kit/spring-boot-event-driven-patterns.md","repo":"https://github.com/giuseppe-trisciuoglio/developer-kit"},"meta":{"agents_supported":[],"first_seen":"2026-07-28","forks":37,"language":"Python","last_updated":"2026-06-22","license":"MIT","name":"spring-boot-event-driven-patterns","publisher":"giuseppe-trisciuoglio","stars":311},"relations":{"categories":["spring-boot","event-driven-architecture","microservices"],"similar":[{"id":"travisjneuman/.claude/event-driven-architecture"},{"id":"giuseppe-trisciuoglio/developer-kit/spring-boot-saga-pattern"},{"id":"yonatangross/orchestkit/distributed-systems"},{"id":"LambdaTest/agent-skills/api-integration-helper"},{"id":"HermeticOrmus/LibreUIUX-Claude-Code/microservices-patterns"},{"id":"pluginagentmarketplace/custom-plugin-java/java-microservices"},{"id":"secondsky/claude-skills/microservices-patterns"},{"id":"NickCrew/Claude-Cortex/event-driven-architecture"},{"id":"patricio0312rev/skills/event-driven-architect"},{"id":"olehsvyrydov/AI-development-team/solution-architect"}]},"slug":{"owner":"giuseppe-trisciuoglio","repo":"developer-kit","skill":"spring-boot-event-driven-patterns"},"version":"0ad6da91"}