Transaktioner

4.1 Introduktion til transaktioner i Hibernate

Til alt ovenstående vil jeg gerne tilføje oplysninger om transaktioner. Som du allerede ved, er en transaktion en gruppe handlinger, der kun skal udføres samlet . Hvis en handling mislykkedes eller blev udført med en fejl, skal alle andre handlinger annulleres.

Hibernate kan arbejde med to typer transaktioner:

• JDBC
• JTA

En JDBC-transaktion er faktisk en databasetransaktion. Det er knyttet til at arbejde med databasen til JDBC-forbindelsen. Og han sørger for, at handlingerne, når man arbejder med databasen, bliver udført, som de skal: enten alt eller intet.

JTA - Transaktion er en transaktion på applikationsniveau. Det er ikke bundet til nogen database. Dens opgave er at sikre, at visse handlinger udføres: enten alt eller intet.

For eksempel kan du skrive data til flere forskellige databaser inden for en enkelt JTA-transaktion. Hvis der så opstår en fejl, bliver JTA-transaktionen nødt til at rulle ændringerne tilbage i alle databaser. Selv dem, der blev udført med succes i form af en bestemt database.

4.2 Dvale transaktionsgrænseflade

I Hibernate-biblioteket er en transaktion repræsenteret af Transaction-grænsefladen, som kan have forskellige implementeringer. For eksempel, når du arbejder med Spring, giver Spring sin egen JTA-transaktionsmekanisme.

Metoderne til denne grænseflade er:

Vigtig! At oprette et transaktionsobjekt og starte en transaktion er to forskellige ting. Her kan du tegne en analogi med Tråd-klassen. Når du opretter et Thread()-objekt, starter JVM'en ikke en ny tråd endnu. For at starte den skal du kalde start()-metoden på Thread-objektet. Det er det samme med en transaktion - den skal kalde start()-metoden.

Et eksempel på, hvordan transaktioner normalt håndteres i 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();
}

Vi ser tre ting her:

For det første er alt arbejde med databasen pakket ind i en transaktion ved at kalde metoder, begin()og commit()alle handlinger mellem opkald til disse to metoder skal udføres: enten alle sammen eller ingenting.

For det andet, hvis der opstår en fejl, forsøger vi at rulle transaktionen tilbage - ring til rollback(). Det betyder, at TransactionManger først skal registrere alle de handlinger, der var mellem begin()og commit(), og derefter returnere alt, som det var, hvis vi kaldte rollback().

Og i øvrigt er det ikke en kendsgerning, at der ikke vil være nogen fejl, når man kalder rollback-metoden. Der sker altid fejl. Du skal bare acceptere dette faktum og være klar til det.

4.3 Transaktionsleder

Fra et transaktionsstyringsperspektiv er Hibernate kun en letvægtsobjektindpakning til JDBC. Hibernate selv har ikke transaktionsbehandlingsfunktioner. Hibernate Transaction er faktisk en indpakning for den underliggende JDBC-transaktion (eller JTA-transaktionsindpakning). JDBCTransaction er standard. Eksempel fra Hiberante indstillingsfil:

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

Lad os tage et nyt kig på vores kode ved hjælp af transaktioner:

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

Lad os nu se på JDBCTransaction-klassekoden:

public class JDBCTransaction implements Transaction {

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

Dette er metoden til at starte en transaktion. Så se på sendemetoden:

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

Lad os nu erstatte denne kode i Hibernate-eksempelkoden:

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

Så native Hibernate-transaktioner er blot native JDBC-kald til databasen. Intet mere og intet mindre. Men JTA-transaktioner er mere interessante. Men mere om det en anden gang.