Mongo Repository End-to-End Application

import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.mapping.Field;

@Document(collection = "books") (1)
...
public class Book {
    @Id (2)
    private String id;
    @Field(name="title") (3)
    private String title;
    private String author;
    private LocalDate published;
...

import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlRootElement;
import com.fasterxml.jackson.dataformat.xml.annotation.JacksonXmlProperty;
import jakarta.xml.bind.annotation.XmlRootElement;
import jakarta.xml.bind.annotation.XmlAccessType;
import jakarta.xml.bind.annotation.XmlAccessorType;
...
@JacksonXmlRootElement(localName = "book", namespace = "urn:ejava.db-repo.books")
@XmlRootElement(name = "book", namespace = "urn:ejava.db-repo.books") (2)
@XmlAccessorType(XmlAccessType.FIELD)
@NoArgsConstructor
...
public class BookDTO { (1)
    @JacksonXmlProperty(isAttribute = true)
    @XmlAttribute
    private String id;
    private String title;
    private String author;
    @XmlJavaTypeAdapter(LocalDateJaxbAdapter.class) (3)
    private LocalDate published;
...

package info.ejava.examples.db.mongo.books.bo;
...
@Document(collection = "books")
@Builder
@With
@ToString
@EqualsAndHashCode
@Getter
@Setter
@AllArgsConstructor
public class Book {
    @Id @Setter(AccessLevel.NONE)
    private String id;
    @Setter
    @Field(name="title")
    private String title;
    @Setter
    private String author;
    @Setter
    private LocalDate published;
}

package info.ejava.examples.db.repo.jpa.books.dto;
...
@JacksonXmlRootElement(localName = "book", namespace = "urn:ejava.db-repo.books")
@XmlRootElement(name = "book", namespace = "urn:ejava.db-repo.books")
@XmlAccessorType(XmlAccessType.FIELD)
@Data @Builder
@NoArgsConstructor @AllArgsConstructor
public class BookDTO {
    @JacksonXmlProperty(isAttribute = true)
    @XmlAttribute
    private int id;
    private String title;
    private String author;
    @XmlJavaTypeAdapter(LocalDateJaxbAdapter.class) (1)
    private LocalDate published;
 ...
}

{
 "id":"609b316de7366e0451a7bcb0",
 "title":"Tirra Lirra by the River",
 "author":"Mr. Arlen Swift",
 "published":"2020-07-26"
}

<book xmlns="urn:ejava.db-repo.books" id="609b32b38065452555d612b8">
  <title xmlns="">To a God Unknown</title>
  <author xmlns="">Rudolf Harris</author>
  <published xmlns="">2019-11-22</published>
</book>

<ns2:book xmlns:ns2="urn:ejava.db-repo.books" id="609b32b38065452555d61222">
    <title>The Mermaids Singing</title>
    <author>Olen Rolfson IV</author>
    <published>2020-10-14</published>
</ns2:book>

@Component
public class BooksMapper {
    public Book map(BookDTO dto) {
        Book bo = null;
        if (dto!=null) {
            bo = Book.builder()
                    .id(dto.getId())
                    .author(dto.getAuthor())
                    .title(dto.getTitle())
                    .published(dto.getPublished())
                    .build();
        }
        return bo;
    }
    ...

    ...
    public BookDTO map(Book bo) {
        BookDTO dto = null;
        if (bo!=null) {
            dto = BookDTO.builder()
                    .id(bo.getId())
                    .author(bo.getAuthor())
                    .title(bo.getTitle())
                    .published(bo.getPublished())
                    .build();
        }
        return dto;
    }
    ...

public interface BooksService {
    BookDTO createBook(BookDTO bookDTO); (1)
    BookDTO getBook(int id);
    void updateBook(int id, BookDTO bookDTO);
    void deleteBook(int id);
    void deleteAllBooks();

