பரிவர்த்தனைகள்

4.1 Hibernate இல் பரிவர்த்தனைகளுக்கான அறிமுகம்

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

ஹைபர்னேட் இரண்டு வகையான பரிவர்த்தனைகளுடன் வேலை செய்ய முடியும்:

• ஜேடிபிசி
• JTA

ஒரு JDBC பரிவர்த்தனை உண்மையில் ஒரு தரவுத்தள பரிவர்த்தனை ஆகும். இது தரவுத்தளத்துடன், ஜேடிபிசி இணைப்புடன் வேலை செய்வதோடு இணைக்கப்பட்டுள்ளது. தரவுத்தளத்துடன் பணிபுரியும் போது அவை செய்ய வேண்டிய செயல்கள் செய்யப்படுவதை அவர் உறுதிசெய்கிறார்: அனைத்தும் அல்லது எதுவும் இல்லை.

JTA - பரிவர்த்தனை என்பது பயன்பாட்டு அளவிலான பரிவர்த்தனையாகும். இது எந்த தரவுத்தளத்துடனும் இணைக்கப்படவில்லை. சில செயல்கள் செய்யப்படுவதை உறுதி செய்வதே அதன் பணி: அனைத்தும் அல்லது எதுவும் இல்லை.

எடுத்துக்காட்டாக, நீங்கள் ஒரு JTA பரிவர்த்தனைக்குள் பல்வேறு தரவுத்தளங்களுக்கு தரவை எழுதலாம். பிழை ஏற்பட்டால், JTA பரிவர்த்தனை அனைத்து தரவுத்தளங்களிலும் மாற்றங்களைத் திரும்பப் பெற வேண்டும். ஒரு குறிப்பிட்ட தரவுத்தளத்தின் அடிப்படையில் வெற்றிகரமாக செயல்படுத்தப்பட்டவை கூட.

4.2 ஹைபர்னேட் பரிவர்த்தனைகள் இடைமுகம்

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

இந்த இடைமுகத்தின் முறைகள்:

முக்கியமான! பரிவர்த்தனை பொருளை உருவாக்குவதும் பரிவர்த்தனையைத் தொடங்குவதும் இரண்டு வெவ்வேறு விஷயங்கள். இங்கே நீங்கள் நூல் வகுப்போடு ஒப்புமை வரையலாம். நீங்கள் ஒரு Thread() ஆப்ஜெக்டை உருவாக்கும் போது, ​​JVM இன்னும் புதிய தொடரை தொடங்கவில்லை. அதைத் தொடங்க, நீங்கள் Thread ஆப்ஜெக்ட்டில் தொடக்க() முறையை அழைக்க வேண்டும். பரிவர்த்தனையிலும் இதுவே தான் - இது தொடக்க() முறையை அழைக்க வேண்டும்.

பொதுவாக ஹைபர்னேட்டில் பரிவர்த்தனைகள் எவ்வாறு கையாளப்படுகின்றன என்பதற்கான எடுத்துக்காட்டு:

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க்கான ஒரு இலகுரக பொருள் ரேப்பர் ஆகும். Hibernate இல் பரிவர்த்தனை செயலாக்க அம்சங்கள் இல்லை. ஹைபர்னேட் பரிவர்த்தனை என்பது உண்மையில் அடிப்படையான ஜேடிபிசி பரிவர்த்தனைக்கான (அல்லது ஜேடிஏ பரிவர்த்தனை ரேப்பர்) ரேப்பர் ஆகும். ஜேடிபிசி பரிவர்த்தனை இயல்புநிலை. 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();

இப்போது JDBCTransaction வகுப்புக் குறியீட்டைப் பார்ப்போம்:

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 பரிவர்த்தனைகள் மிகவும் சுவாரஸ்யமானவை. ஆனால் அதைப் பற்றி மற்றொரு முறை.