Compilerbau – SS 2019 – Teil...

of 21 /21
2 Compilerbau – SS 2019 – Teil 0/Maven Literatur und Web [0-1] Maven by Example http://www.sonatype.com/resources/books/maven-by-example/download [0-2] Maven – the complete Reference http://www.sonatype.com/resources/books/maven-the-complete- reference/download [0-3] Better Builds with Maven http://index-of.es/Java/Better.Builds.With.Maven.pdf [0-4] Maven 3.5 http://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

Embed Size (px)

Transcript of Compilerbau – SS 2019 – Teil...

  • 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: -.

    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: ..-- 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) (02) 4.0.0(03) de.htw_berlin.f4.cb(04) halloMaven(05) 1.0-SNAPSHOT(06) jar(07) (08) UTF-8(09) 11(10) 11(11) (12)

    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

    junit junit 4.12 test

    • 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

    org.apache.maven.plugins maven-checkstyle-plugin 3.0.0 com.puppycrawl.tools checkstyle 8.17 false true

  • 29Compilerbau – SS 2019 – Teil 0/Maven

    Die POM-Datei III - Checkstyle

    org.apache.maven.plugins maven-checkstyle-plugin ...

    org.apache.maven.plugins maven-checkstyle-plugin 3.0.0 true

    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

    org.apache.maven.plugins maven-checkstyle-plugin checkstyle test true false check

  • 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

    org.apache.maven.plugins maven-jar-plugin 3.1.1 de.htw_berlin.f4.cb.mavenpercent de.htw_berlin.f4.cb.mavenpercent.App true

    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

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

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

    • 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.

    11 11 UTF-8 de.htw_berlin.f4.cb.mavenpercent App

    ...

    ${package.name} ${package.name}.${main.name} true

  • 41Compilerbau – SS 2019 – Teil 0/Maven

    Nach dieser Anstrengung etwas Entspannung...