Zum Inhalt springen

Projekte mit Maven

Im letzten Kapitel haben wir den H2-Treiber heruntergeladen, in einen Ordner lib gelegt und als Bibliothek eingetragen. Für eine Bibliothek geht das. Ein echtes Projekt braucht aber schnell zwanzig – und jede davon braucht weitere, in passenden Versionen. Genau dafür gibt es Maven: Wir schreiben auf, was wir brauchen, und Maven besorgt es.

  • ein Maven-Projekt in IntelliJ anlegen und seinen Aufbau erklären
  • in der pom.xml Abhängigkeiten eintragen und ihren Scope wählen
  • die wichtigsten Phasen des Lebenszyklus nutzen: compile, test, package
  • Annahmen im Code mit assert prüfen
  • Tests mit JUnit in einem Maven-Projekt schreiben und starten

Demo-Code: 25-zeiterfassung-maven

⤓ demo-maven.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 25-zeiterfassung-maven wählen → OK → Trust Project. IntelliJ erkennt die pom.xml und lädt die Bibliotheken selbst herunter – das dauert beim ersten Mal einen Moment.

Enthält: pom.xml, Datenbank.java, TabellenAnlegen.java, TeilnehmerAnlegen.java, TeilnehmerListe.java, Behauptungen.java

Das Demo-Projekt ist die Zeiterfassung aus dem letzten Kapitel – diesmal als Maven-Projekt und ohne Ordner lib.

Maven ist ein Build-Werkzeug. Es kümmert sich um alles, was zwischen dem Quelltext und einem fertigen Programm passiert:

  • Abhängigkeiten: Es lädt die Bibliotheken, die das Projekt braucht – samt allem, was diese wiederum brauchen – aus dem zentralen Verzeichnis Maven Central.
  • Ein fester Aufbau: Jedes Maven-Projekt sieht gleich aus. Wer eines kennt, findet sich in jedem zurecht.
  • Ein fester Ablauf: Übersetzen, Tests ausführen, ein JAR bauen – immer mit denselben Befehlen, in IntelliJ genauso wie auf einem Build-Server.

IntelliJ bringt Maven mit. Installieren musst du nichts.

  1. File → New → Project…, links Java.

  2. Fülle aus wie bisher – aber mit anderem Build-System:

    Feld Eintrag
    Name zeiterfassung
    Location C:\dev\intellij
    Build system Maven
    JDK dein JDK 21
    Add sample code kein Häkchen
  3. Klappe Advanced Settings auf und trage bei GroupId de.drv ein. Die ArtifactId übernimmt IntelliJ aus dem Namen.

  4. Create.

  • Ordnerzeiterfassung
    • pom.xml die Beschreibung des Projekts
    • Ordnersrc
      • Ordnermain
        • java\ der Quelltext des Programms
        • resources\ andere Dateien, die zum Programm gehören
      • Ordnertest
        • java\ der Quelltext der Tests
    • target\ alles, was Maven erzeugt – entsteht beim ersten Build

Programm und Tests liegen getrennt, und was Maven erzeugt, landet in target statt in out. Dieser Aufbau ist Konvention: Maven erwartet ihn so, und deshalb muss ihn niemand konfigurieren.

Das Herz jedes Maven-Projekts ist die Datei pom.xml (Project Object Model). So sieht sie im Demo-Projekt aus:

pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<!-- Wer bin ich? Die Koordinaten des Projekts -->
<groupId>de.drv</groupId>
<artifactId>zeiterfassung</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<maven.compiler.release>21</maven.compiler.release>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<!-- Was brauche ich? Maven lädt es von Maven Central -->
<dependencies>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<version>2.5.252</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter</artifactId>
<version>6.1.3</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

Wer bin ich? – Die Koordinaten des Projekts: groupId (wie ein Package, meist die umgedrehte Domain der Firma), artifactId (der Name des Projekts) und version. SNAPSHOT heißt: noch in Arbeit.

