2Compilerbau – SS 2019 – Teil 0/Maven

Literatur und Web

[0-1] Maven by Examplehttp://www.sonatype.com/resources/books/maven-by-example/download

[0-2] Maven – the complete Referencehttp://www.sonatype.com/resources/books/maven-the-complete-reference/download

[0-3] Better Builds with Mavenhttp://index-of.es/Java/Better.Builds.With.Maven.pdf

[0-4] Maven 3.5http://www.torsten-horn.de/techdocs/maven.htm

[0-5] Behrendt, Mario: Jenkins. Kurz&Gut, O'Reilly, 20111

[0-6] http://www.avajava.com/tutorials/categories/maven

[0-7] http://best-practice-software-engineering.ifs.tuwien.ac.at/plugins.html

3Compilerbau – SS 2019 – Teil 0/Maven

Maven – Ein Projekt-Management-Werkzeug

• Maven (Sammler des Wissens)

• In Maven werden die Prozesse zum Generieren von Applikationen definiert; dies erfolgt deklarativ.

• Maven ist unabhängig von der Programmiersprache.

• Web:

– http://de.wikipedia.org/wiki/Apache_Maven

– http://maven.apache.org/

– http://mvnrepository.com/ (Repository)

• Aktuelle Version: 3.6

• Download:http://maven.apache.org/download.cgi

• Für sehr viele Anwendungen gibt es Plugins, die die eigentliche Aufgabe realisieren.

4Compilerbau – SS 2019 – Teil 0/Maven

Maven – Funktionen I

• Steuerung folgender Prozesse:

– Übersetzen

– Testen

– Zusammensetzen (Build)

• Neben der Herstellung einer lauffähigen Version der betreffenden Software werden noch Dokumentationen, z.B. javadoc, erzeugt.

• Die Arbeit erfolgt unmittelbar durch Aufruf von mvn über die Shell-SchnittstelleEs gibt Plugins für Eclipse und netbeans.

– http://wiki.netbeans.org/Maven

– http://maven.apache.org/eclipse-plugin.html

• Wer über einen Server dies im Hintergrund ablaufen lassen möchte, was für große Projekte geboten ist, der benutze Jenkins.http://jenkins-ci.org/

5Compilerbau – SS 2019 – Teil 0/Maven

Maven – Funktionen II

• Beachtung und Verwaltung der Abhängigkeiten(Dependency Management)

• Globales Repository für

– Plugins

– Notwendige Software-Komponenten in den entsprechenden Versionen, z.B. mockito oder hamcrest

• Aufgrund der Implementierung in Java und XML sind alle Spezifikationen der Software in Maven portabel.

6Compilerbau – SS 2019 – Teil 0/Maven

Installation I - Windows

• Herunterladen der neuesten Version, z.B. 3.6

• Auspacken und den Ordner an die Stelle bewegen, wo er installiert sein soll, z.B. „D:\Java\apache-maven-3.6".

• Den Durchsuchpfad für Kommandos auf den bin-Ordner von Maven setzen:am besten global:

Computer>Systemeigenschaften>Erweiterte Systemeinstellungen>Erweitert>Umgebungsvariablen

Systemvariablen

7Compilerbau – SS 2019 – Teil 0/Maven

Installation II - Windows

• Die Variablen JAVA_HOME und M2_HOME anlegen:– JAVA_HOME anlegen und auf JDK-Ordner setzen

z.B. JAVA_HOME auf C:\Program Files\Java\jdk-11.0.2

– M2_HOME anlegen und auf Maven-Ordner setzenM2_HOME auf D:\Java\apache-maven-3.6.0

• PATH mit ";%JAVA_HOME%\bin;%M2_HOME%\bin" erweitern

• Das Ganze wird mit einem neu gestarteten(!) MSDOS-Eingabe-Fenster mit dem Kommando mvn -v geprüft.

