లావాదేవీలు

4.1 హైబర్నేట్‌లో లావాదేవీలకు పరిచయం

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

హైబర్నేట్ రెండు రకాల లావాదేవీలతో పని చేయగలదు:

• JDBC
• JTA

JDBC లావాదేవీ వాస్తవానికి డేటాబేస్ లావాదేవీ. ఇది JDBC కనెక్షన్‌తో డేటాబేస్‌తో పని చేయడంతో ముడిపడి ఉంది. మరియు అతను డేటాబేస్తో పనిచేసేటప్పుడు చర్యలు తప్పనిసరిగా నిర్వహించబడతాయని నిర్ధారించుకుంటాడు: అన్నీ లేదా ఏమీ లేవు.

JTA - లావాదేవీ అనేది అప్లికేషన్ స్థాయి లావాదేవీ. ఇది ఏ డేటాబేస్‌తో ముడిపడి లేదు. కొన్ని చర్యలు నిర్వహించబడుతున్నాయని నిర్ధారించుకోవడం దీని పని: అన్నీ లేదా ఏమీ.

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

4.2 హైబర్నేట్ లావాదేవీల ఇంటర్‌ఫేస్

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

ఈ ఇంటర్ఫేస్ యొక్క పద్ధతులు:

ముఖ్యమైనది! లావాదేవీ వస్తువును సృష్టించడం మరియు లావాదేవీని ప్రారంభించడం రెండు వేర్వేరు విషయాలు. ఇక్కడ మీరు థ్రెడ్ క్లాస్‌తో సారూప్యతను గీయవచ్చు. మీరు థ్రెడ్() ఆబ్జెక్ట్‌ని సృష్టించినప్పుడు, JVM ఇంకా కొత్త థ్రెడ్‌ని ప్రారంభించదు. దీన్ని ప్రారంభించడానికి, మీరు థ్రెడ్ ఆబ్జెక్ట్‌పై ప్రారంభ () పద్ధతిని కాల్ చేయాలి. ఇది లావాదేవీతో కూడా అదే - ఇది ప్రారంభం() పద్ధతిని కాల్ చేయాలి.

సాధారణంగా హైబర్నేట్‌లో లావాదేవీలు ఎలా నిర్వహించబడతాయి అనేదానికి ఉదాహరణ:

Session session = sessionFactory.openSession();
Transaction transaction = session.getTransaction();
try {
    transaction.begin();
    Long count = session.createQuery("select count(*) from Employee", Long.class).uniqueResult();
    transaction.commit();
}
catch (Exception e) {
	if (transaction.getStatus() == ACTIVE || transaction.getStatus() == MARKED_ROLLBACK) {
    transaction.rollback();
    }
}
finally {
	session.close();
	sessionFactory.close();
}

ఇక్కడ మనకు మూడు విషయాలు కనిపిస్తాయి:

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

రెండవది, ఏదైనా లోపం సంభవించినట్లయితే, మేము లావాదేవీని వెనక్కి తీసుకోవడానికి ప్రయత్నిస్తాము - కాల్ చేయండి rollback(). begin()దీనర్థం TransactionManger ముందుగా మరియు మధ్య ఉన్న అన్ని చర్యలను రికార్డ్ చేసి commit(), ఆపై మనం కాల్ చేస్తే ప్రతిదీ తిరిగి ఇవ్వాలి rollback().

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

4.3 లావాదేవీ నిర్వాహకుడు

లావాదేవీ నిర్వహణ దృక్కోణంలో, హైబర్నేట్ అనేది JDBC కోసం తేలికైన వస్తువు రేపర్. హైబర్నేట్ దానికదే లావాదేవీ ప్రాసెసింగ్ ఫీచర్‌లను కలిగి ఉండదు. హైబర్నేట్ లావాదేవీ వాస్తవానికి అంతర్లీన JDBC లావాదేవీ (లేదా JTA లావాదేవీ రేపర్) కోసం ఒక రేపర్. JDBC లావాదేవీ డిఫాల్ట్. Hiberante సెట్టింగ్‌ల ఫైల్ నుండి ఉదాహరణ:

hibernate.transaction.factory_class  org.hibernate.transaction.JTATransactionFactory
hibernate.transaction.factory_class  org.hibernate.transaction.JDBCTransactionFactory

లావాదేవీలను ఉపయోగించి మా కోడ్‌ను మరొకసారి చూద్దాం:

Session session = sessionFactory.openSession();
Transaction transaction = session.getTransaction();
transaction.begin();
//here is your code for working with the base
session.flush();
transaction.commit();
session.close();

ఇప్పుడు JDBCట్రాన్సాక్షన్ క్లాస్ కోడ్‌ని చూద్దాం:

public class JDBCTransaction implements Transaction {
 
    public void begin() throws HibernateException {
    	...
    	if (toggleAutoCommit) jdbcContext.connection().setAutoCommit(false);
    	...
    }
}

లావాదేవీని ప్రారంభించే పద్ధతి ఇది. అప్పుడు పంపే పద్ధతిని చూడండి:

public void commit() throws HibernateException {
    ...
    jdbcContext.connection().commit();
    ...
    jdbcContext.connection().setAutoCommit( true );
    ...
}

ఇప్పుడు ఈ కోడ్‌ని హైబర్నేట్ ఉదాహరణ కోడ్‌లో ప్రత్యామ్నాయం చేద్దాం:

Session session = sessionFactory.openSession();
Transaction transaction = session.getTransaction();
transaction.begin();
//here is your code for working with the database
session.flush();
transaction.commit();
session.close();

Connection conn = jdbcContext.connection();
conn.setAutoCommit(false);
 
//here is your database code
conn.commit ()
conn.setAutoCommit(true);
conn.close();

కాబట్టి స్థానిక హైబర్నేట్ లావాదేవీలు డేటాబేస్‌కు స్థానిక JDBC కాల్‌లు మాత్రమే. ఏమీ ఎక్కువ మరియు తక్కువ ఏమీ లేదు. కానీ JTA లావాదేవీలు మరింత ఆసక్తికరంగా ఉంటాయి. కానీ దాని గురించి మరొకసారి.