Transazioni
Commit e rollback
Transazioni è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.
Che cos'è una transazione
Una transazione raggruppa diverse operazioni SQL in un'unica unità che viene eseguita interamente oppure annullata.
O tutte le istruzioni vengono completate correttamente e le modifiche diventano permanenti (commit), oppure si verifica un errore e vengono annullate tutte (rollback). In questo modo il database rimane coerente.
ACID in un minuto
Le transazioni offrono le garanzie ACID:
- Atomicità — tutto oppure niente.
- Coerenza — porta il DB da uno stato valido a un altro.
- Isolamento — le transazioni concorrenti non si danneggiano a vicenda.
- Durabilità — dopo il commit, le modifiche sopravvivono a un arresto anomalo.
Modalità di auto-commit
Per impostazione predefinita, le connessioni JDBC funzionano in modalità auto-commit: ogni istruzione costituisce una transazione separata, sottoposta immediatamente a commit.
Questo va bene per le singole istruzioni, ma non serve quando diverse scritture devono riuscire insieme. Per gestire personalmente le transazioni, disattivi l'auto-commit.
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 e rollback
Con l'auto-commit disattivato, decide Lei i limiti della transazione:
conn.commit()rende permanenti tutte le modifiche in sospeso.conn.rollback()le annulla.
L'esempio classico è un trasferimento di denaro: addebitare un conto e accreditare un altro. Devono riuscire entrambe le operazioni, oppure nessuna delle due.
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());
}
}
}Pattern di rollback in caso di errore
Questa è la struttura da memorizzare:
- Disattivi l'auto-commit.
- Esegua il lavoro all'interno di un
tryinterno. - In caso di successo, chiami
commit(). - Nel blocco
catch, chiamirollback()e rilanci l'eccezione oppure registri l'errore.
Senza il rollback, un errore potrebbe lasciare il database aggiornato solo parzialmente.
Simulare l'atomicità
Ecco l'idea del tutto-o-niente, modellata in semplice Java per poter essere eseguita in autonomia. Applichiamo due aggiornamenti a un'istantanea; se uno dei due fallisce, ripristiniamo l'istantanea.
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]);
}
}
}Savepoint
Un savepoint è un marcatore all'interno di una transazione. È possibile eseguire il rollback fino a quel punto senza annullare l'intera transazione.
Savepoint sp = conn.setSavepoint()conn.rollback(sp)annulla solo il lavoro eseguito dopo quel punto.
È utile per il ripristino parziale nelle transazioni lunghe.
Livelli di isolamento
L'isolamento controlla ciò che una transazione vede del lavoro non ancora sottoposto a commit di un'altra. JDBC definisce i livelli tramite conn.setTransactionIsolation(...):
TRANSACTION_READ_COMMITTED— l'impostazione predefinita più comune.TRANSACTION_REPEATABLE_READTRANSACTION_SERIALIZABLE— il più forte e il più lento.
Un isolamento maggiore previene le anomalie, ma riduce la concorrenza.
Anomalie di lettura
Un livello di isolamento più basso può consentire:
- Letture sporche — visualizzare una modifica non ancora sottoposta a commit da parte di un'altra transazione.
- Letture non ripetibili — una riga cambia tra due letture.
- Letture fantasma — compaiono nuove righe che corrispondono a una query precedente.
Scelga il livello più basso che impedisca comunque le anomalie che la logica dell'applicazione non può tollerare.
Ripristinare l'auto-commit
Se ha preso la connessione da un pool, ne ripristini lo stato originale prima di restituirla.
Dopo una transazione manuale, imposti nuovamente conn.setAutoCommit(true) (oppure ripristini il valore rilevato al momento del prelievo), così l'utente successivo non si troverà di fronte a impostazioni inattese.
Mantenga brevi le transazioni
Una transazione mantiene i lock fino al commit o al rollback. Le transazioni lunghe bloccano altro lavoro e aumentano il rischio di deadlock.
- Non esegua chiamate di rete lente né richieda l'intervento dell'utente all'interno di una transazione aperta.
- Raccolga prima i dati, quindi apra la transazione, scriva e faccia rapidamente il commit.
Le transazioni brevi e mirate scalano molto meglio.
Verifica rapida
Qual è l'effetto della chiamata connection.rollback()?
Riepilogo
Le transazioni garantiscono la sicurezza del tutto-o-niente:
- Disattivi l'auto-commit con
setAutoCommit(false). - Chiami
commit()in caso di successo erollback()in caso di errore. - Utilizzi i savepoint per eseguire rollback parziali.
- Regoli i livelli di isolamento per bilanciare correttezza e concorrenza.
- Ripristini l'auto-commit prima di restituire una connessione al pool.
Domande Frequenti
La lezione «Transazioni» è gratuita?
Sì — il testo completo di «Transazioni» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.
Cosa imparerò in «Transazioni»?
Commit e rollback Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Java Academy?
Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.
Quanto tempo richiede la lezione «Transazioni»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Java Academy?
Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.