8Compilerbau – SS 2019 – Teil 0/Maven

Installation III - Linux

• Die Installation auf Linux verläuft analog, nur dass der Mechanismus des Setzens der PATH-Variablen anders ist.

• Z.B. für den bash in .bashrc oder .profile jeweils im Home-Verzeichnis:– export JAVA_HOME=...

– export M2_HOME=...

– export PATH=$PATH:$JAVA_HOME/bin:$M2_HOME/bin

Infos für beide Betriebssysteme:http://maven.apache.org/download.cgi#Installation

9Compilerbau – SS 2019 – Teil 0/Maven

Hallo world mit Maven I - Vorbereitung

1) Es muss das Plugin maven installiert sein:tools>plugins (entfällt bei netbeans 10)

2) Externe maven-Software muss dem Plugin bekannt gemacht werden:

10Compilerbau – SS 2019 – Teil 0/Maven

Hallo world mit Maven II - Projektanlegen

Maven-Java ApplicationProjekt anlegen

Namen und weiteres zumProjekt angeben

11Compilerbau – SS 2019 – Teil 0/Maven

Bemerkungen - Koordinaten

Artifact Id Name des Artifakts, meist eines Programms. Der Dateiname wird meist nach folgendem Schema aufgebaut: <artifactId>-<version>.<packaging>

Group Id Name einer Gruppe/Zusammenfassung mehrerer Artefakte, in der Regel Klassenkomplexe oder Programme,Üblich ist ein Name ähnlich dem Paketnamen in Java

Version gibt die Version nach folgendem Schema an: <Major>.<Minor>.<Bugfix>-<Qualifier>-<Buildnumber> Für unfertige Versionen ist der Qualifier SNAPSHOT vorgesehen

Package Name Paketname in Java

• Koordinaten = Zusammensetzung von Informationen über das Projekt zur eindeutigen Identifizierung

• Die Koordinaten bestehen aus GroupId, ArtifactId, Version und Packaging (Typ des Pakets, z.B. jar, ear, war oder pom)

12Compilerbau – SS 2019 – Teil 0/Maven

Hallo world mit Maven III

Aufgebaute Struktur derOrdner

Das Hallo Word-Programm

13Compilerbau – SS 2019 – Teil 0/Maven

Hallo world mit Maven IV

• Nach dem Start läuft alles unter der Kontrolle von maven ab.

• Es werden alle vom Programm benötigten Abhängigkeiten automatisch in ein lokales Repository herunter geladen.

• Das Programm wird übersetzt und gestartet.

14Compilerbau – SS 2019 – Teil 0/Maven

Hallo world mit Maven V

Ordnerstrukturinnerhalb von netbeans

Das von maven ange-legte Repository

class-Dateien

Java-Dateien

15Compilerbau – SS 2019 – Teil 0/Maven

Hallo world mit Maven VI

(01) <project xmlns="http://maven.apache.org/POM/4.0.0" ...>(02) <modelVersion>4.0.0</modelVersion>(03) <groupId>de.htw_berlin.f4.cb</groupId>(04) <artifactId>halloMaven</artifactId>(05) <version>1.0-SNAPSHOT</version>(06) <packaging>jar</packaging>(07) <properties>(08) <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>(09) <maven.compiler.source>11</maven.compiler.source>(10) <maven.compiler.target>11</maven.compiler.target>(11) </properties>(12) </project>

Projektdatei mit den Koordinaten

16Compilerbau – SS 2019 – Teil 0/Maven

Bemerkungen

• Die Konfiguration erfolgt durch eine XML-Datei, die an der Wurzel der zu behandelnden Software liegt.

• Diese XML-Datei heißt pom.xml. POM = Project Object Modell

• (01): Angabe der Grammatik sowie der Namensräume

• (02): Version der POM

• (03-06) sind die Koordinaten (Identifizierung des Projektes)

