Transaksi

4.1 Pengantar transaksi di Hibernate

Untuk semua hal di atas, saya ingin menambahkan informasi tentang transaksi. Seperti yang sudah Anda ketahui, transaksi adalah sekumpulan tindakan yang harus dilakukan secara bersamaan . Jika ada tindakan yang gagal atau dijalankan dengan kesalahan, maka semua tindakan lainnya harus dibatalkan.

Hibernate dapat bekerja dengan dua jenis transaksi:

• JDBC
• JTA

Transaksi JDBC sebenarnya adalah transaksi basis data. Ini terkait dengan bekerja dengan database, ke koneksi JDBC. Dan dia memastikan bahwa tindakan saat bekerja dengan database dilakukan sebagaimana mestinya: semua atau tidak sama sekali.

JTA - Transaksi adalah transaksi tingkat aplikasi. Itu tidak terikat dengan basis data apa pun. Tugasnya adalah memastikan bahwa tindakan tertentu dilakukan: semua atau tidak sama sekali.

Misalnya, Anda dapat menulis data ke beberapa database berbeda dalam satu transaksi JTA. Kemudian jika terjadi kesalahan, maka transaksi JTA harus mengembalikan perubahan di semua database. Bahkan yang berhasil dieksekusi dalam hal database tertentu.

4.2 Antarmuka Transaksi Hibernasi

Di perpustakaan Hibernate, sebuah transaksi diwakili oleh antarmuka Transaksi, yang dapat memiliki implementasi yang berbeda. Misalnya, saat bekerja dengan Spring, Spring menyediakan mekanisme transaksi JTA-nya sendiri.

Metode antarmuka ini adalah:

Penting! Membuat objek transaksi dan memulai transaksi adalah dua hal yang berbeda. Di sini Anda bisa menggambar analogi dengan kelas Thread. Saat Anda membuat objek Thread() , JVM belum memulai utas baru. Untuk memulainya, Anda perlu memanggil metode start() pada objek Thread. Ini sama dengan transaksi - perlu memanggil metode begin() .

Contoh bagaimana transaksi biasanya ditangani di Hibernate:

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

Kami melihat tiga hal di sini:

Pertama, semua pekerjaan dengan database dibungkus dalam transaksi dengan metode pemanggilan begin()dan commit()Semua tindakan antara panggilan ke kedua metode ini harus dilakukan: semuanya bersama-sama, atau tidak sama sekali.

Kedua, jika terjadi kesalahan, kami mencoba mengembalikan transaksi - panggil file rollback(). Ini berarti bahwa TransactionManger pertama-tama harus mencatat semua tindakan yang berada di antara begin()dan commit(), lalu mengembalikan semuanya seperti semula jika kita memanggil rollback().

Dan omong-omong, bukan fakta bahwa tidak akan ada kesalahan saat memanggil metode rollback. Kesalahan selalu terjadi. Anda hanya perlu menerima fakta ini dan bersiap untuk itu.

4.3 Manajer transaksi

Dari perspektif manajemen transaksi, Hibernate hanyalah pembungkus objek yang ringan untuk JDBC. Hibernate sendiri tidak memiliki fitur pemrosesan transaksi. Transaksi Hibernasi sebenarnya adalah pembungkus untuk transaksi JDBC yang mendasarinya (atau pembungkus transaksi JTA). JDBCTransaction adalah defaultnya. Contoh dari file pengaturan Hiberante:

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

Mari kita lihat lagi kode kita menggunakan transaksi:

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

Sekarang mari kita lihat kode kelas JDBCTransaction:

public class JDBCTransaction implements Transaction {

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

Ini adalah metode untuk memulai transaksi. Kemudian lihat metode kirim:

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

Sekarang mari kita gantikan kode ini ke dalam kode contoh Hibernasi:

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

Jadi transaksi Hibernasi asli hanyalah panggilan JDBC asli ke database. Tidak lebih dan tidak kurang. Tapi transaksi JTA lebih menarik. Tetapi lebih banyak tentang itu lain kali.