Transaksiyalar

4.1 Hibernate transaksiyalari bilan tanishish

Yuqorida aytilganlarga qo'shimcha sifatida transaksiyalar haqida ma'lumot berishni istardim. Sen allaqachon bilganingdek, transaksiya – bu birgalikda bajarilishi kerak bo'lgan harakatlar guruhi. Agar biror amal bajarilmasa yoki xatolik bilan bajarilsa, qolgan barcha amallar bekor qilinishi kerak.

Hibernate ikkita turdagi transaksiyalar bilan ishlay oladi:

• JDBC
• JTA

JDBC-transaksiya – bu aslida ma'lumotlar bazasi transaksiyasi. U ma'lumotlar bazasi bilan ishlashga, JDBC-ulanishga bog'langan. Va ma'lumotlar bazasi bilan ishlashda amallar to'g'ri bajarilganligini kuzatadi: hammasi yoki hech narsa.

JTA – transaksiya – bu dastur darajasidagi transaksiya. U hech qanday ma'lumotlar bazasiga bog'lanmagan. Uning vazifasi ba'zi amallar bajarilganligini kuzatish: hammasi yoki hech narsa.

Masalan, bir nechta turli ma'lumotlar bazasida ma'lumotlarni bir JTA-transaksiya doirasida yozib qo'yishingiz mumkin. Agar xatolik yuz bersa, JTA-transaksiya barcha ma'lumotlar bazalarida o'zgarishlarni orqaga qaytarishi kerak. Hatto muayyan ma'lumotlar bazasi nuqtai nazaridan muvaffaqiyatli bajarilgan bo'lsa ham.

4.2 Hibernate Transactions Interface

Hibernate kutubxonasida transaksiya Transaction interfeysi bilan ifodalanadi, u turli xil realizatsiyalarga ega bo'lishi mumkin. Masalan, Spring bilan ishlaganda, Spring o'zining JTA-transaksiyalar mexanizmini taqdim etadi.

Bu interfeysning metodlari quyidagicha:

Аҳмиятли! Transaksiya ob'ektini yaratish va transaksiyani ishga tushirish – bu har xil narsalar. Bu yerda Thread sinfiga o'xshashlik keltirish mumkin. Sen ob'ekt Thread()ni yaratsang, yangi oqim hali JVM ni ishga tushirmaydi. Uni ishga tushirish uchun Thread ob'ektining start() metodini chaqirish kerak. Transaksiya bilan ham shunday – unga begin() metodini chaqirish kerak.

Hibernate transaksiyalari bilan odatda qanday ishlashini misol qilib ko'rsatamiz:

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();
}

Bu yerda biz uch narsani ko'ramiz:

Birinchidan, ma'lumotlar bazasi bilan ish butunlay transaksiyaga o'ralgan holda amalga oshirilmoqda, bu begin() va commit() metodlarini chaqirish orqali amalga oshiriladi. Bu ikki metodlar orasida amalga oshirilgan barcha amallar: yoki birgalikda bajarilishi kerak, yoki hech narsa.

Ikkinchidan, har qanday xatolik yuz berganida, biz transaksiyani ortga qaytarishga harakat qilamiz – rollback() metodini chaqirish orqali. Bu TransactionManger begin() va commit() o'rtasidagi barcha amallarni avvaliga yozib qo'yishi kerakligini va rollback() chaqirilganda hammasini orqaga qaytarishi kerakligini anglatadi.

Va qo'shimcha ravishda, rollback metodini chaqirganda ham xatolik yuz berishi mumkin. Xatoliklar har doim yuz beradi. Sen bu faktni qabul qilishing kerak va bunga tayyor bo'lishing kerak.

4.3 Transaction Manager

Transaksiyalar boshqaruvi nuqtai nazaridan qaraganda, Hibernate – bu shunchaki JDBC-ni osonlashtiruvchi ob'ektlarning qobig'i. O'zi Hibernate transaksiyalarning qayta ishlanishi funktsiyalariga ega emas. Hibernate Transaction aslida JDBC asosiy transaksiyasining (yoki JTA transaksiyalari qobig'i) qobig'i hisoblanadi. Odatiy holatda JDBCTransaction ishlatiladi. Hibernatening sozlash faylidan namunasi:

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

Keling, yana bir bor transaksiyalar bilan foydalanish kodimizga qaraylik:

Session session = sessionFactory.openSession();
Transaction transaction = session.getTransaction();
transaction.begin();
//bu yerda sizning baza bilan ishlash kodingiz
session.flush();
transaction.commit();
session.close();

Endi JDBCTransaction sinfining kodiga qaraylik:

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

Bu transaksiyani ishga tushirish metodidir. Endi esa jo'natish metodiga qaraylik:

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

Endi bu kodni Hibernate misolidagi kodga qo'llab ko'ramiz:

Session session = sessionFactory.openSession();
Transaction transaction = session.getTransaction();
transaction.begin();
//bu yerda sizning baza bilan ishlash kodingiz
session.flush();
transaction.commit();
session.close();

Connection conn = jdbcContext.connection();
conn.setAutoCommit(false);
 
//bu yerda sizning baza bilan ishlash kodingiz
conn.commit ()
conn.setAutoCommit(true);
conn.close();

Shunday qilib, Hibernate-ning o'ziga xos transaksiyalari – bu faqat JDBC-kodning bazaga chaqiruvlari. Ko'proq emas, kamroq ham emas. JTA transaksiyalari esa qiziqarliroq. Lekin bu haqda boshqa safar gaplashamiz.