• (07-12): Angabe der Projekteigenschaften, ohne die Kodierung nach UTF-8 kommen Fehlermeldungen, siehe dazu: http://maven.apache.org/general.html

17Compilerbau – SS 2019 – Teil 0/Maven

Typische Verzeichnisstruktur (Auszug)

project home = {baseDir} Wurzel mit der POM-Datei

{baseDir}/src/main/java/... Quellen der Java-Software entsprechend dem Paketnamen in Unterordner verteilt

{baseDir}/src/main/resources Property-Dateien etc.

{baseDir}/src/test/java Klassen zum Testen, z.B. Junit-Klassen

{baseDir}/src/test/resources Property-Dateien und weitere Dateien, die für das Testen notwendig sind

18Compilerbau – SS 2019 – Teil 0/Maven

Archetypes – Projekt-Templates

• Es sind Projekt-Templates für typische Projektarten definiert

• Diese Templates installieren Basisversionen, die dann weiter entwickelt werden

• Es gibt sehr viele archetypes, z.B. für Web-Anwendungen, Scala-Projekte etc.

• Jedes Projekt kann eigene Templates entwerfen und der Welt zur Verfügung stellen

• Zur Erzeugung wird das Plugin archetype benutzt:archetype-quickstart-jdk8

• Dieses Template definiert initial eine Struktur, mit der die meisten Projekte auskommen; es können aber auch kleinere Ergänzungen gemacht werden.

In dem nächsten Beispiel werden Unittests benutzt.Es geht um einfache Prozentrechnungen.

19Compilerbau – SS 2019 – Teil 0/Maven

Percent-Junit I

Jetzt wird aus der Bibliothek derArchetypen eines ausgewählt.

Die Wahl fällt aufarchetype-quickstart-jdk8

Gehen könnte auch:quickstart-java8java8-quickstart-archetype

20Compilerbau – SS 2019 – Teil 0/Maven

Percent-Junit II

Die Koordinatenwerden eingetragen.

Ein etwas komplexeresDateigerüst entsteht

21Compilerbau – SS 2019 – Teil 0/Maven

Percent-Junit III

Der normale Bereichder Klassen

Der Bereichder Testklassen

22Compilerbau – SS 2019 – Teil 0/Maven

Percent-Junit IV

Das fertig eingegebene ProjektDie Datei AppTest.java kanngelöscht werden.

Die zu testende Klasse

Das Ergebnis:

23Compilerbau – SS 2019 – Teil 0/Maven

Source der Testklassen I - Invertation1Test

package de.htw_berlin.f4.cb.mavenpercent;

import org.junit.After; import org.junit.Before;import org.junit.Test; import static org.junit.Assert.*;

public class Invertation1Test { Invertation value; public Invertation1Test() {} @Before public void setUp() { value= new Invertation(); } @After public void tearDown() { value= null; } @Test public void testValues() { assertEquals(0.01, value.invers(100), 0.001); assertEquals(0.1, value.invers(10), 0.001); assertEquals(1, value.invers(1), 0.001); }}

Mit diesemTeil beginntjedeTestklasse

Dies ist die „alte“ Version von JUnit 4.

24Compilerbau – SS 2019 – Teil 0/Maven

Source der Testklassen II - Invertation2/3Test

@Test public void testNegative() { assertEquals(-0.01, value.invers(-100), 0.001); assertEquals(-0.1, value.invers(-10), 0.001); assertEquals(-1, value.invers(-1), 0.001); }

@Test public void testZero() { try { double val= value.invers(0); fail("IllegalArgumentException expected"); } catch (IllegalArgumentException args) { } }

Test des Werfens einer Exception

25Compilerbau – SS 2019 – Teil 0/Maven

Source der Testklassen III – Die Suite

package de.htw_berlin.f4.cb.mavenpercent;import org.junit.runners.Suite;import org.junit.runner.RunWith;