Wie wird übersetzt? – maven.compiler.release legt den Sprachstand fest, genau wie --release bei javac. IntelliJ schreibt beim Anlegen maven.compiler.source und maven.compiler.target hinein – ersetze beide durch die eine Zeile maven.compiler.release. sourceEncoding sorgt dafür, dass die Umlaute im Quelltext auf jedem Rechner richtig ankommen.

Was brauche ich? – Jede dependency nennt eine Bibliothek mit ihren drei Koordinaten. Woher kennt man sie? Auf central.sonatype.com nach dem Namen suchen, die Bibliothek öffnen und den Block unter Maven kopieren.

Scope gebraucht zum … Beispiel
compile (Standard, wenn nichts dasteht) Übersetzen und Ausführen eine Bibliothek, deren Klassen wir im Code benutzen
runtime nur zum Ausführen der H2-Treiber
test nur für die Tests JUnit

Der H2-Treiber steht auf runtime. Unser Code kennt ja nur die Interfaces aus java.sql – zum Übersetzen braucht er H2 nicht. Mehr noch: Mit runtime kann niemand versehentlich eine Klasse von H2 benutzen. Der Compiler würde sie gar nicht finden. „Gegen das Interface programmieren“ ist damit nicht nur eine gute Absicht, sondern eine Regel, auf die Maven achtet.

Öffne rechts das Fenster Maven → zeiterfassung → Dependencies. Zwei Einträge haben wir hingeschrieben, Maven hat mehr geholt:

Terminal-Fenster
de.drv:zeiterfassung:jar:1.0-SNAPSHOT
+- com.h2database:h2:jar:2.5.252:runtime
\- org.junit.jupiter:junit-jupiter:jar:6.1.3:test
+- org.junit.jupiter:junit-jupiter-api:jar:6.1.3:test
| +- org.opentest4j:opentest4j:jar:1.3.0:test
| +- org.junit.platform:junit-platform-commons:jar:6.1.3:test
| +- org.apiguardian:apiguardian-api:jar:1.1.2:test
| \- org.jspecify:jspecify:jar:1.0.0:test
+- org.junit.jupiter:junit-jupiter-params:jar:6.1.3:test
\- org.junit.jupiter:junit-jupiter-engine:jar:6.1.3:test
\- org.junit.platform:junit-platform-engine:jar:6.1.3:test

JUnit braucht selbst acht weitere Bibliotheken – das sind die transitiven Abhängigkeiten. Von Hand müssten wir jede einzeln suchen, in der passenden Version.

Gespeichert werden alle Bibliotheken einmal pro Rechner, im lokalen Repository C:\Users\<dein Name>\.m2\repository. Das nächste Projekt, das H2 braucht, lädt nichts mehr herunter.

Im Fenster Maven unter Lifecycle stehen die Phasen eines Builds. Ein Doppelklick startet eine Phase – und alle davor:

Phase macht Ergebnis in target
clean löscht target –
compile übersetzt src\main\java classes\
test übersetzt src\test\java und führt alle Tests aus test-classes\, surefire-reports\
package baut ein JAR – aber nur, wenn alle Tests grün sind zeiterfassung-1.0-SNAPSHOT.jar
install legt das JAR ins lokale Repository –

package heißt also immer auch compile und test. Schlägt ein Test fehl, bricht Maven ab – ein JAR mit kaputtem Code entsteht gar nicht erst.

In Woche 1 kam JUnit mit Eclipse. Ohne Maven hätten wir es in IntelliJ von Hand einbinden müssen – deshalb gab es zuletzt Prüfprogramme mit main. Jetzt steht JUnit in der pom.xml, und Tests gehören nach src\test\java, in dasselbe Package wie die Klasse, die sie prüfen:

  • Ordnersrc
    • Ordnermain
      • Ordnerjava
        • Ordnerde
          • Ordnerdrv
            • Ordnerzeiten
              • Arbeitstag.java
    • Ordnertest
      • Ordnerjava
        • Ordnerde
          • Ordnerdrv
            • Ordnerzeiten
              • ArbeitstagTest.java

