Transaktioner
Commit och rollback.
Transaktioner är en gratis lektion i Java Academy på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Java Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Java Academy innehåller totalt 4 lektioner.
Vad är en transaktion
En transaktion grupperar flera SQL-operationer till en enda allt-eller-inget-enhet.
Antingen lyckas varje sats och ändringarna görs permanenta (commit), eller så misslyckas något och alla ändringar rullas tillbaka (rollback). Detta håller databasen konsistent.
ACID på en minut
Transaktioner ger följande ACID-garantier:
- Atomicitet — allt eller inget.
- Konsistens — flyttar databasen från ett giltigt tillstånd till ett annat.
- Isolering — samtidiga transaktioner korrumperar inte varandra.
- Beständighet — när ändringarna har committats överlever de en krasch.
Läget auto-commit
Som standard körs JDBC-anslutningar i läget auto-commit: varje sats är sin egen transaktion och genomförs omedelbart.
Det fungerar bra för enstaka satser, men är oanvändbart när flera skrivningar måste lyckas tillsammans. För att styra transaktionerna själv stängs auto-commit av.
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 och rollback
När auto-commit är avstängt bestämmer man själv gränserna:
conn.commit()gör alla väntande ändringar permanenta.conn.rollback()rullar tillbaka dem.
Det klassiska exemplet är en penningöverföring: ett konto debiteras och ett annat krediteras. Båda åtgärderna måste genomföras, eller ingen av dem.
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());
}
}
}Mönstret rollback vid fel
Strukturen som ska memoreras:
- Stäng av auto-commit.
- Utför arbetet i ett inre
try-block. - Anropa
commit()när allt lyckas. - Anropa
rollback()icatchoch kasta om undantaget eller logga det.
Utan rollback kan ett fel lämna databasen delvis uppdaterad.
Simulera atomicitet
Här modelleras allt-eller-inget-principen i vanlig Java så att koden kan köras fristående. Två uppdateringar tillämpas på en ögonblicksbild; om någon av dem misslyckas återställs ögonblicksbilden.
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]);
}
}
}Sparpunkter
En sparpunkt är en markör inuti en transaktion. Det går att rulla tillbaka till den utan att hela transaktionen förkastas.
Savepoint sp = conn.setSavepoint()conn.rollback(sp)återställer endast arbetet efter den punkten.
Användbart för partiell återställning i långa transaktioner.
Isoleringsnivåer
Isolering styr vad en transaktion ser av en annan transaktions ännu inte committade arbete. JDBC definierar nivåerna via conn.setTransactionIsolation(...):
TRANSACTION_READ_COMMITTED— den vanligaste standardnivån.TRANSACTION_REPEATABLE_READTRANSACTION_SERIALIZABLE— starkast och långsammast.
Högre isolering förhindrar anomalier men minskar samtidigheten.
Anomalier vid läsning
Lägre isolering kan tillåta följande:
- Dirty read — en annan transaktions ännu inte committade ändring visas.
- Non-repeatable read — en rad ändras mellan två läsningar.
- Phantom read — nya rader visas som matchar en tidigare fråga.
Välj den lägsta nivå som ändå förhindrar de anomalier som logiken inte kan tolerera.
Återställ auto-commit
Om anslutningen lånades från en pool ska dess ursprungliga tillstånd återställas innan den lämnas tillbaka.
Efter en manuell transaktion ska conn.setAutoCommit(true) ställas in igen (eller återställas till det värde som observerades när anslutningen lånades), så att nästa användare inte överraskas av inställningarna.
Håll transaktionerna korta
En transaktion håller lås tills den committas eller rullas tillbaka. Långa transaktioner blockerar annat arbete och ökar risken för dödlägen.
- Utför inte långsamma nätverksanrop och be inte om användarinmatning i en öppen transaktion.
- Samla först in data, öppna sedan transaktionen, skriv och committa snabbt.
Korta, fokuserade transaktioner skalar mycket bättre.
Snabb kontroll
Vilken effekt har det att anropa connection.rollback()?
Sammanfattning
Transaktioner ger säkerhet enligt allt-eller-inget-principen:
- Stäng av auto-commit med
setAutoCommit(false). - Anropa
commit()vid framgång ochrollback()vid fel. - Använd sparpunkter för partiell återställning.
- Justera isoleringsnivåer för att balansera korrekthet och samtidighet.
- Återställ auto-commit innan en poolad anslutning lämnas tillbaka.
Lär dig Java med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 104
- Lektioner
- 374
Vanliga frågor
Är lektionen ”Transaktioner” gratis?
Ja – hela texten till ”Transaktioner” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Java Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Java Academy innehåller totalt 4 lektioner.
Vad lär jag mig i ”Transaktioner”?
Commit och rollback. Ni övar på Java Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Java Academy?
Du behöver inga förkunskaper. Utbildningen i Java Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.
Hur lång tid tar lektionen ”Transaktioner”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Java Academy-lektionen?
Ja. Varje Java Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.