In der Klausur muesst ihr JDBC-Code nicht nur lesen und kommentieren, sondern auch selbst SCHREIBEN und AENDERN. Bonusaufgaben: Syntaxfehler korrigieren, Java-Programme umschreiben. Ueber die Muster unten sollen tippfertig sitzen.
Class.forName(org.postgresql.Driver) laedt 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.
Repraesentiert die aktive Verbindung zur Datenbank. Ueber 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 fuer statische SQL-Strings ohne Parameter (SQL Injection Gefahr bei Konkatenation, keine Wiederverwendung). PreparedStatement fuer parametrisierte Abfragen mit Platzhaltern ?, vorkompiliert, sicher gegen SQL Injection, ideal bei wiederholten Aufrufen. CallableStatement fuer Stored Procedure Calls mit Syntax {CALL name(?)}.
Datenkontainer / Cursor fuer 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. Standardmaessig Forward-Only und Read-Only.
Standard: autoCommit=true (jedes Statement eigene Transaktion). Fuer atomare Multi-Statement-Operationen setAutoCommit(false) aufrufen. Bei Erfolg conn.commit(), bei Fehler conn.rollback() im catch-Block. Am Ende autoCommit wieder auf true zuruecksetzen. Ohne diese Steuerung sind zusammengehoerige Aenderungen 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. Loest das haeufige 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 Ueben in einer IDE.
Der absolute Standard-Einstieg jeder JDBC-Anwendung. Treiber wird geladen, Connection wird geoeffnet und garantiert wieder geschlossen - auch bei Exception. Das try-with-resources ruft close() automatisch auf, deshalb kein finally noetig.
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)Ausfuehren einer Anfrage mit Benutzereingabe. Der Fragezeichen-Platzhalter und setString/setInt verhindern SQL Injection. Das ResultSet wird mit rs.next() Zeile fuer 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); }Datenaenderungen werden mit executeUpdate ausgefuehrt (nicht executeQuery). Der Rueckgabewert 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 zusammengehoerige Aenderungen (klassisch: Ueberweisung zwischen zwei Konten) muessen 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 enthaelt mehrere Anti-Patterns: Statement (kein PreparedStatement) mit String-Konkatenation (SQL Injection), kein close (Ressourcen-Leak), autoCommit nicht gesetzt bei zwei zusammengehoerigen 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 fuer 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 muessen zusammen erfolgreich sein oder gar nicht. autoCommit muss auf false gesetzt werden, damit die zwei Statements in einer Transaktion gebuendelt 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 muessen 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. Loesung: PreparedStatement einmal vorbereiten, in Schleife addBatch aufrufen und am Ende executeBatch. Zusaetzlich autoCommit=false verwenden damit alle 1000 Inserts in einer Transaktion laufen. Am Ende commit.