Gestartet werden Tests wie gewohnt über das grüne Dreieck neben der Klasse – oder für das ganze Projekt mit der Phase test:

Terminal-Fenster
[INFO] Tests run: 7, Failures: 0, Errors: 0, Skipped: 0
[INFO] BUILD SUCCESS

Neben Tests gibt es eine zweite Art, Annahmen zu prüfen – direkt im Code, mit dem Schlüsselwort assert:

Behauptungen.java
package de.drv.zeiten;
import java.time.Duration;
import java.time.LocalDate;
import java.time.LocalTime;
/** assert: eine Annahme im Code, die nur geprüft wird, wenn man es einschaltet (-ea). */
public class Behauptungen {
public static void main(String[] args) {
Arbeitstag normal = new Arbeitstag(LocalDate.of(2026, 10, 22), LocalTime.of(8, 0), LocalTime.of(16, 0), 60, 30);
System.out.println("Arbeitszeit: " + Arbeitstag.format(pruefe(normal)));
Arbeitstag lang = new Arbeitstag(LocalDate.of(2026, 10, 23), LocalTime.of(6, 0), LocalTime.of(20, 0), 60, 30);
System.out.println("Arbeitszeit: " + Arbeitstag.format(pruefe(lang)));
}
/** Rechnet die Arbeitszeit aus – und prüft dabei Annahmen, die immer stimmen sollten. */
static Duration pruefe(Arbeitstag tag) {
Duration zeit = tag.arbeitszeit();
assert !zeit.isNegative() : "negative Arbeitszeit am " + tag.datum();
assert zeit.compareTo(Duration.ofHours(12)) <= 0 : "mehr als 12 Stunden am " + tag.datum() + ": " + zeit;
return zeit;
}
}
Terminal-Fenster
Arbeitszeit: 8:00
Arbeitszeit: 13:45

Nichts passiert – obwohl 13:45 Stunden die Annahme verletzen. Assertions sind nämlich standardmäßig ausgeschaltet. Eingeschaltet werden sie mit der JVM-Option -ea (enable assertions): In IntelliJ in der Run Configuration unter Modify options → Add VM options, dort -ea eintragen.

Terminal-Fenster
Arbeitszeit: 8:00
Exception in thread "main" java.lang.AssertionError: mehr als 12 Stunden am 2026-10-23: PT13H45M
at de.drv.zeiten.Behauptungen.pruefe(Behauptungen.java:22)
  • assert bedingung : meldung; – ist die Bedingung false, gibt es einen AssertionError mit der Meldung.
  • Weil sie im Betrieb ausgeschaltet sind, prüfen Assertions keine Eingaben. Eine falsche Uhrzeit vom Benutzer bekommt eine Exception, wie bisher. Eine Assertion sagt: „Wenn das hier nicht stimmt, ist mein Code falsch.“
  • Was in einer Assertion steht, darf nichts verändern – sonst verhält sich das Programm mit -ea anders als ohne.
  • Maven schaltet Assertions beim Ausführen der Tests automatisch ein. Eine verletzte Annahme fällt also spätestens dort auf.