@RunWith(Suite.class)@Suite.SuiteClasses({ Invertation1Test.class, Invertation2Test.class, Invertation3Test.class,})public class InvertationSuite { }

Dies dient der Demonstration wie komplexe Tests einzeln definiertund in eine (oder mehrere) Suite(s) zusammengefasst werden können.Alle Test(-Suites) können einzeln gestartet werden.

26Compilerbau – SS 2019 – Teil 0/Maven

Percent-Junit V - Output

------------------------------------------------------- T E S T S-------------------------------------------------------Running de.htw_berlin.f4.cb.mavenpercent.Invertation1TestTests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.126 secRunning de.htw_berlin.f4.cb.mavenpercent.Invertation2TestTests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0 secRunning de.htw_berlin.f4.cb.mavenpercent.Invertation3TestTests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0 sec

Results :

Tests run: 3, Failures: 0, Errors: 0, Skipped: 0

Der Ablauf und die Ergebnisse der einzelnen Tests sind leichtzu erkennen.

27Compilerbau – SS 2019 – Teil 0/Maven

Die POM-Datei I

<dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> <scope>test</scope> </dependency> </dependencies>

• Dies ist der Eintrag für junit 4.12.

• Diese Einträge mit den unterstützten Versionen stehen inhttps://mvnrepository.com/artifact/junit/junit/4.12 oder ähnlich

Leider sind viele Archetypen veraltet und werden nicht gepflegt bzw.es ist nur durch Probieren erkennbar, ob ein bestimmter Archetypeaktuell funktioniert – d.h. es ist fast immer Handarbeit angesagt.

Checkstyle ist wichtig, weil es auf Konventionen achtet; die roten Teile wurdengeändert, so dass die Sun-Regeln mit der aktuellen Version benutzt werden.

28Compilerbau – SS 2019 – Teil 0/Maven

Die POM-Datei II - Checkstyle

<build><pluginManagement> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-checkstyle-plugin</artifactId> <version>3.0.0</version> <dependencies> <dependency> <groupId>com.puppycrawl.tools</groupId> <artifactId>checkstyle</artifactId> <version>8.17</version> </dependency> </dependencies> <configuration> <linkXRef>false</linkXRef> <includeTestSourceDirectory>true</includeTestSourceDirectory> </configuration> </plugin> </plugins> </pluginManagement>

29Compilerbau – SS 2019 – Teil 0/Maven

Die POM-Datei III - Checkstyle

<plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-checkstyle-plugin</artifactId> </plugin>...<reporting> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-checkstyle-plugin</artifactId> <version>3.0.0</version> <configuration> <includeTestSourceDirectory>true</includeTestSourceDirectory> </configuration> </plugin>

Es müssen an vier Stellen Änderungen durchgeführt werden, die imWesentlichen eine Versionsnummer hinzufügen und die eigenen Regelnlöschen. Es werden dann die Default-Regeln von SUN benutzt.

30Compilerbau – SS 2019 – Teil 0/Maven

Die POM-Datei IV - Checkstyle

<profile> <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-checkstyle-plugin</artifactId> <executions> <execution> <id>checkstyle</id> <phase>test</phase> <configuration> <consoleOutput>true</consoleOutput> <linkXRef>false</linkXRef> </configuration> <goals> <goal>check</goal> </goals> </execution> </executions> </plugin>

31Compilerbau – SS 2019 – Teil 0/Maven

Die POM-Datei V - Checkstyle

• https://maven.apache.org/plugins/maven-checkstyle-plugin/examples/upgrading-checkstyle.html

• https://mvnrepository.com/artifact/com.puppycrawl.tools/checkstyle/8.17

• http://checkstyle.sourceforge.net/dependency-info.html

• http://www.oracle.com/technetwork/java/codeconvtoc-136057.html

• http://google.github.io/styleguide/javaguide.html

Informationen über Checkstyle gibt es:

