JPA Repository End-to-End Application

@Entity
@Table(name="REPOSONGS_SONG")
@NoArgsConstructor
...
public class Song {
    @Id @GeneratedValue(strategy = GenerationType.SEQUENCE)
    private int id;
 ...

@JacksonXmlRootElement(localName = "song", namespace = "urn:ejava.db-repo.songs")
@XmlRootElement(name = "song", namespace = "urn:ejava.db-repo.songs") (2)
@NoArgsConstructor
...
public class SongDTO { (1)
    @JacksonXmlProperty(isAttribute = true)
    @XmlAttribute
    private int id;

package info.ejava.examples.db.repo.jpa.songs.bo;
...
@Entity
@Table(name="REPOSONGS_SONG")
@Getter
@ToString
@Builder
@With
@AllArgsConstructor
@NoArgsConstructor
...
public class Song {
    @Id @GeneratedValue(strategy = GenerationType.SEQUENCE)
    @Column(name="ID", nullable=false, insertable=true, updatable=false)
    private int id;
    @Setter
    @Column(name="TITLE", length=255, nullable=true, insertable=true, updatable=true)
    private String title;
    @Setter
    private String artist;
    @Setter
    private LocalDate released;
}

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

{
  "id" : 1,
  "title" : "Tender Is the Night",
  "artist" : "No Doubt",
  "released" : "2003-11-16"
}

<song xmlns="urn:ejava.db-repo.songs" id="2">
  <title xmlns="">The Mirror Crack'd from Side to Side</title>
  <artist xmlns="">Earth Wind and Fire</artist>
  <released xmlns="">2018-01-01</released>
</song>

<ns2:song xmlns:ns2="urn:ejava.db-repo.songs" id="1">
    <title>Brandy of the Damned</title>
    <artist>Orbital</artist>
    <released>2015-11-10</released>
</ns2:song>

@Component
public class SongsMapper {
    public Song map(SongDTO dto) {
        Song bo = null;
        if (dto!=null) {
            bo = Song.builder()
                    .id(dto.getId())
                    .artist(dto.getArtist())
                    .title(dto.getTitle())
                    .released(dto.getReleased())
                    .build();
        }
        return bo;
    }
    ...

    ...
    public SongDTO map(Song bo) {
        SongDTO dto = null;
        if (bo!=null) {
            dto = SongDTO.builder()
                    .id(bo.getId())
                    .artist(bo.getArtist())
                    .title(bo.getTitle())
                    .released(bo.getReleased())
                    .build();
        }
        return dto;
    }
    ...

public interface SongsService {
    SongDTO createSong(SongDTO songDTO); (1)
    SongDTO getSong(int id);
    void updateSong(int id, SongDTO songDTO);
    void deleteSong(int id);
    void deleteAllSongs();

    Page<SongDTO> findReleasedAfter(LocalDate exclusive, Pageable pageable);(2)
    Page<SongDTO> findSongsMatchingAll(SongDTO probe, Pageable pageable);
}

@RequiredArgsConstructor (1) (2)
@Service
public class SongsServiceImpl implements SongsService {
    private final SongsMapper mapper;
    private final SongsRepository songsRepo;

@Transactional(propagation = Propagation.REQUIRED) (1) (2) (3)
public SongDTO createSong(SongDTO songDTO) {
    Song songBO = mapper.map(songDTO); (4)

    //manage instance
    songsRepo.save(songBO); (5)

    return mapper.map(songBO); (6)
}

@Transactional(propagation = Propagation.SUPPORTS) (1) (2) (3)
public Page<SongDTO> findSongsMatchingAll(SongDTO probeDTO, Pageable pageable) {
    Song probe = mapper.map(probeDTO); (4)
    ExampleMatcher matcher = ExampleMatcher.matchingAll().withIgnorePaths("id"); (5)
    Page<Song> songs = songsRepo.findAll(Example.of(probe, matcher), pageable); (6)
    return mapper.map(songs); (7)
}

@RequestMapping(path=SONGS_PATH,
        method=RequestMethod.POST,
        consumes={MediaType.APPLICATION_JSON_VALUE, MediaType.APPLICATION_XML_VALUE},
        produces={MediaType.APPLICATION_JSON_VALUE, MediaType.APPLICATION_XML_VALUE})
public ResponseEntity<SongDTO> createSong(@RequestBody SongDTO songDTO) {

    SongDTO result = songsService.createSong(songDTO); (1)

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

@RequestMapping(path=SONGS_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<SongsPageDTO> findSongsByExample(
        @RequestParam(value="pageNumber",defaultValue="0",required=false) Integer pageNumber,
        @RequestParam(value="pageSize",required=false) Integer pageSize,
        @RequestParam(value="sort",required=false) String sortString,
        @RequestBody SongDTO probe) {

    Pageable pageable=PageableDTO.of(pageNumber, pageSize, sortString).toPageable();(1)
    Page<SongDTO> result=songsService.findSongsMatchingAll(probe, pageable); (2)

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

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