Maven - was ist das überhaupt?

Maven ist für viele Java-Einsteiger eines der ersten Werkzeuge, die ihnen im Projektalltag begegnen. Und oft wirkt es am Anfang abstrakt: eine pom.xml, viele unbekannte Elemente, fremde Ordnerstruktur, automatische Downloads - was passiert hier eigentlich? Als Ausbilder sehe ich immer wieder, wie sehr Maven den Einstieg erleichtern kann, wenn man einmal verstanden hat, was es macht: Es organisiert dein Projekt, verwaltet Abhängigkeiten, baut dein Programm und sorgt dafür, dass es auf jedem Rechner gleich gebaut werden kann. In diesem Beitrag führe ich dich Schritt für Schritt durch die Grundlagen.

Was Maven eigentlich macht

Maven ist ein Build- und Projektmanagement-Tool für Java. Du kannst dir Maven wie einen sehr fleißigen Assistenten vorstellen: Du beschreibst ihm in einer Datei, wie dein Projekt heißt, welche Bibliotheken du brauchst und wie das Ergebnis aussehen soll - Maven kümmert sich dann um den Rest.

Die zentrale Datei heißt pom.xml (Project Object Model). Darin legst du fest: Projektinformationen (z. B. Name und Version), welche externen Bibliotheken du verwenden möchtest und welche Plugins beim Bauen ausgeführt werden sollen. Statt Bibliotheken manuell herunterzuladen, in Ordner zu kopieren und Classpaths zu pflegen, schreibst du sie einmal in die pom.xml und Maven lädt sie automatisch aus einem Repository.

Die typische Projektstruktur

Einer der großen Vorteile von Maven ist, dass es eine einheitliche Struktur vorgibt. Wenn du ein Maven-Projekt siehst, erkennst du sofort, wo der Quellcode liegt, wo Tests liegen und wo das fertige Artefakt erzeugt wird. Das Prinzip dahinter heißt „Convention over Configuration“: Wenn wir uns an die Konventionen halten, müssen wir weniger konfigurieren.

my-first-maven-project/
  src/
    main/
      java/
        com/example/App.java
    test/
      java/
  pom.xml

Wichtige Punkte:

Alles, was später im fertigen Programm landet, liegt im Ordner src/main/java. Tests gehören nach src/test/java. Die pom.xml liegt direkt im Projektwurzelordner und beschreibt das gesamte Projekt.

Wenn du dieses Schema beibehältst, fühlen sich auch größere Projekte schnell vertraut an - und Kolleginnen und Kollegen finden sich direkt zurecht.

Deine erste pom.xml

Schauen wir uns eine einfache pom.xml an. Sie ist das Herzstück deines Projekts.

<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 http://maven.apache.org/xsd/maven-4.0.0.xsd">

  <modelversion>4.0.0</modelversion>

  <groupid>com.example</groupid>
  <artifactid>mein-erstes-maven-projekt</artifactid>
  <version>1.0.0</version>
  <packaging>jar</packaging>

  <dependencies>
    <dependency>
      <groupid>com.google.code.gson</groupid>
      <artifactid>gson</artifactid>
      <version>2.10.1</version>
    </dependency>
  </dependencies>

</project>

Die Kombination aus groupId, artifactId und version macht dein Projekt eindeutig. Ähnlich funktioniert das bei Abhängigkeiten: Mit nur drei Angaben kannst du GSON, JUnit oder jede andere Bibliothek einbinden, ohne dich um Downloads, Pfade oder Versionskonflikte kümmern zu müssen.

Ein kleines Java-Beispiel mit Abhängigkeit

Jetzt wollen wir sehen, wie sich eine Abhängigkeit im Code auswirkt. Wir nutzen GSON, um ein Java-Objekt in JSON zu verwandeln. Lege im Ordner src/main/java/com/example eine Datei App.java an:

package com.example;

import com.google.gson.Gson;

public class App {
    public static void main(String[] args) {
        Person p = new Person("Marvin", 22);
        Gson gson = new Gson();
        String json = gson.toJson(p);
        System.out.println("JSON-Ausgabe:");
        System.out.println(json);
    }
}

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

Hier siehst du: Wir verwenden einfach import com.google.gson.Gson;, als wäre GSON schon immer da gewesen. Maven sorgt im Hintergrund dafür, dass die Bibliothek gefunden und eingebunden wird.

Ausgabe (wenn du das Programm startest):

JSON-Ausgabe:
{"name":"Marvin","age":22}

