Mga transaksyon

4.1 Panimula sa mga transaksyon sa Hibernate

Sa lahat ng nasa itaas, gusto kong magdagdag ng impormasyon tungkol sa mga transaksyon. Tulad ng alam mo na, ang isang transaksyon ay isang pangkat ng mga aksyon na dapat gawin nang magkasama . Kung ang anumang pagkilos ay nabigo o naisakatuparan nang may error, dapat na kanselahin ang lahat ng iba pang pagkilos.

Ang hibernate ay maaaring gumana sa dalawang uri ng mga transaksyon:

• JDBC
• JTA

Ang isang transaksyon sa JDBC ay talagang isang transaksyon sa database. Ito ay nakatali sa pagtatrabaho sa database, sa koneksyon ng JDBC. At tinitiyak niya na ang mga aksyon kapag nagtatrabaho sa database ay ginagawa ayon sa nararapat: alinman sa lahat o wala.

JTA - Ang transaksyon ay isang transaksyon sa antas ng aplikasyon. Hindi ito nakatali sa anumang database. Ang gawain nito ay upang matiyak na ang ilang mga aksyon ay isinasagawa: alinman sa lahat o wala.

Halimbawa, maaari kang magsulat ng data sa maraming iba't ibang mga database sa loob ng isang transaksyon sa JTA. Pagkatapos kung may nangyaring error, ang transaksyon ng JTA ay kailangang ibalik ang mga pagbabago sa lahat ng database. Kahit na ang mga matagumpay na naisakatuparan sa mga tuntunin ng isang partikular na database.

4.2 Interface ng Mga Transaksyon sa Hibernate

Sa Hibernate library, ang isang transaksyon ay kinakatawan ng Transaction interface, na maaaring magkaroon ng iba't ibang pagpapatupad. Halimbawa, kapag nagtatrabaho sa Spring, nagbibigay ang Spring ng sarili nitong mekanismo ng transaksyon sa JTA.

Ang mga pamamaraan ng interface na ito ay:

Mahalaga! Ang paglikha ng object ng transaksyon at pagsisimula ng transaksyon ay dalawang magkaibang bagay. Dito maaari kang gumuhit ng isang pagkakatulad sa klase ng Thread. Kapag gumawa ka ng Thread() object, hindi pa magsisimula ng bagong thread ang JVM. Upang simulan ito, kailangan mong tawagan ang start() na paraan sa Thread object. Ito ay pareho sa isang transaksyon - kailangan nitong tawagan ang begin() na paraan.

Isang halimbawa kung paano karaniwang pinangangasiwaan ang mga transaksyon sa 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();
}

Nakikita natin ang tatlong bagay dito:

Una, ang lahat ng trabaho sa database ay nakabalot sa isang transaksyon sa pamamagitan ng mga pamamaraan ng pagtawag begin()at commit()Lahat ng mga aksyon sa pagitan ng mga tawag sa dalawang pamamaraang ito ay dapat na maisagawa: alinman sa magkakasama, o wala.

Pangalawa, kung may nangyaring error, susubukan naming i-rollback ang transaksyon - tawagan ang rollback(). Nangangahulugan ito na dapat munang itala ng TransactionManger ang lahat ng mga aksyon na nasa pagitan begin()ng at commit(), at pagkatapos ay ibalik ang lahat tulad ng kung tayo ay tumawag rollback().

At sa pamamagitan ng paraan, ito ay hindi isang katotohanan na walang magiging error kapag tumatawag sa paraan ng rollback. Ang mga pagkakamali ay laging nangyayari. Kailangan mo lang tanggapin ang katotohanang ito at maging handa para dito.

4.3 Tagapamahala ng transaksyon

Mula sa isang pananaw sa pamamahala ng transaksyon, ang Hibernate ay isang magaan na bagay na wrapper para sa JDBC. Ang hibernate mismo ay walang mga feature sa pagpoproseso ng transaksyon. Ang Hibernate Transaction ay talagang isang wrapper para sa pinagbabatayan na transaksyon ng JDBC (o JTA transaction wrapper). Ang JDBCTransaction ay ang default. Halimbawa mula sa file ng mga setting ng Hiberante:

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

Tingnan natin muli ang aming code gamit ang mga transaksyon:

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

Ngayon tingnan natin ang JDBCTransaction class code:

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

Ito ang paraan para magsimula ng transaksyon. Pagkatapos ay tingnan ang paraan ng pagpapadala:

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

Ngayon ay palitan natin ang code na ito sa halimbawang code ng 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();

Kaya ang mga native na transaksyon sa Hibernate ay mga native na tawag sa JDBC sa database. Walang hihigit at walang kulang. Ngunit ang mga transaksyon sa JTA ay mas kawili-wili. Ngunit higit pa tungkol doon sa ibang pagkakataon.