一个全面的领域驱动设计示例，包含问题空间战略分析和各种战术模式

def 'should synchronize PatronBooks, Book and DailySheet with events'() {
    given:
        bookRepository.save(book)
    and:
        patronBooksRepo.publish(patronCreated())
    when:
        patronBooksRepo.publish(placedOnHold(book))
    then:
        patronShouldBeFoundInDatabaseWithOneBookOnHold(patronId)
    and:
        bookReactedToPlacedOnHoldEvent()
    and:
        dailySheetIsUpdated()
}

<b>boolean</b> bookReactedToPlacedOnHoldEvent() {
    <b>return</b> bookRepository.findBy(book.bookId).get() instanceof BookOnHold
}

<b>boolean</b> dailySheetIsUpdated() {
    <b>return</b> <b>new</b> JdbcTemplate(datasource).query(<font>"select count(*) from holds_sheet s where s.hold_by_patron_id = ?"</font><font>,
            [patronId.patronId] as Object[],
            <b>new</b> ColumnMapRowMapper()).get(0)
            .get(</font><font>"COUNT(*)"</font><font>) == 1
}
</font>

@AllArgsConstructor
<b>public</b> <b>class</b> JustForwardDomainEventPublisher implements DomainEvents {

    <b>private</b> <b>final</b> ApplicationEventPublisher applicationEventPublisher;

    @Override
    <b>public</b> <b>void</b> publish(DomainEvent event) {
        applicationEventPublisher.publishEvent(event);
    }
}

def 'should synchronize PatronBooks, Book and DailySheet with events'() {
    given:
        bookRepository.save(book)
    and:
        patronBooksRepo.publish(patronCreated())
    when:
        patronBooksRepo.publish(placedOnHold(book))
    then:
        patronShouldBeFoundInDatabaseWithOneBookOnHold(patronId)
    and:
        bookReactedToPlacedOnHoldEvent()
    and:
        dailySheetIsUpdated()
}

<b>void</b> bookReactedToPlacedOnHoldEvent() {
    pollingConditions.eventually {
        assert bookRepository.findBy(book.bookId).get() instanceof BookOnHold
    }
}

<b>void</b> dailySheetIsUpdated() {
    pollingConditions.eventually {
        assert countOfHoldsInDailySheet() == 1
    }
}

@AllArgsConstructor
<b>public</b> <b>class</b> StoreAndForwardDomainEventPublisher implements DomainEvents {

    <b>private</b> <b>final</b> JustForwardDomainEventPublisher justForwardDomainEventPublisher;
    <b>private</b> <b>final</b> EventsStorage eventsStorage;

    @Override
    <b>public</b> <b>void</b> publish(DomainEvent event) {
        eventsStorage.save(event);
    }

    @Scheduled(fixedRate = 3000L)
    @Transactional
    <b>public</b> <b>void</b> publishAllPeriodically() {
        List<DomainEvent> domainEvents = eventsStorage.toPublish();
        domainEvents.forEach(justForwardDomainEventPublisher::publish);
        eventsStorage.published(domainEvents);
    }
}

@ArchTest
<b>public</b> <b>static</b> <b>final</b> ArchRule model_should_not_depend_on_infrastructure =
    noClasses()
        .that()
        .resideInAPackage(<font>"..model.."</font><font>)
        .should()
        .dependOnClassesThat()
        .resideInAPackage(</font><font>"..infrastructure.."</font><font>);
</font>

@ArchTest
<b>public</b> <b>static</b> <b>final</b> ArchRule model_should_not_depend_on_spring =
    noClasses()
        .that()
        .resideInAPackage(<font>"..io.pillopl.library.lending..model.."</font><font>)
        .should()
        .dependOnClassesThat()
        .resideInAPackage(</font><font>"org.springframework.."</font><font>);
</font>

@FunctionalInterface 
<b>public</b>  <b>interface</b>  FindAvailableBook { Option < AvailableBook > findAvailableBookBy（BookId bookId）; 
}

@AllArgsConstructor
<b>class</b> BookDatabaseRepository implements FindAvailableBook {

    <b>private</b> <b>final</b> JdbcTemplate jdbcTemplate;

    @Override
    <b>public</b> Option<AvailableBook> findAvailableBookBy(BookId bookId) {
        <b>return</b> Match(findBy(bookId)).of(
                Case($Some($(instanceOf(AvailableBook.<b>class</b>))), Option::of),
                Case($(), Option::none)
        );
    }  

    Option<Book> findBy(BookId bookId) {
        <b>return</b> findBookById(bookId)
                .map(BookDatabaseEntity::toDomainModel);
    }

    <b>private</b> Option<BookDatabaseEntity> findBookById(BookId bookId) {
        <b>return</b> Try
                .ofSupplier(() -> of(jdbcTemplate.queryForObject(<font>"SELECT b.* FROM book_database_entity b WHERE b.book_id = ?"</font><font>,
                                      <b>new</b> BeanPropertyRowMapper<>(BookDatabaseEntity.<b>class</b>), bookId.getBookId())))
                .getOrElse(none());
    }  
} 
</font>

