Working with Events and Listeners

// Modern: any POJO works
public record OrderPlaced(Long orderId, BigDecimal total, Instant when) {}

// Legacy: extend ApplicationEvent
public class LegacyEvent extends ApplicationEvent {
  public LegacyEvent(Object source) { super(source); }
}

@Service
public class OrderService {
  private final ApplicationEventPublisher publisher;
  public OrderService(ApplicationEventPublisher publisher) { this.publisher = publisher; }
  public void place(NewOrder o) {
    var saved = repo.save(Order.from(o));
    publisher.publishEvent(new OrderPlaced(saved.getId(), saved.getTotal(), Instant.now()));
  }
}

@Component
public class OrderListeners {
  @EventListener
  public void onPlaced(OrderPlaced evt) { /* react */ }
}

@EventListener(condition = "#evt.total > 1000")
public void highValueOrder(OrderPlaced evt) { /* premium handling */ }

@Async
@EventListener
public void asyncHandler(OrderPlaced evt) { /* runs on TaskExecutor */ }

@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
public void afterCommit(OrderPlaced evt) { /* publish to MQ */ }

public class TypedEvent<T> implements ResolvableTypeProvider {
  private final T payload;
  public TypedEvent(T payload) { this.payload = payload; }
  public T payload() { return payload; }
  @Override public ResolvableType getResolvableType() {
    return ResolvableType.forClassWithGenerics(getClass(), ResolvableType.forInstance(payload));
  }
}

@EventListener
public void onUserEvent(TypedEvent<User> e) { /* only User events */ }

@SpringBootTest
@RecordApplicationEvents
class OrderServiceTests {
  @Autowired ApplicationEvents events;
  @Autowired OrderService svc;
  @Test void publishes() {
    svc.place(new NewOrder(/*…*/));
    assertEquals(1, events.stream(OrderPlaced.class).count());
  }
}