Solution de tâche Spring Boot avec ManyToMany

L'article vous est adressé, errant dans l'obscurité de la nuit. Toi, dont le chemin n'est éclairé que par des lucioles solitaires. En général, un programmeur qui étudie Spring Boot et la relation ManyToMany dans Hibernate.

Il a fait une tâche de test sur un thème musical abstrait: écrire un service pour stocker des données sur des musiciens, des chansons, des albums, en utilisant Java, Spring, Hibernate. Une partie de la mission consistait à créer les classes «Compositions» et «Interprètes». Une composition peut être interprétée par de nombreux interprètes, et un interprète peut effectuer de nombreuses compositions. Attitude bidirectionnelle typique de ManyToMany.

Les cours de Khasang ont enseigné comment éviter les demandes de repos en boucle autour de Spring en utilisant la classe DTO, mais Spring Boot est une autre histoire. Sur les sites en langue russe, j'ai vu des réponses comme «Oui, tout est élémentaire», mais sans explications spécifiques. Je vais donner un exemple de résolution de ce problème. Le code complet est situé sur le github, lien ci-dessous.

Créez d'abord Entity: People et SongPlayers. Les getters et setters sont omis par souci de concision.

@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; //. . . . . . . . . } 

Ensuite, nous créons des interfaces de référentiel pour la classe People.

 @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); } 

Et pour la classe SongPlayers

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

L'annotation Repository étend l'annotation Component , ce qui permet à la classe implémentée d'être un bean et, par conséquent, un câblage automatique.

L'extension de l'interface JpaRepository vous permet d'effectuer les opérations CRUD nécessaires sans description supplémentaire et autres choses utiles.

Vous devez maintenant créer des classes DTO pour Entity People et SongPlayers. Ici, je ne citerai que PeopleDTO pour ne pas encombrer l'article. Getters et setters ont de nouveau baissé.

 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; } //. . . . . . . . . } 

Par analogie, la classe SongPlayersDTO est également créée. Nous sélectionnons les champs nécessaires à afficher dans la réponse restante.

Créez un contrôleur pour les personnes. Attention, surveillez vos mains!

 @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()); } //. . . . . . . } 

Ouais, tu dis. Cela ne fonctionnera pas. Où est l'implémentation de l'interface PeopleRepository?
Fonctionnera, la classe PeopleRepository est créée à la volée! Tout simplement fantastique.

Comparez maintenant le nombre de classes et d'interfaces créées pour un projet identique sur Spring et Spring Boot

cours dans un projet de printemps	cours au printemps

Je vous souhaite une programmation réussie. En attente de vos commentaires.

• Projet de lien sur github.

Littérature utilisée:

• Chaussure Felipe Gutierrez Pro Spring
• Craig Walls Spring in action 5e édition