4.1 Pambuka kanggo transaksi ing Hibernate
Kanggo kabeh sing kasebut ing ndhuwur, aku pengin nambah informasi babagan transaksi. Kaya sing wis dingerteni, transaksi minangka klompok tumindak sing mung kudu ditindakake bebarengan . Yen tumindak gagal utawa ditindakake kanthi kesalahan, kabeh tumindak liyane kudu dibatalake.
Hibernate bisa nggarap rong jinis transaksi:
- JDBC
- JTA
Transaksi JDBC sejatine minangka transaksi database. Iku disambungake kanggo nggarap database, kanggo sambungan JDBC. Lan dheweke nggawe manawa tumindak nalika nggarap database ditindakake kaya sing dikarepake: kabeh utawa ora ana.
JTA - Transaksi minangka transaksi tingkat aplikasi. Iku ora disambungake menyang database sembarang. Tugase kanggo mesthekake yen tumindak tartamtu ditindakake: kabeh utawa ora ana.
Contone, sampeyan bisa nulis data menyang sawetara database beda ing siji transaksi JTA. Banjur yen ana kesalahan, transaksi JTA kudu mbalekake owah-owahan ing kabeh database. Malah sing dieksekusi kanthi sukses ing babagan basis data tartamtu.
4.2 Antarmuka Transaksi Hibernate
Ing perpustakaan Hibernate, transaksi diwakili dening antarmuka Transaksi, sing bisa duwe implementasine beda. Contone, nalika nggarap Spring, Spring nyedhiyakake mekanisme transaksi JTA dhewe.
Cara antarmuka iki yaiku:
# | Metode | Katrangan |
---|---|---|
1 | wiwit () | Miwiti transaksi anyar |
2 | komitmen() | Mungkasi transaksi, push / nindakake kabeh owah-owahan |
3 | muter balik() | Muter maneh transaksi saiki |
4 | setTimeout (int detik) | Nyetel wektu eksekusi transaksi maksimal |
5 | isActive() | Priksa yen transaksi aktif utawa ora |
6 | wasRolledBack() | Priksa yen transaksi mbalek maneh kanthi normal |
7 | wasCommitted() | Priksa yen transaksi wis ditindakake kanthi normal |
8 | registerSinkronisasi() | Ndhaptar callback kanggo ngontrol transaksi |
Penting! Nggawe obyek transaksi lan miwiti transaksi iku rong perkara sing beda. Ing kene sampeyan bisa nggambar analogi karo kelas Utas. Nalika sampeyan nggawe obyek Utas (), JVM durung miwiti thread anyar. Kanggo miwiti, sampeyan kudu nelpon cara wiwitan () ing obyek Utas. Iku padha karo transaksi - iku perlu kanggo nelpon wiwitan () cara.
Conto carane transaksi biasane ditangani ing 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();
}
Kita ndeleng telung perkara ing kene:
Kaping pisanan, kabeh karya karo database wis kebungkus ing transaksi kanthi cara nelpon begin()
lan commit()
Kabeh tumindak antarane telpon kanggo rong cara iki kudu dileksanakake: salah siji kabeh bebarengan, utawa ora ana.
Kapindho, yen ana kesalahan, kita nyoba mbatalake transaksi kasebut - nelpon rollback()
. Iki tegese TransactionManger kudu ngrekam kabeh tumindak sing ana ing antarane begin()
lan commit()
, banjur bali kabeh kaya yen kita disebut rollback()
.
Lan kanthi cara iki, dudu kasunyatan manawa ora ana kesalahan nalika nelpon metode rollback. Kesalahan tansah kelakon. Sampeyan mung kudu nampa kasunyatan iki lan siyap.
4.3 Manajer transaksi
Saka perspektif manajemen transaksi, Hibernate mung minangka bungkus obyek sing entheng kanggo JDBC. Hibernate dhewe ora duwe fitur pangolahan transaksi. Transaksi Hibernate sejatine minangka bungkus kanggo transaksi JDBC sing ndasari (utawa bungkus transaksi JTA). JDBCTransaction minangka standar. Conto saka file setelan Hiberante:
hibernate.transaction.factory_class org.hibernate.transaction.JTATransactionFactory
hibernate.transaction.factory_class org.hibernate.transaction.JDBCTransactionFactory
Ayo deleng maneh kode kita nggunakake 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();
Saiki ayo goleki kode kelas JDBCTransaction:
public class JDBCTransaction implements Transaction {
public void begin() throws HibernateException {
...
if (toggleAutoCommit) jdbcContext.connection().setAutoCommit(false);
...
}
}
Iki minangka cara kanggo miwiti transaksi. Banjur deleng cara ngirim:
public void commit() throws HibernateException {
...
jdbcContext.connection().commit();
...
jdbcContext.connection().setAutoCommit( true );
...
}
Saiki ayo ngganti kode iki menyang kode conto Hibernate:
Hibernate | Kode JDBC prasaja |
---|---|
|
|
Dadi transaksi Hibernate asli mung panggilan JDBC asli menyang database. Ora luwih lan ora kurang. Nanging transaksi JTA luwih menarik. Nanging liyane babagan liyane wektu.
GO TO FULL VERSION