Zum Inhalt springen

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.

  • 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, PreparedStatement und ResultSet mit try-with-resources benutzen
  • mehrere Befehle in einer Transaktion zusammenfassen

Demo-Code: 24-zeiterfassung

⤓ demo-zeiterfassung.zip herunterladen

Der 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

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 in zeiten, 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.

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.

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.

Öffne das Demo-Projekt und starte TabellenAnlegen:

Terminal-Fenster
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.

  1. Lade die Datei h2-2.5.252.jar von Maven Central herunter: repo1.maven.org/maven2/com/h2database/h2/2.5.252/ → h2-2.5.252.jar.

  2. Lege im Projekt einen Ordner lib an: 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.

  3. Klicke mit rechts auf die JAR-Datei → Add as Library… → OK.

Starte TabellenAnlegen noch einmal:

Terminal-Fenster
Tabellen bereit: jdbc:h2:./daten/zeiterfassung
Verbindung: org.h2.jdbc.JdbcConnection

Unter 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.

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.

Datenbank.java
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 Datei daten\zeiterfassung.mv.db im Projektordner.
  • Benutzer sa ohne 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.
TabellenAnlegen.java
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 Connection ist die geöffnete Verbindung, ein Statement ein SQL-Befehl darauf. Beide sind AutoCloseable – also try-with-resources.
  • execute führt einen beliebigen Befehl aus. Das SQL steht in einem Textblock, so bleibt es lesbar.
  • IF NOT EXISTS sorgt dafür, dass das Programm beliebig oft laufen darf.
  • Die Tabelle zeiten kennt zwei Regeln: REFERENCES teilnehmer – jede Personalnummer muss es in teilnehmer geben. Und UNIQUE (personalnummer, datum) – pro Person nur ein Eintrag je Tag. Die Datenbank achtet selbst darauf.
TeilnehmerAnlegen.java
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:

Terminal-Fenster
1 Teilnehmer angelegt: 4711 Anna Muster
1 Teilnehmer angelegt: 4712 Ben Beispiel
Die Personalnummer 4711 gibt es schon.
  • Ein PreparedStatement enthält das SQL mit Platzhaltern ?. Mit setString, setInt und Co. werden sie gefüllt – gezählt ab 1, nicht ab 0.
  • executeUpdate führt INSERT, UPDATE oder DELETE aus 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 der SQLException, die bei Datenbanken immer droht.
TeilnehmerListe.java
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"));
}
}
}
}
Terminal-Fenster
Nummer Name Arbeitsweg
4711 Anna Muster 40 min
4712 Ben Beispiel 25 min
  • executeQuery führt ein SELECT aus und liefert ein ResultSet: einen Zeiger, der vor der ersten Zeile steht.
  • next() rückt eine Zeile weiter und sagt, ob es noch eine gab. Daher die Schleife while (ergebnis.next()) – ganz ähnlich wie readLine() 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.

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:

NeuMitErstemTag.java
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:

Terminal-Fenster
Teilnehmer eingefügt – noch nicht gespeichert
Nichts gespeichert: Das Ende muss nach dem Beginn liegen.
Terminal-Fenster
Teilnehmer eingefügt – noch nicht gespeichert
Gespeichert: Clara Krause mit erstem Tag 2026-10-22

Nach 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.

Arbeite im Demo-Projekt 24-zeiterfassung weiter. Lege zuerst mit TeilnehmerAnlegen dich selbst und eine Nachbarin oder einen Nachbarn an.

  1. Zeit erfassen: Das Programm ZeitErfassen bekommt fünf Argumente – Personalnummer, Datum, Beginn, Ende und den Weg zum Schulungsort in Minuten – und fügt eine Zeile in zeiten ein:

    Terminal-Fenster
    Erfasst: 4711 am 2026-10-19 von 08:00 bis 16:15
    • Aus den Texten werden mit LocalDate.parse("2026-10-19") und LocalTime.parse("08:00") ein Datum und eine Uhrzeit.
    • befehl.setObject(2, datum) übergibt sie an das PreparedStatement – JDBC kennt die Klassen aus java.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.
  2. Zeitkonto: Das Programm Zeitkonto bekommt eine Personalnummer und gibt alle erfassten Tage aus – nach Datum sortiert, mit dem Namen in der Überschrift. Den Namen holst du mit einem JOIN gleich in derselben Abfrage:

    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

    Ein Datum liest du mit ergebnis.getObject("datum", LocalDate.class).

  3. Rechnen: Schreibe einen Record Arbeitstag mit Datum, Beginn, Ende und den beiden Wegzeiten, und gib ihm Methoden für die Regeln:

    • Anwesenheit: Ende minus Beginn – mit Duration.between aus 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 Zeitkonto gibt dann für jeden Tag alle Werte aus und am Ende die Summe:

    Terminal-Fenster
    Zeitkonto 4711 – Anna Muster
    Datum von bis da Pause Weg zählt
    2026-10-19 08:00 16:15 8:15 0:30 0:30 8:15
    2026-10-20 08:10 13:45 5:35 0:00 0:30 6:05
    2026-10-21 07:45 17:00 9:15 0:45 0:00 8:30
    3 Tage, zusammen 22:50
  4. Für Schnelle: Wer sich vertippt hat, braucht eine Korrektur. Das Programm ZeitKorrigieren ändert Beginn und Ende eines schon erfassten Tages mit UPDATE. 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.

ZeitErfassen.java
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.

  • Duration vergleicht man mit compareTo, nicht mit < – es ist ein Objekt.
  • toMinutesPart() liefert nur die Minuten innerhalb der Stunde, also 15 bei 8 Stunden 15 Minuten. toMinutes() lieferte 495.
Arbeitstag.java
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.

Zeitkonto.java
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.

Terminal-Fenster
Korrigiert: 4711 am 2026-10-20 von 08:10 bis 15:30
Kein Eintrag für 4711 am 2026-10-30 – nichts geändert.
ZeitKorrigieren.java
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]);
}
}
}
}