Transaksi

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:

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:

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

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.