Tranzakciók

4.1 A tranzakciók bemutatása hibernált állapotban

A fentiekhez a tranzakciókkal kapcsolatos információkat szeretnék kiegészíteni. Mint már tudja, a tranzakció olyan műveletek csoportja, amelyeket csak együtt kell végrehajtani . Ha valamelyik művelet meghiúsult vagy hibásan hajtódott végre, akkor az összes többi műveletet törölni kell.

A Hibernate kétféle tranzakcióval képes dolgozni:

• JDBC
• JTA

A JDBC tranzakció valójában egy adatbázis-tranzakció. Az adatbázissal való munkához, a JDBC kapcsolathoz van kötve. És gondoskodik arról, hogy az adatbázissal végzett munka során a műveleteket úgy hajtsák végre, ahogy kell: vagy mindent, vagy semmit.

JTA – A tranzakció egy alkalmazás szintű tranzakció. Nincs semmilyen adatbázishoz kötve. Feladata bizonyos műveletek végrehajtásának biztosítása: vagy mindent, vagy semmit.

Például egyetlen JTA-tranzakción belül több különböző adatbázisba is írhat adatokat. Ha ezután hiba történik, akkor a JTA-tranzakciónak vissza kell vonnia a változtatásokat az összes adatbázisban. Még azok is, amelyeket sikeresen végrehajtottak egy adott adatbázis szempontjából.

4.2 Hibernált tranzakciós felület

A Hibernate könyvtárban egy tranzakciót a Tranzakció felület képvisel, amelynek különböző megvalósításai lehetnek. Például, amikor a Spring-szel dolgozik, a Spring saját JTA tranzakciós mechanizmust biztosít.

Ennek az interfésznek a módszerei a következők:

Fontos! Egy tranzakció objektum létrehozása és egy tranzakció elindítása két különböző dolog. Itt analógiát vonhatunk a Thread osztállyal. Thread() objektum létrehozásakor a JVM még nem indít új szálat. Az elindításához meg kell hívni a start() metódust a Thread objektumon. Ugyanez a helyzet egy tranzakcióval is – meg kell hívnia a begin() metódust.

Példa arra, hogy a tranzakciókat általában hogyan kezelik hibernált állapotban:

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

Három dolgot látunk itt:

Először is, az adatbázissal végzett minden munka egy tranzakcióba van csomagolva metódusok hívásával, begin()és commit()a két metódus hívásai között minden műveletet végre kell hajtani: vagy együtt, vagy semmit.

Másodszor, ha bármilyen hiba történik, megpróbáljuk visszaállítani a tranzakciót - hívja meg a rollback(). begin()Ez azt jelenti, hogy a TransactionMangernek először rögzítenie kell az összes és közötti műveletet commit(), majd mindent úgy kell visszaadnia, ahogyan hívtuk volna rollback().

És mellesleg nem tény, hogy a rollback metódus meghívásakor nem lesz hiba. Hibák mindig történnek. Csak el kell fogadnia ezt a tényt, és készen kell állnia rá.

4.3 Tranzakciókezelő

Tranzakciókezelési szempontból a Hibernate csak egy könnyű objektumcsomagoló a JDBC számára. Maga a hibernált állapot nem rendelkezik tranzakciófeldolgozási funkciókkal. A Hibernate Tranzakció valójában az alapul szolgáló JDBC-tranzakció (vagy JTA-tranzakció burkolója) burkolója. A JDBCTransaction az alapértelmezett. Példa a Hiberante beállítási fájlból:

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

Vessünk még egy pillantást a kódunkra a tranzakciók használatával:

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

Most nézzük meg a JDBCTransaction osztálykódot:

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

Ez a tranzakció indításának módja. Ezután nézze meg a küldési módot:

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

Most cseréljük be ezt a kódot a hibernált példakódba:

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

Tehát a natív hibernált tranzakciók csak natív JDBC-hívások az adatbázishoz. Se több, se kevesebb. De a JTA tranzakciók érdekesebbek. De erről majd máskor.