prüft ist an bei Fehler
Exception Eingaben und Zustände, die vorkommen können immer das Programm reagiert darauf
assert Annahmen über den eigenen Code nur mit -ea AssertionError – ein Fehler im Programm
JUnit-Test Verhalten, von außen wenn die Tests laufen der Test schlägt fehl
  1. Umzug: Kopiere deine Klassen aus 24-zeiterfassung – ZeitErfassen, Arbeitstag, Zeitkonto und, wenn vorhanden, ZeitKorrigieren – nach src\main\java\de\drv\zeiten im Demo-Projekt. Starte TabellenAnlegen, lege einen Teilnehmer an, erfasse einen Tag und lass dir das Zeitkonto zeigen. Kein lib, kein Add as Library – Maven hat den Treiber schon geholt.

    Die Datenbank liegt im neuen Projekt in einem neuen Ordner daten. Wer seine Einträge behalten will, kopiert den Ordner daten aus dem alten Projekt mit.

  2. Tests: Schreibe eine Testklasse ArbeitstagTest. Prüfe die Regeln genau an den Grenzen – dort passieren die Fehler:

    • genau 6 Stunden: keine Pause; 6 Stunden und 1 Minute: 30 Minuten
    • genau 9 Stunden: 30 Minuten; 9 Stunden und 1 Minute: 45 Minuten
    • Wegpauschale bei längerem und bei kürzerem Weg zum Schulungsort
    • die Arbeitszeit eines ganzen Tages
    • das Format, etwa 8:05 und 0:00

    Ändere danach zum Test in Arbeitstag ein > in >=. Welcher Test schlägt fehl?

  3. Ein JAR bauen: Starte die Phase package und suche das JAR in target. Öffne ein Terminal in IntelliJ und starte daraus TeilnehmerListe:

    PowerShell
    java -cp target\zeiterfassung-1.0-SNAPSHOT.jar de.drv.zeiten.TeilnehmerListe

    Warum kommt No suitable driver found? Was muss noch auf den Classpath, und wo findest du es?

  4. Für Schnelle: Das Programm Wikipedia aus dem Kapitel Ströme und Ressourcen liest das JSON mit indexOf – eine Notlösung. Lege ein neues Maven-Projekt wikipedia an, trage die Bibliothek Gson von Google als Abhängigkeit ein (com.google.code.gson:gson) und lies die Felder title, description und extract mit JsonParser.parseReader(leser).getAsJsonObject().

Lösung

Die Hilfsmethode tag(beginn, ende) hält die Tests kurz: Beide Wegzeiten sind gleich, die Wegpauschale ist also 0 – so prüft jeder Test nur das, worum es ihm geht.

Mit >= statt > bei den 6 Stunden schlägt bisSechsStunden fehl:

Terminal-Fenster
[ERROR] ArbeitstagTest.bisSechsStunden:25 expected: <PT0S> but was: <PT30M>

PT30M ist die Schreibweise einer Duration als Text: Period of Time, 30 Minutes.

ArbeitstagTest.java
package de.drv.zeiten;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.time.Duration;
import java.time.LocalDate;
import java.time.LocalTime;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
class ArbeitstagTest {
private static final LocalDate TAG = LocalDate.of(2026, 10, 20);
/** Ein Tag von beginn bis ende, ohne Wegpauschale. */
private static Arbeitstag tag(String beginn, String ende) {
return new Arbeitstag(TAG, LocalTime.parse(beginn), LocalTime.parse(ende), 40, 40);
}
@Test
@DisplayName("Bis einschließlich 6 Stunden keine Pause")
void bisSechsStunden() {
assertEquals(Duration.ZERO, tag("08:00", "12:00").pause());
assertEquals(Duration.ZERO, tag("08:00", "14:00").pause());
}
@Test
@DisplayName("Über 6 bis einschließlich 9 Stunden 30 Minuten Pause")
void ueberSechsStunden() {
assertEquals(Duration.ofMinutes(30), tag("08:00", "14:01").pause());
assertEquals(Duration.ofMinutes(30), tag("08:00", "17:00").pause());
}
@Test
@DisplayName("Über 9 Stunden 45 Minuten Pause")
void ueberNeunStunden() {
assertEquals(Duration.ofMinutes(45), tag("08:00", "17:01").pause());
}
@Test
@DisplayName("Die Wegpauschale ist der Mehrweg zum Schulungsort")
void wegpauschale() {
Arbeitstag weiter = new Arbeitstag(TAG, LocalTime.of(8, 0), LocalTime.of(16, 0), 70, 40);
assertEquals(Duration.ofMinutes(30), weiter.wegpauschale());
}
@Test
@DisplayName("Ein kürzerer Weg zum Schulungsort ergibt keine negative Wegpauschale")
void keineNegativeWegpauschale() {
Arbeitstag naeher = new Arbeitstag(TAG, LocalTime.of(8, 0), LocalTime.of(16, 0), 20, 40);
assertEquals(Duration.ZERO, naeher.wegpauschale());
}
@Test
@DisplayName("Arbeitszeit = Anwesenheit − Pause + Wegpauschale")
void arbeitszeit() {
Arbeitstag tag = new Arbeitstag(TAG, LocalTime.of(8, 0), LocalTime.of(16, 15), 70, 40);
assertEquals(Duration.ofHours(8).plusMinutes(15), tag.arbeitszeit()); // 8:15 − 0:30 + 0:30
}
@Test
@DisplayName("Dauern werden als Stunden und Minuten formatiert")
void format() {
assertEquals("8:05", Arbeitstag.format(Duration.ofMinutes(485)));
assertEquals("0:00", Arbeitstag.format(Duration.ZERO));
assertEquals("24:05", Arbeitstag.format(Duration.ofMinutes(24 * 60 + 5)));
}
}
Lösung

