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

సాధ్యమైన వస్తువు స్థితి ఎంపికలు

మీరు గమనించినట్లుగా, ఒక వస్తువు హైబర్నేట్‌కు జోడించబడినప్పుడు, దాని స్థితిని పెర్సిస్టెంట్ లేదా మేనేజ్డ్ అంటారు . ఎంత సరైనది? నిలకడగా ఉందా లేదా నిర్వహించబడిందా?

ఇది సాధ్యమే మరియు అందువలన, మరియు. JPA స్పెసిఫికేషన్ ప్రకారం, ఒక వస్తువుకు పెర్సిస్ట్ స్థితి ఉంటుంది మరియు హైబర్నేట్ స్పెసిఫికేషన్ ప్రకారం, దాని స్థితిని మేనేజ్డ్ అంటారు.

హైబర్నేట్‌లో, డేటాబేస్‌తో పని org.hibernate.Session రకం వస్తువు ద్వారా నిర్వహించబడుతుంది . JPA ప్రకారం, తరగతిని javax.persistence.EntityManager అని పిలవాలి. రెండు రకాలు ఇంటర్‌ఫేస్‌లు కాబట్టి ఇది నిజంగా పెద్ద సమస్య కాదు.

org.hibernate.Session ఇంటర్‌ఫేస్ ఇలా ప్రకటించబడింది:

interface Session extends java.lang.AutoCloseable, javax.persistence.EntityManager, HibernateEntityManager,    QueryProducer, java.io.Serializable, SharedSessionContract {

}

కాబట్టి, సెషన్ ఇంటర్‌ఫేస్ EntityManager ఇంటర్‌ఫేస్‌లో ఉన్న అన్ని పద్ధతులను కలిగి ఉంది . కానీ ఇది దాని స్వంతదానిని కలిగి ఉంది, ఇది హైబర్నేట్ యొక్క మునుపటి సంస్కరణల నుండి వారసత్వంగా పొందింది, ఇంకా JPA స్పెసిఫికేషన్ లేనప్పుడు.

ఈ మొత్తం పరిస్థితి క్రింది విధంగా వివరించబడింది:

సెషన్ ఇంటర్‌ఫేస్‌లో ఉన్న అన్ని పద్ధతులను, అలాగే వారి పని యొక్క సూక్ష్మ నైపుణ్యాలను పరిశీలిద్దాం.

పెర్సిస్ట్() పద్ధతి యొక్క సూక్ష్మ నైపుణ్యాలు

డేటాబేస్‌లో వస్తువును సేవ్ చేసేటప్పుడు, మీరు రెండు విషయాలను గుర్తుంచుకోవాలి.

మొదట, ఆబ్జెక్ట్‌ను సేవ్ చేయడం వలన చివరికి SQL ఆదేశాలలో ఒకదానిని అమలు చేయడం జరుగుతుంది: INSERT లేదా UPDATE. రెండవది, వస్తువు యొక్క పద్ధతిని పిలిచిన వెంటనే ఈ చర్యలు జరగవుసెషన్, కానీ లావాదేవీని మూసివేసిన తర్వాత మాత్రమే.

కొన్ని సాధారణ పరిస్థితిని పరిశీలిద్దాం, ఉదాహరణకు, మీకు వినియోగదారు తరగతి ఉంది :

@Entity
public class User {
	@Id
	@GeneratedValue
    public Integer id;

	@Columnt(name=”user_name”)
    public String name;
}

persist() పద్ధతిని ఉపయోగించి దాని వస్తువుని డేటాబేస్‌లో సేవ్ చేద్దాం .

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

ఈ పద్ధతి యొక్క ఉద్దేశ్యం డేటాబేస్కు కొత్త వస్తువును సేవ్ చేయడం. ఇంకా అలాంటి వస్తువు ఏదీ లేకుంటే, అది INSERT SQL పద్ధతికి కాల్ చేయడం ద్వారా డేటాబేస్‌కు జోడించబడుతుంది .

ఆబ్జెక్ట్ ఇప్పటికే డేటాబేస్లో ఉంటే, అప్పుడు ఏమీ జరగదు. అయితే, మూడవ కేసు కూడా సాధ్యమే - డేటాబేస్‌లో డిటాచ్డ్ స్టేటస్‌తో ఆబ్జెక్ట్‌ను సేవ్ చేసే ప్రయత్నం. ఈ సందర్భంలో, ఒక మినహాయింపు విసిరివేయబడుతుంది. ఉదాహరణ:

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

session.evict(user);     // detach the object from the session
session.persist(user); // a PersistenceException will be thrown here!

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

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

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

ముఖ్యమైనది! హైబర్నేట్ ID స్పెసిఫికేషన్ ప్రకారం, ఇది ఒక సంఖ్య మాత్రమే కాకుండా ఏదైనా సీరియలైజ్ చేయగల వస్తువు కావచ్చు. ఇది స్ట్రింగ్, ఒక సంఖ్య, ఒక enum, డేటాబేస్లో పట్టిక యొక్క ఒక నిలువు వరుసలో పూర్తిగా ఉంచగలిగే సాధారణంగా ఏదైనా కావచ్చు.

సేవ్() పద్ధతి సీరియలైజ్డ్ రిజల్ట్ రకాన్ని కలిగి ఉంది, కాబట్టి దాని ఫలితం సరైన రకానికి ప్రసారం చేయాలి:

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

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

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

session.evict(user); 	// detach the object from the session
Integer id2 = (Integer) session.save(user);

id మరియు id2 వేరియబుల్స్ భిన్నంగా ఉంటాయి. డేటాబేస్‌లోని టేబుల్‌కి రెండు రికార్డ్‌లు జోడించబడతాయి, ప్రతి సేవ్() ఆపరేషన్‌కు ఒకటి .