Upload
others
View
7
Download
0
Embed Size (px)
Citation preview
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...