Maven - Aufgaben

Aufgaben zu Modul #S2 - Maven

Vorbereitung

Repository und Maven Mirror einrichten

Die nachfolgenden Informationen in diesem Abschnitt richten sich an Auszubildende der SBB
Falls du nicht in Ausbildung bei der SBB bist und deinen Code in einem Repository ablegen möchtest, musst du dir ein eigenes Repository eröffnen, z.B. auf BitBucket, GitHub oder Azure.

Erstelle ein neues persönliches Repository
Klone das neue Repository mit IntelliJ IDEA
Richte das Repository ein, wie auf code.sbb.ch beschrieben (nachdem man das Repo erstellt hat)
Optional: Konfigure den Maven Mirror von SBB

Achtung: Der Maven Mirror von SBB ist nur im VPN erreichbar. Mit konfiguriertem Maven Mirror von SBB kann es beim Builden zu Problemen kommen, wenn man nicht mit dem VPN verbunden ist.

Maven-Projekt aufsetzen

Erstelle ein neues Projekt, welches wir später für das Modul Unit-Testing verwenden werden.

Erstelle in IntelliJ IDEA die für Maven erforderliche Ordnerstruktur:
- Im Root-Verzeichnis des Repositories eine .gitignore Datei, angepasst für ein IntelliJ Maven Projekt.
- Ordner src erstellen
- Im Ordner src zwei Ordner erstellen: main und test
- In den beiden Ordnern main und test jeweils zwei weitere Ordner erstellen: java und resources
- Die Ordner markieren (Rechtsklick -> Mark Directory as…)
  - src/main/java -> Sources Root
  - src/main/resources -> Resources Root
  - src/test/java -> Test Sources Root
  - src/test/resources -> Test Resources Root

Lege im Root des Projektes eine Datei mit dem Namen pom.xml an und füge den folgenden Inhalt ein:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
<?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>

    <groupId>Deine Group-ID</groupId>
    <artifactId>Deine Artifact-ID</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>Name des Projekts</name>
    <description>Beschreibung des Projekts</description>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <java.version>Java-Major-Version wählen, z.B. 21</java.version>
        <maven.build.timestamp.format>yyyy-MM-dd HH:mm</maven.build.timestamp.format>
        <timestamp>${maven.build.timestamp}</timestamp>
    </properties>

    <dependencies>
        <!-- Test -->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>5.6.2</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>5.6.2</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-engine</artifactId>
            <version>5.6.2</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-params</artifactId>
            <version>5.6.2</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.vintage</groupId>
            <artifactId>junit-vintage-engine</artifactId>
            <version>5.6.2</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.platform</groupId>
            <artifactId>junit-platform-engine</artifactId>
            <version>1.7.0-RC1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.platform</groupId>
            <artifactId>junit-platform-commons</artifactId>
            <version>1.7.0-RC1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.mockito</groupId>
            <artifactId>mockito-core</artifactId>
            <version>4.1.0</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <compilerVersion>${java.version}</compilerVersion>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

    <developers>
        <developer>
            <id>Deine Personalnummer</id>
            <name>Dein Name</name>
            <email>Dein E-Mail</email>
            <organization>SBB</organization>
            <organizationUrl>https://www.sbb.ch</organizationUrl>
            <roles>
                <role>Deine Rolle</role>
            </roles>
        </developer>
    </developers>
</project>

Passe die GroupID und ArtifactID gemäss der Theorie an. Dabei kannst du für die GroupID ch.sbb.{dein_name} und für die ArtifactID die aktuelle Aufgabe wählen, also zum Beispiel ch.sbb.johncarmack:J5.
Passe die Java Version an: <java.version>Java-Major-Version wählen, z.B. 21</java.version>. Mit dem Befehl mvn --version oder java --version findest du heraus, welche Version verwendet wird (Achtung, als Version nur die erste Zahl von der Version nehmen).
Hinterlege das Projekt im IntelliJ als Maven-Projekt. Zu diesem Zweck Ctrl+Shift+A drücken und unter Aktion nach “Maven” suchen.
Aus der Liste dann entweder “Add as Maven Project” oder “Add Maven Projects” wählen.
Bei der ersten Aktion wird das Projekt direkt hinzugefügt, bei der zweiten muss das pom.xml noch ausgewählt werden.
Auf der rechten Seite in IntelliJ gibt es den Tab Maven, dort müsste das Projekt nun erscheinen.

Wenn alles geklappt hat, dann werden die definierten Abhängigkeiten aus dem POM in das lokale Repository heruntergeladen.

MAVEN Troubleshoot

Es kann sein, dass nach Ctrl+Shift+A und dem Auswählen als Maven Project der Maven Tab rechts nicht erscheint. Der Grund wird wahrscheinlich ein Fehler im pom.xml sein.

Um den Fehler zu finden kannst du in IntelliJ eine Konsole öffnen und dort den Befehl mvn install clean -e ausführen. Das -e gibt zusätzliche Informationen in der Konsole aus, falls es ein Problem gibt.

Aufgaben

