ஹைபர்னேட்டில் ஒரு பொருளை எவ்வாறு மாற்றுவது

ஒன்றிணைத்தல்() முறையின் நுணுக்கங்கள்

தரவுத்தளத்தில் ஏற்கனவே சேமிக்கப்பட்ட ஒரு பொருளை மாற்ற ஹைபர்னேட்டைப் பயன்படுத்த விரும்பினால், இதற்கும் பல முறைகள் உள்ளன.

முதலாவது merge() முறை , இது அனுப்பப்பட்ட பொருளின் அடிப்படையில் தரவுத்தளத்தில் உள்ள தகவலைப் புதுப்பிக்கிறது . இது SQL UPDATE வினவலைத் தூண்டும். உதாரணமாக:

User user = new User();
user.setName("Kolyan");
session.save(user);

session.evict(user);     // detach the object from the session
user.setName("Masha");

User user2 = (User) session.merge(user);

இங்கே பல முக்கியமான நுணுக்கங்கள் உள்ளன.

முதலில், merge() முறையானது , புதுப்பிக்கப்பட்ட பொருளின் முடிவை வழங்குகிறது. இந்த ஆப்ஜெக்ட் பெர்சிஸ்ட் நிலையைக் கொண்டுள்ளது மற்றும் அமர்வு பொருளுடன் இணைக்கப்பட்டுள்ளது. merge() முறைக்கு அனுப்பப்பட்ட பொருள் மாறாது.

பயனர் மற்றும் பயனர் 2 இடையே எந்த வித்தியாசமும் இல்லை என்று தோன்றலாம், ஆனால் அது இல்லை. நீங்கள் ஒரு POJO பொருளை merge() முறைக்கு அனுப்பலாம் , இதன் விளைவாக, முறையானது ப்ராக்ஸியை (Hibernate அமைப்புகளைப் பொறுத்து) திரும்பப் பெறலாம். எனவே merge() முறை கடந்து சென்ற பொருளை மாற்றாது என்பதை நினைவில் கொள்ளுங்கள்.

இரண்டாவதாக, மெர்ஜ்() க்கு அனுப்பப்பட்ட பொருளுக்கு இடைநிலை நிலை இருந்தால் (அதற்கு ஐடி இல்லை), தரவுத்தளத்தில் அதற்கென தனி வரி உருவாக்கப்படும். வேறு வார்த்தைகளில் கூறுவதானால், persist() கட்டளை செயல்படுத்தப்படும் .

மூன்றாவதாக, அமர்வில் ஏற்கனவே இணைக்கப்பட்ட ஒரு பொருள் (பெர்சிஸ்ட் நிலையுடன்) merge() முறைக்கு அனுப்பப்பட்டால், எதுவும் நடக்காது - முறை அதே பொருளைத் திருப்பித் தரும். ஏன்? ஏனெனில் பரிவர்த்தனை செய்யப்படும் போது, ​​தரவு எப்படியும் தரவுத்தளத்தில் எழுதப்படும்:

User user = new User();
user.setName("Kolyan");
session.save(user);

user.setName("Masha"); //change the object attached to the session

session.close();  //all changed objects will be written to the database

பொருளின் எந்த மாற்றத்திற்கும் பிறகு ஒவ்வொரு முறையும் அதைச் சேமிக்க வேண்டிய அவசியமில்லை. இந்த பொருள் பெர்சிஸ்ட் நிலையில் இருந்தால், ஹைபர்னேட் எல்லாவற்றையும் தானே செய்யும். "அடித்தளத்துடன் இணைக்கப்பட்ட" ஒரு பொருளை நீங்கள் மாற்றினால், அதன் அனைத்து மாற்றங்களும் அடித்தளத்தில் எழுதப்படும்.

புதுப்பிப்பு() முறையின் நுணுக்கங்கள்

ஹைபர்னேட்டில் ஒரு புதுப்பிப்பு() முறையும் உள்ளது , இது சேவ்() முறையைப் போலவே , முந்தைய பதிப்புகளிலிருந்து பெறப்பட்டது. இந்த முறை மூலம், ஏற்கனவே சேமித்த பொருளின் தரவை மட்டுமே புதுப்பிக்க முடியும். இது SQL UPDATE வினவலைத் தூண்டும். உதாரணமாக:

User user = new User();
user.setName("Kolyan");
session.save(user);

session.evict(user);     // detach the object from the session
user.setName("Masha");

session.update(user);

இந்த முறை எதையும் திருப்பித் தராது மற்றும் ஏற்கனவே உள்ள பொருளை மாற்றாது.

இந்த முறையை நீங்கள் ஒரு புதிய பொருளில் அழைத்தால், ஒரு விதிவிலக்கு வெறுமனே வீசப்படும்:

User user = new User();
user.setName("Kolyan");
session.update(user);   //an exception will be thrown here

saveOrUpdate() முறை

JPA வருவதற்கு முன், persist() முறையின் செயல்பாடு saveOrUpdate() முறை மூலம் செய்யப்பட்டது . தரவுத்தளத்தில் இருக்கும் பொருளின் தகவலை புதுப்பிப்பதே அவரது பணியாக இருந்தது, எதுவும் இல்லை என்றால், அதை உருவாக்கவும். சேமி() மற்றும் புதுப்பிப்பு() முறைகளுக்குப் பதிலாக இது எப்போதும் பயன்படுத்தப்படுகிறது .

புதுப்பிப்பு () முறையைப் போலல்லாமல் , அதற்கு அனுப்பப்பட்ட பொருளை மாற்றலாம். எடுத்துக்காட்டாக, தரவுத்தளத்தில் சேமிக்கும் போது ஒதுக்கப்பட்ட ஐடிக்கு அதை அமைக்கவும். உதாரணமாக:

User user = new User();
user.setName("Kolyan");
session.saveOrUpdate(user);   //object will be written to the database

எப்படி இது செயல்படுகிறது:

• அனுப்பப்பட்ட பொருளுக்கு ஐடி இருந்தால், அப்டேட் SQL முறை அழைக்கப்படுகிறது
• அனுப்பப்பட்ட பொருளின் ஐடி அமைக்கப்படவில்லை என்றால், INSERT SQL முறை அழைக்கப்படுகிறது