    Page<BookDTO> findPublishedAfter(LocalDate exclusive, Pageable pageable);(2)
    Page<BookDTO> findBooksMatchingAll(BookDTO probe, Pageable pageable);
}

@RequiredArgsConstructor (1) (2)
@Service
public class BooksServiceImpl implements BooksService {
    private final BooksMapper mapper;
    private final BooksRepository booksRepo;

public BookDTO createBook(BookDTO bookDTO) {
    Book bookBO = mapper.map(bookDTO); (1)

    //insert instance
    booksRepo.save(bookBO); (2)

    return mapper.map(bookBO); (3)
}

public Page<BookDTO> findBooksMatchingAll(BookDTO probeDTO, Pageable pageable) {
    Book probe = mapper.map(probeDTO); (1)
    ExampleMatcher matcher = ExampleMatcher.matchingAll(); (2)
    Page<Book> books = booksRepo.findAll(Example.of(probe, matcher), pageable); (3)
    return mapper.map(books); (4)
}

@RequestMapping(path=BOOKS_PATH,
        method=RequestMethod.POST,
        consumes={MediaType.APPLICATION_JSON_VALUE, MediaType.APPLICATION_XML_VALUE},
        produces={MediaType.APPLICATION_JSON_VALUE, MediaType.APPLICATION_XML_VALUE})
public ResponseEntity<BookDTO> createBook(@RequestBody BookDTO bookDTO) {

    BookDTO result = booksService.createBook(bookDTO); (1)

    URI uri = ServletUriComponentsBuilder.fromCurrentRequestUri()
            .replacePath(BOOK_PATH)
            .build(result.getId()); (2)
    ResponseEntity<BookDTO> response = ResponseEntity.created(uri).body(result);
    return response; (3)
}

@RequestMapping(path=BOOKS_PATH + "/example",
        method=RequestMethod.POST,
        consumes={MediaType.APPLICATION_JSON_VALUE, MediaType.APPLICATION_XML_VALUE},
        produces={MediaType.APPLICATION_JSON_VALUE, MediaType.APPLICATION_XML_VALUE})
public ResponseEntity<BooksPageDTO> findBooksByExample(
        @RequestParam(value="pageNumber",defaultValue="0",required=false) Integer pageNumber,
        @RequestParam(value="pageSize",required=false) Integer pageSize,
        @RequestParam(value="sort",required=false) String sortString,
        @RequestBody BookDTO probe) {

    Pageable pageable=PageableDTO.of(pageNumber, pageSize, sortString).toPageable();(1)
    Page<BookDTO> result=booksService.findBooksMatchingAll(probe, pageable); (2)

    BooksPageDTO resultDTO = new BooksPageDTO(result); (3)
    ResponseEntity<BooksPageDTO> response = ResponseEntity.ok(resultDTO);
    return response;
}

@Autowired
private WebClient webClient;
...
UriComponentsBuilder findByExampleUriBuilder = UriComponentsBuilder
        .fromUri(serverConfig.getBaseUrl())
        .path(BooksController.BOOKS_PATH).path("/example");
...
//given
MediaType mediaType = ...
PageRequest pageable = PageRequest.of(0, 5, Sort.by(Sort.Order.desc("published")));
PageableDTO pageSpec = PageableDTO.of(pageable); (1)
BookDTO allBooksProbe = BookDTO.builder().build(); (2)
URI uri = findByExampleUriBuilder.queryParams(pageSpec.getQueryParams()) (3)
                                 .build().toUri();
WebClient.RequestHeadersSpec<?> request = webClient.post()
        .uri(uri)
        .contentType(mediaType)
        .body(Mono.just(allBooksProbe), BookDTO.class)
        .accept(mediaType);
//when
ResponseEntity<BooksPageDTO> response = request
        .retrieve()
        .toEntity(BooksPageDTO.class).block();
//then
then(response.getStatusCode().is2xxSuccessful()).isTrue();
BooksPageDTO page = response.getBody();