Aufgabe 1 - Warnungen behandeln

Mit dem folgenden Befehl kannst Du die Maven Umgebung so aufsetzen, wie sie im pom.xml definiert ist:

1
mvn clean install -e

Dabei wirst Du womöglich feststellen, dass es mehrere Warnings gibt.

Schau Dir die Warnings an und passe das pom.xml an, damit die Warnings nicht mehr kommen. Falls Du nicht weisst, welche Version Du für eine Dependency oder ein Plugin nehmen sollst, kannst Du im Maven Repository nachschauen gehen.

Aufgabe 2 - Dependencies aktualisieren

Im pom.xml wird z.B. org.junit.jupiter:junit-jupiter in der Version 5.6.2 verwendet. Diese ist aus dem Jahr 2020 und hat zahlreiche Verbesserungen erfahren. Auch die anderen Dependencies sind schon recht alt.

Aktualisiere alle Dependencies mit Hilfe des Plugins org.codehaus.mojo:versions-maven-plugin:

Installiere das Plugin in der pom.xml, den Xml-Code für das Plugin findest du im Maven Repository.
Mit der Standard Konfiguration werden die Dependencies auf die aktuellste Version aktualisert. Das kann auch ein Snapshot oder ein Version mit Qualifier sein. Um nur Releases zu berücksichtigen kannst du folgende Konfiguration zum org.codehaus.mojo:versions-maven-plugin Plugin hinzufügen (damit werden alle Versionen ignoriert, welche ein ‘-’ enthalten):
1 2 3
<configuration> <ignoredVersions>.*-.*</ignoredVersions> </configuration>
Mit dem folgenden Befehl kannst du testen, wie ein Update aussehen würde:
1
mvn versions:display-dependency-updates
Wenn du mit dem Resultat zufrieden bist, die pom.xml mit folgendem Befehl aktualisieren:
1
mvn versions:use-latest-versions

Aufgabe 3 - Springboot Projekt vorbereiten.

Da wir im folgenden Modul mit Springboot arbeiten findest du hier die Dependencies dafür und wofür diese gedacht sind.

Wichtig zu erwähnen ist, dass die hier aufgeführten Starter nur ein Bruchteil von allen verfügbaren sind. Es sind jedoch die wichtigsten und am häufigsten verwendeten Starter.

Test Starter: Für Testing brauchen wir normalerweise ein Paar der folgenden Erweiterungen: JUnit, Hamcrest, Mockito oder Spring Test. Diese könnten wir manuell einbinden oder verwenden den Test Starter der das für uns erledigt.
Data JPA Starter: Der Data JPA Starter hilft dir, dich effizient mit relationalen Datenbanken zu verbinden. Intern verwendet der Data JPA Starter die Spring-boot-Jpa-Abhängigkeit. Jedoch schreiben wir die SQL-Abfragen nicht mehr wie z.b. bei JDBC, denn in der JPA speichern wir die Daten von Objekten in Tabellen und umgekehrt.
Mail Starter: Vielleicht wirst du diesen Starter nicht allzu oft verwenden, jedoch ist es wichtig ihn zu erwähnen, damit du ihn kennst. Der Mail Starter kann hilfreich sein in der Unternehmensentwicklung, da dort das Senden von E-Mails und der direkte Umgang mit Java Mail API normalerweise schwierig sein kann. Mail Starter verbirgt diese Komplexitäten.
Web Starter: Der Spring Boot Web Starter konfiguriert dir automatisch folgende Dinge: Dispatcher, Servlet, Fehlerseite, Web-JAR’s und eingebettete Servlet-Behälter. Dies sind alles wichtige Konfigurationen, wenn du ein Spring Boot Backend für Web aufbauen willst.

Nun schauen wir uns kurz an, wie man diese Starter in das Projekt einbringen würde:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
<?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>
 <parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-parent</artifactId>
  <version>4.0.2</version>
  <relativePath/> <!-- lookup parent from repository -->
 </parent>
 <groupId>ch.sbb.tafy.mynotes</groupId>
 <artifactId>mynotes</artifactId>
 <version>0.0.1-SNAPSHOT</version>
 <name>mynotes</name>
 <description>mynotes</description>
 <url/>
 <licenses>
  <license/>
 </licenses>
 <developers>
  <developer/>
 </developers>
 <scm>
  <connection/>
  <developerConnection/>
  <tag/>
  <url/>
 </scm>

 <properties>
  <java.version>21</java.version>
 </properties>

 <dependencies>
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-webmvc</artifactId>
  </dependency>

  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-webmvc-test</artifactId>
   <scope>test</scope>
  </dependency>
 </dependencies>

 <build>
  <plugins>
   <plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
   </plugin>
  </plugins>
 </build>

</project>

Passe nun die Datei pom.xml nun entsprechend an damit du erolgreich ein Springboot Projekt aufsetzen kannst.
Einige der oben verwendeten Dependencies werden hierbei nicht mehr von Nöten sein.

Hier kannst du zurück zur Theorie.

Last modified February 11, 2026: links fix (26bf73979)