Spring Boot Task-Lösung mit ManyToMany

Der Artikel ist an Sie gerichtet und wandert in der Dunkelheit der Nacht. Du, dessen Weg nur von einsamen Glühwürmchen beleuchtet wird. Im Allgemeinen ein Programmierer, der Spring Boot und die ManyToMany-Beziehung in Hibernate studiert.

Er führte eine Testaufgabe zu einem abstrakten Musikthema durch: Schreiben eines Dienstes zum Speichern von Daten über Musiker, Songs, Alben mit Java, Spring, Hibernate. Teil der Aufgabe war die Erstellung der Klassen „Compositions“ und „Performers“. Eine Komposition kann von vielen Interpreten aufgeführt werden, und ein Performer kann viele Kompositionen aufführen. Typische bidirektionale Einstellung von ManyToMany.

In Khasang-Kursen wurde gelehrt, wie man mithilfe der DTO-Klasse Ruhezeiten vermeidet, die sich um Spring drehen, aber Spring Boot ist eine andere Geschichte. Auf russischsprachigen Websites sah ich Antworten wie „Ja, es ist alles elementar“, aber ohne spezifische Erklärungen. Ich werde ein Beispiel für die Lösung dieses Problems geben. Der vollständige Code befindet sich auf dem Github, Link unten.

Erstellen Sie zunächst Entity: People und SongPlayers. Getter und Setter sind der Kürze halber weggelassen.

@Entity public class People { @Id @GeneratedValue(strategy = GenerationType.AUTO) private long id; private String human; //      @ManyToOne(cascade = CascadeType.ALL) private RockGroups rockGroups; //     @ManyToMany(mappedBy = "songInstrumentalist",fetch = FetchType.EAGER) private List<SongPlayers> songItems; public People(){} public People(long id, String human){ this.id = id; this.human = human; } //. . . . . . . . . } 

 @Entity public class SongPlayers { @Id @GeneratedValue(strategy = GenerationType.AUTO) private long id; private String song; //    private String composer; //     private String poet; //    private String album; //   //     @ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.EAGER) private List<People> songInstrumentalist; //. . . . . . . . . } 

Anschließend erstellen wir Repository-Schnittstellen für die People-Klasse.

 @Repository public interface PeopleRepository extends JpaRepository<People, Long> { @Query("select h from People h where h.human=?1") List<People> searchByHuman(String human); List<People> findPeopleByHuman(String human); } 

Und für die SongPlayers-Klasse

 @Repository public interface SongPlayersRepository extends JpaRepository<SongPlayers, Long> { List<SongPlayers> findSongPlayersBySong(String song); List<SongPlayers> findSongPlayersByComposer(String composer); List<SongPlayers> findSongPlayersByPoet(String poet); } 

Die Repository- Annotation erweitert die Component- Annotation, wodurch die implementierte Klasse eine Bean und dementsprechend eine automatische Verdrahtung sein kann.

Durch die Erweiterung der JpaRepository-Schnittstelle können Sie die erforderlichen CRUD-Operationen ohne zusätzliche Beschreibung und andere nützliche Dinge ausführen.

Jetzt müssen Sie DTO-Klassen für Entity People und SongPlayers erstellen. Hier werde ich nur PeopleDTO zitieren, um den Artikel nicht zu überladen. Getter und Setter wieder abgesenkt.

 public class PeopleDTO { private long id; private String human; private RockGroups rockGroups; private List<SongPlayersDTO> songPlayersList; public List<PeopleDTO> getPeopleDTOList(List<People> peopleList){ List<PeopleDTO> peopleDTOList = new ArrayList<>(); for (People people : peopleList){ songPlayersList = new ArrayList<>(); PeopleDTO peopleDTO = new PeopleDTO(); peopleDTO.setId(people.getId()); peopleDTO.setHuman(people.getHuman()); peopleDTO.setRockGroups(people.getRockGroups()); for (SongPlayers songPlayers : people.getSongItems()){ SongPlayersDTO songPlayersDTO = new SongPlayersDTO(); songPlayersDTO.setId(songPlayers.getId()); songPlayersDTO.setSong(songPlayers.getSong()); songPlayersDTO.setPoet(songPlayers.getPoet()); songPlayersDTO.setComposer(songPlayers.getComposer()); songPlayersDTO.setAlbum(songPlayers.getAlbum()); songPlayersList.add(songPlayersDTO); } peopleDTO.setSongPlayersList(songPlayersList); peopleDTOList.add(peopleDTO); } return peopleDTOList; } //. . . . . . . . . } 

Analog dazu wird auch die SongPlayersDTO-Klasse erstellt. Wir wählen die erforderlichen Felder aus, die in der restlichen Antwort angezeigt werden sollen.

Erstellen Sie einen Controller für Personen. Achtung, pass auf deine Hände auf!

 @RestController @RequestMapping("/people") public class PeopleController { @Autowired private PeopleRepository repository; @GetMapping("/all") public List<PeopleDTO> getAllPeople(){ PeopleDTO peopleDTO = new PeopleDTO(); return peopleDTO.getPeopleDTOList(repository.findAll()); } //. . . . . . . } 

Ja, sagst du? Dies wird nicht funktionieren. Wo ist die Implementierung der PeopleRepository-Schnittstelle?
Funktioniert, wird die PeopleRepository-Klasse im laufenden Betrieb erstellt! Einfach fantastisch.

Vergleichen Sie nun die Anzahl der Klassen und Schnittstellen, die für ein identisches Projekt in Spring und Spring Boot erstellt wurden

Klassen in einem Frühlingsprojekt	Klassen im Frühjahr Stiefel

Ich wünsche Ihnen allen eine erfolgreiche Programmierung. Warten auf Ihre Kommentare.

• Projekt auf Github verlinken.

Gebrauchte Literatur:

• Felipe Gutierrez Pro Spring Boot
• Craig Walls Spring in Aktion 5. Auflage