Pourquoi les transactions sont nécessaires
Très souvent, lorsque vous travaillez avec une base de données, une situation se présente lorsque vous devez effectuer de nombreuses actions différentes, mais elles n'ont de sens qu'ensemble.
Par exemple, nous écrivons un logiciel bancaire qui devrait faire trois choses :
- Retirer de l'argent du compte du client
- Ajouter de l'argent sur le compte du destinataire
- Enregistrer les données de détachement dans le "journal de détachement"
Si une erreur se produit lors de l'exécution de l'une de ces actions, les deux autres doivent également être annulées. Il est impossible de déduire de l'argent du client et de ne pas l'ajouter au destinataire ? Eh bien, ou ajouter au destinataire, mais ne pas radier du client ?
Ainsi, un tel regroupement logique de différentes actions en une seule s'appelle une transaction . En d'autres termes, 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.
Une transaction a généralement trois états :
- état initial - l'état du système avant l'exécution d'un groupe d'actions
- état de réussite - état une fois le groupe d'actions terminé
- état d'échec - quelque chose s'est mal passé
Dans ce cas, il y a généralement trois commandes :
- begin/start - exécuté avant le début du groupe logique d'actions
- commit - exécuté après le groupe d'actions de transaction
- rollback - démarre le processus de retour du système de l'état d'échec à l'état initial
Cela fonctionne comme ça.
Vous devez d'abord ouvrir une transaction - appelez la méthode begin() ou start() . L'appel de cette méthode indique l'état du système auquel nous essaierons de revenir en cas de problème.
Ensuite, toutes les actions sont effectuées, qui sont combinées dans un groupe logique - une transaction.
Ensuite, la méthode commit() est appelée . Son appel marque la fin d'un groupe logique d'actions et démarre généralement le processus de mise en pratique de ces actions.
Rappelez-vous comment nous avons écrit quelque chose dans FileWriter : d'abord, tout ce que nous avons écrit est stocké en mémoire, puis lorsque la méthode flush() est appelée , toutes les données du tampon en mémoire sont écrites sur le disque. Ce flush() est la validation de la transaction.
Eh bien, si une erreur s'est produite lors de l'exécution de la transaction, vous devez lancer le processus de retour à l'état de départ. Ce processus s'appelle rollback() , et la méthode du même nom en est généralement responsable.
Grosso modo, il y a 2 façons de conclure une transaction :
- COMMIT - nous confirmons toutes les modifications apportées
- ROLLBACK - annuler toutes les modifications apportées
Transactions dans JDBC
Presque tous les SGBD peuvent fonctionner avec des transactions. JDBC prend donc également en charge ce cas. Tout est mis en œuvre très simplement.
Tout d'abord, chaque appel à la méthode execute() de l'objet Statement est exécuté dans une transaction distincte. Pour ce faire, Connection dispose d'un paramètre AutoCommit . S'il est défini sur true , alors commit() sera appelé après chaque appel à la méthode execute() .
Deuxièmement, si vous souhaitez exécuter plusieurs commandes en une seule transaction, vous pouvez le faire comme ceci :
- désactiver AutoCommit
- appeler nos équipes
- appeler explicitement la méthode commit()
Ça a l'air très simple :
connection.setAutoCommit(false);
Statement statement = connection.createStatement();
int rowsCount1 = statement.executeUpdate("UPDATE employee SET salary = salary+1000");
int rowsCount2 = statement.executeUpdate("UPDATE employee SET salary = salary+1000");
int rowsCount3 = statement.executeUpdate("UPDATE employee SET salary = salary+1000");
connection.commit();Si une erreur se produit sur le serveur alors que la méthode commit() est en cours d'exécution , le serveur SQL annulera les trois actions.
Mais il y a des situations où l'erreur se produit toujours du côté client, et nous n'avons jamais eu l'appel de la méthode commit() :
connection.setAutoCommit(false);
Statement statement = connection.createStatement();
int rowsCount1 = statement.executeUpdate("UPDATE employee SET salary = salary+1000");
int rowsCount2 = statement.executeUpdate("UPDATE employee SET salary = salary+1000");
int rowsCount3 = statement.executeUpdate("UPDATE multiple typos will result in an exception");
connection.commit();Si une erreur se produit lors de l'exécution d'un executeUpdate() , alors la méthode commit() ne sera pas appelée. Pour annuler toutes les actions entreprises, vous devez appeler la méthode rollback() . Il ressemble généralement à ceci :
try{
connection.setAutoCommit(false);
Statement statement = connection.createStatement();
int rowsCount1 = statement.executeUpdate("UPDATE employee SET salary = salary+1000");
int rowsCount2 = statement.executeUpdate("UPDATE employee SET salary = salary+1000");
int rowsCount3 = statement.executeUpdate("UPDATE multiple typos will result in an exception");
connection.commit();
}
catch (Exception e) {
connection.rollback();
}Points de sauvegarde
Avec l'avènement de JDBC 3.0, il est devenu possible de travailler plus efficacement avec la restauration des transactions. Vous pouvez maintenant définir des points de sauvegarde - points de sauvegarde, et lorsque vous appelez l' opération rollback() , revenez à un point de sauvegarde spécifique.
Pour sauvegarder, il faut créer un point de sauvegarde, cela se fait avec la commande :
Savepoint save = connection.setSavepoint();Le retour à un point de sauvegarde se fait avec la commande :
connection.rollback(save);Essayons d'ajouter un point de sauvegarde avant notre commande problématique :
try{
connection.setAutoCommit(false);
Statement statement = connection.createStatement();
int rowsCount1 = statement.executeUpdate("UPDATE employee SET salary = salary+1000");
int rowsCount2 = statement.executeUpdate("UPDATE employee SET salary = salary+1000");
Savepoint save = connection.setSavepoint();
try{
int rowsCount3 = statement.executeUpdate("UPDATE multiple typos will result in an exception");
}
catch (Exception e) {
connection.rollback(save);
}
connection.commit();
}
catch (Exception e) {
connection.rollback();
}Nous avons organisé les transactions imbriquées en ajoutant un point de sauvegarde avant d'appeler la méthode problématique et en revenant à l'état enregistré en appelant la méthode rollback(save) .
Oui, c'est très similaire à sauvegarder/charger dans les jeux.