Im JAR stecken nur unsere Klassen – Maven packt die Abhängigkeiten nicht mit hinein. Der H2-Treiber liegt im lokalen Repository und muss mit auf den Classpath, getrennt durch ein Semikolon:

PowerShell
java -cp "target\zeiterfassung-1.0-SNAPSHOT.jar;$HOME\.m2\repository\com\h2database\h2\2.5.252\h2-2.5.252.jar" de.drv.zeiten.TeilnehmerListe

In IntelliJ merkt man davon nichts, weil IntelliJ den Classpath aus der pom.xml zusammenstellt. Für ein Programm, das man weitergeben will, gibt es Maven-Plugins, die alle Abhängigkeiten in ein JAR packen – das kommt später.

Lösung

Die Abhängigkeit in der pom.xml:

<dependencies>
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.14.0</version>
</dependency>
</dependencies>

Diesmal ohne scope – also compile: Unser Code benutzt JsonParser und JsonObject direkt, er braucht Gson schon zum Übersetzen.

Terminal-Fenster
Köln
Millionenmetropole am Rhein und bevölkerungsreichste Stadt Nordrhein-Westfalens
Köln ist eine kreisfreie Stadt im Land Nordrhein-Westfalen mit rund einer Million Einwohnern. Sie ist die bevölkerungsreichste Gemeinde des Bundeslandes und die viertgrößte Deutschlands.

JsonParser.parseReader liest direkt aus dem Reader – das Zusammensetzen im StringBuilder fällt weg. Nicht jeder Artikel hat eine description, deshalb fragt has vorher nach.

Wikipedia.java
package de.drv.stroeme;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URI;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
/** Holt die Kurzbeschreibung eines Wikipedia-Artikels – und liest das JSON mit Gson. */
public class Wikipedia {
public static void main(String[] args) throws IOException, InterruptedException {
String titel = args.length > 0 ? String.join(" ", args) : "Köln";
String kodiert = URLEncoder.encode(titel.replace(' ', '_'), StandardCharsets.UTF_8);
URI adresse = URI.create("https://de.wikipedia.org/api/rest_v1/page/summary/" + kodiert);
HttpRequest anfrage = HttpRequest.newBuilder(adresse)
.header("User-Agent", "Java-Schulung (https://java.lean-stack.rocks)")
.build();
try (HttpClient client = HttpClient.newHttpClient()) {
HttpResponse<InputStream> antwort = client.send(anfrage, HttpResponse.BodyHandlers.ofInputStream());
if (antwort.statusCode() != 200) {
antwort.body().close();
System.out.println("Keinen Artikel gefunden: " + titel);
return;
}
try (BufferedReader leser = new BufferedReader(
new InputStreamReader(antwort.body(), StandardCharsets.UTF_8))) {
// Gson liest direkt aus dem Reader – kein Zusammensetzen, kein indexOf
JsonObject artikel = JsonParser.parseReader(leser).getAsJsonObject();
System.out.println(artikel.get("title").getAsString());
if (artikel.has("description")) { // nicht jeder Artikel hat eine
System.out.println(artikel.get("description").getAsString());
}
System.out.println();
System.out.println(artikel.get("extract").getAsString());
}
}
}
}