Ereignisse & Produktionsreife

BookVault is secured and tested. The final layers make it decoupled and deployable: a domain event on borrow, then the observability, virtual threads, and container packaging that turn a working app into one you can run in production.

A domain event on borrow

When a book is borrowed, other things should happen - notify the member, update a dashboard - but the borrow shouldn't depend on them. So the service publishes an event rather than calling a notifier directly:

@Transactional
public Loan borrow(String isbn, Long memberId) {
    // ... reserve a copy, save the loan ...
    events.publishEvent(new BookBorrowedEvent(isbn, memberId, loan.getId()));
    return loan;
}

// a listener reacts AFTER the transaction commits, so nobody is notified about a rolled-back borrow
@TransactionalEventListener
@Async
void onBorrow(BookBorrowedEvent event) { notifier.send(event); }

@TransactionalEventListener(AFTER_COMMIT) ensures the notification only fires once the borrow is truly committed; @Async keeps it off the request thread. This in-process event is also the seam a future microservices split would follow - the same event becomes a broker message between services.

Observability: see it running

You can't operate what you can't see. Actuator exposes health (with liveness/readiness probes an orchestrator uses to route and restart), and Micrometer exposes metrics - JVM, HTTP, and your own:

// a domain metric, visible at /actuator/prometheus for scraping
loansCreated = Counter.builder("bookvault.loans.created")
    .description("Number of book loans created").register(meterRegistry);
// ...
loansCreated.increment();   // on each successful borrow

Virtual threads: scale the simple way

BookVault is blocking, imperative code - and with Java 21 virtual threads that scales to high concurrency without a rewrite. One property, and every request runs on a cheap virtual thread that doesn't tie up an OS thread while it waits on I/O:

spring:
  threads:
    virtual:
      enabled: true

Package it: a container

Finally, package the app as an immutable container image and inject configuration at runtime - the same image runs in every environment (twelve-factor). BookVault ships a layered Dockerfile so dependency layers cache and only the small app layer rebuilds:

docker build -t bookvault .
docker run -p 8080:8080 -e JWT_SECRET=... -e SPRING_PROFILES_ACTIVE=prod bookvault