హైబర్నేట్‌లో వస్తువును ఎలా మార్చాలి

విలీనం() పద్ధతి యొక్క సూక్ష్మ నైపుణ్యాలు

డేటాబేస్లో ఇప్పటికే నిల్వ చేయబడిన వస్తువును మార్చడానికి మీరు హైబర్నేట్ను ఉపయోగించాలనుకుంటే, దీని కోసం అనేక పద్ధతులు కూడా ఉన్నాయి.

మొదటిది మెర్జ్() పద్ధతి , ఇది పాస్ చేయబడిన ఆబ్జెక్ట్ ఆధారంగా డేటాబేస్‌లోని సమాచారాన్ని నవీకరిస్తుంది . ఇది 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);

ఇక్కడ అనేక ముఖ్యమైన సూక్ష్మ నైపుణ్యాలు ఉన్నాయి.

మొదట, విలీనం() పద్ధతి ఫలితాన్ని, నవీకరించబడిన వస్తువును అందిస్తుంది. ఈ వస్తువు పెర్సిస్ట్ స్థితిని కలిగి ఉంది మరియు సెషన్ ఆబ్జెక్ట్‌కు జోడించబడింది. విలీనం() పద్ధతికి పంపబడిన వస్తువు మారదు.

యూజర్ మరియు యూజర్ 2 మధ్య తేడా లేదని అనిపించవచ్చు, కానీ అది కాదు. మీరు విలీన() పద్ధతికి POJO ఆబ్జెక్ట్‌ను పంపవచ్చు మరియు ఫలితంగా, పద్ధతి ప్రాక్సీని తిరిగి ఇవ్వగలదు (హైబర్నేట్ సెట్టింగ్‌లను బట్టి). కాబట్టి విలీనం() పద్ధతి పాస్ అయిన వస్తువును మార్చదని గుర్తుంచుకోండి .

రెండవది, విలీనం() కి పంపబడిన ఆబ్జెక్ట్ తాత్కాలిక స్థితిని కలిగి ఉంటే (మరియు దానికి ID లేదు), అప్పుడు డేటాబేస్లో దాని కోసం ప్రత్యేక లైన్ సృష్టించబడుతుంది. మరో మాటలో చెప్పాలంటే, persist() కమాండ్ అమలు చేయబడుతుంది .

మూడవదిగా, సెషన్‌కు ఇప్పటికే జోడించబడిన ఆబ్జెక్ట్ (పెర్సిస్ట్ స్టేటస్‌తో) విలీన() పద్ధతికి పంపబడితే, అప్పుడు ఏమీ జరగదు - పద్ధతి అదే వస్తువును తిరిగి ఇస్తుంది. ఎందుకు? మరియు అన్ని ఎందుకంటే లావాదేవీ కట్టుబడి ఉన్నప్పుడు, డేటా ఏమైనప్పటికీ డేటాబేస్కు వ్రాయబడుతుంది:

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() పద్ధతి ద్వారా నిర్వహించబడుతుంది . డేటాబేస్లో ఇప్పటికే ఉన్న వస్తువుపై సమాచారాన్ని నవీకరించడం అతని పని, మరియు ఏదీ లేకపోతే, దానిని సృష్టించండి. ఇది దాదాపు ఎల్లప్పుడూ సేవ్() మరియు అప్‌డేట్() పద్ధతుల స్థానంలో ఉపయోగించబడుతుంది .

నవీకరణ() పద్ధతి వలె కాకుండా , ఇది దానికి పంపిన వస్తువును మార్చగలదు. ఉదాహరణకు, డేటాబేస్‌లో సేవ్ చేస్తున్నప్పుడు కేటాయించిన IDకి సెట్ చేయండి. ఉదాహరణ:

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

అది ఎలా పని చేస్తుంది:

• పాస్ చేయబడిన వస్తువుకు ID ఉంటే, అప్పుడు UPDATE SQL పద్ధతి అంటారు
• పాస్ చేయబడిన ఆబ్జెక్ట్ యొక్క ID సెట్ చేయబడకపోతే, INSERT SQL పద్ధతి అంటారు