Datenbanken mit JDBC
Jeden Tag dasselbe: Schulungsbeginn und -ende eintragen, die Pause abziehen, die Wegpauschale dazurechnen. Das bauen wir jetzt – mit einer Datenbank. Anders als eine Datei kann sie Daten in mehreren Tabellen verknüpfen, gezielt Zeilen heraussuchen und selbst auf Regeln achten: zum Beispiel, dass niemand denselben Tag zweimal erfasst.
Was du am Ende kannst
Abschnitt betitelt „Was du am Ende kannst“- einen Datenbanktreiber von Hand in ein Projekt einbinden
- erklären, warum JDBC fast nur aus Interfaces besteht
- mit SQL Tabellen anlegen, Daten einfügen, lesen und ändern
Connection,PreparedStatementundResultSetmit try-with-resources benutzen- mehrere Befehle in einer Transaktion zusammenfassen
Demo-Code: 24-zeiterfassung
⤓ demo-zeiterfassung.zip herunterladenDer fertige Stand aus der Vorführung – zum Nachlesen, Ausprobieren und Weiterbauen.
Entpacke die ZIP-Datei nach C:\dev\intellij. In IntelliJ: File → Open… → den Ordner 24-zeiterfassung wählen → OK → Trust Project. Zeigt IntelliJ oben Project JDK is not defined: auf Setup SDK klicken und das JDK 21 wählen.
Enthält: Datenbank.java, TabellenAnlegen.java, TeilnehmerAnlegen.java, TeilnehmerListe.java, NeuMitErstemTag.java
Das Datenmodell
Abschnitt betitelt „Das Datenmodell“Zwei Tabellen genügen:
┌────────────────────────────┐ ┌──────────────────────────┐│ teilnehmer │ │ zeiten │├────────────────────────────┤ 1 * ├──────────────────────────┤│ personalnummer (Schlüssel) │◀────────┤ personalnummer ││ name │ │ datum ││ arbeitsweg (Minuten) │ │ beginn, ende │└────────────────────────────┘ │ schulungsweg (Minuten) │ └──────────────────────────┘- Jeder Teilnehmer steht einmal in
teilnehmer, erkennbar an seiner Personalnummer. Jeder erfasste Tag ist eine Zeile inzeiten, die über die Personalnummer auf ihren Teilnehmer zeigt. So kann auch jemand für einen anderen erfassen. - Die Wegzeiten (hin und zurück, in Minuten) stehen an zwei Stellen: der übliche Weg zur Arbeitsstätte beim Teilnehmer, der Weg zum Schulungsort bei jedem Tag – der Ort kann ja wechseln. Gutgeschrieben wird der Mehrweg.
- Pause und Wegpauschale speichern wir nicht. Sie ergeben sich aus den gespeicherten Zeiten, und das rechnet Java aus.
SQL in fünf Befehlen
Abschnitt betitelt „SQL in fünf Befehlen“Mit einer Datenbank spricht man SQL. Für dieses Kapitel reichen diese Befehle:
| Befehl | macht | Beispiel |
|---|---|---|
CREATE TABLE |
legt eine Tabelle an | CREATE TABLE teilnehmer (personalnummer VARCHAR(10) PRIMARY KEY, …) |
INSERT |
fügt eine Zeile ein | INSERT INTO teilnehmer (personalnummer, name, arbeitsweg) VALUES ('4711', 'Anna Muster', 40) |
SELECT |
liest Zeilen | SELECT name FROM teilnehmer WHERE personalnummer = '4711' |
UPDATE |
ändert Zeilen | UPDATE zeiten SET ende = '16:30' WHERE id = 3 |
DELETE |
löscht Zeilen | DELETE FROM zeiten WHERE id = 3 |
Groß- und Kleinschreibung spielt bei den Schlüsselwörtern keine Rolle. Großbuchstaben machen sie nur leichter erkennbar.
H2 – eine Datenbank als JAR-Datei
Abschnitt betitelt „H2 – eine Datenbank als JAR-Datei“Für die Schulung nehmen wir H2: eine Datenbank, die selbst in Java geschrieben ist und als eine JAR-Datei kommt. Sie braucht keinen Server und keine Installation – sie speichert alles in einer Datei im Projektordner. Im Beruf heißt die Datenbank vielleicht Oracle, DB2 oder PostgreSQL. Der Java-Code bleibt derselbe.
Erster Versuch – ohne Treiber
Abschnitt betitelt „Erster Versuch – ohne Treiber“Öffne das Demo-Projekt und starte TabellenAnlegen:
Exception in thread "main" java.sql.SQLException: No suitable driver found for jdbc:h2:./daten/zeiterfassung at java.sql/java.sql.DriverManager.getConnection(DriverManager.java:638) …Bemerkenswert ist nicht der Fehler – sondern dass das Programm sich überhaupt
übersetzen ließ. Es benutzt Connection, Statement und ResultSet aus dem
Package java.sql. Das sind alles Interfaces: die Spezifikation. Die
Implementierung – der Treiber – fehlt noch. Genau das Muster aus dem Kapitel
Verträge.
Den Treiber einbinden
Abschnitt betitelt „Den Treiber einbinden“-
Lade die Datei
h2-2.5.252.jarvon Maven Central herunter: repo1.maven.org/maven2/com/h2database/h2/2.5.252/ →h2-2.5.252.jar. -
Lege im Projekt einen Ordner
liban: Rechtsklick auf das Projekt → New → Directory →lib. Kopiere die JAR-Datei hinein – zum Beispiel per Drag-and-drop aus dem Explorer in den Ordner im Fenster Project. -
Klicke mit rechts auf die JAR-Datei → Add as Library… → OK.
Starte TabellenAnlegen noch einmal:
Tabellen bereit: jdbc:h2:./daten/zeiterfassungVerbindung: org.h2.jdbc.JdbcConnectionUnter File → Project Structure → Modules → Dependencies steht die JAR jetzt
als Bibliothek – und im java-Befehl in der ersten Zeile des Fensters Run
taucht sie im -classpath auf. Es ist der Classpath aus Woche 1, nur dass
IntelliJ ihn für uns pflegt.
Wie findet Java den Treiber?
Abschnitt betitelt „Wie findet Java den Treiber?“Unser Code nennt nirgends eine Klasse von H2. Trotzdem ist aus der Connection
ein org.h2.jdbc.JdbcConnection geworden. Das erledigt der ServiceLoader:
In der JAR-Datei liegt eine kleine Textdatei
META-INF/services/java.sql.Driver, in der genau eine Zeile steht:
org.h2.Driver. Der DriverManager liest beim Start alle diese Dateien auf dem
Classpath und fragt jeden Treiber, ob er mit der Adresse jdbc:h2:… etwas
anfangen kann.
Interface aus java.sql |
Klasse aus der H2-JAR |
|---|---|
Driver |
org.h2.Driver |
Connection |
org.h2.jdbc.JdbcConnection |
PreparedStatement |
org.h2.jdbc.JdbcPreparedStatement |
ResultSet |
org.h2.jdbc.JdbcResultSet |
Wer zu PostgreSQL wechselt, tauscht die JAR-Datei und die Adresse – sonst nichts.
Die Verbindung
Abschnitt betitelt „Die Verbindung“package de.drv.zeiten;
import java.sql.Connection;import java.sql.DriverManager;import java.sql.SQLException;
/** Wo die Datenbank liegt und wie man sich mit ihr verbindet – an einer Stelle. */public class Datenbank {
// H2 legt die Datenbank als Datei an: daten/zeiterfassung.mv.db im Projektordner private static final String URL = "jdbc:h2:./daten/zeiterfassung"; private static final String BENUTZER = "sa"; private static final String PASSWORT = "";
public static Connection verbinde() throws SQLException { return DriverManager.getConnection(URL, BENUTZER, PASSWORT); }
}- Die Adresse beginnt immer mit
jdbc:, danach kommt der Treiber, danach, was dieser Treiber braucht. Bei H2 ist das ein Pfad: Die Datenbank landet in der Dateidaten\zeiterfassung.mv.dbim Projektordner. - Benutzer
saohne Passwort ist bei H2 der Standard für eine neue Datenbank. Bei einer echten Datenbank stehen hier richtige Zugangsdaten – und nicht im Quelltext. - Alle Programme holen sich ihre Verbindung über
Datenbank.verbinde(). Wer die Datenbank wechselt, ändert eine Klasse.
Tabellen anlegen
Abschnitt betitelt „Tabellen anlegen“package de.drv.zeiten;
import java.sql.Connection;import java.sql.SQLException;import java.sql.Statement;
/** Legt die beiden Tabellen an – nur, wenn es sie noch nicht gibt. */public class TabellenAnlegen {
public static void main(String[] args) throws SQLException { try (Connection verbindung = Datenbank.verbinde(); Statement befehl = verbindung.createStatement()) {
befehl.execute(""" CREATE TABLE IF NOT EXISTS teilnehmer ( personalnummer VARCHAR(10) PRIMARY KEY, name VARCHAR(100) NOT NULL, arbeitsweg INT NOT NULL )""");
befehl.execute(""" CREATE TABLE IF NOT EXISTS zeiten ( id INT GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY, personalnummer VARCHAR(10) NOT NULL REFERENCES teilnehmer, datum DATE NOT NULL, beginn TIME NOT NULL, ende TIME NOT NULL, schulungsweg INT NOT NULL, UNIQUE (personalnummer, datum) )""");
System.out.println("Tabellen bereit: " + verbindung.getMetaData().getURL()); // Connection ist ein Interface – welche Klasse steckt dahinter? System.out.println("Verbindung: " + verbindung.getClass().getName()); } }
}- Eine
Connectionist die geöffnete Verbindung, einStatementein SQL-Befehl darauf. Beide sindAutoCloseable– also try-with-resources. executeführt einen beliebigen Befehl aus. Das SQL steht in einem Textblock, so bleibt es lesbar.IF NOT EXISTSsorgt dafür, dass das Programm beliebig oft laufen darf.- Die Tabelle
zeitenkennt zwei Regeln:REFERENCES teilnehmer– jede Personalnummer muss es inteilnehmergeben. UndUNIQUE (personalnummer, datum)– pro Person nur ein Eintrag je Tag. Die Datenbank achtet selbst darauf.
Daten einfügen
Abschnitt betitelt „Daten einfügen“package de.drv.zeiten;
import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.SQLException;import java.sql.SQLIntegrityConstraintViolationException;import java.util.Arrays;
/** Legt einen Teilnehmer an: Personalnummer, Arbeitsweg in Minuten (hin und zurück), Name. */public class TeilnehmerAnlegen {
public static void main(String[] args) throws SQLException { if (args.length < 3) { System.out.println("Aufruf: TeilnehmerAnlegen <Personalnummer> <Arbeitsweg in Minuten> <Name …>"); return; } String personalnummer = args[0]; int arbeitsweg = Integer.parseInt(args[1]); String name = String.join(" ", Arrays.copyOfRange(args, 2, args.length));
String sql = "INSERT INTO teilnehmer (personalnummer, name, arbeitsweg) VALUES (?, ?, ?)"; try (Connection verbindung = Datenbank.verbinde(); PreparedStatement befehl = verbindung.prepareStatement(sql)) { befehl.setString(1, personalnummer); befehl.setString(2, name); befehl.setInt(3, arbeitsweg); int zeilen = befehl.executeUpdate(); System.out.println(zeilen + " Teilnehmer angelegt: " + personalnummer + " " + name); } catch (SQLIntegrityConstraintViolationException e) { System.out.println("Die Personalnummer " + personalnummer + " gibt es schon."); } }
}Mit 4711 40 Anna Muster, 4712 25 Ben Beispiel und noch einmal
4711 30 Clara Doppelt als Argumenten:
1 Teilnehmer angelegt: 4711 Anna Muster1 Teilnehmer angelegt: 4712 Ben BeispielDie Personalnummer 4711 gibt es schon.- Ein
PreparedStatemententhält das SQL mit Platzhaltern?. MitsetString,setIntund Co. werden sie gefüllt – gezählt ab 1, nicht ab 0. executeUpdateführtINSERT,UPDATEoderDELETEaus und liefert, wie viele Zeilen betroffen waren.- Verletzt ein Befehl eine Regel der Tabelle – hier den Schlüssel –, kommt eine
SQLIntegrityConstraintViolationException. Sie ist eine Unterklasse derSQLException, die bei Datenbanken immer droht.
Daten lesen
Abschnitt betitelt „Daten lesen“package de.drv.zeiten;
import java.sql.Connection;import java.sql.ResultSet;import java.sql.SQLException;import java.sql.Statement;
/** Gibt alle Teilnehmer aus, nach Namen sortiert. */public class TeilnehmerListe {
public static void main(String[] args) throws SQLException { String sql = "SELECT personalnummer, name, arbeitsweg FROM teilnehmer ORDER BY name"; try (Connection verbindung = Datenbank.verbinde(); Statement befehl = verbindung.createStatement(); ResultSet ergebnis = befehl.executeQuery(sql)) {
System.out.printf("%-8s %-20s %s%n", "Nummer", "Name", "Arbeitsweg"); while (ergebnis.next()) { System.out.printf("%-8s %-20s %3d min%n", ergebnis.getString("personalnummer"), ergebnis.getString("name"), ergebnis.getInt("arbeitsweg")); } } }
}Nummer Name Arbeitsweg4711 Anna Muster 40 min4712 Ben Beispiel 25 minexecuteQueryführt einSELECTaus und liefert einResultSet: einen Zeiger, der vor der ersten Zeile steht.next()rückt eine Zeile weiter und sagt, ob es noch eine gab. Daher die Schleifewhile (ergebnis.next())– ganz ähnlich wiereadLine()beim Lesen einer Datei.getString("name"),getInt("arbeitsweg")lesen eine Spalte der aktuellen Zeile, über ihren Namen.- Drei Ressourcen in einem
try: Verbindung, Befehl und Ergebnis. Geschlossen wird rückwärts.
Transaktionen: alles oder nichts
Abschnitt betitelt „Transaktionen: alles oder nichts“Bisher war jeder Befehl sofort gespeichert. Das ist der Normalfall: Eine
Connection steht auf Auto-Commit. Manchmal gehören aber mehrere Befehle
zusammen – ein neuer Teilnehmer soll nur gespeichert werden, wenn auch sein
erster Tag gespeichert werden kann. Dafür gibt es Transaktionen:
package de.drv.zeiten;
import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.SQLException;import java.time.LocalDate;import java.time.LocalTime;import java.util.Arrays;
/** Legt einen Teilnehmer und seinen ersten Tag an – beides oder nichts. */public class NeuMitErstemTag {
public static void main(String[] args) throws SQLException { if (args.length < 7) { System.out.println("Aufruf: NeuMitErstemTag <Nummer> <Arbeitsweg> <Datum> <Beginn> <Ende> <Schulungsweg> <Name …>"); return; } String nummer = args[0]; LocalDate datum = LocalDate.parse(args[2]); LocalTime beginn = LocalTime.parse(args[3]); LocalTime ende = LocalTime.parse(args[4]); String name = String.join(" ", Arrays.copyOfRange(args, 6, args.length));
try (Connection verbindung = Datenbank.verbinde()) { verbindung.setAutoCommit(false); // ab jetzt gilt nichts, bis wir commit sagen
try (PreparedStatement teilnehmer = verbindung.prepareStatement( "INSERT INTO teilnehmer (personalnummer, name, arbeitsweg) VALUES (?, ?, ?)"); PreparedStatement zeit = verbindung.prepareStatement( "INSERT INTO zeiten (personalnummer, datum, beginn, ende, schulungsweg) VALUES (?, ?, ?, ?, ?)")) {
teilnehmer.setString(1, nummer); teilnehmer.setString(2, name); teilnehmer.setInt(3, Integer.parseInt(args[1])); teilnehmer.executeUpdate(); System.out.println("Teilnehmer eingefügt – noch nicht gespeichert");
if (!ende.isAfter(beginn)) { throw new IllegalArgumentException("Das Ende muss nach dem Beginn liegen."); } zeit.setString(1, nummer); zeit.setObject(2, datum); zeit.setObject(3, beginn); zeit.setObject(4, ende); zeit.setInt(5, Integer.parseInt(args[5])); zeit.executeUpdate();
verbindung.commit(); // beides gilt System.out.println("Gespeichert: " + name + " mit erstem Tag " + datum); } catch (SQLException | IllegalArgumentException e) { verbindung.rollback(); // nichts gilt – auch nicht der Teilnehmer System.out.println("Nichts gespeichert: " + e.getMessage()); } } }
}Zuerst mit Ende vor Beginn, dann richtig:
Teilnehmer eingefügt – noch nicht gespeichertNichts gespeichert: Das Ende muss nach dem Beginn liegen.Teilnehmer eingefügt – noch nicht gespeichertGespeichert: Clara Krause mit erstem Tag 2026-10-22Nach dem ersten Aufruf zeigt TeilnehmerListe keine Clara Krause – obwohl ihr
INSERT schon ausgeführt war.
setAutoCommit(false)beginnt eine Transaktion: Was jetzt geschieht, gilt erst, wenn das Programm es bestätigt.commit()bestätigt alles seit dem Beginn auf einmal.rollback()nimmt alles seit dem Beginn zurück – als wäre nichts gewesen.catch (SQLException | IllegalArgumentException e)fängt zwei Arten von Exceptions mit einem Block – ein Multi-Catch. Bei beiden soll dasselbe passieren: zurückrollen.
Ruft man das Programm ein zweites Mal mit derselben Personalnummer auf, scheitert
schon das erste INSERT – und die Meldung kommt von H2 auf Deutsch, weil der
Rechner deutsch eingestellt ist: Eindeutiger Index oder Primärschlüssel
verletzt.
Übung: Die Zeiterfassung
Abschnitt betitelt „Übung: Die Zeiterfassung“Arbeite im Demo-Projekt 24-zeiterfassung weiter. Lege zuerst mit
TeilnehmerAnlegen dich selbst und eine Nachbarin oder einen Nachbarn an.
-
Zeit erfassen: Das Programm
ZeitErfassenbekommt fünf Argumente – Personalnummer, Datum, Beginn, Ende und den Weg zum Schulungsort in Minuten – und fügt eine Zeile inzeitenein:Terminal-Fenster Erfasst: 4711 am 2026-10-19 von 08:00 bis 16:15- Aus den Texten werden mit
LocalDate.parse("2026-10-19")undLocalTime.parse("08:00")ein Datum und eine Uhrzeit. befehl.setObject(2, datum)übergibt sie an dasPreparedStatement– JDBC kennt die Klassen ausjava.time.- Prüfe, dass das Ende nach dem Beginn liegt. Und probiere aus, was passiert, wenn du denselben Tag zweimal erfasst oder eine unbekannte Personalnummer nimmst.
- Aus den Texten werden mit
-
Zeitkonto: Das Programm
Zeitkontobekommt eine Personalnummer und gibt alle erfassten Tage aus – nach Datum sortiert, mit dem Namen in der Überschrift. Den Namen holst du mit einemJOINgleich in derselben Abfrage:SELECT t.name, t.arbeitsweg, z.datum, z.beginn, z.ende, z.schulungswegFROM zeiten z JOIN teilnehmer t ON z.personalnummer = t.personalnummerWHERE z.personalnummer = ?ORDER BY z.datumEin Datum liest du mit
ergebnis.getObject("datum", LocalDate.class). -
Rechnen: Schreibe einen Record
Arbeitstagmit Datum, Beginn, Ende und den beiden Wegzeiten, und gib ihm Methoden für die Regeln:- Anwesenheit: Ende minus Beginn – mit
Duration.betweenaus dem Kapitel Datum und Zeit - Pause nach dem Arbeitszeitgesetz: bei mehr als 6 Stunden 30 Minuten, bei mehr als 9 Stunden 45 Minuten
- Wegpauschale: Weg zum Schulungsort minus Arbeitsweg – aber nie negativ
- Arbeitszeit: Anwesenheit minus Pause plus Wegpauschale
Das
Zeitkontogibt dann für jeden Tag alle Werte aus und am Ende die Summe:Terminal-Fenster Zeitkonto 4711 – Anna MusterDatum von bis da Pause Weg zählt2026-10-19 08:00 16:15 8:15 0:30 0:30 8:152026-10-20 08:10 13:45 5:35 0:00 0:30 6:052026-10-21 07:45 17:00 9:15 0:45 0:00 8:303 Tage, zusammen 22:50 - Anwesenheit: Ende minus Beginn – mit
-
Für Schnelle: Wer sich vertippt hat, braucht eine Korrektur. Das Programm
ZeitKorrigierenändert Beginn und Ende eines schon erfassten Tages mitUPDATE. Gibt es für Person und Datum keinen Eintrag, meldet es das – woran erkennst du das?
Lösung
Beide Fehlerfälle – doppelter Tag und unbekannte Personalnummer – verletzen eine
Regel der Tabelle, UNIQUE und REFERENCES. Die Datenbank meldet beide als
SQLIntegrityConstraintViolationException. Wer sie unterscheiden will, kann
vorher mit einem SELECT nachsehen, ob es die Personalnummer gibt.
package de.drv.zeiten;
import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.SQLException;import java.sql.SQLIntegrityConstraintViolationException;import java.time.LocalDate;import java.time.LocalTime;import java.time.format.DateTimeParseException;
/** Stufe 1: erfasst einen Schulungstag – Datum, Beginn, Ende, Weg zum Schulungsort. */public class ZeitErfassen {
public static void main(String[] args) throws SQLException { if (args.length != 5) { System.out.println("Aufruf: ZeitErfassen <Personalnummer> <Datum> <Beginn> <Ende> <Schulungsweg in Minuten>"); System.out.println("Beispiel: ZeitErfassen 4711 2026-10-20 08:00 16:15 70"); return; } String personalnummer = args[0]; LocalDate datum; LocalTime beginn; LocalTime ende; try { datum = LocalDate.parse(args[1]); beginn = LocalTime.parse(args[2]); ende = LocalTime.parse(args[3]); } catch (DateTimeParseException e) { System.out.println("Datum wie 2026-10-20, Uhrzeiten wie 08:00 angeben: " + e.getParsedString()); return; } int schulungsweg = Integer.parseInt(args[4]); if (!ende.isAfter(beginn)) { System.out.println("Das Ende muss nach dem Beginn liegen."); return; }
String sql = "INSERT INTO zeiten (personalnummer, datum, beginn, ende, schulungsweg) VALUES (?, ?, ?, ?, ?)"; try (Connection verbindung = Datenbank.verbinde(); PreparedStatement befehl = verbindung.prepareStatement(sql)) { befehl.setString(1, personalnummer); befehl.setObject(2, datum); befehl.setObject(3, beginn); befehl.setObject(4, ende); befehl.setInt(5, schulungsweg); befehl.executeUpdate(); System.out.println("Erfasst: " + personalnummer + " am " + datum + " von " + beginn + " bis " + ende); } catch (SQLIntegrityConstraintViolationException e) { // doppelter Tag oder unbekannte Personalnummer – beides verletzt eine Regel der Tabelle System.out.println("Nicht erfasst – für diesen Tag gibt es schon einen Eintrag," + " oder die Personalnummer ist unbekannt."); } }
}Lösung
Die Regeln stehen an einer Stelle, im Record – nicht verstreut im Hauptprogramm. Wer die Pausenregel ändern muss, findet sie sofort.
Durationvergleicht man mitcompareTo, nicht mit<– es ist ein Objekt.toMinutesPart()liefert nur die Minuten innerhalb der Stunde, also 15 bei 8 Stunden 15 Minuten.toMinutes()lieferte 495.
package de.drv.zeiten;
import java.time.Duration;import java.time.LocalDate;import java.time.LocalTime;
/** Ein erfasster Tag mit den Regeln zur Berechnung der anrechenbaren Zeit. */public record Arbeitstag(LocalDate datum, LocalTime beginn, LocalTime ende, int schulungsweg, int arbeitsweg) {
/** Zeit zwischen Beginn und Ende. */ public Duration anwesenheit() { return Duration.between(beginn, ende); }
/** Pause nach dem Arbeitszeitgesetz: über 6 Stunden 30 Minuten, über 9 Stunden 45 Minuten. */ public Duration pause() { Duration anwesenheit = anwesenheit(); if (anwesenheit.compareTo(Duration.ofHours(9)) > 0) { return Duration.ofMinutes(45); } else if (anwesenheit.compareTo(Duration.ofHours(6)) > 0) { return Duration.ofMinutes(30); } else { return Duration.ZERO; } }
/** Der Mehrweg zum Schulungsort gegenüber dem üblichen Arbeitsweg – nie negativ. */ public Duration wegpauschale() { return Duration.ofMinutes(Math.max(0, schulungsweg - arbeitsweg)); }
/** Anrechenbare Zeit: Anwesenheit ohne Pause, plus Wegpauschale. */ public Duration arbeitszeit() { return anwesenheit().minus(pause()).plus(wegpauschale()); }
/** Eine Dauer als Stunden und Minuten, z. B. 7:45. */ public static String format(Duration dauer) { return String.format("%d:%02d", dauer.toHours(), dauer.toMinutesPart()); }
}Lösung
Erst sammelt das Programm alle Tage in einer Liste, dann gibt es sie aus. So ist die Datenbankverbindung schon wieder geschlossen, während gerechnet und ausgegeben wird – und das Programm weiß vor der Ausgabe, ob es überhaupt Tage gibt.
package de.drv.zeiten;
import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.SQLException;import java.time.Duration;import java.time.LocalDate;import java.time.LocalTime;import java.util.ArrayList;import java.util.List;
/** Stufen 2 und 3: alle Tage eines Teilnehmers mit Pause, Wegpauschale und Summe. */public class Zeitkonto {
public static void main(String[] args) throws SQLException { if (args.length != 1) { System.out.println("Aufruf: Zeitkonto <Personalnummer>"); return; } String sql = """ SELECT t.name, t.arbeitsweg, z.datum, z.beginn, z.ende, z.schulungsweg FROM zeiten z JOIN teilnehmer t ON z.personalnummer = t.personalnummer WHERE z.personalnummer = ? ORDER BY z.datum""";
String name = null; List<Arbeitstag> tage = new ArrayList<>(); try (Connection verbindung = Datenbank.verbinde(); PreparedStatement befehl = verbindung.prepareStatement(sql)) { befehl.setString(1, args[0]); try (ResultSet ergebnis = befehl.executeQuery()) { while (ergebnis.next()) { name = ergebnis.getString("name"); tage.add(new Arbeitstag( ergebnis.getObject("datum", LocalDate.class), ergebnis.getObject("beginn", LocalTime.class), ergebnis.getObject("ende", LocalTime.class), ergebnis.getInt("schulungsweg"), ergebnis.getInt("arbeitsweg"))); } } }
if (tage.isEmpty()) { System.out.println("Keine Zeiten für " + args[0]); return; } System.out.println("Zeitkonto " + args[0] + " – " + name); System.out.printf("%-10s %5s %5s %7s %5s %5s %7s%n", "Datum", "von", "bis", "da", "Pause", "Weg", "zählt"); Duration summe = Duration.ZERO; for (Arbeitstag tag : tage) { System.out.printf("%-10s %5s %5s %7s %5s %5s %7s%n", tag.datum(), tag.beginn(), tag.ende(), Arbeitstag.format(tag.anwesenheit()), Arbeitstag.format(tag.pause()), Arbeitstag.format(tag.wegpauschale()), Arbeitstag.format(tag.arbeitszeit())); summe = summe.plus(tag.arbeitszeit()); } System.out.printf("%-42s %7s%n", tage.size() + " Tage, zusammen", Arbeitstag.format(summe)); }
}Lösung
executeUpdate liefert die Zahl der geänderten Zeilen. Ist sie 0, gab es keinen
Eintrag – ein UPDATE, das nichts findet, ist für die Datenbank kein Fehler.
Korrigiert: 4711 am 2026-10-20 von 08:10 bis 15:30Kein Eintrag für 4711 am 2026-10-30 – nichts geändert.package de.drv.zeiten;
import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.SQLException;import java.time.LocalDate;import java.time.LocalTime;
/** Stufe 4: ändert Beginn und Ende eines schon erfassten Tages. */public class ZeitKorrigieren {
public static void main(String[] args) throws SQLException { if (args.length != 4) { System.out.println("Aufruf: ZeitKorrigieren <Personalnummer> <Datum> <Beginn> <Ende>"); return; } String sql = "UPDATE zeiten SET beginn = ?, ende = ? WHERE personalnummer = ? AND datum = ?"; try (Connection verbindung = Datenbank.verbinde(); PreparedStatement befehl = verbindung.prepareStatement(sql)) { befehl.setObject(1, LocalTime.parse(args[2])); befehl.setObject(2, LocalTime.parse(args[3])); befehl.setString(3, args[0]); befehl.setObject(4, LocalDate.parse(args[1])); int geaendert = befehl.executeUpdate(); if (geaendert == 0) { System.out.println("Kein Eintrag für " + args[0] + " am " + args[1] + " – nichts geändert."); } else { System.out.println("Korrigiert: " + args[0] + " am " + args[1] + " von " + args[2] + " bis " + args[3]); } } }
}