ఎంటిటీ ఆబ్జెక్ట్‌లతో పని చేస్తోంది

4.1 లావాదేవీలు మరియు డేటాబేస్ సమగ్రత

వందలాది విభిన్న క్లయింట్ల నుండి ప్రతి నిమిషానికి వేలకొద్దీ అభ్యర్థనలను స్వీకరించినప్పుడు డేటాబేస్ యొక్క సాధారణ ఆపరేషన్ విధానం. ఈ సందర్భంలో, వివిధ ప్రశ్నల నుండి ఒకే డేటాను యాక్సెస్ చేసినప్పుడు తరచుగా పరిస్థితులు తలెత్తుతాయి.

తక్కువ తరచుగా, కానీ, మళ్ళీ, ఎప్పటికప్పుడు ఒక అభ్యర్థన ఒక నిర్దిష్ట పంక్తిని చదివినప్పుడు మరియు మరొక అభ్యర్థన అదే సమయంలో మార్చినప్పుడు పరిస్థితులు ఉన్నాయి. ఎవరైనా సగం మారిన పంక్తిని చదివితే ఏమి జరుగుతుందో ఊహించండి? ఏమీ బాగోలేదు.

ఈ సమస్య అనేక విధాలుగా పరిష్కరించబడుతుంది. ముందుగా, మీరు మారుతున్న లైన్‌ను లాక్ చేయవచ్చు. చదవడానికి మరియు వ్రాయడానికి రెండూ. ఈ పద్ధతి పనిచేస్తుంది, కానీ బేస్ యొక్క వేగం బాగా బాధపడుతుంది.

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

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

ఏదైనా ఆధునిక SQL సర్వర్ లావాదేవీలలో మాత్రమే డేటాను మార్చడానికి మిమ్మల్ని అనుమతిస్తుంది. మీరు లావాదేవీని తెరిచి, ఎన్ని టేబుల్‌లకైనా ఏవైనా మార్పులు చేసి, లావాదేవీకి కట్టుబడి ఉంటారు. SQL సర్వర్ మార్పులు చేయడానికి ప్రయత్నిస్తుంది. ప్రతిదీ సరిగ్గా ఉంటే, అప్పుడు వారు సాధారణ డేటాబేస్కు జోడించబడతారు. సమస్యలు ఉంటే, అన్ని మార్పులు రద్దు చేయబడతాయి.

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

మేము ఈ అంశానికి మరింత వివరంగా వెళ్తాము, అయితే ప్రస్తుతానికి, లావాదేవీలు ఎందుకు అవసరమో మరియు అవి సాధారణంగా ఎక్కడ ఉపయోగించబడుతున్నాయో తెలుసుకోండి.

4.2 వస్తువులను పొందడం

హైబర్నేట్ డేటాను పొందడానికి అభ్యర్థనను అమలు చేస్తే, లావాదేవీని స్పష్టంగా తెరవాల్సిన అవసరం లేదు. హైబర్నేట్ సరిపోతుందనిపిస్తే దానంతట అదే చేస్తుంది: దీనికి దాని సెట్టింగ్‌లు అలాగే SQL సర్వర్ సెట్టింగ్‌లు ఉన్నాయి.

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

Class Name = session.get(Class.class, ID);

ఉదాహరణ:

public User getUserById(Integer id) {
    try (Session session = sessionFactory.openSession()) {
        User user = session.get(User.class, id);
        return user;
    }
}

4.3 వస్తువులను సేవ్ చేయడం (జోడించడం).

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

అటువంటి అభ్యర్థన యొక్క సాధారణ రూపం:

session.persist(An object);

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

public boolean saveUser(User user) {
    try (Session session = sessionFactory.openSession()) {
            Transaction transaction = session.beginTransaction();
            session.persist(user);
            transaction.commit();
            return true;
    }
    catch() {
    return false;
   	}
}

సెషన్ ఆబ్జెక్ట్ కూడా save()ఇదే విధమైన పనితీరును చేసే పద్ధతిని కలిగి ఉంది . ఇది కేవలం పద్ధతి save()పాత హైబర్నేట్ ప్రమాణం మరియు పద్ధతి persist()JPA ప్రమాణం.

4.4 వస్తువులను తొలగిస్తోంది

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

అటువంటి అభ్యర్థన యొక్క సాధారణ రూపం:

session.remove(An object);

మరియు, వాస్తవానికి, కోడ్‌ను ఒక ఉదాహరణతో వ్రాస్దాం:

public boolean removeUser(User user) {
    try (Session session = sessionFactory.openSession()) {
            Transaction transaction = session.beginTransaction();
            session.remove(user);
            transaction.commit();
            return true;
    }
    catch() {
    return false;
   	}
}

ఎందుకు చాలా కష్టం, మీరు అడగండి?

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