Transacties
Commit en rollback
Transacties is een gratis Java Academy-les op CoddyKit. Dit is les 3 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Java Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Java Academy bevat in totaal 4 lessen.
Wat is een transactie?
Een transactie groepeert meerdere SQL-bewerkingen in één alles-of-niets-eenheid.
Of elke instructie slaagt en de wijzigingen definitief worden gemaakt (vastlegging), of er gaat iets mis en ze worden allemaal ongedaan gemaakt (terugdraaiing). Zo blijft de database consistent.
ACID in één minuut
Transacties bieden de ACID-garanties:
- Atomiciteit — alles of niets.
- Consistentie — verplaatst de database van de ene geldige toestand naar een andere.
- Isolatie — gelijktijdige transacties maken elkaar niet ongeldig.
- Duurzaamheid — eenmaal vastgelegd blijven wijzigingen na een crash behouden.
Modus voor automatisch vastleggen
JDBC-verbindingen werken standaard in de modus voor automatisch vastleggen: elke instructie is een eigen transactie die meteen wordt vastgelegd.
Dat is prima voor losse instructies, maar nutteloos wanneer meerdere schrijfbewerkingen samen moeten slagen. Zet automatisch vastleggen uit als je transacties zelf wilt beheren.
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());
}
}
}Vastleggen en terugdraaien
Als automatisch vastleggen uitstaat, bepaal je zelf de grenzen:
conn.commit()maakt alle openstaande wijzigingen definitief.conn.rollback()maakt ze ongedaan.
Het klassieke voorbeeld is een geldoverschrijving: trek geld af van de ene rekening en tel het bij de andere op. Beide bewerkingen moeten plaatsvinden, of geen van beide.
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());
}
}
}Patroon voor terugdraaien bij fouten
De structuur om te onthouden:
- Schakel automatisch vastleggen uit.
- Voer het werk uit in een binnenste
try-blok. - Roep bij succes
commit()aan. - Roep in
catchrollback()aan en gooi de fout opnieuw of registreer die in het logboek.
Zonder het terugdraaien kan een fout de database half bijgewerkt achterlaten.
Atomiciteit simuleren
Hier zie je het alles-of-nietsprincipe in gewone Java, zodat het zelfstandig kan worden uitgevoerd. We passen twee wijzigingen toe op een momentopname; als er één mislukt, zetten we de momentopname terug.
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]);
}
}
}Herstelpunten
Een herstelpunt is een markering binnen een transactie. Je kunt terugdraaien naar dat punt zonder de hele transactie weg te gooien.
Savepoint sp = conn.setSavepoint()conn.rollback(sp)maakt alleen werk na dat punt ongedaan.
Handig voor gedeeltelijk herstel in lange transacties.
Isolatieniveaus
Isolatie bepaalt wat de ene transactie ziet van het niet-vastgelegde werk van een andere. JDBC definieert niveaus via conn.setTransactionIsolation(...):
TRANSACTION_READ_COMMITTED— de gebruikelijke standaard.TRANSACTION_REPEATABLE_READTRANSACTION_SERIALIZABLE— het sterkst, maar ook het langzaamst.
Hogere isolatie voorkomt afwijkingen, maar vermindert de gelijktijdigheid.
Leesafwijkingen
Een lager isolatieniveau kan het volgende toestaan:
- Vuile lezing — de niet-vastgelegde wijziging van een andere transactie zien.
- Niet-herhaalbare lezing — een rij verandert tussen twee lezingen.
- Fantoomlezing — er verschijnen nieuwe rijen die overeenkomen met een eerdere query.
Kies het laagste niveau dat de afwijkingen voorkomt die je logica niet kan verdragen.
Automatisch vastleggen herstellen
Als je de verbinding uit een pool hebt geleend, zet je de oorspronkelijke toestand terug voordat je haar teruggeeft.
Na een handmatige transactie zet je conn.setAutoCommit(true) weer aan (of zet je de waarde terug die je bij het lenen zag), zodat de volgende gebruiker niet wordt verrast door je instellingen.
Houd transacties kort
Een transactie houdt vergrendelingen vast totdat ze wordt vastgelegd of teruggedraaid. Lange transacties blokkeren ander werk en vergroten het risico op deadlocks.
- Voer geen trage netwerkaanroepen uit en toon geen vragen aan de gebruiker binnen een geopende transactie.
- Verzamel je gegevens eerst, open daarna de transactie, schrijf en leg snel vast.
Korte, gerichte transacties schalen veel beter.
Korte controle
Wat is het effect van het aanroepen van connection.rollback()?
Samenvatting
Transacties geven je veiligheid volgens het alles-of-nietsprincipe:
- Schakel automatisch vastleggen uit met
setAutoCommit(false). commit()bij succes,rollback()bij fouten.- Gebruik herstelpunten voor gedeeltelijk terugdraaien.
- Stem isolatieniveaus af om juistheid en gelijktijdigheid in balans te houden.
- Herstel automatisch vastleggen voordat je een verbinding uit een pool teruggeeft.
Leer Java met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 104
- Lessen
- 374
Veelgestelde vragen
Is de les “Transacties” gratis?
Ja — de volledige tekst van “Transacties” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Java Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Java Academy bevat in totaal 4 lessen.
Wat leer ik in “Transacties”?
Commit en rollback Je oefent met Java Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Java Academy te beginnen?
Ervaring vooraf is niet nodig. Java Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.
Hoe lang duurt de les “Transacties”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Java Academy?
Ja. Elke les over Java Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.