Ohne Maven müsstest du GSON manuell herunterladen, als .jar-Datei einbinden und bei jeder neuen Version wieder nachpflegen. Mit Maven ist es ein einziger Eintrag in der pom.xml - und du kannst dich auf den eigentlichen Code konzentrieren.

Wie du Maven ausführst

Damit Maven für dich arbeiten kann, brauchst du nur das Terminal (oder die Maven-Integration deiner IDE). Die wichtigsten Befehle für den Einstieg sind:

Projekt kompilieren:

mvn compile

Damit übersetzt Maven deinen Quellcode in Bytecode und legt die Klassen im target-Ordner ab.

Tests ausführen:

mvn test

Alle Tests im Ordner src/test/java werden automatisch ausgeführt. So kannst du dein Projekt früh und häufig überprüfen.

Fertiges Artefakt bauen:

mvn package

Dieser Befehl führt alle Schritte des Build-Lebenszyklus aus (kompilieren, testen, paketieren) und erzeugt anschließend im target/-Ordner ein .jar-File. In unserem Beispiel wäre das zum Beispiel mein-erstes-maven-projekt-1.0.0.jar.

Wenn du dieses Jar ausführbar machen möchtest, kannst du später mit einem Plugin einen „Main-Class“-Eintrag hinzufügen. Für den Einstieg reicht es aber völlig, zu verstehen, dass Maven dir aus deinem Quellcode ein reproduzierbares Artefakt baut.

Ein Schritt weiter: Die Java-Version festlegen

In echten Projekten ist es wichtig, dass alle dieselbe Java-Version verwenden. Auch das kannst du in der pom.xml festlegen. Ein typisches Beispiel (stark vereinfacht) sieht so aus:

<build>
  <plugins>
    <plugin>
      <groupid>org.apache.maven.plugins</groupid>
      <artifactid>maven-compiler-plugin</artifactid>
      <version>3.11.0</version>
      <configuration>
        <source>17
        <target>17</target>
      </configuration>
    </plugin>
  </plugins>
</build>

Damit stellst du sicher, dass das Projekt mit Java 17 kompiliert wird - unabhängig davon, welche Default-Version auf dem Rechner eingestellt ist. Für Teams ist das Gold wert, weil Builds dadurch deutlich weniger „Überraschungen“ produzieren.

Warum Maven dir das Leben leichter macht

Gerade als Einsteiger ist es verlockend, „einfach loszucoden“ und sich um Build-Prozesse später zu kümmern. Spätestens wenn das Projekt wächst, merkst du aber, wie wichtig Struktur ist. Genau hier spielt Maven seine Stärken aus.

Ein paar zentrale Vorteile: Du bekommst eine klare, einheitliche Projektstruktur. Du musst Bibliotheken nicht mehr manuell verwalten - Versionen und Abhängigkeiten werden zentral in der pom.xml gepflegt. Du kannst Builds und Tests mit einem Befehl ausführen und bekommst reproduzierbare Ergebnisse: Wenn es auf deinem Rechner baut, sollte es auch auf dem Build-Server genauso bauen.

Und nicht zuletzt: Fast jedes größere Java-Projekt nutzt Maven (oder Gradle). Wenn du als Berufsanfänger Maven sicher beherrschst, bist du sofort produktiver und verstehst bestehende Projekte viel schneller.

Fazit

Maven wirkt am Anfang vielleicht wie ein weiteres „kompliziertes Tool“, das man lernen muss. In Wirklichkeit ist es genau das Gegenteil: Es nimmt dir viele wiederkehrende Aufgaben ab und gibt dir eine Struktur, in der du dich auf das konzentrieren kannst, was dir als Entwickler am wichtigsten sein sollte - sauberen, verständlichen Code zu schreiben.

Wenn du mit Maven starten möchtest, reicht für den Anfang ein kleines Projekt: Lege eine simple pom.xml an, füge eine Abhängigkeit wie GSON hinzu, schreibe eine kleine Klasse und baue dein Projekt mit mvn package. Sobald du das ein paar Mal gemacht hast, fühlt sich Maven nicht mehr wie ein Fremdkörper an, sondern wie ein ganz natürlicher Teil deines Entwicklungsalltags.

Und keine Sorge: Alles, was darüber hinausgeht - komplexe Plugins, Multi-Modul-Projekte, Integration mit Application Servern - kannst du Schritt für Schritt nachlernen. Wichtig ist nur, dass du die Grundlagen verstanden hast. Der Rest wächst mit deiner Erfahrung.