Transactions

4.1 Introduction aux transactions dans Hibernate

À tout ce qui précède, je voudrais ajouter des informations sur les transactions. Comme vous le savez déjà, une transaction est un ensemble d'actions qui ne doivent être effectuées que toutes ensemble . Si une action a échoué ou a été exécutée avec une erreur, toutes les autres actions doivent être annulées.

Hibernate est capable de travailler avec deux types de transactions :

• JDBCName
• JTA

Une transaction JDBC est en fait une transaction de base de données. Il est lié au travail avec la base de données, à la connexion JDBC. Et il s'assure que les actions lors de l'utilisation de la base de données sont effectuées comme il se doit : soit tout, soit rien.

JTA - Transaction est une transaction au niveau de l'application. Il n'est lié à aucune base de données. Sa tâche est de s'assurer que certaines actions sont effectuées : tout ou rien.

Par exemple, vous pouvez écrire des données dans plusieurs bases de données différentes au sein d'une même transaction JTA. Ensuite, si une erreur se produit, la transaction JTA devra annuler les modifications dans toutes les bases de données. Même ceux qui ont été exécutés avec succès en termes d'une base de données particulière.

4.2 Interface des transactions d'hibernation

Dans la bibliothèque Hibernate, une transaction est représentée par l'interface Transaction, qui peut avoir différentes implémentations. Par exemple, lorsque vous travaillez avec Spring, Spring fournit son propre mécanisme de transaction JTA.

Les méthodes de cette interface sont :

Important! La création d'un objet de transaction et le démarrage d'une transaction sont deux choses différentes. Ici, vous pouvez faire une analogie avec la classe Thread. Lorsque vous créez un objet Thread(), la JVM ne démarre pas encore de nouveau thread. Pour le démarrer, vous devez appeler la méthode start() sur l'objet Thread. C'est la même chose avec une transaction - elle doit appeler la méthode begin().

Un exemple de la façon dont les transactions sont généralement gérées dans 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();
}

Nous voyons ici trois choses :

Tout d'abord, tout le travail avec la base de données est enveloppé dans une transaction en appelant des méthodes begin()et commit()Toutes les actions entre les appels à ces deux méthodes doivent être effectuées : soit toutes ensemble, soit rien.

Deuxièmement, si une erreur se produit, nous essayons d'annuler la transaction - appelez le rollback(). Cela signifie que TransactionManger doit d'abord enregistrer toutes les actions qui se trouvaient entre begin()et commit(), puis retourner tout tel qu'il était si nous avions appelé rollback().

Et au fait, ce n'est pas un fait qu'il n'y aura pas d'erreur lors de l'appel de la méthode rollback. Les erreurs arrivent toujours. Vous avez juste besoin d'accepter ce fait et d'être prêt pour cela.

4.3 Gestionnaire de transactions

Du point de vue de la gestion des transactions, Hibernate n'est qu'un wrapper d'objet léger pour JDBC. Hibernate lui-même n'a pas de fonctionnalités de traitement des transactions. Hibernate Transaction est en fait un wrapper pour la transaction JDBC sous-jacente (ou wrapper de transaction JTA). JDBCTransaction est la valeur par défaut. Exemple du fichier de paramètres Hiberante :

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

Reprenons notre code utilisant les transactions :

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

Examinons maintenant le code de la classe JDBCTransaction :

public class JDBCTransaction implements Transaction {

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

C'est la méthode pour démarrer une transaction. Ensuite, regardez la méthode send :

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

Remplaçons maintenant ce code dans l'exemple de code 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();

Ainsi, les transactions Hibernate natives ne sont que des appels JDBC natifs à la base de données. Rien de plus et rien de moins. Mais les transactions JTA sont plus intéressantes. Mais plus à ce sujet une autre fois.