MapTruct समस्या कईToMany के साथ सुलझाने

नमस्कार प्रिय पाठकों! जो लोग स्प्रिंग फ्रेमवर्क का उपयोग करके जावा वेब एप्लिकेशन विकसित करते हैं, जो इन अनुप्रयोगों पर टिप्पणी करते हैं और बस रुचि रखते हैं।

पिछले लेख में, "कई बूटमोनी के साथ स्प्रिंग बूट समस्या का समाधान"

मैंने एक परीक्षण एप्लिकेशन का एक उदाहरण दिया जिसमें दो वर्गों के बीच एक द्विदिश संबंध ManyToMany है। डीटीओ वर्ग का उपयोग करके बाकी प्रतिक्रिया प्राप्त करने पर लेख लूपिंग समस्या को हल करने का एक उदाहरण प्रदान करता है। लूपिंग समस्या को हल करने के लिए MapStruct लाइब्रेरी का उपयोग करके सुझाए गए टिप्पणियों में पाठक।

दस्तावेज़ीकरण की समीक्षा करने के बाद , मुझे विश्वास हो गया कि यह वास्तव में एक शक्तिशाली चीज है, जिसके साथ आप वस्तुओं के बीच डेटा स्थानांतरित करने के काफी जटिल कार्यों को हल कर सकते हैं। MapStruct लूपिंग समस्या को हल करता है।

इस लेख में, मैं MapStruct लाइब्रेरी का उपयोग करके स्प्रिंग बूट एप्लिकेशन के समान समस्या को हल करने का एक उदाहरण दूंगा। स्रोत कोड Github पर उपलब्ध है

एंटिटी पीपल और सॉन्गप्लेर्स अपरिवर्तित रहे। गेटर्स और सेटर कम हो गए।

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

हम लोग और सॉन्गप्लेयर्स कक्षाओं के लिए रिपॉजिटरी इंटरफेस भी बनाते हैं।

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

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

हम लोग और सॉन्गप्लेयर्स के लिए डीटीओ क्लासेज भी बनाते हैं, जो अब इतनी भारी नहीं लगती हैं। गेटर्स एंड सेटर्स I लोअर।

 public class PeopleDTO { private long id; private String human; private RockGroups rockGroups; private List<SongPlayersDTO> songPlayersList; // . . . . . } 

 public class SongPlayersDTO { private long id; private String song; private String composer; private String poet; private String album; // . . . . . } 

स्रोत ऑब्जेक्ट से डीटीओ ऑब्जेक्ट पर डेटा स्थानांतरित करने के नियम का वर्णन करने के लिए और, यदि आवश्यक हो, तो वापस हम प्रत्येक वर्ग के लिए मैपर इंटरफेस बनाते हैं जिसके लिए लूपिंग के खिलाफ सुरक्षा की आवश्यकता होती है। यहाँ PeopleMapper और SongPlayersMapper है

 @Mapper(uses = SongPlayersMapper.class) public interface PeopleMapper { PeopleMapper PEOPLE_MAPPER = Mappers.getMapper(PeopleMapper.class); @Mapping(source = "songItems", target = "songPlayersList") PeopleDTO fromPeople(People people); } 

 @Mapper/*(uses = {PeopleMapper.class})*/ public interface SongPlayersMapper { SongPlayersMapper SONG_PLAYERS_MAPPER = Mappers.getMapper(SongPlayersMapper.class); SongPlayersDTO fromSongPlayers(SongPlayers songPlayers); @InheritInverseConfiguration SongPlayers toSongPlayers(SongPlayersDTO songPlayersDTO); } 

सेवा फ़ोल्डर में, सेवा वर्गों के इंटरफेस और कार्यान्वयन बनाएं, जिसमें हम डेटा प्राप्त करने के तरीके डालते हैं (मैं इसे लोगों के लिए दूंगा)।

 public interface PeopleService { List<PeopleDTO> getAllPeople(); PeopleDTO getPeopleById(long id); People addPeople(People people); void delPeople(long id); ResponseEntity<Object> updPeople(People people, long id); List<RockGroups> getByHuman(String human); List<String> getSongByHuman(String human); } 

 @Service("peopleservice") public class PeopleServiceImpl implements PeopleService { @Autowired private PeopleRepository repository; @Override public List<PeopleDTO> getAllPeople() { List<PeopleDTO> peopleDTOList = new ArrayList<>(); List<People> peopleList = repository.findAll(); for (People people : peopleList){ peopleDTOList.add(PeopleMapper.PEOPLE_MAPPER.fromPeople(people)); } return peopleDTOList; } // . . . . . } 

नियंत्रकों में, हम इन विधियों को तदनुसार लागू करेंगे (केवल लोगों के लिए फिर से)

 @RestController @RequestMapping("/people") public class PeopleController { @Autowired private PeopleServiceImpl service; @GetMapping("/all") public List<PeopleDTO> getAllPeople(){ return service.getAllPeople(); } // . . . . . } 

ManyToMany संबंध के लिए लूपिंग समस्या के उपरोक्त समाधान से, मैं कह सकता हूं कि पिछले लेख से DTO वर्गों के साथ विकल्प और इस लेख से MapStruct पुस्तकालय के साथ संस्करण भी काम कर रहे हैं। पिछले संस्करण की तुलना में, डीटीओ वर्ग को बहुत सरल बनाया गया है, लेकिन मैपर इंटरफेस को जोड़ा गया है। सामान्य तौर पर, किसी भी विधि का उपयोग किया जा सकता है, सरल मामलों के लिए मैं पहले विकल्प के लिए इच्छुक हूं।

मैं चर्चा में सभी प्रतिभागियों का धन्यवाद करता हूं। आपकी टिप्पणियों की प्रतीक्षा है।

पिछले लेख का लिंक।

गिथब पर परियोजना के लिए लिंक।

प्रयुक्त साहित्य:

• फेलिप गुटिरेज प्रो स्प्रिंग बूट
• क्रेग वॉल्स स्प्रिंग इन एक्शन 5 वें संस्करण