In der Klausur müsst ihr JDBC-Code nicht nur lesen und kommentieren, sondern auch selbst SCHREIBEN und AENDERN. Bonusaufgaben: Syntaxfehler korrigieren, Java-Programme umschreiben. Über die Muster unten sollen tippfertig sitzen.
Class.forName(org.postgresql.Driver) lädt die Treiberklasse und registriert sie beim DriverManager. Danach liefert DriverManager.getConnection(url, user, pw) eine Connection. Die URL hat die Form jdbc:<dbms>://host:port/db. Seit JDBC 4 werden Treiber via ServiceLoader oft automatisch geladen - Class.forName wird aber in Lehrbeispielen weiter gezeigt.
Repräsentiert die aktive Verbindung zur Datenbank. Über die Connection werden Statements erstellt und Transaktionen gesteuert (setAutoCommit, commit, rollback). Nach Gebrauch muss sie geschlossen werden - am besten via try-with-resources. Eine Connection kapselt einen Netzwerk-Socket zum DBMS.
Statement für statische SQL-Strings ohne Parameter (SQL Injection Gefahr bei Konkatenation, keine Wiederverwendung). PreparedStatement für parametrisierte Abfragen mit Platzhaltern ?, vorkompiliert, sicher gegen SQL Injection, ideal bei wiederholten Aufrufen. CallableStatement für Stored Procedure Calls mit Syntax {CALL name(?)}.
Datenkontainer / Cursor für SELECT-Ergebnisse. Startet VOR der ersten Zeile. rs.next() bewegt Cursor eine Zeile weiter und liefert boolean. Zugriff auf Werte via getInt(spalte), getString(spalte) - entweder per Spaltenname oder 1-basiertem Index. Standardmäßig Forward-Only und Read-Only.
Standard: autoCommit=true (jedes Statement eigene Transaktion). Für atomare Multi-Statement-Operationen setAutoCommit(false) aufrufen. Bei Erfolg conn.commit(), bei Fehler conn.rollback() im catch-Block. Am Ende autoCommit wieder auf true zurücksetzen. Ohne diese Steuerung sind zusammengehörige Änderungen NICHT atomar.
Fast alle JDBC-Methoden werfen SQLException (checked exception). Muss per try-catch behandelt oder deklariert werden. SQLException bietet getMessage, getSQLState (SQL-Standard-Codes) und getErrorCode (DBMS-spezifisch). Bei Transaktionen im catch-Block immer rollback aufrufen.
Connection, Statement, PreparedStatement und ResultSet implementieren AutoCloseable. try (Resource r = ...) ruft close automatisch auf - auch bei Exception, in umgekehrter Deklarationsreihenfolge. Löst das häufige Problem vergessener close-Aufrufe (Ressourcen-Leak, Sperren, Deadlocks).
Nach conn.prepareStatement(sql mit ?) werden Parameter mit setInt(index, wert), setString(index, wert), setDate, setBigDecimal etc. gebunden. Index ist 1-basiert (nicht 0-basiert). Erst danach executeQuery oder executeUpdate aufrufen. Reihenfolge der ? bestimmt den Index.
Jedes Muster einmal mitschreiben. Der Kopieren-Button hilft beim Üben in einer IDE.
Der absolute Standard-Einstieg jeder JDBC-Anwendung. Treiber wird geladen, Connection wird geöffnet und garantiert wieder geschlossen - auch bei Exception. Das try-with-resources ruft close() automatisch auf, deshalb kein finally nötig.
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class DbConnect {
public static void main(String[] args) {
String url = "jdbc:postgresql://localhost:5432/uni";
String user = "scott";
String pw = "tiger";
try {
Class.forName("org.postgresql.Driver");
} catch (ClassNotFoundException e) {
System.err.println("Treiber nicht gefunden: " + e.getMessage());
return;
}
try (Connection conn = DriverManager.getConnection(url, user, pw)) {
System.out.println("Verbindung offen: " + !conn.isClosed());
} catch (SQLException e) {
System.err.println("Fehler: " + e.getMessage());
}
}
}Class.forName(org.postgresql.Driver)DriverManager.getConnection(url, user, pw)try (Connection conn = ...) - schliesst automatischcatch (SQLException e)Ausführen einer Anfrage mit Benutzereingabe. Der Fragezeichen-Platzhalter und setString/setInt verhindern SQL Injection. Das ResultSet wird mit rs.next() Zeile für Zeile abgearbeitet.
String sql = "SELECT matrnr, name, semester FROM studenten WHERE semester >= ?";
try (Connection conn = DriverManager.getConnection(url, user, pw);
PreparedStatement ps = conn.prepareStatement(sql)) {
ps.setInt(1, 3);
try (ResultSet rs = ps.executeQuery()) {
while (rs.next()) {
int matrnr = rs.getInt("matrnr");
String name = rs.getString("name");
int sem = rs.getInt("semester");
System.out.println(matrnr + " " + name + " " + sem);
}
}
} catch (SQLException e) {
e.printStackTrace();
}conn.prepareStatement(sql) mit Platzhalternps.setInt(1, wert) - Parameter binden, 1-basiertResultSet rs = ps.executeQuery()while (rs.next()) { rs.getString(spalte); }Datenänderungen werden mit executeUpdate ausgeführt (nicht executeQuery). Der Rückgabewert ist die Anzahl betroffener Zeilen als int. Auch hier PreparedStatement mit setXxx-Methoden verwenden.
String insertSql = "INSERT INTO studenten (matrnr, name, semester) VALUES (?, ?, ?)";
try (Connection conn = DriverManager.getConnection(url, user, pw);
PreparedStatement ps = conn.prepareStatement(insertSql)) {
ps.setInt(1, 29999);
ps.setString(2, "Meier");
ps.setInt(3, 1);
int rows = ps.executeUpdate();
System.out.println(rows + " Zeile(n) eingefuegt");
} catch (SQLException e) {
System.err.println("Insert fehlgeschlagen: " + e.getMessage());
}
// UPDATE-Muster analog:
String updSql = "UPDATE studenten SET semester = ? WHERE matrnr = ?";
try (Connection conn = DriverManager.getConnection(url, user, pw);
PreparedStatement ps = conn.prepareStatement(updSql)) {
ps.setInt(1, 4);
ps.setInt(2, 29999);
int updated = ps.executeUpdate();
}
// DELETE analog:
String delSql = "DELETE FROM studenten WHERE matrnr = ?";
try (PreparedStatement ps = conn.prepareStatement(delSql)) {
ps.setInt(1, 29999);
ps.executeUpdate();
}executeUpdate() statt executeQuery() bei INSERT/UPDATE/DELETERueckgabewert int = Anzahl betroffener Zeilenps.setInt / ps.setString mit 1-basiertem IndexPreparedStatement wiederverwendbar durch setXxx neu setzenZwei zusammengehörige Änderungen (klassisch: Überweisung zwischen zwei Konten) müssen atomar erfolgen. Ohne setAutoCommit(false) wird jedes Statement einzeln committet - das darf hier nicht passieren.
String abbuchen = "UPDATE konto SET saldo = saldo - ? WHERE id = ?";
String gutschreiben = "UPDATE konto SET saldo = saldo + ? WHERE id = ?";
Connection conn = null;
try {
conn = DriverManager.getConnection(url, user, pw);
conn.setAutoCommit(false);
try (PreparedStatement ps1 = conn.prepareStatement(abbuchen);
PreparedStatement ps2 = conn.prepareStatement(gutschreiben)) {
ps1.setBigDecimal(1, new BigDecimal("100.00"));
ps1.setInt(2, 1001);
ps1.executeUpdate();
ps2.setBigDecimal(1, new BigDecimal("100.00"));
ps2.setInt(2, 1002);
ps2.executeUpdate();
conn.commit();
}
} catch (SQLException e) {
if (conn != null) {
try { conn.rollback(); } catch (SQLException ex) { /* log */ }
}
throw new RuntimeException(e);
} finally {
if (conn != null) {
try { conn.setAutoCommit(true); conn.close(); } catch (SQLException e) { /* log */ }
}
}conn.setAutoCommit(false) - Transaktion beginntconn.commit() - am Ende des try-Blocks nach allen Statementsconn.rollback() - im catch bei jedem Fehlerfinally: setAutoCommit(true) und close()1000 einzelne INSERTs = 1000 Netzwerk-Roundtrips = langsam. Batch fasst mehrere Statements zusammen und sendet sie als Block. Idealerweise kombiniert mit einer Transaktion.
String sql = "INSERT INTO logeintraege (zeitstempel, nachricht) VALUES (?, ?)";
try (Connection conn = DriverManager.getConnection(url, user, pw)) {
conn.setAutoCommit(false);
try (PreparedStatement ps = conn.prepareStatement(sql)) {
for (int i = 0; i < 1000; i++) {
ps.setTimestamp(1, new Timestamp(System.currentTimeMillis()));
ps.setString(2, "Nachricht Nr " + i);
ps.addBatch();
if (i % 100 == 0) {
ps.executeBatch();
}
}
int[] ergebnisse = ps.executeBatch();
conn.commit();
System.out.println("Insgesamt " + ergebnisse.length + " Statements");
} catch (SQLException e) {
conn.rollback();
throw e;
}
}ps.addBatch() - Statement zur Batch hinzufuegenps.executeBatch() - alle gesammelten Statements ausfuehrenconn.setAutoCommit(false) - Batch in einer TransaktionRueckgabe int[] = Anzahl betroffener Zeilen pro StatementKlassische Klausur-Aufgabe. Das erste Snippet enthält mehrere Anti-Patterns: Statement (kein PreparedStatement) mit String-Konkatenation (SQL Injection), kein close (Ressourcen-Leak), autoCommit nicht gesetzt bei zwei zusammengehörigen Statements, kein Rollback im Fehlerfall.
// FEHLERHAFT:
Connection conn = DriverManager.getConnection(url, user, pw);
Statement stmt = conn.createStatement();
String userInput = request.getParameter("name");
ResultSet rs = stmt.executeQuery("SELECT * FROM users WHERE name = '" + userInput + "'");
stmt.executeUpdate("UPDATE konto SET saldo = saldo - 100 WHERE id = 1");
stmt.executeUpdate("UPDATE konto SET saldo = saldo + 100 WHERE id = 2");
// KORRIGIERT:
String sel = "SELECT * FROM users WHERE name = ?";
String upd1 = "UPDATE konto SET saldo = saldo - ? WHERE id = ?";
String upd2 = "UPDATE konto SET saldo = saldo + ? WHERE id = ?";
try (Connection conn = DriverManager.getConnection(url, user, pw)) {
conn.setAutoCommit(false);
try (PreparedStatement ps = conn.prepareStatement(sel)) {
ps.setString(1, userInput);
try (ResultSet rs = ps.executeQuery()) {
while (rs.next()) { /* ... */ }
}
}
try (PreparedStatement p1 = conn.prepareStatement(upd1);
PreparedStatement p2 = conn.prepareStatement(upd2)) {
p1.setInt(1, 100); p1.setInt(2, 1); p1.executeUpdate();
p2.setInt(1, 100); p2.setInt(2, 2); p2.executeUpdate();
conn.commit();
} catch (SQLException e) {
conn.rollback();
throw e;
}
}Statement + String-Konkatenation ist SQL Injection anfaelligPreparedStatement mit ? und setXxx ist sicherFehlendes close() = Ressourcen-Leak - try-with-resources loest dasZwei zusammengehoerige Updates brauchen setAutoCommit(false) + commit/rollbackZum Aufruf einer gespeicherten Prozedur in der Datenbank nutzt man CallableStatement mit prepareCall und der Syntax {CALL name(?, ?)}. Parameter werden wie bei PreparedStatement gebunden.
String call = "{CALL upd_customer_order(?)}";
try (Connection conn = DriverManager.getConnection(url, user, pw);
CallableStatement cstmt = conn.prepareCall(call)) {
cstmt.setInt(1, 4711);
try (ResultSet rs = cstmt.executeQuery()) {
while (rs.next()) {
System.out.println(rs.getString(1));
}
}
} catch (SQLException e) {
e.printStackTrace();
}CallableStatement statt PreparedStatementconn.prepareCall({CALL name(?)}) mit geschweiften KlammernsetInt / setString wie sonst auchexecuteQuery() bzw executeUpdate() je nach ProzedurKlassisches 5-Schritt-Muster: Treiber laden, Verbindung aufbauen, PreparedStatement erstellen mit Platzhaltern, Parameter binden, executeQuery aufrufen, ResultSet in while-Schleife durchlaufen und mit rs.next() Zeile für Zeile abarbeiten, Ressourcen im richtigen umgekehrten Reihenfolge schliessen (rs, ps, conn) - am besten via try-with-resources damit dies automatisch geschieht.
1. Class.forName(org.postgresql.Driver) - Treiber registrieren
2. DriverManager.getConnection(url, user, pw) - Verbindung
3. conn.prepareStatement(SELECT ... WHERE x = ?) - PreparedStatement
4. ps.setInt(1, wert) - Parameter binden
5. ResultSet rs = ps.executeQuery() - Ausfuehren
6. while (rs.next()) { rs.getString(name); rs.getInt(alter); } - Iterieren
7. Ressourcen schliessen (automatisch mit try-with-resources)Klassische Uni-Aufgabe: Betrag von Konto A abbuchen und auf Konto B gutschreiben. Beide UPDATEs müssen zusammen erfolgreich sein oder gar nicht. autoCommit muss auf false gesetzt werden, damit die zwei Statements in einer Transaktion gebündelt werden. Bei Exception: rollback im catch-Block. Bei Erfolg: commit am Ende des try-Blocks. Im finally: autoCommit wieder auf true setzen und Connection schliessen.
conn.setAutoCommit(false)
UPDATE konto SET saldo = saldo - 100 WHERE id = A
UPDATE konto SET saldo = saldo + 100 WHERE id = B
conn.commit()
catch (SQLException e) { conn.rollback(); }Ein typisches Klausur-Beispiel: Statement (kein PreparedStatement) mit String-Konkatenation, kein close, kein try-catch, autoCommit nicht gesetzt. Studenten müssen die drei bis vier Fehler benennen (SQL Injection Risiko, Ressourcen-Leak, keine Transaktion, kein Exception-Handling) und den Code korrigieren.
Fehlerhafter Code: stmt.executeQuery(SELECT * FROM users WHERE name = + userInput)
Korrekt: PreparedStatement mit ? und ps.setString(1, userInput) in try-with-resourcesGrosse Datenmengen mit einzelnen executeUpdate-Aufrufen verursachen viele Roundtrips. Lösung: PreparedStatement einmal vorbereiten, in Schleife addBatch aufrufen und am Ende executeBatch. Zusätzlich autoCommit=false verwenden damit alle 1000 Inserts in einer Transaktion laufen. Am Ende commit.