Wenn bei den Änderungen etwas vergessen wird, gibt es Fehlermeldungen,die aussagekräftig sind.

32Compilerbau – SS 2019 – Teil 0/Maven

Benutzung von Checkstyle I

There are 65 errors reported by Checkstyle 8.8 with sun_checks.xml ruleset.------------------------------------------------------------------------BUILD SUCCESS------------------------------------------------------------------------Total time: 4.181sFinished at: Wed Feb 21 21:45:48 CET 2018Final Memory: 18M/212M------------------------------------------------------------------------

65 Stilfehler! Pfui!

Klick auf checkstyle:checkstyledann wird manuell Checkstylegestartet.

33Compilerbau – SS 2019 – Teil 0/Maven

Benutzung von Checkstyle II

Die Ergebnisse stehen in checkstyle-result.xml (damit sie von anderenWerkzeugen ausgewertet werden können).

34Compilerbau – SS 2019 – Teil 0/Maven

Benutzung von Checkstyle III

Klick auf checkstyle:checkdann wird manuell Checkstylegestartet und der Outputerscheint verständlich im Konsolenfenster.

35Compilerbau – SS 2019 – Teil 0/Maven

Findbugs I

Das Plugin mussinstalliert sein.

Im Menue Source wirdder Eintrag Inspect… gewählt.

36Compilerbau – SS 2019 – Teil 0/Maven

Findbugs II

Findbugs und dasProjekt wirdausgewählt

Unten erscheinendann die Meldungen

37Compilerbau – SS 2019 – Teil 0/Maven

Ein jar-File erzeugen I

<plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-jar-plugin</artifactId> <version>3.1.1</version> <configuration> <archive> <manifest> <packageName>de.htw_berlin.f4.cb.mavenpercent</packageName> <mainClass>de.htw_berlin.f4.cb.mavenpercent.App</mainClass> <addClasspath>true</addClasspath> </manifest> </archive> </configuration></plugin>

Im Build-Teil muss dieses weitere Plugin spezifiziert werden.

38Compilerbau – SS 2019 – Teil 0/Maven

Ein jar-File erzeugen II

Auf das Projekt mit der rechten Maustaste, um dann Build auszuwählen.Es wird dann alles, einschließlich Test durchgeführt und dann dasjar-File generiert.

39Compilerbau – SS 2019 – Teil 0/Maven

Erläuterungen

• <build> bedeutet, dass der eingeschlossene Text sich auf die Build-Phase bezieht.

• <plugins> leitet eine Liste der Plugins ein – hier für den Build-Prozess

• <configuration> ist der Abschnitt mit Parametern für ein spezielles Plugin. Welche Parameter was bedeuten, muss der Plugin-Dokumentation entnommen werden.

• Siehe:

– http://mvnrepository.com/artifact/org.apache.maven.plugins/maven-jar-plugin

– http://maven.apache.org/plugins/maven-jar-plugin/plugin-info.html

– http://de.wikihow.com/Eine-.Jar-Java-Datei-ausführen

40Compilerbau – SS 2019 – Teil 0/Maven

Noch eine kleine Optimierung

• Vorne stehen die Properties, das sind eigentlich Macros, die später verwendet werden.

• Hier werden zwei neue Makros (die roten) eingefügt und später aufgerufen, so dass nur noch der vordere Teil projektspezifisch ist.

• Dann kann dieses POM-File relativ einfach mehrfach verwendet werden.

<properties> <maven.compiler.source>11</maven.compiler.source> <maven.compiler.target>11</maven.compiler.target> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <package.name>de.htw_berlin.f4.cb.mavenpercent</package.name> <main.name>App</main.name></properties>... <manifest> <packageName>${package.name}</packageName> <mainClass>${package.name}.${main.name}</mainClass> <addClasspath>true</addClasspath></manifest>

41Compilerbau – SS 2019 – Teil 0/Maven

Nach dieser Anstrengung etwas Entspannung...