<b>public</b> Either<BookHoldFailed, BookPlacedOnHoldEvents> placeOnHold(Book book) {
  <b>if</b> (book.status == AVAILABLE) {  
      ...
  }
}

<b>public</b>  < BookHoldFailed，BookPlacedOnHoldEvents > placeOnHold（AvailableBook book）{
       ... 
}

Option<Book> findBy(BookId bookId) {
    ...
}

Either<BookHoldFailed, BookPlacedOnHoldEvents> placeOnHold(AvailableBook book) {
    ...
}

Try<Result> placeOnHold(@NonNull PlaceOnHoldCommand command) {
    ...
}

<b>private</b> Book handleBookPlacedOnHold(Book book, BookPlacedOnHold bookPlacedOnHold) {
    <b>return</b> API.Match(book).of(
        Case($(instanceOf(AvailableBook.<b>class</b>)), availableBook -> availableBook.handle(bookPlacedOnHold)),
        Case($(instanceOf(BookOnHold.<b>class</b>)), bookOnHold -> raiseDuplicateHoldFoundEvent(bookOnHold, bookPlacedOnHold)),
        Case($(), () -> book)
    );
}

<b>interface</b> PatronBooksEntityRepository <b>extends</b> CrudRepository<PatronBooksDatabaseEntity, Long> {

    @Query(<font>"SELECT p.* FROM patron_books_database_entity p where p.patron_id = :patronId"</font><font>)
    PatronBooksDatabaseEntity findByPatronId(@Param(</font><font>"patronId"</font><font>) UUID patronId);

}
</font>

@AllArgsConstructor
<b>class</b> BookDatabaseRepository implements BookRepository, FindAvailableBook, FindBookOnHold {

    <b>private</b> <b>final</b> JdbcTemplate jdbcTemplate;

    @Override
    <b>public</b> Option<Book> findBy(BookId bookId) {
        <b>return</b> findBookById(bookId)
                .map(BookDatabaseEntity::toDomainModel);
    }

    <b>private</b> Option<BookDatabaseEntity> findBookById(BookId bookId) {
        <b>return</b> Try
                .ofSupplier(() -> of(jdbcTemplate.queryForObject(<font>"SELECT b.* FROM book_database_entity b WHERE b.book_id = ?"</font><font>,
                                     <b>new</b> BeanPropertyRowMapper<>(BookDatabaseEntity.<b>class</b>), bookId.getBookId())))
                .getOrElse(none());
    }
    
    ...
}
</font>

└── library
    ├── catalogue
    ├── commons
    │   ├── aggregates
    │   ├── commands
    │   └── events
    │       └── publisher
    └── lending
        ├── book
        │   ├── application
        │   ├── infrastructure
        │   └── model
        ├── dailysheet
        │   ├── infrastructure
        │   └── model
        ├── librarybranch
        │   └── model
        ├── patron
        │   ├── application
        │   ├── infrastructure
        │   └── model
        └── patronprofile
            ├── infrastructure
            ├── model
            └── web

@Value
<b>class</b> PlaceOnHoldCommand {
    ...
}
@Value
<b>class</b> BookPlacedOnHold implements PatronBooksEvent {
    ...
}
@Value
<b>class</b> MaximumNumberOhHoldsReached implements PatronBooksEvent {
    ...    
}
@Value
<b>class</b> BookHoldFailed implements PatronBooksEvent {
    ...
}

<b>public</b> <b>class</b> PatronBooks {

    <b>public</b> Either<BookHoldFailed, BookPlacedOnHoldEvents> placeOnHold(AvailableBook book) {
        <b>return</b> placeOnHold(book, HoldDuration.openEnded());
    }
    
    ...
}    

@Value
<b>class</b> BookPlacedOnHoldEvents implements PatronBooksEvent {
    @NonNull UUID eventId = UUID.randomUUID();
    @NonNull UUID patronId;
    @NonNull BookPlacedOnHold bookPlacedOnHold;
    @NonNull Option<MaximumNumberOhHoldsReached> maximumNumberOhHoldsReached;

    @Override
    <b>public</b> Instant getWhen() {
        <b>return</b> bookPlacedOnHold.when;
    }

    <b>public</b> <b>static</b> BookPlacedOnHoldEvents events(BookPlacedOnHold bookPlacedOnHold) {
        <b>return</b> <b>new</b> BookPlacedOnHoldEvents(bookPlacedOnHold.getPatronId(), bookPlacedOnHold, Option.none());
    }

    <b>public</b> <b>static</b> BookPlacedOnHoldEvents events(BookPlacedOnHold bookPlacedOnHold, MaximumNumberOhHoldsReached maximumNumberOhHoldsReached) {
        <b>return</b> <b>new</b> BookPlacedOnHoldEvents(bookPlacedOnHold.patronId, bookPlacedOnHold, Option.of(maximumNumberOhHoldsReached));
    }

    <b>public</b> List<DomainEvent> normalize() {
        <b>return</b> List.<DomainEvent>of(bookPlacedOnHold).appendAll(maximumNumberOhHoldsReached.toList());
    }
}