ஒரு பொருளைப் பெற பல்வேறு வழிகள்

EntityClass Name = session.get(EntityClass.class, Object primaryKey);

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

User user = session.get(User.class, 2);

இந்த ஐடியுடன் கூடிய பதிவு தரவுத்தளத்தில் காணப்படவில்லை என்றால், முறை பூஜ்யமாக மாறும்.

சுமை () முறை

ஒரு பொருளை ஏற்றுவதற்கான இரண்டாவது முறை சுமை() முறை . சுமை() முறையின் பொதுவான வடிவம் ஒன்றே:

EntityClass Name = session.load(EntityClass.class, Object primaryKey);

இருப்பினும், அதன் நடத்தை get() முறையிலிருந்து வேறுபட்டது .

முதலில், இந்த முறை ஒரு உண்மையான பொருளைத் தராது, ஆனால் ஒரு ப்ராக்ஸி: ஒரு மெய்நிகர் ஸ்டப்.

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

மூன்றாவதாக, ப்ராக்ஸி பொருளின் முறைகளை அழைக்கும்போது தரவுத்தளத்துடனான அனைத்து வேலைகளும் நிகழும். நீங்கள் அழைக்க முயற்சித்தால், எடுத்துக்காட்டாக, getName() முறை , பின்னர் தரவுத்தளத்திற்கு முதல் அழைப்பு ஏற்படும். உதாரணமாக:

User user = session.load(User.class, new Integer(123));
String name = user.getName(); //this is where the first call to the database will occur

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

கண்டுபிடி () முறை

ஜேபிஏ தரநிலையிலிருந்து ஃபைண்ட்() முறை அமர்வு இடைமுகத்திற்கு அனுப்பப்பட்டது. உங்களுக்குத் தெரிந்தபடி, இந்த தரநிலை முறைகளின் கையொப்பத்தை மட்டும் விவரிக்கிறது, ஆனால் நடத்தையை ஒழுங்குபடுத்துகிறது.

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

User user = session.find(User.class, -2); //method will return null

புதுப்பித்தல் () முறை

ஒரு தரவுத்தளத்திலிருந்து ஒரு பொருளை ஏற்றுவதுடன் தொடர்புடைய மற்றொரு பயனுள்ள முறை புதுப்பிப்பு () முறை ஆகும் .

அனுப்பப்பட்ட பொருளின் அடிப்படையில் தரவுத்தளத்தில் தரவைப் புதுப்பிக்கும் persist() முறையை நினைவில் கொள்கிறீர்களா ? எனவே, புதுப்பிப்பு () முறை இதற்கு நேர்மாறாக செயல்படுகிறது: இது தரவுத்தளத்திலிருந்து தரவின் அடிப்படையில் இருக்கும் பொருளைப் புதுப்பிக்கிறது.

உதாரணமாக, தரவுத்தளத்தில் ஒரு பொருளை எழுதும் போது, ​​எழுதப்பட்ட தரவை சரிசெய்யும் பல்வேறு சேமிக்கப்பட்ட நடைமுறைகள் அங்கு அழைக்கப்பட்டால் இந்த நடத்தை அவசியம்.

இதுபோன்ற சந்தர்ப்பங்களில், தரவுத்தளத்திலிருந்து பொருள் மாறியிருக்க வாய்ப்பு இருந்தால், அதை மீண்டும் படிப்பது பயனுள்ளதாக இருக்கும். உதாரணமாக:

User user = new User();
user.setName("Kolyan");
session.persist(user);
session.flush();  //Force called SQL INSERT and call triggers

session.refresh(user);
// here we continue to work with the updated object