giuseppe-trisciuoglio/developer-kit / plugins/developer-kit-java/skills/spring-boot-event-driven-patterns
spring-boot-event-driven-patterns
VerifiedProvides Event-Driven Architecture (EDA) patterns for Spring Boot — creates domain events, configures ApplicationEvent and @TransactionalEventListener, sets up Kafka producers and consumers, and implements the transactional outbox pattern for reliable distributed messaging. Use when implementing event-driven systems in Spring Boot, setting up async messaging with Kafka, publishing domain events from DDD aggregates, or needing reliable event publishing with the outbox pattern.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 9.0 KB |
| references/aggregate-root-patterns.md | markdown | 8.4 KB |
| references/configuration.md | markdown | 2.8 KB |
| references/dependency-setup.md | markdown | 2.1 KB |
| references/domain-events-design.md | markdown | 7.1 KB |
| references/event-driven-patterns-reference.md | markdown | 12.5 KB |
| references/event-handling.md | markdown | 11.3 KB |
| references/event-publishing.md | markdown | 8.2 KB |
| references/examples.md | markdown | 14.5 KB |
| references/outbox-pattern.md | markdown | 10.9 KB |
| references/testing-strategies.md | markdown | 12.3 KB |
references/event-publishing.md
View on GitHub# Event Publishing Patterns
## Local Event Publishing
### Application Event Publisher
```java
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import lombok.RequiredArgsConstructor;
@Service
@RequiredArgsConstructor
public class ProductApplicationService {
private final ProductRepository productRepository;
private final ApplicationEventPublisher eventPublisher;
@Transactional
public ProductResponse createProduct(CreateProductRequest request) {
Product product = Product.create(
request.getName(),
request.getPrice(),
request.getStock()
);
productRepository.save(product);
// Publish domain events
product.getDomainEvents().forEach(eventPublisher::publishEvent);
product.clearDomainEvents();
return mapToResponse(product);
}
}
```
## Distributed Event Publishing
### Kafka Event Publisher
```java
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Component;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
@Component
@RequiredArgsConstructor
@Slf4j
public class ProductEventPublisher {
private final KafkaTemplate<String, Object> kafkaTemplate;
public void publishProductCreatedEvent(ProductCreatedEvent event) {
ProductCreatedEventDto dto = mapToDto(event);
kafkaTemplate.send("product-events", event.getProductId().getValue(), dto)
.whenComplete((result, ex) -> {
if (ex == null) {
log.info("Published ProductCreatedEvent: {}", event.getProductId());
} else {
log.error("Failed to publish ProductCreatedEvent", ex);
}
});
}
private ProductCreatedEventDto mapToDto(ProductCreatedEvent event) {
return new ProductCreatedEventDto(
event.getEventId().toString(),
event.getProductId().getValue(),
event.getName(),
event.getPrice(),
event.getStock(),
event.getOccurredAt(),
event.getCorrelationId().toString()
);
}
}
```
### Event Publisher with Retry
```java
import org.springframework.kafka.support.SendResult;
import org.springframework.util.concurrent.ListenableFutureCallback;
import org.springframework.retry.annotation.Retryable;
import org.springframework.retry.backoff.FixedBackOffPolicy;
import org.springframework.retry.policy.SimpleRetryPolicy;
import org.springframework.retry.support.RetryTemplate;
@Component
@RequiredArgsConstructor
public class ResilientEventPublisher {
private final KafkaTemplate<String, Object> kafkaTemplate;
private final RetryTemplate retryTemplate;
public void publishEvent(String topic, String key, Object payload) {
retryTemplate.execute(context -> {
try {
kafkaTemplate.send(topic, key, payload).get();
return true;
} catch (Exception e) {
log.error("Failed to publish event to topic: {}", topic, e);
throw new EventPublishingException("Failed to publish event", e);
}
});
}
@Bean
public RetryTemplate retryTemplate() {
RetryTemplate retryTemplate = new RetryTemplate();
FixedBackOffPolicy backOffPolicy = new FixedBackOffPolicy();
backOffPolicy.setBackOffPeriod(1000L);
SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy();
retryPolicy.setMaxAttempts(3);
retryTemplate.setBackOffPolicy(backOffPolicy);
retryTemplate.setRetryPolicy(retryPolicy);
return retryTemplate;
}
}
```
## Spring Cloud Stream Publishing
### Functional Publisher
```java
import org.springframework.cloud.stream.function.StreamBridge;
import org.springframework.stereotype.Component;
import lombok.RequiredArgsConstructor;
@Component
@RequiredArgsConstructor
public class ProductEventStreamPublisher {
private final StreamBridge streamBridge;
public void publishProductCreatedEvent(ProductCreatedEvent event) {
ProductCreatedEventDto dto = mapToDto(event);
streamBridge.send("productCreated-out-0", dto);
}
private ProductCreatedEventDto mapToDto(ProductCreatedEvent event) {
return new ProductCreatedEventDto(
event.getEventId().toString(),
event.getProductId().getValue(),
event.getName(),
event.getPrice(),
event.getStock(),
event.getOccurredAt(),
event.getCorrelationId().toString()
);
}
}
```
### Producer Configuration
```yaml
spring:
cloud:
stream:
bindings:
productCreated-out-0:
destination: product-events
producer:
partition-count: 3
required-groups: order-service, inventory-service
kafka:
bindings:
productCreated-out-0:
producer:
configuration:
acks: all
retries: 3
enable.idempotence: true
```
## Event Publishing from Event Listener
### Publishing Events After Handling
```java
@Component
@RequiredArgsConstructor
public class OrderEventHandler {
private final OrderRepository orderRepository;
private final ApplicationEventPublisher eventPublisher;
@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
public void handleOrderCreated(OrderCreatedEvent event) {
// Process order creation
Order order = orderRepository.findById(event.getOrderId())
.orElseThrow();
// Publish derived events
eventPublisher.publishEvent(new InventoryReservationRequestedEvent(
event.getOrderId(),
event.getItems()
));
eventPublisher.publishEvent(new PaymentRequestedEvent(
event.getOrderId(),
event.getTotalAmount()
));
}
}
```
## Batching Events
### Batch Event Publisher
```java
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import lombok.RequiredArgsConstructor;
@Component
@RequiredArgsConstructor
public class BatchEventPublisher {
private final List<DomainEvent> eventBuffer = new ArrayList<>();
private final KafkaTemplate<String, Object> kafkaTemplate;
public synchronized void addEvent(DomainEvent event) {
eventBuffer.add(event);
if (eventBuffer.size() >= 100) {
flush();
}
}
@Scheduled(fixedDelay = 5000)
public synchronized void flush() {
if (eventBuffer.isEmpty()) {
return;
}
try {
eventBuffer.forEach(event -> {
kafkaTemplate.send("events", event);
});
} finally {
eventBuffer.clear();
}
}
}
```
## Event Publishing Best Practices
### 1. Publish After Transaction Commit
```java
@Transactional
public void executeBusinessOperation() {
// Perform business logic
aggregateRoot.performAction();
// Save to database
repository.save(aggregateRoot);
// Publish events AFTER transaction commits
TransactionSynchronizationManager.registerSynchronization(
new TransactionSynchronization() {
@Override
public void afterCommit() {
aggregateRoot.getDomainEvents().forEach(eventPublisher::publishEvent);
aggregateRoot.clearDomainEvents();
}
}
);
}
```
### 2. Use Transactional Event Listener
```java
@Component
public class EventForwardingHandler {
private final KafkaTemplate<String, Object> kafkaTemplate;
@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
public void forwardToKafka(DomainEvent event) {
kafkaTemplate.send("events", event);
}
}
```
### 3. Handle Publishing Failures
```java
public void publishEventWithFallback(DomainEvent event) {
try {
kafkaTemplate.send("events", event).get(5, TimeUnit.SECONDS);
} catch (Exception e) {
log.error("Failed to publish event, storing in outbox", e);
outboxRepository.save(OutboxEvent.from(event));
}
}
```
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack." | Stars: 197k | Updated | Claude CodeCodex | Verified | Install |
| ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |