Transactions
Validation et annulation
Transactions est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.
Qu’est-ce qu’une transaction
Une transaction regroupe plusieurs opérations SQL en une seule unité indivisible.
Soit chaque instruction réussit et les modifications deviennent définitives (commit), soit quelque chose échoue et elles sont toutes annulées (rollback). La base de données reste ainsi cohérente.
ACID en une minute
Les transactions fournissent les garanties ACID :
- Atomicité — tout ou rien.
- Cohérence — fait passer la base de données d’un état valide à un autre.
- Isolation — les transactions concurrentes ne se corrompent pas mutuellement.
- Durabilité — une fois validées, les modifications survivent à une panne.
Mode de validation automatique
Par défaut, les connexions JDBC fonctionnent en mode de validation automatique : chaque instruction constitue sa propre transaction et est validée immédiatement.
Cela convient aux instructions uniques, mais ne sert à rien lorsque plusieurs écritures doivent réussir ensemble. Pour contrôler vous-même les transactions, désactivez la validation automatique.
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class Main {
public static void main(String[] args) {
String url = "jdbc:postgresql://localhost:5432/bank";
try (Connection conn = DriverManager.getConnection(url, "app", "secret")) {
System.out.println("Default auto-commit: " + conn.getAutoCommit());
conn.setAutoCommit(false);
System.out.println("Now manual: " + conn.getAutoCommit());
} catch (SQLException e) {
System.out.println(e.getMessage());
}
}
}Commit et rollback
Lorsque la validation automatique est désactivée, vous choisissez les limites :
conn.commit()rend définitives toutes les modifications en attente.conn.rollback()les annule.
L’exemple classique est un virement : débiter un compte et en créditer un autre. Les deux opérations doivent être effectuées, ou aucune des deux.
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class Main {
public static void main(String[] args) {
String url = "jdbc:postgresql://localhost:5432/bank";
String debit = "UPDATE account SET balance = balance - ? WHERE id = ?";
String credit = "UPDATE account SET balance = balance + ? WHERE id = ?";
try (Connection conn = DriverManager.getConnection(url, "app", "secret")) {
conn.setAutoCommit(false);
try (PreparedStatement d = conn.prepareStatement(debit);
PreparedStatement c = conn.prepareStatement(credit)) {
d.setInt(1, 100); d.setInt(2, 1); d.executeUpdate();
c.setInt(1, 100); c.setInt(2, 2); c.executeUpdate();
conn.commit();
System.out.println("Transfer committed");
} catch (SQLException ex) {
conn.rollback();
System.out.println("Rolled back: " + ex.getMessage());
}
} catch (SQLException e) {
System.out.println(e.getMessage());
}
}
}Schéma d’annulation en cas d’échec
Voici la structure à retenir :
- Désactivez la validation automatique.
- Effectuez le travail dans un
tryinterne. - En cas de réussite, appelez
commit(). - Dans
catch, appelezrollback(), puis relancez l’exception ou consignez-la.
Sans l’annulation, un échec pourrait laisser la base de données partiellement mise à jour.
Simuler l’atomicité
Voici l’idée du tout ou rien, modélisée en Java simple afin de pouvoir l’exécuter de manière autonome. Nous appliquons deux mises à jour à un instantané ; si l’une ou l’autre échoue, nous restaurons l’instantané.
public class Main {
public static void main(String[] args) {
int[] balances = {500, 300};
int[] backup = balances.clone();
try {
balances[0] -= 200;
if (balances[0] < 0) throw new IllegalStateException("insufficient funds");
balances[1] += 200;
System.out.println("Commit: " + balances[0] + ", " + balances[1]);
} catch (RuntimeException e) {
balances = backup;
System.out.println("Rollback: " + balances[0] + ", " + balances[1]);
}
}
}Points de sauvegarde
Un point de sauvegarde est un marqueur placé dans une transaction. Vous pouvez effectuer une annulation jusqu’à ce point sans supprimer toute la transaction.
Savepoint sp = conn.setSavepoint()conn.rollback(sp)annule uniquement le travail effectué après ce point.
C’est utile pour permettre une récupération partielle dans les transactions longues.
Niveaux d’isolation
L’isolation contrôle ce qu’une transaction voit du travail non validé d’une autre. JDBC définit les niveaux avec conn.setTransactionIsolation(...) :
TRANSACTION_READ_COMMITTED— la valeur par défaut courante.TRANSACTION_REPEATABLE_READTRANSACTION_SERIALIZABLE— le plus strict et le plus lent.
Une isolation plus forte empêche les anomalies, mais réduit la concurrence.
Anomalies de lecture
Une isolation plus faible peut autoriser :
- Lecture sale — voir une modification non validée d’une autre transaction.
- Lecture non répétable — une ligne change entre deux lectures.
- Lecture fantôme — de nouvelles lignes correspondant à une requête précédente apparaissent.
Choisissez le niveau le plus faible qui empêche encore les anomalies que votre logique ne peut pas tolérer.
Rétablir la validation automatique
Si vous avez emprunté la connexion à un réservoir, rétablissez son état initial avant de la rendre.
Après une transaction manuelle, réactivez la validation automatique avec conn.setAutoCommit(true) (ou rétablissez la valeur observée lors de l’emprunt), afin que l’utilisateur suivant ne soit pas surpris par vos réglages.
Gardez les transactions courtes
Une transaction conserve les verrous jusqu’à sa validation ou son annulation. Les transactions longues bloquent les autres opérations et augmentent le risque d’interblocage.
- N’effectuez pas d’appels réseau lents et ne sollicitez pas l’utilisateur dans une transaction ouverte.
- Rassemblez d’abord vos données, puis ouvrez la transaction, écrivez et validez rapidement.
Les transactions courtes et ciblées évoluent beaucoup mieux.
Vérification rapide
Quel est l’effet de l’appel à connection.rollback() ?
Récapitulatif
Les transactions vous offrent une sécurité fondée sur le tout ou rien :
- Désactivez la validation automatique avec
setAutoCommit(false). - Appelez
commit()en cas de réussite etrollback()en cas d’échec. - Utilisez des points de sauvegarde pour les annulations partielles.
- Ajustez les niveaux d’isolation pour équilibrer exactitude et concurrence.
- Rétablissez la validation automatique avant de rendre une connexion issue d’un réservoir.
Questions Fréquemment Posées
La leçon « Transactions » est-elle gratuite ?
Oui — le texte complet de « Transactions » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Transactions » ?
Validation et annulation Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Java Academy ?
Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.
Combien de temps prend la leçon « Transactions » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?
Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.