Apache Maven ist
(ähnlich wie Ant
und Gradle)
ein leistungsfähiges Werkzeug, um viele in der Softwareentwicklung
immer wieder anfallende Prozeduren zu automatisieren und zu vereinfachen.
Es wird manchmal als "Build Management System" bezeichnet und ist Teil vom
"Software Configuration Management (SCM)".
Während Ant eher kommandoorientiert arbeitet, ist Maven eher strategisch orientiert, realisiert mehr Abstraktionen, wird deklarativer gesteuert, berücksichtigt Abhängigkeiten besser und ist besonders für aufwändigere Multimodulprojekte geeignet.
Im Folgenden wird nur auf die veraltete Version Maven 3.3.9 eingegangen. Informationen zu anderen Versionen finden Sie unter Maven 3.5, Maven 2.2.1 und Maven 1.
Sowohl Ant als auch Maven sind leistungsfähige Werkzeuge, um viele in der Softwareentwicklung immer wieder anfallende Prozeduren zu automatisieren und zu vereinfachen. Beide haben ihre bevorzugten Einsatzbereiche.
Vorteile von Ant:
Vorteile von Maven:
Die Aufruf-Syntax der im Kommandozeilenfenster aufrufbaren mvn-Kommandos lautet:
"mvn [options] [<goal(s)>] [<phase(s)>]".
Es können also übergeben werden (sowohl einzeln als auch kombiniert):
Einige wichtige oder häufig benutzte Maven-Kommandos sind:
| Kommando | Bedeutung |
|---|---|
| mvn -v | Anzeige der Version von Maven |
| mvn -h | Hilfe zu den Kommandozeilenoptionen von Maven |
| mvn help:help | Hilfe zur aktuellen Build-Umgebung |
| mvn help:describe -Dplugin=... | Hilfe zu bestimmten Plugins (und mit -Ddetail auch zu Goals) |
| mvn help:effective-settings | Anzeige der aktuellen projektübergreifenden Settings-Einstellungen |
| mvn help:effective-pom | Anzeige der aktuell resultierenden projektbezogenen POM |
| mvn help:active-profiles | Anzeige der aktiven Profile (aber ohne geerbte Profile) |
| mvn help:all-profiles | Anzeige aller Profile (aber ohne geerbte Profile) |
| mvn help:evaluate -Dexpression=... | Auflösung von Maven-Ausdrücken, z.B. in Batchdatei: for /f "delims=" %%a in ('mvn help:evaluate -Dexpression^=settings.localRepository ^| findstr /V [') do set _mvnrepo=%%a Auch Server-Props können abgefragt werden, z.B.: mvn help:evaluate -Dexpression=settings.servers[0].username |
| mvn dependency:tree -Dverbose | Übersicht zum Abhängigkeitsbaum; weitere Goals: analyze, build-classpath, resolve-plugins, go-offline, copy-dependencies |
| mvn dependency:sources | Zusätzlich zu den Libs und POMs auch die Sourcen downloaden, falls vorhanden |
| mvn dependency:resolve -Dclassifier=javadoc | Zusätzlich zu den Libs und POMs auch die Javadoc-Dateien downloaden |
| mvn clean | Löschen aller erzeugten Artefakte und des target-Verzeichnisses |
| mvn compile | Kompilierung |
| mvn test | Ausführen der Komponententests (z.B. JUnit-Tests) |
| mvn package | Build und Erzeugung der Ergebnis-Artefakte |
| mvn verify | Ausführen der Integrationstests (nicht "mvn integration-test", damit auch die "post-integration-test"-Phase ausgeführt wird) |
| mvn install | Kopieren des Ergebnis-Artefakts ins lokale Maven-Repository |
| mvn deploy | Kopieren des Ergebnis-Artefakts ins Remote Repository |
| mvn site | Erzeugen der Projektdokumentation |
| mvn archetype:generate | Projektstruktur erzeugen |
| mvn test -Dtest=MeinTest | Nur eine einzige Testklasse ausführen |
| mvn test -Dtest=MeinAbcTest,MeinXyzTest | Mehrere Testklassen in definierter Reihenfolge ausführen |
| mvn package -DskipTests | Test-Klassen werden kompiliert, aber nicht ausgeführt |
| mvn package -Dmaven.test.skip=true | Test-Klassen werden nicht kompiliert und nicht ausgeführt |
| mvn jetty:run | Startet den Jetty-Server und führt das Webapp-Projekt aus |
Maven-Basisinstallation unter Linux
Maven-Basisinstallation unter Windows
Setzen Sie folgende Umgebungsvariablen (Environment-Variablen)
(passen Sie die Pfadangaben an Ihre Java- und Maven-Verzeichnisse an)
(unter Windows 7 und Vista: 'WindowsTaste + PauseTaste' | 'Erweiterte Systemeinstellungen' | Reiter 'Erweitert' | 'Umgebungsvariablen...';
unter Windows XP: 'WindowsTaste + PauseTaste' | 'Erweitert' | 'Umgebungsvariablen';
unter Linux: siehe linux.htm#Umgebungsvariablen):
| Benutzervariablen setzen: | |
| JAVA_HOME | C:\Program Files\Java\jdk1.8 |
| M2_HOME | D:\Tools\Maven3 |
| MAVEN_OPTS | -Xms256m -Xmx512m |
| PATH | %JAVA_HOME%\bin;%M2_HOME%\bin |
Bitte beachten Sie, dass Sie nicht die PATH-Systemvariable um die "%...%\bin"-Pfade erweitern, sondern eine PATH-Benutzervariable anlegen (sonst funktioniert die "%...%"-Syntax nicht).
Jetzt müssen folgende Kommandos ein erfolgreiches Ergebnis liefern. Öffnen Sie (in Windows mit 'Windows-Taste' + 'R' und 'cmd') ein neues Kommandozeilenfenster (damit die Änderung der Umgebungsvariablen wirksam wird) und geben Sie ein:
set
set JAVA_HOME
set M2_HOME
path
java -version
javac -version
javac -help
mvn -v
mvn -h
Konfiguration
Fehlende Bibliotheken und Plug-ins lädt Maven automatisch zum Beispiel von http://central.maven.org/maven2. Beachten Sie auch die Hinweise zu Sun JARs.
Wenn Sie die Voreinstellung nicht ändern, wird als lokales Maven-Repository-Verzeichnis je nach Betriebssystem zum Beispiel C:\Users\%USERNAME%\.m2\repository, C:\Dokumente und Einstellungen\%USERNAME%\.m2\repository, <user-home>/.m2/repository oder ~/.m2/repository verwendet.
Für alle Projekte geltende Voreinstellungen (z.B. Zugangsdaten zu CVS- oder Subversion-Servern) werden in
settings.xml-Dateien definiert:
%M2_HOME%\conf\settings.xml für systemweite Einstellungen,
%USERPROFILE%\.m2\settings.xml für benutzerspezifische Einstellungen.
Projektabhängige Einstellungen befinden sich in den jeweiligen pom.xml-Dateien.
Falls Sie spezielle Konfigurationen benötigen, wie zum Beispiel HTTP-Proxy-Server, Repository-Manager oder Server-Authentifizierung, lesen Sie bitte Maven-Repository, Configuring Maven, Settings Reference, Technical Settings Descriptor und Password Encryption.
Falls Sie eine Fehlermeldung ähnlich zu folgender erhalten:
Failed to invoke Maven build. Error configuring command-line. Reason: Maven executable not found at: ...\bin\mvn.bat
Dann prüfen Sie, ob sich in Ihrem Maven-bin-Verzeichnis eine mvn.bat-Datei befindet. Falls nicht, führen Sie aus:
cd /D %M2_HOME%\bin
dir mvn.*
if not exist mvn.bat copy mvn.cmd mvn.bat
Maven in Firmen
In Firmen sind in der systemweiten settings.xml meistens zumindest Einstellungen zum localRepository und eines mirrors erforderlich, beispielsweise so:
<settings>
<localRepository>D:\Tools\Maven3-Repo</localRepository>
<mirrors>
<mirror>
<id>MeineMirrorId</id>
<mirrorOf>central</mirrorOf>
<url>http://firma.repository.server:port/repo/path</url>
</mirror>
</mirrors>
</settings>
Das localRepository-Verzeichnis sollte in Firmen nicht im <user-home>-Verzeichnis liegen, weil in Firmen häufig das <user-home>-Verzeichnis bei jedem PC-Herunterfahren gesichert und beim Starten wiederhergestellt wird, was unnötig Backup-Speicherplatz kosten und diese Vorgänge verlangsamen würde.
Ein mirror-Server muss oft definiert werden, damit Artefakte nicht vom Internet, sondern von einem firmeninternen Server geladen werden, weil in Firmen eventuell restriktivere Sicherheitsvorschriften gelten oder weil vielleicht nur bestimmte Libs und Versionen zur Verwendung freigegeben sind.
Sehen Sie sich die eingestellten Settings an über:
mvn help:effective-settings
Weiteres zur settings.xml und zum Umgang mit Firmen-Proxies und Repository-Manager finden Sie weiter unten unter Maven-Repository.
Maven mit Eclipse mit M2E (empfohlen)
Wenn Sie Eclipse verwenden, sollten Sie normalerweise nicht das maven-eclipse-plugin verwenden, sondern stattdessen Maven-Projekte mit dem M2Eclipse-Plugin importieren. Siehe hierzu: Das M2Eclipse-Plugin (m2e) zur Zusammenarbeit von Eclipse mit Maven.
Falls Sie Maven-Multimodulprojekte in Eclipse bearbeiten wollen, sehen Sie sich an: maven-multiproj.htm#Maven-Multimodulprojekt-in-Eclipse und Using maven-eclipse-plugin in multi-module projects with WTP.
Maven mit Eclipse ohne M2E (nicht empfohlen)
Wenn Sie unbedingt das maven-eclipse-plugin verwenden wollen, obwohl es nicht empfohlen ist:
Geben Sie das lokale Maven-Repository-Verzeichnis über die Eclipse-Variable "M2_REPO" bekannt. Dies geht am einfachsten über das Maven-Goal eclipse:configure-workspace über folgenden Kommandozeilenbefehl (bitte Eclipse-Workspace-Pfad "D:\MeinWorkspace" anpassen):
mvn -Declipse.workspace=D:\MeinWorkspace eclipse:configure-workspace
Alternativ können Sie in Eclipse über 'Window' | 'Preferences' | '[+] Java' | '[+] Build Path' | 'Classpath Variables' | 'New...' eingeben (bitte Pfad anpassen):
| Eclipse Classpath Variables: | |
| M2_REPO | C:\Users\%USERNAME%\.m2\repository |
| Bzw. je nach Konfiguration: | |
| M2_REPO | D:\Tools\Maven3-Repo |
Anschließend müssen Sie Eclipse neu starten.
Bei neuen Maven-Projekten oder nach Updates auf bestehenden Maven-Projekten müssen Sie als Erstes die Eclipse-Projektdateien erstellen bzw. aktualisieren. Falls Sie nicht das M2Eclipse-Plugin verwenden, erfolgt das über "mvn eclipse:..."-Kommandos:
mvn eclipse:eclipse
Falls Sie nachträglich Konfigurationsänderungen durchführen, kann folgendes Kommando "aufräumen":
mvn eclipse:clean eclipse:eclipse
Wichtig: Nach dem "mvn eclipse:eclipse"-Kommando und auch nach jeder anderen Änderung, die Sie außerhalb von Eclipse vornehmen, müssen Sie in Eclipse im 'Package Explorer' die Projektmodule markieren und mit 'F5' einen 'Refresh' ausführen.
Öffnen Sie ein Kommandozeilenfenster ('Windows-Taste' + 'R', 'cmd'), wechseln Sie in Ihr Projekte-Verzeichnis (z.B. \MeinWorkspace), erzeugen Sie mit dem Maven-archetype-Plugin eine einfache Standard-Directory-Struktur und sehen Sie sich diese an (das mvn-Kommando in einer Zeile):
cd \MeinWorkspace
mvn archetype:generate -DinteractiveMode=false -DgroupId=de.meinefirma.meinprojekt -DartifactId=MvnHelloApp
cd MvnHelloApp
tree /F
Sie erhalten:
[\MeinWorkspace\MvnHelloApp] |- [src] | |- [main] | | '- [java] | | '- [de] | | '- [meinefirma] | | '- [meinprojekt] | | '- App.java | '- [test] | '- [java] | '- [de] | '- [meinefirma] | '- [meinprojekt] | '- AppTest.java '- pom.xml
Um den Build durchzuführen und das entstandene Programm auszuführen, geben Sie im Kommandozeilenfenster ein:
cd \MeinWorkspace\MvnHelloApp
mvn package
java -cp target/MvnHelloApp-1.0-SNAPSHOT.jar de.meinefirma.meinprojekt.App
Sie erhalten:
Hello World!
Sehen Sie nach, was im target-Verzeichnis entstanden ist und was in der resultierenden Jar-Datei enthalten ist:
cd \MeinWorkspace\MvnHelloApp
tree /F
jar tvf target/MvnHelloApp-1.0-SNAPSHOT.jar
Fügen Sie in App.java etwas Sinnvolles ein und testen Sie dies in AppTest.java.
Folgeaufrufe von "mvn package" gehen wesentlich schneller, weil jetzt die benötigten Maven-Plugins im lokalen Maven-Repository vorhanden sind.
Im letzten Beispiel wurde direkt die kompilierte Klasse App.class ausgeführt. Im folgenden Beispiel wird das letzte Beispiel so erweitert, dass die kompilierten Klassen mit dem Maven JAR Plugin zu einem ausführbaren Jar-Archiv zusammengefasst werden, inklusive einer automatisch generierten MANIFEST.MF mit geignetem Main-Class-Eintrag.
Falls Sie zusätzlich Libs einbinden wollen, sehen Sie sich die Beispiele zum maven-assembly-plugin und zum maven-shade-plugin an.
Ersetzen Sie im MvnHelloApp-Projektverzeichnis den Inhalt der pom.xml durch:
<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>de.meinefirma.meinprojekt</groupId>
<artifactId>MvnHelloApp</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>MvnHelloApp</name>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<version>3.0.2</version>
<configuration>
<archive>
<manifest>
<mainClass>de.meinefirma.meinprojekt.App</mainClass>
<addClasspath>true</addClasspath>
</manifest>
</archive>
</configuration>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>
Führen Sie die Jar-Datei im Kommandozeilenfenster aus:
cd \MeinWorkspace\MvnHelloApp
mvn package
java -jar target/MvnHelloApp-1.0-SNAPSHOT.jar
Sie erhalten wieder:
Hello World!
Sie können auch weiterhin die App.class direkt ausführen (wie im obigen Beispiel):
java -cp target/MvnHelloApp-1.0-SNAPSHOT.jar de.meinefirma.meinprojekt.App
Sehen Sie sich die generierte MANIFEST.MF mit dem Main-Class-Eintrag an:
cd \MeinWorkspace\MvnHelloApp
jar xvf target/MvnHelloApp-1.0-SNAPSHOT.jar META-INF/MANIFEST.MF
type META-INF\MANIFEST.MF
Sie enthält die Zeile:
Main-Class: de.meinefirma.meinprojekt.App
Übrigens kann das maven-jar-plugin noch mehr, beispielsweise können Sie mit dem test-jar-Goal Testartefakte auch in anderen Modulen nutzen, siehe Test-Jar. Sie können auch mehrere verschiedene Artifakte mit einem Aufruf erzeugen, siehe REST-Client mit REST-JUnit-Test.
Falls Sie die Attribute in der MANIFEST.MF zur Laufzeit auslesen wollen, ersetzen Sie den Inhalt der App.java durch:
package de.meinefirma.meinprojekt;
import java.io.File;
import java.util.jar.*;
public class App
{
public static void main( String[] args ) throws Exception
{
System.out.println( "\nManifest-Attribute:\n" + getJarManifestAttributes( App.class ).entrySet() );
}
public static Attributes getJarManifestAttributes( Class<?> clazz ) throws Exception
{
JarFile jarFile = new JarFile( new File( clazz.getProtectionDomain().getCodeSource().getLocation().toURI() ) );
Manifest manifest = jarFile.getManifest();
jarFile.close();
return manifest.getMainAttributes();
}
}
Und führen Sie aus:
mvn package
java -jar target/MvnHelloApp-1.0-SNAPSHOT.jar
Im folgenden Beispiel besteht die Anwendung aus einer Klasse, die eine zusätzliche .jar-Bibliothek benötigt. Die kompilierten Klassen, die benötigten .jar-Libs und eine automatisch generierte MANIFEST.MF werden mit dem Maven Assembly Plugin in ein ausführbares "Fat-Jar" gepackt.
Alternativ zum maven-assembly-plugin wird mittlerweile häufig das maven-shade-plugin bevorzugt. Siehe hierzu das Beispiel Vert.x-HelloWorld.
Starten Sie ein neues Projekt:
cd \MeinWorkspace
mvn archetype:generate -DinteractiveMode=false -DgroupId=de.meinefirma.meinprojekt -DartifactId=MvnJarMitLibs
cd MvnJarMitLibs
Ersetzen Sie im src\main\java\de\meinefirma\meinprojekt-Verzeichnis den Inhalt von App.java durch:
package de.meinefirma.meinprojekt;
import org.apache.log4j.Logger;
public class App
{
private static final Logger LOGGER = Logger.getRootLogger();
public static void main( String[] args )
{
LOGGER.info( "---- Hallo Logger! ----" );
}
}
Die Anwendung verwendet den Log4j-Logger. Falls Sie Log4j nicht kennen: Sehen Sie sich java-log4j.htm an.
Ersetzen Sie im src\test\java\de\meinefirma\meinprojekt-Verzeichnis den Inhalt von AppTest.java durch:
package de.meinefirma.meinprojekt;
import junit.framework.TestCase;
public class AppTest extends TestCase
{
public void testApp()
{
App.main( null );
}
}
Erzeugen Sie im src\main-Verzeichnis das Unterverzeichnis resources und darin folgende Log4j-Konfigurationsdatei: log4j.properties
log4j.rootLogger=DEBUG, MeinConsoleAppender
log4j.appender.MeinConsoleAppender=org.apache.log4j.ConsoleAppender
log4j.appender.MeinConsoleAppender.layout=org.apache.log4j.PatternLayout
log4j.appender.MeinConsoleAppender.layout.ConversionPattern=%d{ISO8601} %-5p [%t] %c: %m%n
Die Abhängigkeit zur log4j-1.2.17.jar muss in die pom.xml eingetragen werden. Ersetzen Sie im MvnJarMitLibs-Projektverzeichnis den Inhalt der pom.xml durch:
<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>de.meinefirma.meinprojekt</groupId>
<artifactId>MvnJarMitLibs</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>MvnJarMitLibs</name>
<dependencies>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>
Sehen Sie sich mit tree /F die Verzeichnisstruktur an:
[\MeinWorkspace\MvnJarMitLibs] |- [src] | |- [main] | | |- [java] | | | '- [de] | | | '- [meinefirma] | | | '- [meinprojekt] | | | '- App.java | | '- [resources] | | '- log4j.properties | '- [test] | '- [java] | '- [de] | '- [meinefirma] | '- [meinprojekt] | '- AppTest.java '- pom.xml
Führen Sie den JUnit-Test aus:
mvn test
Sie erhalten:
2015-01-01 11:12:13,456 INFO [main] root: ---- Hallo Logger! ----
Im Test ist die log4j-1.2.17.jar im Classpath und der Log4j-Logger funktioniert.
Führen Sie den Build-Prozess aus, sehen Sie sich an, was in der erstellten Jar-Datei enthalten ist und versuchen Sie die Anwendung zu starten:
mvn package
jar tvf target/MvnJarMitLibs-1.0-SNAPSHOT.jar
java -cp target/MvnJarMitLibs-1.0-SNAPSHOT.jar de.meinefirma.meinprojekt.App
Weil in der erstellten Jar-Datei die log4j-1.2.17.jar-Lib fehlt, erhalten Sie die Exception:
Exception in thread "main" java.lang.NoClassDefFoundError: org/apache/log4j/Logger
Um eine ausführbare Jar-Datei zu erhalten, sind zwei Erweiterungen notwendig:
Dies leistet das maven-assembly-plugin.
Ersetzen Sie im MvnJarMitLibs-Projektverzeichnis den Inhalt der pom.xml durch:
<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>de.meinefirma.meinprojekt</groupId>
<artifactId>MvnJarMitLibs</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>MvnJarMitLibs</name>
<build>
<plugins>
<plugin>
<artifactId>maven-assembly-plugin</artifactId>
<version>2.6</version>
<configuration>
<descriptorRefs>
<descriptorRef>jar-with-dependencies</descriptorRef>
</descriptorRefs>
<archive>
<manifest>
<mainClass>de.meinefirma.meinprojekt.App</mainClass>
</manifest>
</archive>
</configuration>
<executions>
<execution>
<id>make-assembly</id>
<phase>package</phase>
<goals>
<goal>single</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>
<descriptorRef>jar-with-dependencies</descriptorRef>
ist ein vordefinierter "prefabricated assembly descriptor" zur Integration von Abhängigkeiten, wie zum Beispiel .jar-Libs. Weitere
Pre-defined Descriptor Files
sind: bin, src und project.
Alternativ können Sie auch einen selbst erstellten "custom assembly descriptor" verwenden, wie unter
Configuration and Usage beschrieben ist.
<mainClass>de.meinefirma.meinprojekt.App</mainClass> definiert die auszuführende Klasse, welche die main()-Methode enthält.
Bauen Sie die "jar-with-dependencies" und führen Sie sie aus:
mvn clean package
dir target\MvnJarMitLibs*.jar
jar tvf target\MvnJarMitLibs-1.0-SNAPSHOT-jar-with-dependencies.jar
--> Die org/apache/log4j/...-Klassen sind enthalten.
java -jar target\MvnJarMitLibs-1.0-SNAPSHOT-jar-with-dependencies.jar
--> Die Jar-Datei kann ausgeführt werden und Sie erhalten das korrekte Ergebnis:
2015-01-01 11:12:13,456 INFO [main] root: ---- Hallo Logger! ----
Sehen Sie sich die Hilfstexte zu den Goals des Assembly-Plugins an:
mvn help:describe -Dplugin=org.apache.maven.plugins:maven-assembly-plugin
Öffnen Sie ein Kommandozeilenfenster ('Windows-Taste' + 'R', 'cmd'), wechseln Sie in Ihr Projekte-Verzeichnis (z.B. \MeinWorkspace) und erzeugen Sie eine Webapp-Projektstruktur (das mvn-Kommando in einer Zeile):
cd \MeinWorkspace
mvn archetype:generate -DinteractiveMode=false -DarchetypeArtifactId=maven-archetype-webapp -DgroupId=de.meinefirma.meinprojekt -DartifactId=MvnJettyWebApp
cd MvnJettyWebApp
tree /F
Sie erhalten:
[\MeinWorkspace\MvnJettyWebApp] |- [src] | '- [main] | |- [resources] | '- [webapp] | |- [WEB-INF] | | '- web.xml | '- index.jsp '- pom.xml
Ersetzen Sie den Inhalt der pom.xml durch:
<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>de.meinefirma.meinprojekt</groupId>
<artifactId>MvnJettyWebApp</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>war</packaging>
<name>MvnJettyWebApp Maven Webapp</name>
<url>http://www.meinefirma.de</url>
<build>
<finalName>${project.artifactId}</finalName>
<plugins>
<plugin>
<groupId>org.eclipse.jetty</groupId>
<artifactId>jetty-maven-plugin</artifactId>
<version>9.3.10.v20160621</version>
<configuration>
<webAppConfig>
<contextPath>/${project.artifactId}</contextPath>
</webAppConfig>
</configuration>
</plugin>
</plugins>
</build>
</project>
Ausführung des Projekts:
cd \MeinWorkspace\MvnJettyWebApp
mvn jetty:run
Warten Sie, bis "Started Jetty Server" erscheint, und rufen Sie dann im Webbrowser auf:
http://localhost:8080/MvnJettyWebApp
Sie erhalten eine Webseite mit:
Hello World!
Beenden Sie Jetty mit "Strg + C".
Sehen Sie sich die Hilfstexte zu dem genannten und anderen Goals des Jetty-Plugins an:
mvn help:describe -Dplugin=org.eclipse.jetty:jetty-maven-plugin
Sehen Sie sich Konfigurationsoptionen des Jetty-Plugins an:
http://eclipse.org/jetty/documentation/current/jetty-maven-plugin.html.
Dieses Beispiel demonstriert Folgendes:
Führen Sie folgende Schritte durch:
Öffnen Sie ein Kommandozeilenfenster, wechseln Sie in Ihr Projekte-Verzeichnis (z.B. \MeinWorkspace) und erzeugen Sie eine Webapp-Projektstruktur:
cd \MeinWorkspace
mvn archetype:generate -DinteractiveMode=false -DarchetypeArtifactId=maven-archetype-webapp -DgroupId=de.meinefirma.meinprojekt -DartifactId=MvnWebManifest
cd MvnWebManifest
tree /F
Sie erhalten:
[\MeinWorkspace\MvnWebManifest] |- [src] | '- [main] | |- [resources] | '- [webapp] | |- [WEB-INF] | | '- web.xml | '- index.jsp '- pom.xml
Ersetzen Sie den Inhalt der pom.xml durch:
<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>de.meinefirma.meinprojekt</groupId>
<artifactId>MvnWebManifest</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>war</packaging>
<name>MvnWebManifest</name>
<url>http://www.meinefirma.de</url>
<properties>
<maven.build.timestamp.format>yyyy-MM-dd HH:mm</maven.build.timestamp.format>
</properties>
<build>
<finalName>${project.artifactId}</finalName>
<plugins>
<plugin>
<artifactId>maven-war-plugin</artifactId>
<version>2.6</version>
<configuration>
<!-- <packagingExcludes>, um folgende Warnung mit der 2.1.1-Version zu vermeiden:
[WARNING] Warning: selected war files include a WEB-INF/web.xml which will be ignored
(webxml attribute is missing from war task, or ignoreWebxml attribute is specified as 'true') -->
<packagingExcludes>WEB-INF/web.xml</packagingExcludes>
<archive>
<manifest>
<!-- Default-Properties: -->
<addDefaultImplementationEntries>false</addDefaultImplementationEntries>
</manifest>
<manifestEntries>
<!-- Maven-Properties: -->
<Modulname>${project.name}</Modulname>
<Modulversion>${project.version}</Modulversion>
<Maven-Build-Timestamp>${maven.build.timestamp}</Maven-Build-Timestamp>
<!-- Andere Properties, z.B. per buildnumber-maven-plugin, von Jenkins/Hudson oder per Kommandozeile gesetzt: -->
<VCS-Buildnumber>${buildNumber}</VCS-Buildnumber>
<hg-ChangeSet-ID>${changeSet}, ${changeSetDate}</hg-ChangeSet-ID>
<Modulbuild>${BUILD_TAG}, ${BUILD_ID}</Modulbuild>
<MeinSpezProp>${MeinSpezProp}</MeinSpezProp>
</manifestEntries>
</archive>
</configuration>
</plugin>
<plugin>
<groupId>org.eclipse.jetty</groupId>
<artifactId>jetty-maven-plugin</artifactId>
<version>9.3.10.v20160621</version>
<configuration>
<webAppConfig>
<contextPath>/${project.artifactId}</contextPath>
</webAppConfig>
</configuration>
</plugin>
</plugins>
</build>
</project>
Ersetzen Sie im src\main\webapp-Verzeichnis den Inhalt der index.jsp durch:
<%@ page import="java.io.*" %>
<%@ page import="java.util.*" %>
<%@ page import="java.util.jar.*" %>
<html>
<body>
<h2>Hello World!</h2>
<%
String pth = getServletConfig().getServletContext().getRealPath( "/" );
if( !pth.endsWith( "/" ) && !pth.endsWith( "\\" ) ) pth += "/";
File mf = new File( pth + "META-INF/MANIFEST.MF" );
if( mf.exists() ) {
out.println( "<h4>Attribute in der META-INF/MANIFEST.MF:</h4>" );
Manifest manifest = new Manifest( new FileInputStream( mf ) );
for( Map.Entry<Object,Object> attr : manifest.getMainAttributes().entrySet() ) {
out.println( attr + "<br>" );
}
}
%>
</body>
</html>
Ausführung des Projekts:
cd \MeinWorkspace\MvnWebManifest
mvn clean war:manifest war:war -DMeinSpezProp=AbcXyz
type src\main\webapp\META-INF\MANIFEST.MF
mvn jetty:run
Warten Sie, bis "Started Jetty Server" erscheint, und rufen Sie dann im Webbrowser auf:
Sie erhalten eine Webseite mit der Auflistung der Attribute in der MANIFEST.MF
inklusive des per Kommandozeile angegebenen Attributs MeinSpezProp=AbcXyz.
Das ${buildNumber}-Property kann durch das
buildnumber-maven-plugin mit dem
create-Goal
gesetzt werden (falls Ihr Versionskontrollsystem unterstützt wird und korrekt im
SCM-Tag eingetragen ist).
Falls Sie Mercurial (hg) als Versionskontrollsystem verwenden,
können mit dem
buildnumber-maven-plugin-hgchangeset-Goal
die ${changeSet}- und ${changeSetDate}"-Properties gesetzt werden.
Die BUILD_...-Properties können z.B. durch
Jenkins/Hudson gesetzt werden.
Falls einige Properties beim oben gezeigten Aufruf nicht gesetzt werden (z.B. weil sie erst in der validate-Phase gesetzt werden): Führen Sie folgende Kommandos aus, um sie anzuzeigen:
cd \MeinWorkspace\MvnWebManifest
call mvn clean install
cd target
jar xf MvnWebManifest.war
type META-INF\MANIFEST.MF
Beenden Sie Jetty mit "Strg + C".
Sie können die resultierende WAR-Datei target\MvnWebManifest.war auch in beliebige andere Web Application Server (z.B. Tomcat) deployen.
Dieses Beispiel zeigt Zweierlei:
In diesem Programmierbeispiel werden die Property-Werte lediglich in der Java-Anwendung ausgelesen und angezeigt. Mit Property-Werten könnte aber auch der Build-Prozess gesteuert werden (z.B. über Profile).
Alternativ könnten auch mit dem maven-replacer-plugin Ausdrücke ersetzt werden.
Öffnen Sie ein Kommandozeilenfenster, wechseln Sie in Ihr Projekte-Verzeichnis (z.B. \MeinWorkspace) und erzeugen Sie eine neue Projektstruktur:
cd \MeinWorkspace
mvn archetype:generate -DinteractiveMode=false -DgroupId=de.meinefirma.meinprojekt -DartifactId=MvnPropApp
cd MvnPropApp
md src\main\filters
md src\main\resources\filtered
md src\test\resources
Ersetzen Sie in src\main\java\de\meinefirma\meinprojekt den Inhalt von App.java durch:
package de.meinefirma.meinprojekt;
import java.io.IOException;
import java.util.Properties;
public class App
{
public static void main( String[] args )
{
System.out.println( (new App()).run() );
}
public String run()
{
Properties props = new Properties();
try {
// Properties einlesen:
props.load( getClass().getResourceAsStream( "/filtered/MeineProps.properties" ) );
} catch( IOException ex ) {
throw new RuntimeException( ex.getCause() );
}
// Properties zu String wandeln:
String s = props.toString();
if( s.length() > 2 ) { s = s.substring( 1, s.length() - 1 ); }
return s.replace( ", ", "\n" );
}
}
Ersetzen Sie in src\test\java\de\meinefirma\meinprojekt den Inhalt von AppTest.java durch:
package de.meinefirma.meinprojekt;
import java.io.IOException;
import java.util.Properties;
import junit.framework.TestCase;
public class AppTest extends TestCase
{
public void testApp()
{
Properties propsApp = new Properties(), propsTst = new Properties();
try {
propsApp.load( getClass().getResourceAsStream( "/filtered/MeineProps.properties" ) );
propsTst.load( getClass().getResourceAsStream( "/MeineTestProps.properties" ) );
} catch( IOException ex ) {
throw new RuntimeException( ex.getCause() );
}
assertEquals( "MeinPomProp vor Merge", "PropAusPom", propsApp.get( "MeinPomProp" ) );
propsApp.putAll( propsTst );
assertEquals( "MeinPomProp nach Merge", "PropAusTestProps", propsApp.get( "MeinPomProp" ) );
}
}
Bitte beachten Sie, dass Sie im Test sowohl auf die Ressourcen
unter src\main\resources als auch
unter src\test\resources zugreifen können.
Wenn Sie wie im Beispiel gezeigt einen Merge durchführen, können Sie Properties für den Testfall überschreiben.
Ersetzen Sie den Inhalt der pom.xml durch:
<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>de.meinefirma.meinprojekt</groupId>
<artifactId>MvnPropApp</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>MvnPropApp</name>
<url>http://www.meinefirma.de</url>
<build>
<filters>
<filter>src/main/filters/filter.properties</filter>
</filters>
<resources>
<resource>
<filtering>true</filtering>
<directory>src/main/resources</directory>
<includes>
<include>**/filtered/*</include>
</includes>
</resource>
<resource>
<filtering>false</filtering>
<directory>src/main/resources</directory>
<excludes>
<exclude>**/filtered/*</exclude>
</excludes>
</resource>
</resources>
</build>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
</dependencies>
<properties>
<MeinProp>PropAusPom</MeinProp>
<MeinPomProp>PropAusPom</MeinPomProp>
</properties>
</project>
Beachten Sie bitte den <build>- und den <properties>-Block:
Im <properties>-Block werden zwei Property-Werte definiert.
Im <build>-Block wird eine zusätzlich zu berücksichtigende Filter-Datei definiert (<filter>src/main/filters/filter.properties)
und es wird Filterung aktiviert (<filtering>true),
aber nicht für alle Ressourcen, sondern nur für die im filtered-Unterverzeichnis.
Wählen Sie für Filterung besser nicht das gesamte Ressourcen-Verzeichnis:
Vielleicht wollen Sie später Dateien hinzufügen, die nicht gefiltert werden dürfen (z.B. Bilddateien).
Erzeugen Sie unterhalb von src\main ein Unterverzeichnis mit dem Namen filters.
Erzeugen Sie in diesem Unterverzeichnis die Datei filter.properties mit folgendem Inhalt:
MeinProp=PropAusFilter MeinFilterProp=PropAusFilter
Erzeugen Sie unterhalb von src\main ein Unterverzeichnis mit dem Namen resources
und darunter eines mit dem Namen filtered.
Erzeugen Sie in letzterem die Datei MeineProps.properties mit folgendem Inhalt:
MeinPropsProp=PropAusMeineProps
MeinCmdProp=${MeinCmdProp}
MeinPomProp=${MeinPomProp}
MeinFilterProp=${MeinFilterProp}
MeinProp=${MeinProp}
pom.name=${pom.name}
pom.version=${pom.version}
pom.build.finalName=${pom.build.finalName}
pom.url=${pom.url}
settings.localRepository=${settings.localRepository}
basedir=${basedir}
os.arch=${os.arch}
os.name=${os.name}
java.version=${java.version}
user.home=${user.home}
Erzeugen Sie unterhalb von src\test ein Unterverzeichnis mit dem Namen resources und erzeugen Sie darin die Datei MeineTestProps.properties mit folgendem Inhalt:
MeinPomProp=PropAusTestProps
Lassen Sie sich die Verzeichnisstruktur anzeigen:
cd \MeinWorkspace\MvnPropApp
tree /F
-->
[\MeinWorkspace\MvnPropApp] |- [src] | |- [main] | | |- [filters] | | | '- filter.properties | | |- [java] | | | '- [de] | | | '- [meinefirma] | | | '- [meinprojekt] | | | '- App.java | | '- [resources] | | '- [filtered] | | '- MeineProps.properties | '- [test] | |- [java] | | '- [de] | | '- [meinefirma] | | '- [meinprojekt] | | '- AppTest.java | '- [resources] | '- MeineTestProps.properties '- pom.xml
Um den Build durchzuführen und das entstandene Programm inklusive eines Kommandozeilenparameters ("-D...") auszuführen, geben Sie im Kommandozeilenfenster ein:
cd \MeinWorkspace\MvnPropApp
mvn clean package "-DMeinCmdProp=PropVonCmd"
java -cp target/MvnPropApp-1.0-SNAPSHOT.jar de.meinefirma.meinprojekt.App
Sie erhalten eine Ausgabe ähnlich zu:
MeinPropsProp=PropAusMeineProps MeinCmdProp=PropVonCmd MeinPomProp=PropAusPom MeinFilterProp=PropAusFilter MeinProp=PropAusPom pom.name=MvnPropApp pom.version=1.0-SNAPSHOT pom.build.finalName=MvnPropApp-1.0-SNAPSHOT pom.url=http://www.meinefirma.de settings.localRepository=C:\Users\User\.m2\repository basedir=\MeinWorkspace\MvnPropApp os.arch=amd64 os.name=Windows 8.1 java.version=1.8 user.home=C:\Users\User
Die Property-Werte stammen aus unterschiedlichen Quellen:
Um nur die JUnit-Tests auszuführen, geben Sie im Kommandozeilenfenster ein:
cd \MeinWorkspace\MvnPropApp
mvn clean test
Falls es Probleme beim Test gibt, sehen Sie sich die Dateien im target\surefire-reports-Verzeichnis an:
start target\surefire-reports\de.meinefirma.meinprojekt.AppTest.txt
start target\surefire-reports\TEST-de.meinefirma.meinprojekt.AppTest.xml
Die XML-Datei enthält auch relevante Environment-Variablen und Konfigurationen
(z.B. <property name="localRepository" value="C:\Users\User\.m2\repository"/>).
Sehen Sie nach, was in der resultierenden Jar-Datei enthalten ist:
cd \MeinWorkspace\MvnPropApp
mvn package "-DMeinCmdProp=PropVonCmd"
jar tvf target/MvnPropApp-1.0-SNAPSHOT.jar
-->
de/meinefirma/meinprojekt/App.class filtered/MeineProps.properties META-INF/MANIFEST.MF META-INF/maven/de.meinefirma.meinprojekt/MvnPropApp/pom.properties META-INF/maven/de.meinefirma.meinprojekt/MvnPropApp/pom.xml
Bitte beachten Sie: Die filter.properties-Datei wurde zwar beim Filtern berücksichtigt (${MeinFilterProp} wurde umgewandelt in PropAusFilter), aber sie wird nicht dem Ergebnis-Artefakt hinzugefügt.
Ein profile definiert Voreinstellungen. Über Umgebungsbedingungen, Kommandozeilenoptionen oder andere Parameter können Profile aktiviert werden. Eine Einführung finden Sie unter Introduction to Build Profiles. Ein anderes Profile verwendendes Beispiel finden Sie unter Integrationstest mit Cargo.
Außer in der pom.xml können Profile auch in einer settings.xml definiert werden. Unter Maven 2.2.1 war zusätzlich auch die Definition von Profilen in einer profiles.xml-Datei möglich, was ab Maven 3.0 nicht mehr möglich ist (siehe Maven Release Notes und Maven 3.x Compatibility Notes).
In der settings.xml definierte Profile beeinflussen hauptsächlich:
Am meisten Einflussmöglichkeiten gibt es, wenn das Profil in der pom.xml definiert wird. Dann sind beispielsweise zusätzlich beeinflussbar:
Die Auswahl und Aktivierung (activation) eines (oder mehrerer) Profile kann über verschiedene Auslöser erfolgen:
Normalerweise werden die verschiedenen Profile eines Projekts in nur einer der möglichen Dateien gespeichert, fast immer in der pom.xml.
Von den vielen Möglichkeiten kann das folgende Beispiel nur wenig demonstrieren: Die Profile-Aktivierung erfolgt über -P-Kommandos oder alternativ über Properties, die per Umgebungsvariable oder Kommandozeilenparameter gesetzt werden. Und als Effekt werden lediglich die eingestellten Properties ausgegeben.
Damit die steuernde Property auch per Umgebungsvariable gesetzt werden kann, muss sie mit einem vorangestellten "env." beginnen und ansonsten in Großbuchstaben geschrieben sein (im Beispiel lautet sie: "env.UMGEBUNG"). Als Umgebungsvariable wird sie ohne das "env." gesetzt (siehe Beispiel unten).
Sie können dieses und die meisten der folgenden Programmierbeispiele wahlweise downloaden oder, wie im Folgenden beschrieben wird, schrittweise ausführen.
Voraussetzung ist, dass Sie das obige Beispiel Maven-Properties-Projekt (im Folgenden "MvnPropApp" genannt) erfolgreich durchgeführt haben.
Ergänzen Sie im MvnPropApp-Projektverzeichnis in der Datei pom.xml zwischen </properties> und </project> Folgendes:
<profiles>
<profile>
<id>Entw</id>
<activation>
<property>
<name>env.UMGEBUNG</name>
<value>Entwicklung</value>
</property>
</activation>
<properties>
<appsrv.url>meine.Url.zum.lokalen.Appserver</appsrv.url>
<appsrv.usr>mein lokaler AppServer-User</appsrv.usr>
<appsrv.pwd>geheim</appsrv.pwd>
<db.url>meine.Url.zur.lokalen.Datenbank</db.url>
<db.usr>mein lokaler DB-User</db.usr>
<db.pwd>supergeheim</db.pwd>
</properties>
</profile>
<profile>
<id>IntTest</id>
<activation>
<property>
<name>env.UMGEBUNG</name>
<value>Integrationstest</value>
</property>
</activation>
<properties>
<appsrv.url>Url.zum.IntTest.Appserver</appsrv.url>
<appsrv.usr>IntTest-AppServer-User</appsrv.usr>
<appsrv.pwd>geheim</appsrv.pwd>
<db.url>Url.zur.IntTest.Datenbank</db.url>
<db.usr>IntTest-DB-User</db.usr>
<db.pwd>supergeheim</db.pwd>
</properties>
</profile>
</profiles>
Ergänzen Sie in der Properties-Datei src\main\resources\filtered\MeineProps.properties Folgendes:
env.UMGEBUNG=${env.UMGEBUNG}
appsrv.url=${appsrv.url}
appsrv.usr=${appsrv.usr}
appsrv.pwd=${appsrv.pwd}
db.url=${db.url}
db.usr=${db.usr}
db.pwd=${db.pwd}
Öffnen Sie ein Kommandozeilenfenster, wechseln Sie in das MvnPropApp-Projektverzeichnis und führen Sie folgende Kommandos aus:
cd \MeinWorkspace\MvnPropApp
mvn clean package
java -cp target/MvnPropApp-1.0-SNAPSHOT.jar de.meinefirma.meinprojekt.App | sort
--> Die appsrv...- und db...-Properties sind nicht gesetzt.
set UMGEBUNG=Entwicklung
mvn clean package
java -cp target/MvnPropApp-1.0-SNAPSHOT.jar de.meinefirma.meinprojekt.App | sort
--> Die appsrv...- und db...-Properties sind für "Entwicklung" gesetzt.
mvn clean package "-Denv.UMGEBUNG=Integrationstest"
java -cp target/MvnPropApp-1.0-SNAPSHOT.jar de.meinefirma.meinprojekt.App | sort
--> Die appsrv...- und db...-Properties sind für "Integrationstest" gesetzt
(die set-Umgebungsvariable wird durch den Kommandozeilenparameter überschrieben).
Statt des Kommandozeilenparameters können Sie auch die Umgebungsvariable setzen:
set UMGEBUNG=Integrationstest
mvn clean package
java -cp target/MvnPropApp-1.0-SNAPSHOT.jar de.meinefirma.meinprojekt.App | sort
Sie erhalten eine Ausgabe wie oben gezeigt, aber je nach gesetztem env.UMGEBUNG-Property-Wert ergänzt um beispielsweise:
appsrv.pwd=geheim appsrv.url=Url.zum.IntTest.Appserver appsrv.usr=IntTest-AppServer-User db.pwd=supergeheim db.url=Url.zur.IntTest.Datenbank db.usr=IntTest-DB-User env.UMGEBUNG=Integrationstest
Alternativ können Sie die verschiedenen Profile auch über die -P-Option aktivieren:
set UMGEBUNG=
mvn package
java -cp target/MvnPropApp-1.0-SNAPSHOT.jar de.meinefirma.meinprojekt.App | sort
--> Die appsrv...- und db...-Properties sind nicht gesetzt.
mvn -P IntTest package
java -cp target/MvnPropApp-1.0-SNAPSHOT.jar de.meinefirma.meinprojekt.App | sort
--> Die appsrv...- und db...-Properties sind für "Integrationstest" gesetzt.
Falls Sie viele Profile haben und die Übersicht verlieren, können Sie sich mit dem Maven Help Plugin die aktivierten anzeigen lassen:
Wenn Sie
mvn help:active-profiles
ohne Profilangabe aufrufen, wird kein Profil aufgelistet.
Aber sowohl
mvn help:active-profiles "-Denv.UMGEBUNG=Integrationstest"
als auch
mvn help:active-profiles -P IntTest
führen zu:
The following profiles are active: - IntTest (source: ...)
Das Maven Help Plugin bietet noch weitere hilfreiche Kommandos, zum Beispiel:
mvn help:effective-pom "-Denv.UMGEBUNG=Integrationstest"
Sehen Sie sich die Doku zu DocBook und Docbkx an:
http://www.docbook.org/tdg5/en/html/docbook.html
http://docs.codehaus.org/display/MAVENUSER/Docbkx+Maven+Plugin
Öffnen Sie ein Kommandozeilenfenster, wechseln Sie in Ihr Projekte-Verzeichnis (z.B. \MeinWorkspace) und erzeugen Sie eine neue Projektstruktur:
cd \MeinWorkspace
md MvnDocbkx\src\docbkx
cd MvnDocbkx
Erzeugen Sie im MvnDocbkx-Projektverzeichnis die Projektkonfiguration: pom.xml
<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>de.meinefirma.meinprojekt</groupId>
<artifactId>MvnDocbkx</artifactId>
<version>1.0</version>
<packaging>pom</packaging>
<name>MvnDocbkx</name>
<build>
<plugins>
<plugin>
<groupId>com.agilejava.docbkx</groupId>
<artifactId>docbkx-maven-plugin</artifactId>
<version>2.0.14</version>
<executions>
<execution>
<goals>
<goal>generate-html</goal>
<goal>generate-webhelp</goal>
<goal>generate-rtf</goal>
<goal>generate-pdf</goal>
</goals>
<phase>package</phase>
</execution>
</executions>
<configuration>
<includes>book.xml</includes>
</configuration>
</plugin>
</plugins>
</build>
</project>
Erzeugen Sie im src\docbkx-Verzeichnis die Dokumentbeschreibung: book.xml
<book xmlns="http://docbook.org/ns/docbook"
xmlns:xlink="http://www.w3.org/1999/xlink"
version="5.0">
<info>
<author>
<personname><firstname>Torsten</firstname><surname>Horn</surname></personname>
</author>
<copyright><year>2012</year><holder>Torsten Horn</holder></copyright>
</info>
<title>Mein DocBook-Dokument</title>
<article>
<title>Mein erstes Kapitel</title>
<section>
<title>Mein erster Abschnitt</title>
<para>Mein erster Absatz vom ersten Abschnitt.</para>
<para>Mein zweiter Absatz vom ersten Abschnitt.</para>
</section>
<section>
<title>Mein zweiter Abschnitt</title>
<para>Mein erster Absatz vom zweiten Abschnitt.</para>
<para>Mein zweiter Absatz vom zweiten Abschnitt, mit Formatierungen, z.B.:
<quote>quote</quote>, <emphasis>emphasis</emphasis>, <replaceable>replaceable</replaceable>,
<literal>literal</literal>, <userinput>userinput</userinput>.</para>
</section>
</article>
<article>
<title>Mein zweites Kapitel</title>
<section>
<title>Mein neuer Abschnitt im zweiten Kapitel</title>
<para>Mein erster Absatz vom neuen Abschnitt im zweiten Kapitel.</para>
<para>Mein zweiter Absatz vom neuen Abschnitt im zweiten Kapitel mit einer Tabelle und mit HTML-Links:</para>
<table>
<title>Doku-Tabelle</title>
<tgroup cols="2">
<thead><row><entry>Thema</entry><entry>Doku-Link</entry></row></thead>
<tbody>
<row><entry>DocBook</entry><entry><link xlink:href="http://www.docbook.org/tdg5/en/html/docbook.html">http://www.docbook.org/tdg5/en/html/docbook.html</link></entry></row>
<row><entry>Docbkx </entry><entry><link xlink:href="http://docs.codehaus.org/display/MAVENUSER/Docbkx+Maven+Plugin">http://docs.codehaus.org/display/MAVENUSER/Docbkx+Maven+Plugin</link></entry></row>
</tbody>
</tgroup>
</table>
</section>
</article>
</book>
Führen Sie im MvnDocbkx-Projektverzeichnis aus:
cd \MeinWorkspace\MvnDocbkx
mvn clean package
start target/docbkx/html/book.html
start target/docbkx/webhelp/book/content/index.html
start target/docbkx/pdf/book.pdf
start target/docbkx/rtf/book.rtf
Das Layout der Dokumente ist in diesem einfachen Beispiel sehr rudimentär, aber Sie finden in der oben genannten Doku viele Hinweise zur Verbesserung.
Falls es Ihnen um PDF-Generierung geht, sehen Sie sich auch an:
PDF mit Apache PDFBox
PDF mit XSL-FO und Apache FOP
Das folgende Beispiel demonstriert Verschiedenes:
Aus einer XML-Schema-Definitions-Datei (XSD-Datei) wird Java-Code generiert.
Falls Sie sich nicht mit XML-Schema-Definitionen auskennen:
Sehen Sie sich die Einführungen unter
java-xsd.htm und
http://de.wikipedia.org/wiki/XML_Schema an
sowie die
W3C XML Schema Specification
entweder im englischen Original oder ins deutsche übersetzt unter
Einführung,
Strukturen und
Datentypen.
Als Codegenerator wird JAXB 2 verwendet. Siehe hierzu: Generierung von Java-Code aus einem XSD-Schema, JSR 222 und JAXB 2.x.
Die Einbindung in Maven erfolgt über das maven-jaxb2-plugin.
Da JAXB 2 mindestens Java 5 voraussetzt, wird außerdem gezeigt, wie dies dem maven-compiler-plugin mitgeteilt wird (über <configuration>...1.7...).
Öffnen Sie ein Kommandozeilenfenster, wechseln Sie in Ihr Projekte-Verzeichnis (z.B. \MeinWorkspace) und erzeugen Sie eine neue Projektstruktur:
cd \MeinWorkspace
mvn archetype:generate -DinteractiveMode=false -DgroupId=de.meinefirma.meinprojekt -DartifactId=MvnJaxbApp
cd MvnJaxbApp
md src\main\resources
tree /F
Ersetzen Sie den Inhalt der pom.xml durch:
<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>de.meinefirma.meinprojekt</groupId>
<artifactId>MvnJaxbApp</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>MvnJaxbApp</name>
<build>
<plugins>
<plugin>
<groupId>org.jvnet.jaxb2.maven2</groupId>
<artifactId>maven-jaxb2-plugin</artifactId>
<version>0.13.1</version>
<executions>
<execution>
<goals>
<goal>generate</goal>
</goals>
<configuration>
<generatePackage>de.meinefirma.meinprojekt.generated</generatePackage>
</configuration>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.5.1</version>
<configuration>
<source>1.7</source>
<target>1.7</target>
</configuration>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>com.sun.xml.bind</groupId>
<artifactId>jaxb-impl</artifactId>
<version>2.2.11</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>
Ersetzen Sie den Inhalt von src\test\java\de\meinefirma\meinprojekt\AppTest.java durch:
package de.meinefirma.meinprojekt;
import de.meinefirma.meinprojekt.generated.Buch;
import de.meinefirma.meinprojekt.generated.Buecherliste;
import java.math.BigDecimal;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
public class AppTest
{
@Test public void testApp()
{
Buch bu = new Buch();
bu.setTitel( "Mein Java-Buch" );
bu.setJahr( 2009 );
bu.setPreis( new BigDecimal( "47.11" ) );
bu.setKommentar( "Super!" );
Buecherliste bl = new Buecherliste();
bl.setKategorie( "Java-Bücher" );
bl.getListe().add( bu );
assertEquals( "Buecherliste", 1, bl.getListe().size() );
}
}
Erzeugen Sie unterhalb von src\main ein Unterverzeichnis mit dem Namen resources und erzeugen Sie darin die XSD-Datei buecherliste.xsd mit folgendem Inhalt:
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<xsd:complexType name="Buecherliste">
<xsd:sequence>
<xsd:element name="kategorie" type="xsd:string" />
<xsd:element name="liste" type="Buch" maxOccurs="unbounded" />
</xsd:sequence>
</xsd:complexType>
<xsd:complexType name="Buch">
<xsd:sequence>
<xsd:element name="titel" type="xsd:string" />
<xsd:element name="jahr" type="xsd:int" />
<xsd:element name="preis" type="xsd:decimal" />
<xsd:element name="kommentar" type="xsd:string" />
</xsd:sequence>
<xsd:attribute name="id" type="xsd:long" />
</xsd:complexType>
</xsd:schema>
Sehen Sie sich mit tree /F die Verzeichnisstruktur an:
[\MeinWorkspace\MvnJaxbApp] |- [src] | |- [main] | | |- [java] | | | '- [de] | | | '- [meinefirma] | | | '- [meinprojekt] | | | '- App.java | | '- [resources] | | '- buecherliste.xsd | '- [test] | '- [java] | '- [de] | '- [meinefirma] | '- [meinprojekt] | '- AppTest.java '- pom.xml
Bauen Sie das Projekt und sehen Sie sich das Ergebnis im target-Verzeichnis an:
cd \MeinWorkspace\MvnJaxbApp
mvn package
tree /F
Sie erhalten:
[\MeinWorkspace\MvnJaxbApp] |- [src] | |- [main] | | |- [java] | | | '- [de] | | | '- [meinefirma] | | | '- [meinprojekt] | | | '- App.java | | '- [resources] | | '- buecherliste.xsd | '- [test] | '- [java] | '- [de] | '- [meinefirma] | '- [meinprojekt] | '- AppTest.java |- [target] | |- ... | |- [generated-sources] | | '- [xjc] | | |- [de] | | | '- [meinefirma] | | | '- [meinprojekt] | | | '- [generated] | | | |- Buch.java | | | |- Buecherliste.java | | | '- ObjectFactory.java | | '- ... | '- ... '- pom.xml
Aus der XSD-Schema-Definition buecherliste.xsd im src\main\resources-Verzeichnis
wurden drei Java-Klassen im target\generated-sources\xjc\de\meinefirma\meinprojekt\generated-Verzeichnis generiert:
Buch.java, Buecherliste.java und ObjectFactory.java.
Sehen Sie sich diese drei Klassen an und beachten Sie, wie in der Buecherliste die Liste deklariert ist
(über maxOccurs="unbounded").
Wie Sie diese Klassen ganz normal in Ihren Programmen verwenden können, zeigt der JUnit-Test in AppTest.java.
Beispiele für RESTful-Webservices mit JAX-RS finden Sie unter jee-rest.htm#JaxRsMitMaven.
Das folgende Beispiel zeigt die Implementierung eines SOAP-Webservices mit JAX-WS inklusive Server und Client, allerdings nur in einer Quick-and-Dirty-Minimalversion. Weiterführende Hinweise finden Sie unter jee-jax-ws.htm. Wenn Sie mehr Features von JAX-WS nutzen wollen, sollten Sie sich das JAX-WS Maven-Plugin ansehen. Wenn Sie die Webservice-Kommunikation beobachten wollen, empfiehlt sich soapUI.
Öffnen Sie ein Kommandozeilenfenster, wechseln Sie in Ihr Projekte-Verzeichnis (z.B. \MeinWorkspace) und erzeugen Sie eine neue Projektstruktur:
cd \MeinWorkspace
md MvnJaxWs\src\main\java\de\meinefirma\meinprojekt
cd MvnJaxWs
Erstellen Sie im MvnJaxWs-Projektverzeichnis die Projektkonfiguratiosdatei: pom.xml
<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>de.meinefirma.meinprojekt</groupId>
<artifactId>MvnJaxWs</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>MvnJaxWs</name>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.5.1</version>
<configuration>
<source>1.7</source>
<target>1.7</target>
</configuration>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>javax.xml.ws</groupId>
<artifactId>jaxws-api</artifactId>
<version>2.2.11</version>
</dependency>
</dependencies>
</project>
Seit Java SE 6 können Sie den <dependency>...jaxws-api...-Abschnitt auch weglassen.
Legen Sie im Verzeichnis src\main\java\de\meinefirma\meinprojekt die folgenden vier Java-Dateien an:
HalloWelt.java
package de.meinefirma.meinprojekt;
import javax.jws.*;
@WebService
public interface HalloWelt
{
public String hallo( @WebParam( name = "wer" ) String wer );
}
HalloWeltImpl.java
package de.meinefirma.meinprojekt;
import javax.jws.WebService;
@WebService( endpointInterface="de.meinefirma.meinprojekt.HalloWelt" )
public class HalloWeltImpl implements HalloWelt
{
@Override
public String hallo( String wer )
{
return "Hallo " + wer;
}
}
TestWsServer.java
package de.meinefirma.meinprojekt;
import javax.xml.ws.Endpoint;
public class TestWsServer
{
public static void main( final String[] args )
{
String url = ( args.length > 0 ) ? args[0] : "http://localhost:8080/test";
Endpoint.publish( url, new HalloWeltImpl() );
}
}
TestWsClient.java
package de.meinefirma.meinprojekt;
import java.net.URL;
import javax.xml.namespace.QName;
import javax.xml.ws.Service;
public class TestWsClient
{
public static void main( final String[] args ) throws Throwable
{
String url = ( args.length > 0 ) ? args[0] : "http://localhost:8080/test";
Service service = Service.create(
new URL( url + "?wsdl" ),
new QName( "http://meinprojekt.meinefirma.de/", "HalloWeltImplService" ) );
HalloWelt halloWelt = service.getPort( HalloWelt.class );
System.out.println( "\n" + halloWelt.hallo( args.length > 1 ? args[1] : "" ) );
}
}
Die simplifizierte Projektstruktur sieht so aus:
cd \MeinWorkspace\MvnJaxWs
tree /F
[\MeinWorkspace\MvnJaxWs] |- [src] | '- [main] | '- [java] | '- [de] | '- [meinefirma] | '- [meinprojekt] | |- HalloWelt.java | |- HalloWeltImpl.java | |- TestWsClient.java | '- TestWsServer.java '- pom.xml
Öffnen Sie ein Kommandozeilenfenster, bauen Sie das Projekt und starten Sie den Server mit dem Webservice:
cd \MeinWorkspace\MvnJaxWs
mvn clean package
java -cp target/MvnJaxWs-1.0-SNAPSHOT.jar de.meinefirma.meinprojekt.TestWsServer http://localhost:8080/test
Öffnen Sie ein zweites Kommandozeilenfenster und starten Sie den Webservice-Client:
cd \MeinWorkspace\MvnJaxWs
java -cp target/MvnJaxWs-1.0-SNAPSHOT.jar de.meinefirma.meinprojekt.TestWsClient http://localhost:8080/test ich
Sie erhalten:
Hallo ich
Sehen Sie sich die generierte WSDL-Datei über http://localhost:8080/test?wsdl und die generierte Schema-XSD-Datei über http://localhost:8080/test?xsd=1 an.
Falls Ihr Webbrowser nichts anzeigt, verwenden Sie curl:
curl http://localhost:8080/test?wsdl
curl http://localhost:8080/test?xsd=1
Sie können auch andere URLs beim TestWsServer- und TestWsClient-Aufruf übergeben, beispielsweise http://localhost:4711/xyz.
Beenden Sie den Webservice-Server mit "Strg + C".
Sehen Sie sich die Webservice-Kommunikation mit soapUI an (siehe soapUI-Screenshot).
Mehrere Beispiele zu FTP-Projekten mit Maven finden Sie in java-ftp.htm.
Größere Projekte bestehen aus vielen Teilprojekten. Um alle Teilprojekte gemeinsam kompilieren, bauen und verwalten zu können, werden sie zu Multimodulprojekten zusammengefasst (auch Multiprojekt genannt). Dies wird im Folgenden demonstriert. In diesem Dokument werden eher einfache Aspekte von Maven-Multimodulprojekten besprochen. Weitergehende Betrachtungen zum Zusammenspiel mit Eclipse und DVCS (z.B. Mercurial) finden Sie unter: maven-multiproj.htm.
Voraussetzung ist, dass Sie die beiden obigen Beispiele
Maven-Webapp-Projekt (MvnJettyWebApp) und
Maven-Properties-Projekt (MvnPropApp, egal ob mit oder ohne
Erweiterung um Maven-Profile)
erfolgreich durchgeführt haben.
(Alternativ können Sie auch die genannten Projekte oder das Multimodulprojekt
downloaden.)
Kopieren Sie die beiden Projekte MvnPropApp und MvnJettyWebApp in neue "...-Mp1"-Verzeichnisse und erstellen Sie für das neue Multimodulprojekt das neue Verzeichnis MvnMultiProj1:
cd \MeinWorkspace
xcopy MvnPropApp MvnPropApp-Mp1\ /S
xcopy MvnJettyWebApp MvnJettyWebApp-Mp1\ /S
md MvnMultiProj1
Wechseln Sie in das MvnPropApp-Mp1-Verzeichnis und überprüfen Sie, dass das Projekt weiterhin funktioniert:
cd \MeinWorkspace\MvnPropApp-Mp1
mvn clean package "-DMeinCmdProp=PropVonCmd"
java -cp target/MvnPropApp-1.0-SNAPSHOT.jar de.meinefirma.meinprojekt.App | sort
Wechseln Sie in das MvnJettyWebApp-Mp1-Verzeichnis und überprüfen Sie, dass auch dieses Projekt weiterhin funktioniert:
cd \MeinWorkspace\MvnJettyWebApp-Mp1
mvn package jetty:run
Sehen Sie sich die Webseite an:
start http://localhost:8080/MvnJettyWebApp
Beenden Sie Jetty mit "Strg + C".
Bislang sind die beiden Projekte MvnPropApp-Mp1 und MvnJettyWebApp-Mp1 unabhängig voneinander.
Multimodulprojekte machen insbesondere bei voneinander abhängigen Projekten Sinn.
Deshalb ändern wir MvnJettyWebApp-Mp1 so, dass es MvnPropApp-Mp1 benötigt.
Ersetzen Sie im Verzeichnis MvnJettyWebApp-Mp1\src\main\webapp den Inhalt der Datei index.jsp durch:
<%@ page import="java.text.SimpleDateFormat" %>
<%@ page import="java.util.Date" %>
<html>
<head><title>MvnMultiProj-JSP</title></head>
<body>
<h2>MvnMultiProj-JSP</h2>
<%= request.getRemoteHost() %><br>
<%= (new SimpleDateFormat("yyyy-MM-dd, HH:mm:ss")).format(new Date()) + " h" %><br><br>
<%= (new de.meinefirma.meinprojekt.App()).run().replace( "\n", "<br>\n" ) %>
</body>
</html>
Die Abhängigkeit zu MvnPropApp-Mp1 müssen Sie in der pom.xml von MvnJettyWebApp-Mp1 eintragen. Ergänzen Sie im MvnJettyWebApp-Mp1-Verzeichnis die pom.xml um folgenden <dependencies>-Block:
<dependencies>
<dependency>
<groupId>de.meinefirma.meinprojekt</groupId>
<artifactId>MvnPropApp</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
</dependencies>
Wenn Sie jetzt MvnJettyWebApp-Mp1 ausführen, erhalten Sie eine Fehlermeldung:
cd \MeinWorkspace\MvnJettyWebApp-Mp1
mvn package jetty:run
-->
[ERROR] Failed to execute goal on project MvnJettyWebApp: Could not resolve dependencies for project de.meinefirma.meinprojekt:MvnJettyWebApp:war:1.0-SNAPSHOT: Could not find artifact de.meinefirma.meinprojekt:MvnPropApp:jar:1.0-SNAPSHOT
(Falls Sie die Fehlermeldung nicht erhalten, haben Sie wahrscheinlich das Kommando "mvn install" schon mal getestet. Bitte löschen Sie in diesem Fall den Inhalt des Verzeichnisses ${localRepository}\de\meinefirma\meinprojekt.)
Wir könnten jetzt im MvnPropApp-Mp1-Projekt das Kommando "mvn install" ausführen.
Dann würde das MvnPropApp-.jar-Artefakt in das lokale Maven-Repository kopiert und es würde vom MvnJettyWebApp-Mp1-Projekt gefunden werden.
Diese Schritte müssten aber bei Änderungen jeweils wiederholt werden, was spätestens dann nicht mehr sinnvoll durchführbar und verwaltbar ist,
wenn Sie nicht nur zwei, sondern viel mehr Teilprojekte haben.
Deshalb erstellen wir ein übergeordnetes Multimodulprojekt.
Erstellen Sie im MvnMultiProj1-Verzeichnis eine neue pom.xml,
in der alle Teilprojekte eingetragen werden (im Beispiel MvnPropApp-Mp1 und MvnJettyWebApp-Mp1):
<project>
<modelVersion>4.0.0</modelVersion>
<groupId>de.meinefirma.meinprojekt</groupId>
<artifactId>MvnMultiProj1</artifactId>
<version>1.0</version>
<packaging>pom</packaging>
<name>MvnMultiProj1</name>
<modules>
<module>../MvnJettyWebApp-Mp1</module>
<module>../MvnPropApp-Mp1</module>
</modules>
</project>
Die drei Projekte mit ihren jeweiligen pom.xml sind jetzt so angeordnet:
[\MeinWorkspace]
|- [MvnJettyWebApp-Mp1]
| |- [src]
| | '- ...
| '- pom.xml
|- [MvnMultiProj1]
| '- pom.xml
'- [MvnPropApp-Mp1]
|- [src]
| '- ...
'- pom.xml
Jetzt können Sie mit folgenden Kommandos alle Teilprojekte (egal wie viele) kompilieren, alle Artefakte erzeugen und die Anwendung starten:
cd \MeinWorkspace\MvnMultiProj1
mvn install
cd \MeinWorkspace\MvnJettyWebApp-Mp1
mvn jetty:run
Die Webseite des MvnJettyWebApp-Mp1-Projekts zeigt das Ergebnis des MvnPropApp-Mp1-Projekts an:
Falls Unterprojekte (wie MvnPropApp-Mp1 und MvnJettyWebApp-Mp1) vom übergeordneten Basisprojekt (MvnMultiProj1) Einstellungen erben sollen, können Sie das übergeordnete Basisprojekt als <parent> in den pom.xml-Dateien der Unterprojekte eintragen:
<parent>
<groupId>de.meinefirma.meinprojekt</groupId>
<artifactId>MvnMultiProj1</artifactId>
<version>1.0</version>
<relativePath>../MvnMultiProj1/pom.xml</relativePath>
</parent>
Dies wird im folgenden Beispiel demonstriert.
Bei Unterprojekten sollten gemeinsame Einstellungen (z.B. Java-Versionen und Versionen von Libs)
nicht in jeder pom.xml jedes einzelnen Unterprojekts vorgenommen werden,
sondern zentral erfolgen.
Dies hat zwei Vorteile:
- Die pom.xml der einzelnen Unterprojekte sind kürzer und fehlerfreier.
- Änderungen können an einer Stelle für alle Unterprojekte durchgeführt werden.
Bitte beachten Sie, dass durch die im Folgenden vorgestellten <pluginManagement>- und <dependencyManagement>-Blöcke noch keine Abhängigkeiten erzeugt werden, sondern vorerst lediglich Deklarationen und Konfigurationen erfolgen (z.B. zur Versionsnummer, zum Scope und <configuration>-Einstellungen).
Ein noch etwas ausgefeilteres Multimodulprojektbeispiel finden Sie unter Java EE mit EJB3.
Voraussetzung für das folgende Beispiel ist, dass Sie die Beispiele
JAX-WS (MvnJaxWs) und
Einfaches Multimodulprojekt (MvnMultiProj1) erfolgreich durchgeführt haben.
(Alternativ können Sie die Projekte auch
downloaden.)
Kopieren Sie die drei Unterprojekte in neue Verzeichnisse und erstellen Sie für das neue Multimodulprojekt das neue Verzeichnis MvnMultiProj2:
cd \MeinWorkspace
xcopy MvnJaxWs MvnJaxWs-Mp2\ /S
xcopy MvnJettyWebApp-Mp1 MvnJettyWebApp-Mp2\ /S
xcopy MvnPropApp-Mp1 MvnPropApp-Mp2\ /S
md MvnMultiProj2
cd MvnMultiProj2
Erzeugen Sie im MvnMultiProj2-Verzeichnis folgende pom.xml:
<project>
<modelVersion>4.0.0</modelVersion>
<groupId>de.meinefirma.meinprojekt</groupId>
<artifactId>MvnMultiProj2</artifactId>
<version>1.0</version>
<packaging>pom</packaging>
<name>MvnMultiProj2</name>
<modules>
<module>../MvnJaxWs-Mp2</module>
<module>../MvnJettyWebApp-Mp2</module>
<module>../MvnPropApp-Mp2</module>
</modules>
</project>
Das neue Projekt MvnMultiProj2 und die drei Unterprojekte sind jetzt so angeordnet:
[\MeinWorkspace]
|- [MvnJaxWs-Mp2]
| |- [src]
| | '- ...
| '- pom.xml
|- [MvnJettyWebApp-Mp2]
| |- [src]
| | '- ...
| '- pom.xml
|- [MvnMultiProj2]
| '- pom.xml
'- [MvnPropApp-Mp2]
|- [src]
| '- ...
'- pom.xml
Bauen Sie alle vier Projekte:
cd \MeinWorkspace\MvnMultiProj2
mvn clean install
In der Reactor Summary wird zu allen vier Projekten SUCCESS gemeldet.
Entfernen Sie im MvnJaxWs-Mp2-Unterprojekt in der pom.xml den "<build>...</build>"-Block
und rufen Sie im MvnMultiProj2-Verzeichnis erneut "mvn clean install" auf:
Ab Maven 3.0 erhalten Sie keine Fehlermeldung, aber wenn Sie Maven 2.2.1 verwenden würden, würden Sie erwartungsgemäß erhalten:
[ERROR] BUILD FAILURE
Compilation failure
...\MvnJaxWs-Mp2\...\HalloWeltImpl.java: annotations are not supported in -source 1.3
Entfernen Sie im MvnPropApp-Mp2-Unterprojekt in der pom.xml die beiden Zeilen
"<version>4.12</version>" und
"<scope>test</scope>"
und rufen Sie im MvnMultiProj2-Verzeichnis erneut "mvn clean install" auf:
Diesmal erhalten Sie wie erwartet die Fehlermeldung:
[ERROR] The project de.meinefirma.meinprojekt:MvnPropApp:1.0-SNAPSHOT has 1 error
[ERROR] 'dependencies.dependency.version' for junit:junit:jar is missing.
Ersetzen Sie im MvnMultiProj2-Verzeichnis die pom.xml durch:
<project>
<modelVersion>4.0.0</modelVersion>
<groupId>de.meinefirma.meinprojekt</groupId>
<artifactId>MvnMultiProj2</artifactId>
<version>1.0</version>
<packaging>pom</packaging>
<name>MvnMultiProj2</name>
<modules>
<module>../MvnJaxWs-Mp2</module>
<module>../MvnJettyWebApp-Mp2</module>
<module>../MvnPropApp-Mp2</module>
</modules>
<build>
<pluginManagement>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.5.1</version>
<configuration>
<source>1.7</source>
<target>1.7</target>
</configuration>
</plugin>
</plugins>
</pluginManagement>
</build>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
</dependencies>
</dependencyManagement>
</project>
Fügen Sie im MvnJaxWs-Mp2-Unterprojekt in der pom.xml folgendenmaßen einen "<parent>...</parent>"-Block hinzu (bei der Gelegenheit können Sie auch den <dependency>...jaxws-api...-Abschnitt entfernen):
<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>
<parent>
<groupId>de.meinefirma.meinprojekt</groupId>
<artifactId>MvnMultiProj2</artifactId>
<version>1.0</version>
<relativePath>../MvnMultiProj2/pom.xml</relativePath>
</parent>
<groupId>de.meinefirma.meinprojekt</groupId>
<artifactId>MvnJaxWs</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>MvnJaxWs</name>
</project>
Fügen Sie im MvnPropApp-Mp2-Unterprojekt ebenso in der pom.xml zwischen <modelVersion> und <groupId> den "<parent>...</parent>"-Block hinzu:
<parent>
<groupId>de.meinefirma.meinprojekt</groupId>
<artifactId>MvnMultiProj2</artifactId>
<version>1.0</version>
<relativePath>../MvnMultiProj2/pom.xml</relativePath>
</parent>
Bauen Sie wieder alle vier Projekte:
cd \MeinWorkspace\MvnMultiProj2
mvn clean install
In der Reactor Summary wird wieder zu allen vier Projekten SUCCESS gemeldet.
Im letzten Beispiel wurde gezeigt, wie Sie bei vielen Unterprojekten gemeinsame Einstellungen (z.B. Java-Versionen und Versionen von Libs)
zentral in einem Parent-Multimodulprojekt verwalten.
Falls Sie mehrere Projekte (oder Multimodulprojekte) haben, sollten Sie noch einen Schritt weiter gehen,
und auch die gemeinsamen Einstellungen der Projekte zentral verwalten, nämlich in einer
"Corporate POM"
(oder "Firmen-POM", "Projekt-POM", "Master POM", "Top POM", ...).
Bitte verwechseln Sie die hier gemeinte selbsterstellte übergeordnete Corporate POM nicht mit der von Maven immer als Grundlage verwendeten Super POM pom-4.0.0.xml (die Sie in der Maven-Installation in der lib/maven-model-builder-3.3.9.jar finden).
Voraussetzung ist, dass Sie das Beispiel
Multimodulprojekt mit Plugin-Management und Dependency-Management
(MvnMultiProj2) erfolgreich durchgeführt haben.
(Alternativ können Sie auch das Multimodulprojekt
downloaden.)
Kopieren Sie die drei Unterprojekte in neue Verzeichnisse, erstellen Sie ein neues Multimodulprojekt in dem neuen Verzeichnis MvnMultiProj3 und legen Sie das neue Corporate-POM-Projekt MvnCorpPom an:
cd \MeinWorkspace
xcopy MvnJaxWs-Mp2 MvnJaxWs-Mp3\ /S
xcopy MvnJettyWebApp-Mp2 MvnJettyWebApp-Mp3\ /S
xcopy MvnPropApp-Mp2 MvnPropApp-Mp3\ /S
md MvnMultiProj3
md MvnCorpPom
Ersetzen Sie sowohl in der MvnJaxWs-Mp3\pom.xml als auch in der MvnPropApp-Mp3\pom.xml jeweils an zwei Stellen:
MvnMultiProj2 durch MvnMultiProj3.
Erzeugen Sie im MvnMultiProj3-Verzeichnis folgende pom.xml:
<project>
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>de.meinefirma.meinprojekt</groupId>
<artifactId>MvnCorpPom</artifactId>
<version>1.0</version>
<relativePath>../MvnCorpPom/pom.xml</relativePath>
</parent>
<groupId>de.meinefirma.meinprojekt</groupId>
<artifactId>MvnMultiProj3</artifactId>
<version>1.0</version>
<packaging>pom</packaging>
<name>MvnMultiProj3</name>
<modules>
<module>../MvnJaxWs-Mp3</module>
<module>../MvnJettyWebApp-Mp3</module>
<module>../MvnPropApp-Mp3</module>
</modules>
</project>
Erzeugen Sie im MvnCorpPom-Verzeichnis folgende pom.xml:
<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>de.meinefirma.meinprojekt</groupId>
<artifactId>MvnCorpPom</artifactId>
<version>1.0</version>
<packaging>pom</packaging>
<name>MvnCorpPom</name>
<properties>
<project.build.sourceEncoding>ISO-8859-1</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
</properties>
<build>
<pluginManagement>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.5.1</version>
<configuration>
<source>1.7</source>
<target>1.7</target>
</configuration>
</plugin>
</plugins>
</pluginManagement>
</build>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
</dependencies>
</dependencyManagement>
</project>
Bauen Sie die Corporate POM und installieren Sie sie im lokalen Maven-Repository:
cd \MeinWorkspace\MvnCorpPom
mvn install
Wechseln Sie in das Multimodulprojekt und bauen Sie es inklusive aller Unterprojekte:
cd \MeinWorkspace\MvnMultiProj3
mvn clean install
In der Reactor Summary wird wieder zu allen vier Projekten SUCCESS gemeldet.
Testen Sie das Webprojekt:
cd \MeinWorkspace\MvnJettyWebApp-Mp3
mvn jetty:run
Rufen Sie die Webseite auf:
In diesem Beispiel erben die Untermodule vom übergeordneten Multimodulprojekt MvnMultiProj3,
welches wiederum von der Corporate POM aus MvnCorpPom erbt.
Alternativ ist es oft sinnvoll, wenn die Untermodule stattdessen direkt die Corporate POM aus MvnCorpPom einbinden.
Dann ist es einfacher, mehrere verschiedene Multimodulprojekte für verschiedene Zwecke einzurichten,
wie etwa für Integrationstests auf dem Entwicklungsrechner, Systemtests in einer Testumgebung, Continuous Integration, Release-Auslieferungen etc.
(falls es zu aufwändig ist, dies über Maven-Profile oder TestNG-Gruppen zu steuern).
Die Corporate POM können Sie erweitern und in beliebige weitere andere Projekte einbinden. In Firmen mit mehreren Projekten ist üblich, eine zentrale Corporate POM für firmenweite Voreinstellungen vorzusehen und zusätzlich pro Projekt eine Projekt-Master-POM für Projektspezifisches zu erstellen. Die Projektmodule binden als Parent die Projekt-Master-POM ein, und diese erbt von der Corporate POM.
Das oben gezeigte Beispiel verwendet das so genannte "Flat Project Layout": Die Maven-Module sind in der Verzeichnisstruktur parallel angeordnet. Alternativ könnten Sie die Maven-Projekthierarchie auch in einer hierarchischen Verzeichnisstruktur abbilden, also die Untermodule in Unterverzeichnisse zum Parent-Multimodulprojekt speichern. Zu den Vor- und Nachteilen sehen Sie sich den Vergleich des "Flat Project Layout" zum "Hierarchical Project Layout" an.
Falls die groupId und/oder die version der Untermodule identisch zum übergeordneten Parent-Modul (z.B. Projekt-Master-POM) sein soll, sollten Sie die Angaben nicht redundant wiederholen, sondern über <groupId>${project.groupId}</groupId> bzw. <version>${project.version}</version> einbinden. Im project-Kopf der abhängigen Module lassen Sie die Angaben einfach weg, dann werden sie automatisch geerbt (andernfalls würde Maven 3 melden: "[WARNING] 'groupId' contains an expression but should be a constant").
Falls die version von Untermodulen nicht identisch zum übergeordneten Parent-Modul sein soll und es Abhängigkeiten zwischen den Untermodulen gibt, dann sollten Sie vermeiden, die Versionsnummer des von anderen Untermodulen verwendeten Untermoduls redundant direkt in den Dependencies einzutragen. Verwalten Sie auch die Versionsnummern der Untermodule in der Parent-POM (z.B. Projekt-Master-POM). Allerdings müssen Sie sicherstellen, dass alle Module stets die aktuellste Parent-POM verwenden und nicht irgendeine zufällig in einem (z.B. lokalen) Repository vorhandene. Besonders in der Startphase eines Projekts, in der es viele Änderungen gibt, kann es praktischer sein, die Projekt-Master-POM nicht im Maven-Repository zur Verfügung zu stellen (also für die Projekt-Master-POM weder mvn install noch mvn deploy auszuführen). Dann muss zusätzlich zum in Bearbeitung befindlichem Modul stets auch das Projekt-Master-POM-Modul aus dem Versionskontrollsystem (Git, Mercurial, Subversion, CVS, ...) ausgecheckt sein und beide Module können regelmäßig abgeglichen und aktualisiert werden. Damit dies funktioniert, muss beim Flat Project Layout der relativePath korrekt gesetzt sein (wie obiges Beispiel zeigt).
Bitte beachten Sie, dass es leider zwei kaum zu vermeidende Probleme gibt:
Planen Sie genau, wie ein Release für eine Auslieferung erstellt werden soll. Oft werden für jedes einzelne Modul eines Projekts folgende Schritte benötigt:
Bei diesen Schritten kann das Maven Release Plugin Unterstützung leisten. Voraussetzung ist eine korrekte SCM-Konfiguration. Bitte beachten Sie, dass hier wie auch beim Maven-SCM-Plugin mit "SCM" nicht das übergreifende "Software Configuration Management" gemeint ist, sondern lediglich "Source Code Management", also das Versionskontrollsystem (VCS).
Falls bei komplizierteren Projekten das Maven Release Plugin nicht ausreicht: Sehen Sie sich das Versions Maven Plugin an.
Sehen Sie sich auch folgende Erläuterungen an: Versionierung und Release-Build mit dem "Maven Release Plugin", dem "Versions Maven Plugin" und dem "Maven SCM Plugin".
Es gibt viele lohnenswerte Maven-Plugins, die automatisch Informationen zu Ihrem Projekt aufbereiten.
Im Folgenden wird die Einbindung einiger solcher Maven-Plugins beispielhaft gezeigt.
Bei den bisherigen Mini-Demos machen Project Reports kaum Sinn, aber vielleicht haben Sie ein größeres Projekt mit mehr Sourcedateien.
Es werden diverse Metriken zur Sourcecodequalität ermittelt, zum Beispiel zu:
Testabdeckung, potenzielle Fehler, Abhängigkeitsprobleme und strukturelle Probleme.
Bitte beachten Sie:
Sie können beispielsweise folgende Ergebnisse erhalten:
| Project Information: | ||
| Dependencies | Auflistung der Dependencies und "Dependency Tree" | maven-project-info-reports-plugin |
| Project Reports: | ||
| Checkstyle | Coding-Standards | maven-checkstyle-plugin |
| Cobertura Test Coverage | Testabdeckung ermitteln (Cobertura nur bis Java 7) | cobertura-maven-plugin |
| CPD Report | Code-Dubletten finden (Copy/Paste Detector) | maven-pmd-plugin |
| Dependency Analysis | Auflistung der Dependencies und unused/undeclared-Überprüfung | maven-dependency-plugin |
| FindBugs Report | Potenzielle Fehler im Sourcecode per Bytecode-Analyse finden | findbugs-maven-plugin |
| JavaDocs | Javadoc-Dokumentation | maven-javadoc-plugin |
| PMD Report | Potenzielle Probleme im Sourcecode finden | maven-pmd-plugin |
| Maven JXR | HTML-basierende Verlinkung des Java-Sourcecodes | maven-jxr-plugin |
| Surefire Report | Testergebnisse | maven-surefire-report-plugin |
| Tag List | Bestimmte im Sourcecode enthaltene Tags auflisten (z.B. TODO, FIXME) | taglist-maven-plugin |
Checkstyle, PMD und FindBugs scheinen sich auf den ersten Blick zu ähneln. Alle drei suchen nach bekannten Fehlermustern (Bug Patterns). Da sie aber verschieden funktionieren, finden sie unterschiedliche Fehler. Zum Beispiel analysieren Checkstyle und PMD den Sourcecode, während FindBugs den erzeugten Bytecode untersucht und so NullPointer, nicht geschlossene Datenströme und fehlerhafte Synchronisierungen aufspürt.
Tragen Sie Ihr korrektes sourceEncoding ein, also das Encoding, mit dem Sie Ihre Sourcedateien speichern (unter Linux meistens UTF-8, unter Windows meistens Cp1252, unter Eclipse konfigurierbar), sowie Ihr gewünschtes reporting.outputEncoding (z.B. UTF-8). Binden Sie den folgenden <properties>-Block in die pom.xml ein:
<properties>
<project.build.sourceEncoding>ISO-8859-1</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
</properties>
Zu Site Reports gibt es seit Maven 3.0 erhebliche Änderungen, siehe hierzu: Maven Release Notes, Maven 3.x Compatibility Notes und Using maven-site-plugin with Maven 3.
Binden Sie die folgenden <properties>- und <reporting>-Blöcke in einem beliebigen Projekt in die pom.xml ein:
...
<properties>
<project.build.sourceEncoding>ISO-8859-1</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
</properties>
...
<reporting>
<outputDirectory>${project.build.directory}/site</outputDirectory>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-site-plugin</artifactId>
<version>3.5.1</version>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-project-info-reports-plugin</artifactId>
<version>2.9</version>
</plugin>
<!-- Falls Versionskontrollsystem konfiguriert ist:
<plugin>
<artifactId>maven-changelog-plugin</artifactId>
</plugin>
-->
<plugin>
<artifactId>maven-checkstyle-plugin</artifactId>
<version>2.17</version>
<configuration>
<configLocation>google_checks.xml</configLocation>
<includeTestSourceDirectory>true</includeTestSourceDirectory>
<excludes>**/generated/*.java</excludes>
</configuration>
</plugin>
<plugin>
<artifactId>maven-dependency-plugin</artifactId>
<version>2.10</version>
<configuration>
<repositoryUrl>--</repositoryUrl>
<artifactItems />
</configuration>
</plugin>
<plugin>
<artifactId>maven-javadoc-plugin</artifactId>
<version>2.10.4</version>
</plugin>
<plugin>
<artifactId>maven-jxr-plugin</artifactId>
<version>2.5</version>
</plugin>
<plugin>
<artifactId>maven-pmd-plugin</artifactId>
<version>3.6</version>
<configuration>
<targetJdk>1.7</targetJdk>
<format>xml</format>
<linkXref>true</linkXref>
<sourceEncoding>ISO-8859-1</sourceEncoding>
<minimumTokens>100</minimumTokens>
<excludes>
<exclude>**/generated/*.java</exclude>
</excludes>
</configuration>
</plugin>
<plugin>
<artifactId>maven-surefire-report-plugin</artifactId>
<version>2.19.1</version>
<configuration>
<!-- Bei grossen Projekten auf false setzen: -->
<showSuccess>true</showSuccess>
</configuration>
</plugin>
<plugin>
<!-- Cobertura 2.1.1 und das cobertura-maven-plugin 2.7 funktionieren nur bis Java 7: -->
<groupId>org.codehaus.mojo</groupId>
<artifactId>cobertura-maven-plugin</artifactId>
<version>2.7</version>
</plugin>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>findbugs-maven-plugin</artifactId>
<version>3.0.3</version>
</plugin>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>taglist-maven-plugin</artifactId>
<version>2.4</version>
<configuration>
<tags>
<tag>fixme</tag>
<tag>FixMe</tag>
<tag>FIXME</tag>
<tag>@todo</tag>
<tag>todo</tag>
<tag>TODO</tag>
<tag>xxx</tag>
<tag>@deprecated</tag>
</tags>
</configuration>
</plugin>
<!-- Falls SonarQube verwendet wird:
<plugin>
<groupId>org.codehaus.sonar-plugins</groupId>
<artifactId>maven-report</artifactId>
<version>0.1</version>
</plugin>
-->
</plugins>
</reporting>
...
Rufen Sie Folgendes auf und sehen Sie sich die Ergebnisseiten an:
mvn site
start target\site\index.html
start target\site\project-info.html
Falls Sie beispielsweise so dass obige JAXB-Beispiel MvnJaxbApp untersuchen, erhalten Sie:
SonarQube erleichtert Sourcecodeanalyse. SonarQube liefert ähnliche Ergebnisse, wie die oben unter "Site Report um Project Reports zur Sourcecodeanalyse erweitern" gezeigten Plug-ins. Die wichtigsten Unterschiede sind:
Idealerweise wird SonarQube in ein "Continuous Integration"-System eingebunden (z.B. Jenkins, Hudson oder TeamCity), siehe hierzu auch: Continuous Integration mit Jenkins / Hudson und Maven 3.
SonarQube ermittelt diverse Metriken zur Sourcecodequalität, zum Beispiel zu: typische Programmierfehler, potenzielle Fehler, Testabdeckung, Abhängigkeitsprobleme und strukturelle Probleme.
Auch hier gilt wieder:
Siehe: Documentation, Requirements, Installing the Server, Running SonarQube as a Service on Windows, ... on Linux, Analyzing with SonarQube Scanner for Maven
Downloaden Sie SonarQube (z.B. sonarqube-6.3.zip) von http://www.sonarqube.org/downloads. Entzippen Sie SonarQube, z.B. unter Windows nach \Tools oder unter Linux nach /opt.
Neuere SonarQube-Versionen setzen mindestens Java 8 voraus. Überprüfen Sie dies mit:
java -version
Prüfen Sie, ob die SonarQube-Default-Portnummer 9000 noch frei ist:
netstat -an | find ":9000"
Falls der Port nicht frei ist: Tragen Sie in \Tools\SonarQube\conf\sonar.properties bei "sonar.web.port" eine andere Portnummer ein (und entfernen Sie das vorangestellte Auskommentierungszeichen '#').
Prüfen Sie, ob die für die SonarQube-Datenbank benötigte Portnummer noch frei ist. Falls Sie die defaultmäßige integrierte Datenbank verwenden wollen: Je nach SonarQube-Version ist dies eine Derby Database (mit Port 1527) oder eine H2 Database (mit Port 9092). Prüfen Sie zum Beispiel so:
netstat -a
netstat -an | find ":1527"
netstat -an | find ":9092"
Falls Sie eine Oracle-Datenbank verwenden wollen, überprüfen Sie Folgendes:
Die DB muss für das Character-Encodung UTF-8 konfiguriert sein, optimalerweise so: NLS_CHARACTERSET = AL32UTF8. Überprüfen Sie dies mit dem SQL-Kommando "Select * from nls_database_parameters;".
Zumindest bei früheren SonarQube-Versionen durfte die Sortierung nicht für GERMAN konfiguriert sein, sondern so: NLS_SORT = BINARY. Überprüfen Sie dies mit demselben SQL-Kommando.
Laut Requirements soll ein Oracle-11.2.x-Treiber verwendet werden, und kein Oracle-12.x-Treiber ("Oracle 12.x drivers are not supported").
Downloaden und kopieren Sie den Oracle-11.2.x-JDBC-Treiber (z.B. ojdbc6.jar in Version 11.2.0.4.0) nach: \Tools\SonarQube\extensions\jdbc-driver\oracle.
Tragen Sie in
\Tools\SonarQube\conf\sonar.properties
die DB-Connection-Parameter ein:
sonar.jdbc.username=...
sonar.jdbc.password=...
sonar.jdbc.url=jdbc:oracle:thin:@localhost:1521:XE
sonar.jdbc.driverClassName=oracle.jdbc.driver.OracleDriver
sonar.jdbc.validationQuery=select 1 from dual
Rufen Sie auf (passen Sie den Pfad an):
Unter Windows:
start "SonarQube-Server" \Tools\SonarQube\bin\windows-x86-64\StartSonar.bat
bzw. unter Linux:
/opt/sonarqube/bin/linux-x86-64/sonar.sh start
Warten Sie, bis der SonarQube-Server fertig gestartet ist, was schon mal mehrere Minuten dauern kann.
Sehen Sie sich die Logdateien an:
type \Tools\SonarQube\logs\*.log
bzw.
cat /opt/sonarqube/logs/*.log
Rufen Sie auf:
start http://localhost:9000
Falls Sie eine Fehlermeldung erhalten ähnlich zu:
Encountered an error running main: java.io.IOException: Unable to create directory \Tools\SonarQube\temp
Dann rufen Sie StartSonar.bat mit Admin-Rechten auf (über rechter Maustaste).
Um SonarQube als automatisch beim PC-Start startenden Service einzurichten, sehen Sie sich an: Running SonarQube as a Service on Windows, Running SonarQube as a Service on Linux, zusätzliche Hinweise.
Dies ist normalerweise unnötig, aber falls Sie besondere Einstellungen benötigen, können diese folgendermaßen in dem zu analysierenden Projekt in die pom.xml (bzw. falls vorhanden besser in eine Master-POM) eingetragen werden:
...
<properties>
<!-- Wird nur benoetigt, wenn eine abweichende SonarQube-URL (z.B. Remote) eingetragen werden muss: -->
<sonar.host.url>http://localhost:9000</sonar.host.url>
...
</properties>
<build>
<plugins>
<!-- Wird nur benoetigt, falls eine bestimmte Versionsnummer vorgegeben werden muss: -->
<plugin>
<groupId>org.sonarsource.scanner.maven</groupId>
<artifactId>sonar-maven-plugin</artifactId>
<version>3.2</version>
</plugin>
...
</plugins>
</build>
...
Rufen Sie auf (passen Sie den Pfad an):
cd \MeinWorkspace\<MeinProjekt>
mvn clean install sonar:sonar
Warten Sie, bis der Analyseprozess fertig durchgelaufen ist, was schon mal mehrere Minuten dauern kann. Rufen Sie anschließend auf:
start http://localhost:9000
Falls beim sonar:sonar-Aufruf falsche Versionen gestartet werden, oder die SonarQube-Server-URL hinzugefügt werden soll, können Sie statt des abgekürzten Kommandos folgendes vollständige Kommando verwenden (vorher anpassen):
mvn clean install org.sonarsource.scanner.maven:sonar-maven-plugin:3.2:sonar -Dsonar.host.url=http://localhost:9000
Falls Sie die Java Code Coverage der JUnit-Tests (= Testabdeckung) erfassen wollen und SonarQube keine Ergebnisse meldet, verwenden Sie folgendermaßen das JaCoCo-Plug-in:
cd \MeinWorkspace\<MeinProjekt>
mvn clean org.jacoco:jacoco-maven-plugin:prepare-agent install -Dmaven.test.failure.ignore=true
mvn sonar:sonar
start http://localhost:9000
Falls Sie das maven-surefire-plugin oder das maven-failsafe-plugin verwenden, beachten Sie die Hinweise zum JaCoCo-Maven Plug-in und zum prepare-agent-Goal. Falls Sie auf Probleme stoßen, sehen Sie sich an: Probleme mit dem JaCoCo-Maven-Plugin.
Falls Sie mehrere Maven-Projekte in parallelen Unterverzeichnissen zu einem gemeinsamen Projekteverzeichnis haben, können Sie mit einem einzigen Aufruf alle Maven-Projekte
Für die SonarQube-Analyse brauchen Sie in den einzelnen Projekten nichts vorzubereiten. Die in der Windows-Batchdatei erstellten Site-Reports dagegen machen erst dann wirklich Sinn, wenn Sie geeignete Vorgaben in den jeweiligen POMs (bzw. falls vorhanden in einer gemeinsamen Master-POM) erstellt haben, etwa so wie oben unter Site Project Reports gezeigt.
Windows:
Wechseln Sie in Ihr Projekte-Verzeichnis und erzeugen Sie ein neues Unterverzeichnis für die Windows-Batchdatei:
cd \MeinWorkspace
md SonarQubeUndSiteReport
cd SonarQubeUndSiteReport
Erzeugen Sie im SonarQubeUndSiteReport-Verzeichnis die Batchdatei: run-SonarQubeUndSiteReport-all.bat
@title run-SonarQubeUndSiteReport-all.bat
cls
@echo.
@echo -------------------------------------------------------------------------
@echo run-SonarQubeUndSiteReport-all.bat
@echo -------------------------------------------------------------------------
@echo.
set _SONAR_START_BAT=\Tools\SonarQube\bin\windows-x86-64\StartSonar.bat
set _SITE_REPORTS_DIR=\MeineSiteReports
set _IGNORED_DIRS=MvnAppSrvFailsaveIntTest MvnAppSrvIntTest MvnMultiProj1 MvnMultiProj2 MvnMultiProj3 MvnSign SonarQubeUndSiteReport
@if not exist "%_SONAR_START_BAT%" goto _Fehler
@if not exist "%_SITE_REPORTS_DIR%" md "%_SITE_REPORTS_DIR%"
@if not exist "%_SITE_REPORTS_DIR%" goto _Fehler
netstat -an | find "0.0.0.0:9000"
@if not errorlevel 1 goto _Sonar_Server_fertig
start "SonarQube" "%_SONAR_START_BAT%"
:_Warte_Sonar_Server
@echo Warten auf den SonarQube-Server ...
@ping -n 5 127.0.0.1>nul
@netstat -an | find "0.0.0.0:9000"
@if errorlevel 1 goto _Warte_Sonar_Server
:_Sonar_Server_fertig
start http://localhost:9000
pushd .
cd ..
@echo off
FOR /F %%i in ('dir /B /A:D') DO (
echo.
call :checkignored %%i
if not errorlevel 1 (
if exist %%i\pom.xml (
echo.
echo -------------------------------------------------------------------------
echo Projektverzeichnis: %%i
echo -------------------------------------------------------------------------
echo on
cd %%i
echo.
echo ---- SonarQube fuer %%i:
echo.
call mvn clean org.jacoco:jacoco-maven-plugin:prepare-agent install -Dmaven.test.failure.ignore=true
call mvn sonar:sonar
if errorlevel 1 goto _Fehler
@echo on
echo.
echo ---- Site-Reports fuer %%i:
echo.
if exist "%_SITE_REPORTS_DIR%\%%i\site" rd /S /Q "%_SITE_REPORTS_DIR%\%%i\site"
call mvn clean site
if errorlevel 1 goto _Fehler
echo on
xcopy target\site "%_SITE_REPORTS_DIR%\%%i\site\" /S
if exist %_SITE_REPORTS_DIR%\%%i\site\project-info.html (
start %_SITE_REPORTS_DIR%\%%i\site\project-info.html
)
@echo.
cd ..
echo off
)
)
)
@echo
start http://localhost:9000
@goto _fertig
:checkignored
FOR /D %%j in (%_IGNORED_DIRS%) DO IF "%1"=="%%j" EXIT /B 1
exit /B 0
:_Fehler
@echo.
@echo -------------------------------------------------------------------------
@echo !!! Fehler !!!
@echo -------------------------------------------------------------------------
@echo
pause
:_fertig
@echo on
@echo.
popd
@echo.
Linux:
Wechseln Sie in Ihr Projekte-Verzeichnis und erzeugen Sie ein neues Unterverzeichnis für das Linux-Shell-Skript:
cd ~/MeinWorkspace
mkdir SonarQube
cd SonarQube
Erzeugen Sie im SonarQube-Verzeichnis das Linux-Shell-Skript: run-SonarQube-all.sh
#!/bin/bash
echo
echo -------------------------------------------------------------------------
echo run-SonarQube-all.sh
echo -------------------------------------------------------------------------
echo
_IGNORED_DIRS=" MvnAppSrvFailsaveIntTest MvnAppSrvIntTest MvnMultiProj1 MvnMultiProj2 MvnMultiProj3 MvnSign SonarUndSiteReport "
if ! netstat -ant | grep -q ':9000'
then
/opt/sonarqube/bin/linux-x86-64/sonar.sh start &
fi
while ! netstat -ant | grep -q ':9000'
do echo Warten auf den SonarQube-Server ... ; sleep 5
done
echo
cd ..
echo "Aktuelles Verzeichnis: "$(pwd)
echo
ls -l
echo
for verzeichnis in *
do
echo -e "\n------------------------------------------------------"
if [[ $_IGNORED_DIRS == *${verzeichnis}* ]]
then
echo "---- "${verzeichnis}" ist zu ignorieren ----"
elif [ ! -d "${verzeichnis}" ]
then
echo "---- "${verzeichnis}" ist kein Verzeichnis ----"
elif [ ! -f "${verzeichnis}/pom.xml" ]
then
echo "---- "${verzeichnis}" enthaelt keine pom.xml ----"
else
echo "---- "${verzeichnis}":"
cd "${verzeichnis}"
mvn clean org.jacoco:jacoco-maven-plugin:prepare-agent install -Dmaven.test.failure.ignore=true
mvn sonar:sonar || exit 1
cd ..
fi
done
echo -e "\n------------------------------------------------------\n"
( speaker-test -t sine -f 1000 > /dev/null )& pid=$! ; sleep 0.1s ; kill -9 $pid
echo -e "\n++++ OK ++++\n"
Je nach SonarQube-Version können Sie beispielsweise erhalten:
Konfigurieren Sie das Aussehen der Dashboard-Startseite,
indem Sie sich über "Log in" mit "admin/admin" einloggen und "Dashboards" | "Home" | "Configure widgets" anklicken.
Meistens empfiehlt es sich, das "Measure Filter as List"-Widget auf die gesamte Breite zu vergrößern,
indem Sie rechts oben nicht das zweigeteilte Rechteck, sondern stattdessen das oberste ungeteilte Rechteck aktivieren.
Außerdem sollten Sie dem "Measure Filter as List"-Widget noch eine Spalte für die Testabdeckung hinzufügen über:
Im "Measure Filter as List"-Widget klicken auf "Projects" | "Change Columns" |
in der Drop-Down-Liste unter Tests "Coverage" wählen | "Add Column" | die neue Spalte eins nach links verschieben |
"Close" | "Save" | zurück mit "Dashboards".
Insgesamt könnten beispielsweise folgende weiteren Spalten sinnvoll sein:
NAME, VERSION, LOC, SQALE RATING, TECHNICAL DEBT, COVERAGE, BLOCKER ISSUES, CRITICAL ISSUES, ISSUES, LAST ANALYSIS.
Außerdem kann eine Ansicht "Measure Filter as Treemap" sinnvoll sein,
beispielsweise mit "Size: Lines of Code" und "Color: Technical Dept Ratio".
Sehen Sie sich die Konfiguration an und führen Sie Anpassungen durch:
Loggen Sie sich mit "admin/admin" ein, klicken Sie auf "Settings" | "Quality Profiles",
und wählen Sie das geeignetste Ausgangsprofil, falls vorhanden am besten "Sonar way with FindBugs".
Kopieren Sie das gewählte Ausgangsprofil mit "Copy", vergeben Sie einen neuen Namen (ohne Sonderzeichen und ohne Leerzeichen)
und setzen Sie die Kopie mit "Set as default" als Standard.
Klicken Sie auf den neuen Profilnamen und klicken Sie auf die "Coding rule"-Namen, um die Regeln zu konfigurieren.
Kandidaten für eine etwas weniger strenge Bewertung könnten sein:
"Avoid commented-out lines of code", "Dodgy - instanceof will always return true",
"Dodgy - int division result cast to double or float", "Dodgy - Redundant nullcheck of value known to be non-null",
"Dodgy - Write to static field from instance method", "Duplicated blocks",
"Execution of the Garbage Collector should be triggered only by the JVM",
"Left curly braces should be located at the end of lines of code",
"Malicious code vulnerability - May expose internal representation by incorporating reference to mutable object",
"Malicious code vulnerability - May expose internal representation by returning reference to mutable object",
"Methods should not be too complex", "Performance - Inefficient use of keySet iterator instead of entrySet iterator",
"Right curly braces should be located at the beginning of lines of code", "Statements should be on separate lines",
"Switch cases should end with an unconditional break statement",
"System.exit(...) and Runtime.getRuntime().exit(...) should not be called",
"The Object.finalize() method should never be overridden"
Falls es das kombinierte Profil "Sonar way with FindBugs" nicht gibt, aber stattdessen die zwei Profile "Sonar way" und "FindBugs": Folgendermaßen können Sie Ihre Projektmodule mit beiden Profilen analysieren:
call mvn clean install sonar:sonar -Dsonar.profile="MeinFindBugsProfil" -Dsonar.branch=FindBugs
call mvn clean install sonar:sonar -Dsonar.profile="MeinSonarWayProfil" -Dsonar.branch=SonarWay
Falls Sie mehr als 20 Projekte haben und das SonarQube-Dashboard mehr als nur 20 Projekte pro Seite anzeigen soll, erhöhen Sie die Page Size unter "Configure widgets" im "Measure Filter as List"-Widget: "Edit" | "Page Size".
Falls Sie bestimmte Packages oder Klassen aus der Analyse ausklammern wollen, zum Beispiel automatisch generierte Klassen (etwa per JAXB), dann geben Sie diese über die Property "sonar.exclusions" an. Dabei können mehrere durch Komma getrennte Pfade angegeben werden, beispielsweise: "meinpackage1/generated/*.java, meinpackage2/**/generated/*.java".
Um Speicherplatz zu sparen, sollten Sie die Aufbewahrungszeiten konfigurieren über: "Log in" | "Settings" | "Configuration" | "General Settings" | "Database Cleaner".
Unter "Settings" | "Configuration" | "Backup" können Sie die Konfiguration über den "Backup"-Button als XML-Datei speichern, entweder als Backup oder um sie auf einen anderen PC zu übertragen. Das Einlesen erfolgt auf derselben Seite über "Restore".
Erläuterungen zu den verwendeten Metriken finden Sie unter:
http://docs.sonarqube.org/display/SONAR/Metric+definitions
Sehen Sie sich die Doku zu SonarQube an:
http://docs.sonarqube.org/display/SONAR/Documentation
Insbesondere in Continuous-Integration-Systemen (z.B. mit Jenkins/Hudson) sollten Sie den SonarQube-Server beim Booten automatisch als Windows-Dienst starten. Sehen Sie sich hierzu an: http://docs.sonarqube.org/display/SONAR/Running+SonarQube+as+a+Service+on+Windows.
Beachten Sie, dass einige SonarQube-Batchdateien (z.B. "SonarQube\bin\windows-x86-64\InstallNTService.bat")
nur in einem Kommandozeilenfenster mit Administratorrechten ausgeführt werden können:
"Start" | "Alle Programme" | "Zubehör" | "Eingabeaufforderung" mit rechter Maustaste und "Als Administrator ausführen".
Beachten Sie, dass Sie beim installierten Windows-Dienst eventuell Windows-Anmeldeinformationen eintragen müssen:
"Start" | "Systemsteuerung" | ["System und Sicherheit"] | "Verwaltung" | "Dienste" | Doppelklick auf "SonarQube" | "Anmelden".
Beachten Sie, dass für systematischen und wiederholten Einsatz empfohlen wird, statt der defaultmäßigen integrierten Datenbank eine externe Datenbank zu verwenden. Diesen und viele weitere Hinweise finden Sie unter: http://docs.sonarqube.org/display/SONAR/Setup+and+Upgrade
Falls Sie JSP oder JSF verwenden, empfiehlt es sich, zusätzlich das SonarQube Web Plugin zu installieren:
Downloaden Sie die Plugin-Jar-Datei (z.B. sonar-web-plugin-2.3.jar) von
http://docs.sonarqube.org/display/SONAR/Web+Plugin,
kopieren Sie sie in den SonarQube-Plugin-Ordner
(z.B. \Tools\SonarQube\extensions\plugins)
und starten Sie SonarQube neu.
Der Aufruf kann zum Beispiel folgendermaßen erfolgen:
cd \MeinWorkspace\<MeinWebProjekt>
mvn clean sonar:sonar -Dsonar.language=web -Dsonar.dynamicAnalysis=false -Dsonar.web.sourceDirectory=src/main/webapp -Dsonar.branch=Web
start http://localhost:9000
Falls Sie serverseitige Probleme haben, sehen Sie sich die Logdateien an:
type \Tools\SonarQube\logs\*.log
Falls Sie mit Ihrem "Quality Profile" Probleme haben, z.B. die Fehlermeldung
[ERROR] Quality profile not found : 'Sonar way with Findbugs' on language 'java'
dann stellen Sie sicher, dass es den Profilnamen gibt, der Profilname keine Sonderzeichen und keine Leerzeichen enthält, und dass es nicht zweierlei SonarQube-Installationen auf demselben PC gibt.
Falls Sie folgende Fehlermeldung erhalten:
[ERROR] Failed to execute goal org.sonarsource.scanner.maven:sonar-maven-plugin:3.2:sonar (default-cli) on project [...]: SCM provider was set to "..." but no SCM provider found for this key. Supported SCM providers are git,svn
oder
[ERROR] Failed to execute goal org.codehaus.mojo:sonar-maven-plugin:2.5:sonar (default-cli) on project [...]: SCM provider was set to "[...]" but no provider found for this key. Supported providers are git,svn
Dann können Sie den SCM-Sensor deaktivieren:
Als "admin" anmelden, und dann je nach Version:
entweder: "Administration" | "SCM" | "Disable the SCM Sensor": "True" | "Save",
oder: "Settings" | "General Settings" | "SCM" | "Disable the SCM Sensor" --> "True".
Falls Sie eine Oracle-Datenbank verwenden wollen und folgende Fehlermeldung erhalten:
org.sonar.api.utils.MessageException: Oracle NLS_CHARACTERSET does not support UTF8
Dann muss der Characterset in der Oracle-Datenbank auf AL32UTF8 umgestellt werden. Überprüfen Sie dies mit dem SQL-Kommando "Select * from nls_database_parameters;" und sehen Sie sich an: Installing the Database, Ändern des Oracle-Datenbank-Character-Encodings.
Falls Sie folgende Fehlermeldung erhalten:
Der Dienst [...] konnte nicht gestartet werden [...] Der Prozess wurde unerwartet beendet
Suchen Sie in der \Tools\SonarQube\logs\sonar.log nach genaueren Fehlermeldungen.
Überprüfen Sie, ob Sie beim installierten Windows-Dienst korrekte Windows-Anmeldeinformationen eingetragen haben.
Eventuell müssen Sie in der
\Tools\SonarQube\conf\wrapper.conf
die Zeile
wrapper.java.command=java
ändern zu:
wrapper.java.command=C:\Program Files\Java\jdk1.7\bin\java.exe
Falls Sie unter 64-bit-Windows installieren und eine ältere Versionen von SonarQube verwenden:
Ältere Versionen vom SonarQube-Wrapper funktionieren eventuell nur mit einem 32-bit-JDK.
Dieses muss installiert (z.B. nach C:\Program Files (x86)\Java\jdk1.7-32bit) und bei SonarQube eingetragen werden.
Hierzu in der
\Tools\SonarQube\conf\wrapper.conf
die Zeile
wrapper.java.command=java
ändern zu:
wrapper.java.command=C:\Program Files (x86)\Java\jdk1.7-32bit\bin\java
Falls Sie Probleme mit der Erfassung und Anzeige der Java Code Coverage der JUnit-Tests mit dem JaCoCo-Plug-in haben:
Prüfen Sie, ob im target-Verzeichnis die Datei jacoco.exec erzeugt wurde.
Beobachten Sie, ob im Kommandozeilenfenster angezeigt wird:
... [INFO] Sensor JaCoCoSensor [java] [INFO] Analysing .../target/jacoco.exec [INFO] Sensor JaCoCoSensor [java] (done) | time=12ms ...
Falls Sie das maven-surefire-plugin oder das maven-failsafe-plugin verwenden, beachten Sie die Hinweise zum JaCoCo-Maven Plug-in und zum prepare-agent-Goal.
Falls irgendwo (z.B. bei der Konfiguration vom maven-surefire-plugin oder maven-failsafe-plugin) in einem Plug-in die Property argLine gesetzt wird, funktioniert die JaCoCo-Parameterweitergabe nicht, dadurch wird die Datei jacoco.exec nicht erzeugt, und Sie erhalten keine Code-Coverage-Ergebnisse. Um dies zu vermeiden, gibt es zwei Optionen:
a) Sie können in den relevanten Plug-ins die argLine-Anweisungen überall (auch in Parent-POMs) entfernen, und die gewünschten Properties global im properties-Block definieren:
<properties>
<argLine>...</argLine>
</properties>
b) Alternativ können Sie vermeiden, dass der vorherige argLine-Wert überschrieben wird, wenn Sie in den Plug-ins statt
<argLine>...</argLine>schreiben:
<argLine>... ${argLine}</argLine>
Falls das JaCoCo-Maven-Plug-in nicht für jedes Goal aktiv ist, kann dies allerdings zu einer der folgenden Fehlermeldungen führen:
Fehler: Hauptklasse ${argLine} konnte nicht gefunden oder geladen werden
Error: Could not find or load main class ${argLine}
In diesem Fall kann die Lösung sein, dass Sie über eine Kommandozeilenvariable verschiedene Profile in der pom.xml aktivieren:
...
<profiles>
<profile>
<id>ohne-JaCoCo</id>
<activation>
<activeByDefault>true</activeByDefault>
<property>
<name>!JaCoCo</name>
</property>
</activation>
<properties>
<jacoco.argLine></jacoco.argLine>
</properties>
</profile>
<profile>
<id>SonarQube-mit-JaCoCo</id>
<activation>
<property>
<name>JaCoCo</name>
</property>
</activation>
<build>
<plugins>
<plugin>
<groupId>org.jacoco</groupId>
<artifactId>jacoco-maven-plugin</artifactId>
<version>0.7.9</version>
<executions>
<execution>
<id>jacoco-initialize</id>
<goals>
<goal>prepare-agent</goal>
</goals>
<configuration>
<propertyName>jacoco.argLine</propertyName>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</profile>
</profiles>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.12</version>
<configuration>
<argLine>-Duser.language=de -Duser.region=DE -Xmx512m -Dfile.encoding=UTF-8 ${jacoco.argLine}</argLine>
</configuration>
</plugin>
</plugins>
</build>
...
So wird bei normalen Kommandos wie z.B. "mvn clean install" die Property jacoco.argLine als Leerstring initialisiert, um die Fehlermeldung zu vermeiden. Für SonarQube-Analysen inklusive JaCoCo-Plug-in führen Sie aus:
mvn clean install sonar:sonar -DJaCoCo
Dann entfällt die Vorinitialisierung der Property jacoco.argLine und das JaCoCo-Plug-in wird aktiviert.
Falls Sie die Code Coverage by Unit Tests (Testabdeckung) nicht mit JaCoCo sondern stattdessen mit Cobertura ermitteln wollen, verfahren Sie wie folgt.
Beachten Sie, dass Cobertura 2.1.1 und das cobertura-maven-plugin 2.7 nur bis Java 7 funktionieren.
Während für JaCoCo in SonarQube kein Plug-in benötigt wird, muss für Cobertura das sonar-cobertura-plugin in einer passenden Version in SonarQube installiert werden. Beispielsweise für SonarQube 6.3 wird sonar-cobertura-plugin-1.9.jar benötigt.
Downloaden Sie die passende Version von: https://github.com/galexandre/sonar-cobertura/releases/.
Kopieren Sie die heruntergeladene sonar-cobertura-plugin-Jar-Datei (z.B. sonar-cobertura-plugin-1.9.jar) in das extensions/plugins-Verzeichnis der SonarQube-Installation (siehe hierzu https://docs.sonarqube.org/display/SONAR/Installing+a+Plugin).
Starten Sie SonarQube neu (z.B. unter Linux per "bin/linux-x86-64/sonar.sh restart").
Jetzt können Sie SonarQube-Reports inklusive Cobertura-Testabdeckungsergebnisse erzeugen:
cd \MeinWorkspace\<MeinProjekt>
mvn clean install cobertura:cobertura -Dcobertura.report.format=xml
--> im target/site/cobertura-Verzeichnis entsteht die Datei coverage.xml.
mvn org.sonarsource.scanner.maven:sonar-maven-plugin:3.2:sonar -Dsonar.host.url=http://localhost:9000
--> u.a. wird gemeldet:
...
[INFO] Sensor CoberturaSensor [cobertura]
[INFO] parsing .../target/site/cobertura/coverage.xml
[INFO] Sensor CoberturaSensor [cobertura] (done) | time=5ms
...
start http://localhost:9000
--> SonarQube zeigt die Testabdeckung an.
Wenn Sie wollen, können Sie die beiden Maven-Kommandos auch in einer einzigen Zeile ausführen:
mvn clean install cobertura:cobertura org.sonarsource.scanner.maven:sonar-maven-plugin:3.2:sonar -Dcobertura.report.format=xml -Dsonar.host.url=http://localhost:9000
Falls Sie folgende Fehlermeldung erhalten:
Unable to register extension org.sonar.plugins.cobertura.CoberturaSensor from plugin 'cobertura': Lorg/sonar/api/scan/filesystem/ModuleFileSystem;: org.sonar.api.scan.filesystem.ModuleFileSystem
Dann passt die Version vom sonar-cobertura-plugin nicht zur SonarQube-Version, siehe hierzu: https://github.com/galexandre/sonar-cobertura/releases/. Für SonarQube 6.3 funktioniert sonar-cobertura-plugin-1.9.jar.
Das folgende Beispiel zeigt, wie Sie mit dem "maven install"-Kommando nicht nur .jar-Artefakte, sondern auch Javadoc und gezippten Sourcecode zu beliebigen Maven-Projekten erzeugen. Dazu werden das Maven Javadoc Plugin und das Maven Source Plugin verwendet.
Falls Sie kein vorhandenes Maven-Projekt verwenden wollen, legen Sie folgendermaßen ein neues an:
cd \MeinWorkspace
mvn archetype:generate -DinteractiveMode=false -DgroupId=de.meinefirma.meinprojekt -DartifactId=MvnSourceUndJavadoc
cd MvnSourceUndJavadoc
Ersetzen Sie den Inhalt der pom.xml durch (bzw. fügen Sie bei anderen Projekten die <plugin>-Blöcke ein):
<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>de.meinefirma.meinprojekt</groupId>
<artifactId>MvnSourceUndJavadoc</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>MvnSourceUndJavadoc</name>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-javadoc-plugin</artifactId>
<version>2.10.4</version>
<executions>
<execution>
<id>attach-javadoc</id>
<goals>
<goal>jar</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-source-plugin</artifactId>
<version>3.0.1</version>
<executions>
<execution>
<id>attach-sources</id>
<goals>
<goal>jar-no-fork</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>
Führen Sie aus:
cd \MeinWorkspace\MvnSourceUndJavadoc
mvn clean install
Die Ergebnisse werden im lokalen Maven-Repository generiert. Setzen Sie folgende Environmentvariable entsprechend Ihres Repo-Pfades, um die Ergebnisse zu untersuchen, beispielsweise:
set MVN_REPO=%USERPROFILE%\.m2\repository
oder
set MVN_REPO=D:\Tools\Maven3-Repo
Sehen Sie sich das Ergebnis in Ihrem lokalen Maven-Repository an:
dir %MVN_REPO%\de\meinefirma\meinprojekt\MvnSourceUndJavadoc\1.0-SNAPSHOT
Zusätzlich zu den üblichen .jar- und .pom-Dateien erhalten Sie eine ...-javadoc.jar und eine ...-sources.jar.
Sehen Sie sich die Javadoc an (die beim Standardbeispiel natürlich nur sehr kurz ausfällt):
md \MeinWorkspace\MvnSourceUndJavadoc\javadoc
cd \MeinWorkspace\MvnSourceUndJavadoc\javadoc
jar xvf %MVN_REPO%\de\meinefirma\meinprojekt\MvnSourceUndJavadoc\1.0-SNAPSHOT\MvnSourceUndJavadoc-1.0-SNAPSHOT-javadoc.jar
start index.html
Listen Sie den Inhalt der ...-sources.jar auf:
jar tvf %MVN_REPO%\de\meinefirma\meinprojekt\MvnSourceUndJavadoc\1.0-SNAPSHOT\MvnSourceUndJavadoc-1.0-SNAPSHOT-sources.jar
Falls Sie Artefakte übers Internet weitergeben wollen (oder z.B. in Maven Central verfügbar machen wollen), empfiehlt es sich, Signaturen hinzuzufügen. Das folgende Beispiel erzeugt Signaturen mit dem PGP Maven plugin.
Voraussetzung für das folgende Beispiel ist eine beliebige Private-Key-Schlüsseldatei und die Passphrase hierzu. Falls Sie dies noch nicht haben und falls Sie GnuPG / Gpg4win installiert haben, können Sie Schlüssel folgendermaßen erzeugen (Erläuterungen hierzu finden Sie unter java-crypto.htm#GnuPG):
gpg2 --gen-key
1 2048 0 j Mein Name MeinName@MeinServer.de GPG-Test f Meine geheime GPG-Passphrase 42
gpg2 -ao GPG-Test-pubkey.asc --export "GPG-Test"
gpg2 -o GPG-Test-seckey.gpg --export-secret-keys "GPG-Test"
Hierbei entsteht die Private-Key-Schlüsseldatei GPG-Test-seckey.gpg und der Public-Key GPG-Test-pubkey.asc.
Weiterhin benötigen Sie für das folgende Beispiel ein beliebiges Maven-Projekt. Falls Sie kein vorhandenes verwenden wollen, legen Sie folgendermaßen ein neues an:
cd \MeinWorkspace
mvn archetype:generate -DinteractiveMode=false -DgroupId=de.meinefirma.meinprojekt -DartifactId=MvnSign
cd MvnSign
Ersetzen Sie den Inhalt der pom.xml durch (bzw. fügen Sie bei anderen Projekten den <plugin>-Block ein):
<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>de.meinefirma.meinprojekt</groupId>
<artifactId>MvnSign</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>MvnSign</name>
<build>
<plugins>
<plugin>
<groupId>org.kohsuke</groupId>
<artifactId>pgp-maven-plugin</artifactId>
<version>1.1</version>
<executions>
<execution>
<goals>
<goal>sign</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>
Führen Sie versuchsweise aus:
cd \MeinWorkspace\MvnSign
mvn clean install
Da Sie keine Schlüsseldatei angegeben haben, erhalten Sie die Fehlermeldung:
[ERROR] Failed to execute goal org.kohsuke:pgp-maven-plugin:1.1:sign (default) on project MvnSign:
No PGP secret key is configured. Either do so in POM, or via -Dpgp.secretkey, or the PGP_SECRETKEY environment variable
Geben Sie die Private-Key-Schlüsseldatei und die Passphrase über eine der genannten Methoden an, z.B. so (passen Sie die Ausdrücke an Ihre Schlüsseldatei an):
mvn clean install -Dpgp.secretkey=keyfile:GPG-Test-seckey.gpg -Dpgp.passphrase="literal:Meine geheime GPG-Passphrase 42"
Um sich das Ergebnis ansehen zu können, setzen Sie zuerst Ihren Pfad zu Ihrem lokalen Maven-Repository, beispielsweise:
set MVN_REPO=%USERPROFILE%\.m2\repository
oder
set MVN_REPO=D:\Tools\Maven3-Repo
Sehen Sie sich das Ergebnis an:
dir %MVN_REPO%\de\meinefirma\meinprojekt\MvnSign\1.0-SNAPSHOT
Zusätzlich zu den üblichen .jar- und .pom-Dateien erhalten Sie mehrere entsprechende .asc-Signatur-Dateien, die mit "-----BEGIN PGP SIGNATURE-----" beginnen:
type %MVN_REPO%\de\meinefirma\meinprojekt\MvnSign\1.0-SNAPSHOT\MvnSign-1.0-SNAPSHOT.jar.asc
Öffnen Sie ein Kommandozeilenfenster, wechseln Sie in Ihr Projekte-Verzeichnis und erzeugen Sie ein beliebiges Projekt:
cd \MeinWorkspace
mvn archetype:generate -DinteractiveMode=false -DgroupId=de.meinefirma.meinprojekt -DartifactId=MvnExec
cd MvnExec
tree /F
Fügen Sie in der pom.xml vor dem <dependencies>-Block hinzu:
<build>
<plugins>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>exec-maven-plugin</artifactId>
<version>1.5.0</version>
<executions>
<execution>
<phase>test</phase>
<goals>
<goal>java</goal>
</goals>
<configuration>
<mainClass>de.meinefirma.meinprojekt.Timestamp</mainClass>
<arguments>
<argument>Timestamp:</argument>
<argument>yyyy-MM-dd HH:mm:ss,S</argument>
</arguments>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
Erzeugen Sie im src\main\java\de\meinefirma\meinprojekt-Verzeichnis die Klasse: Timestamp.java
package de.meinefirma.meinprojekt;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Timestamp
{
public static void main( String[] args )
{
String prefix = ( args.length > 0 ) ? args[0] : "Timestamp:";
String datetimePattern = ( args.length > 1 ) ? args[1] : "yyyy-MM-dd HH:mm:ss,S";
System.out.println( "\n" + prefix + " " + (new SimpleDateFormat( datetimePattern ).format( new Date() )) + "\n" );
}
}
So sieht Ihre Verzeichnisstruktur aus:
[\MeinWorkspace\MvnExec] |- [src] | |- [main] | | '- [java] | | '- [de] | | '- [meinefirma] | | '- [meinprojekt] | | |- App.java | | '- Timestamp.java | '- [test] | '- [java] | '- [de] | '- [meinefirma] | '- [meinprojekt] | '- AppTest.java '- pom.xml
Geben Sie im Kommandozeilenfenster ein:
cd \MeinWorkspace\MvnExec
mvn compile
mvn exec:java -Dexec.mainClass="de.meinefirma.meinprojekt.Timestamp"
mvn exec:java -Dexec.mainClass="de.meinefirma.meinprojekt.Timestamp" -Dexec.args="'Anderer Prefix:' 'yyyy-MM-dd HH:mm'"
Sie erhalten zwei verschiedene Timestamp-Ausgaben mit verschiedener Formatierung.
Interessanter ist, dass die Ausführung des Java-Programms in der pom.xml an die Maven-test-Lifecycle-Phase gekoppelt ist. Führen Sie aus:
mvn package
Auch diesmal erhalten Sie die Timestamp-Ausgabe.
Natürlich können Sie auch an andere Maven-Lifecycle-Phasen ankoppeln und beliebige andere Java- oder andere Programme ausführen.
Sehen Sie sich die Doku zum exec-maven-plugin an.
Das folgende Beispiel zeigt den Einsatz von Google Guice für Dependency Injection (DI) und für aspektorientierte Programmierung (AOP).
Das Beispiel demonstriert anhand der Berechnung von Fibonacci-Zahlen:
Wechseln Sie in Ihr Projekte-Verzeichnis und erzeugen Sie ein neues Projekt:
cd \MeinWorkspace
md MvnGuiceAop
cd MvnGuiceAop
md src\main\java\de\meinefirma\meinprojekt
Erzeugen Sie im Projektverzeichnis die Projektkonfigurationsdatei: pom.xml
<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>de.meinefirma.meinprojekt</groupId>
<artifactId>MvnGuiceAop</artifactId>
<version>1.0-SNAPSHOT</version>
<build>
<plugins>
<plugin>
<artifactId>maven-assembly-plugin</artifactId>
<version>3.0.0</version>
<configuration>
<descriptorRefs>
<descriptorRef>jar-with-dependencies</descriptorRef>
</descriptorRefs>
<archive>
<manifest>
<mainClass>de.meinefirma.meinprojekt.Main</mainClass>
</manifest>
</archive>
</configuration>
<executions>
<execution>
<id>make-assembly</id>
<phase>package</phase>
<goals>
<goal>single</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>com.google.inject</groupId>
<artifactId>guice</artifactId>
<version>4.1.0</version>
</dependency>
<dependency>
<groupId>aopalliance</groupId>
<artifactId>aopalliance</artifactId>
<version>1.0</version>
</dependency>
</dependencies>
</project>
Erzeugen Sie im src\main\java\de\meinefirma\meinprojekt-Verzeichnis folgende fünf Klassen:
Main.java
package de.meinefirma.meinprojekt;
import com.google.inject.Guice;
import com.google.inject.Injector;
public class Main
{
public static void main( String[] args )
{
Injector inj = Guice.createInjector( new AopModule() );
Fibonacci fib = inj.getInstance( Fibonacci.class );
int n = 7;
System.out.println( "\nFibonacci( " + n + " ) ist " + fib.fibonacci( n ) );
}
}
Fibonacci.java
package de.meinefirma.meinprojekt;
public class Fibonacci
{
@UseLoggerInterceptor
public long fibonacci( int n )
{
return ( n < 2 ) ? n : (fibonacci( n - 1 ) + fibonacci( n - 2 ));
}
}
AopModule.java
package de.meinefirma.meinprojekt;
import static com.google.inject.matcher.Matchers.annotatedWith;
import static com.google.inject.matcher.Matchers.any;
import com.google.inject.AbstractModule;
public class AopModule extends AbstractModule
{
protected void configure()
{
bindInterceptor( any(), annotatedWith( UseLoggerInterceptor.class ), new LoggerInterceptor() );
}
}
UseLoggerInterceptor.java
package de.meinefirma.meinprojekt;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
@Retention( RetentionPolicy.RUNTIME )
public @interface UseLoggerInterceptor
{
}
LoggerInterceptor.java
package de.meinefirma.meinprojekt;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import java.lang.reflect.Method;
import java.util.Arrays;
public class LoggerInterceptor implements MethodInterceptor
{
public Object invoke( MethodInvocation methInvoc ) throws Throwable
{
Method mth = methInvoc.getMethod();
Object[] arg = methInvoc.getArguments();
String cll = mth.getName() + Arrays.deepToString( arg );
System.out.print( cll + ": " );
Object result = methInvoc.proceed();
System.out.println( " " + cll + " --> " + result );
return result;
}
}
Geben Sie im Kommandozeilenfenster ein:
cd \MeinWorkspace\MvnGuiceAop
mvn package
java -jar target/MvnGuiceAop-1.0-SNAPSHOT-jar-with-dependencies.jar
Sie sehen zu jedem fibonacci()-Methodenaufruf jeweils eine Meldung vor und eine Meldung nach dem Methodenaufruf.
In Java programmierte Maven-Plugins bestehen aus Mojos.
Ein Mojo ("Maven (plain) old Java Object")
ist eine Java-Klasse die das Interface
org.apache.maven.plugin.Mojo
implementiert (oder
org.apache.maven.plugin.AbstractMojo
erweitert) und damit ein Plugin-Goal realisiert.
Siehe auch guide-java-plugin-development,
maven-plugin-api
und mojo-api-specification.
Öffnen Sie ein Kommandozeilenfenster, wechseln Sie in Ihr Projekte-Verzeichnis (z.B. \MeinWorkspace) und erzeugen Sie ein Mojo-Projekt:
cd \MeinWorkspace
mvn archetype:generate -DinteractiveMode=false -DarchetypeArtifactId=maven-archetype-mojo -DgroupId=de.meinefirma.meinprojekt -DartifactId=MvnTimestampPlugin
cd MvnTimestampPlugin
Sehen Sie sich die generierte pom.xml an und beachten Sie insbesondere das <packaging> und die <dependency>:
...
<packaging>maven-plugin</packaging>
...
<dependencies>
<dependency>
<groupId>org.apache.maven</groupId>
<artifactId>maven-plugin-api</artifactId>
<version>2.0</version>
</dependency>
...
Löschen Sie im Verzeichnis src\main\java\de\meinefirma\meinprojekt die MyMojo.java und legen Sie stattdessen in diesem Verzeichnis die Mojo-Datei TimestampMojo.java mit folgendem Inhalt an:
package de.meinefirma.meinprojekt;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.apache.maven.plugin.AbstractMojo;
/**
* @goal timestamp
*/
public class TimestampMojo extends AbstractMojo
{
/** @parameter */ String prefix = "Timestamp:";
/** @parameter */ String datetimePattern = "yyyy-MM-dd HH:mm:ss,S";
@Override
public void execute()
{
getLog().info( prefix + " " +
(new SimpleDateFormat( datetimePattern ).format( new Date() )) );
}
}
Bitte beachten Sie die für das Maven-Plugin wichtigen Angaben @goal... und @parameter....
Sie können das Goal über @phase auch an eine bestimmte Lifecycle-Phase binden.
Weiteres zu @phase, @goal, @parameter und weiteren Annotationen finden Sie unter
AbstractMojo,
Mojo API Specification und
Guide to Developing Java Plugins.
Die Projektstruktur sieht jetzt so aus:
cd \MeinWorkspace\MvnTimestampPlugin
tree /F
[\MeinWorkspace\MvnTimestampPlugin] |- [src] | '- [main] | '- [java] | '- [de] | '- [meinefirma] | '- [meinprojekt] | '- TimestampMojo.java '- pom.xml
Die allgemeine Syntax, um ein Goal auf der Kommandozeile auszuführen, lautet:
"mvn groupID:artifactID:[version:]goal" (der Versionsteil kann manchmal weggelassen werden).
Bauen Sie das Projekt und führen Sie für einen ersten Test das Goal per Kommandozeile aus:
cd \MeinWorkspace\MvnTimestampPlugin
mvn clean install
mvn de.meinefirma.meinprojekt:MvnTimestampPlugin:1.0-SNAPSHOT:timestamp
Sie erhalten:
[INFO] --- MvnTimestampPlugin:1.0-SNAPSHOT:timestamp (default-cli) @ MvnTimestampPlugin --- [INFO] Timestamp: 2010-10-09 20:42:37,90
Interessant wird es jedoch erst, wenn Sie das neue Maven-Plugin in anderen Projekten verwenden und beispielsweise mit Lifecycle-Phasen verknüpfen. Erweitern Sie die pom.xml irgendeines beliebigen Projekts (z.B. MvnJaxbApp) im <build><plugins>...-Block um folgendes <plugin>-Element:
<plugin>
<groupId>de.meinefirma.meinprojekt</groupId>
<artifactId>MvnTimestampPlugin</artifactId>
<version>1.0-SNAPSHOT</version>
<configuration>
<prefix>+++</prefix>
<datetimePattern>HH:mm:ss</datetimePattern>
</configuration>
<executions>
<execution>
<id>nach clean</id>
<phase>clean</phase>
<goals>
<goal>timestamp</goal>
</goals>
</execution>
<execution>
<id>nach compile</id>
<phase>compile</phase>
<goals>
<goal>timestamp</goal>
</goals>
</execution>
</executions>
</plugin>
Außer der Verknüpfung mit den beiden Lifecycle-Phasen clean und compile findet auch die Konfiguration der beiden Parameter prefix und datetimePattern statt.
Führen Sie jetzt im Projektverzeichnis dieses anderen Projekts aus:
cd \MeinWorkspace\MvnJaxbApp-mit-TimestampMojo [anpassen!]
mvn clean package
Sie erhalten:
... [INFO] --- maven-clean-plugin:2.5:clean (default-clean) @ MvnJaxbApp --- ... [INFO] --- MvnTimestampPlugin:1.0-SNAPSHOT:timestamp (nach clean) @ MvnJaxbApp --- [INFO] +++ 20:52:03 ... [INFO] --- maven-compiler-plugin:3.5.1:compile (default-compile) @ MvnJaxbApp --- ... [INFO] --- MvnTimestampPlugin:1.0-SNAPSHOT:timestamp (nach compile) @ MvnJaxbApp --- [INFO] +++ 20:52:05 ...
Wir wollen das Plugin-Mojo so erweitern, dass es nicht nur die aktuelle Zeit anzeigt,
sondern zusätzlich die Dauer vom letzten Aufruf bis zu diesem Aufruf berechnet.
Dazu ist eine Kommunikation zwischen den verschiedenen Plugin-Aufrufen notwendig.
Eine solche Kommunikation (auch zwischen verschiedenen Plugins) ist über die
"PluginContext"-Map
möglich.
Ersetzen Sie im MvnTimestampPlugin-Projekt im Unterverzeichnis src\main\java\de\meinefirma\meinprojekt
den Inhalt der TimestampMojo.java durch Folgendes:
package de.meinefirma.meinprojekt;
import java.text.SimpleDateFormat;
import java.util.*;
import org.apache.maven.plugin.AbstractMojo;
/**
* @goal timestamp
*/
public class TimestampMojo extends AbstractMojo
{
/** @parameter */ String prefix = "Timestamp:";
/** @parameter */ String datetimePattern = "yyyy-MM-dd HH:mm:ss,S";
@Override
public void execute()
{
final String ctxTimeKey = "TimestampMojo-Time";
Date date = new Date();
Map ctx = getPluginContext();
Long timeZuletzt = (Long) ctx.get( ctxTimeKey );
ctx.put( ctxTimeKey, new Long( date.getTime() ) );
String dauer = ( timeZuletzt == null ) ? "" :
", Dauer: " + (date.getTime() - timeZuletzt.longValue()) + " ms";
getLog().info( prefix + " " +
(new SimpleDateFormat( datetimePattern ).format( date )) + dauer );
}
}
Bauen Sie das Timestamp-Plugin neu:
cd \MeinWorkspace\MvnTimestampPlugin
mvn clean install
Führen Sie wieder im Projektverzeichnis des anderen Projekts aus:
cd \MeinWorkspace\MvnJaxbApp-mit-TimestampMojo [anpassen!]
mvn clean package
Diesmal ist die Ausgabe erweitert um die Anzeige der "Dauer":
... [INFO] --- maven-clean-plugin:2.5:clean (default-clean) @ MvnJaxbApp --- ... [INFO] --- MvnTimestampPlugin:1.0-SNAPSHOT:timestamp (nach clean) @ MvnJaxbApp --- [INFO] +++ 10:48:00 ... [INFO] --- maven-compiler-plugin:3.5.1:compile (default-compile) @ MvnJaxbApp --- ... [INFO] --- MvnTimestampPlugin:1.0-SNAPSHOT:timestamp (nach compile) @ MvnJaxbApp --- [INFO] +++ 10:48:01, Dauer: 1234 ms ...
Es gibt verschiedene Verfahren, um Maven-Plugins automatisiert testen zu können. Einige sind beschrieben unter Introduction / Testing Styles.
Um das maven-plugin-testing-harness-Plugin verwenden zu können, erweitern Sie die pom.xml des MvnTimestampPlugins im <dependencies>...-Block um folgendes <dependency>-Element:
<dependency>
<groupId>org.apache.maven.shared</groupId>
<artifactId>maven-plugin-testing-harness</artifactId>
<version>1.1</version>
<scope>test</scope>
</dependency>
Erzeugen Sie folgendermaßen weitere Unterverzeichnisse:
cd \MeinWorkspace\MvnTimestampPlugin
md src\test\resources
md src\test\java\de\meinefirma\meinprojekt
Für den Test wird nur eine einfache abgespeckte POM benötigt. Erzeugen Sie im src\test\resources-Verzeichnis die Datei test-pom.xml mit folgendem Inhalt:
<project>
<modelVersion>4.0.0</modelVersion>
<groupId>test</groupId>
<artifactId>Test</artifactId>
<build>
<plugins>
<plugin>
<groupId>de.meinefirma.meinprojekt</groupId>
<artifactId>MvnTimestampPlugin</artifactId>
<configuration>
<prefix>+++</prefix>
<datetimePattern>HH:mm:ss</datetimePattern>
</configuration>
</plugin>
</plugins>
</build>
</project>
Erzeugen Sie im src\test\java\de\meinefirma\meinprojekt-Verzeichnis die Datei TimestampMojoTest.java mit folgendem Inhalt:
package de.meinefirma.meinprojekt;
import java.io.File;
import java.util.*;
import org.apache.maven.plugin.logging.SystemStreamLog;
import org.apache.maven.plugin.testing.AbstractMojoTestCase;
public class TimestampMojoTest extends AbstractMojoTestCase
{
public void testTimestampMojo() throws Exception
{
Map pluginContext = new HashMap();
String log1 = executeMojo( pluginContext );
String log2 = executeMojo( pluginContext );
assertTrue( log1.length() < log2.length() );
assertTrue( !log1.contains( "Dauer" ) );
assertTrue( log2.contains( "Dauer" ) );
}
private String executeMojo( Map pluginContext ) throws Exception
{
String testPom = getBasedir() + "/src/test/resources/test-pom.xml";
String artifactId = "MvnTimestampPlugin";
StringBuffer log = new StringBuffer();
TimestampMojo mojo = new TimestampMojo();
configureMojo( mojo, artifactId, new File( testPom ) );
mojo.setPluginContext( pluginContext );
mojo.setLog( new TestLog( log ) );
mojo.execute();
String prefix = (String) getVariableValueFromObject( mojo, "prefix" );
assertNotNull( prefix );
assertEquals( prefix, log.substring( 0, prefix.length() ) );
return log.toString();
}
class TestLog extends SystemStreamLog
{
StringBuffer log;
public TestLog( StringBuffer log )
{
this.log = log;
}
// @Override
public void info( CharSequence content )
{
log.append( content );
}
}
}
Die Variable testPom muss den Pfad zu einer geeigneten POM-Datei enthalten, in welcher das Plugin MvnTimestampPlugin eingetragen ist.
TimestampMojoTest erweitert AbstractMojoTestCase, damit die Methoden getBasedir(), configureMojo() und getVariableValueFromObject() zur Verfügung stehen.
Bitte beachten Sie die Injizierung der Context-Map über setPluginContext() und des Testloggers über setLog(). Letzteres wird benötigt, um die log-Ausgaben abzufangen.
executeMojo() wird zweimal aufgerufen: Beim ersten Mal wird nur der Timestamp geloggt. Beim zweiten Mal wird auch die Dauer geloggt, was durch "assertTrue( log2.contains( "Dauer" ) )" überprüft wird.
Bitte beachten Sie, dass TestLog nur eine einzige der vielen Log-Methoden überschreibt, was für diesen Test reicht, aber für andere Tests eventuell zu wenig sein kann.
Ihre Verzeichnisstruktur sieht jetzt so aus:
cd \MeinWorkspace\MvnTimestampPlugin
tree /F
-->
[\MeinWorkspace\MvnTimestampPlugin] |- [src] | |- [main] | | '- [java] | | '- [de] | | '- [meinefirma] | | '- [meinprojekt] | | '- TimestampMojo.java | '- [test] | |- [java] | | '- [de] | | '- [meinefirma] | | '- [meinprojekt] | | '- TimestampMojoTest.java | '- [resources] | '- test-pom.xml '- pom.xml
Führen Sie den JUnit-Test aus:
cd \MeinWorkspace\MvnTimestampPlugin
mvn test
Erweitern Sie die pom.xml um erläuternde Hilfstexte, damit folgendes Kommando Hilfe bieten kann:
mvn help:describe -Dplugin=de.meinefirma.meinprojekt:MvnTimestampPlugin:1.0-SNAPSHOT -Ddetail
Manchmal werden nur für Tests benötigte wichtige Testhilfsklassen auch in anderen Maven-Modulen benötigt. Die Weitergabe von Testhilfsklassen an andere Module wird durch das maven-jar-plugin über das test-jar-Goal unterstützt, wie das folgende Beispiel zeigt (siehe auch: Guide to using attached tests).
Wechseln Sie in Ihr Projekte-Verzeichnis und erzeugen Sie ein neues Maven-Projekt:
cd \MeinWorkspace
mvn archetype:generate -DinteractiveMode=false -DgroupId=de.meinefirma.meinprojekt -DartifactId=MvnTestJar1
cd MvnTestJar1
Erzeugen Sie im src\test\java\de\meinefirma\meinprojekt-Verzeichnis die wichtige Testhilfsklasse: MeinWichtigesTestUtil.java
package de.meinefirma.meinprojekt;
public class MeinWichtigesTestUtil
{
public static int hilfsmethode( int a, int b )
{
return a * b;
}
}
Ersetzen Sie im src\test\java\de\meinefirma\meinprojekt-Verzeichnis den Inhalt der AppTest.java durch:
package de.meinefirma.meinprojekt;
import junit.framework.Assert;
import junit.framework.TestCase;
public class AppTest extends TestCase
{
public void testApp()
{
Assert.assertEquals( 6, MeinWichtigesTestUtil.hilfsmethode( 2, 3 ) );
}
}
Führen Sie im Kommandozeilenfenster den JUnit-Test aus und installieren Sie das MvnTestJar1-Ergebnisartefakt im lokalen Maven-Repository (passen Sie den Pfad zum lokalen Maven-Repository an):
mvn test
mvn clean install
Die Ergebnisse werden im lokalen Maven-Repository generiert. Setzen Sie folgende Environmentvariable entsprechend Ihres Repo-Pfades, um die Ergebnisse zu untersuchen, beispielsweise:
set MVN_REPO=%USERPROFILE%\.m2\repository
oder
set MVN_REPO=D:\Tools\Maven3-Repo
Sehen Sie sich an:
dir %MVN_REPO%\de\meinefirma\meinprojekt\MvnTestJar1\1.0-SNAPSHOT
Sie erhalten u.a.:
MvnTestJar1-1.0-SNAPSHOT.jar
Erzeugen Sie ein zweites Maven-Projekt:
cd \MeinWorkspace
mvn archetype:generate -DinteractiveMode=false -DgroupId=de.meinefirma.meinprojekt -DartifactId=MvnTestJar2
cd MvnTestJar2
copy ..\MvnTestJar1\src\test\java\de\meinefirma\meinprojekt\AppTest.java src\test\java\de\meinefirma\meinprojekt /Y
mvn test
Da die Dependency zu MvnTestJar1 fehlt, erhalten Sie erwartungsgemäß die Fehlermeldung:
[ERROR] COMPILATION ERROR : ...\AppTest.java: cannot find ... MeinWichtigesTestUtil
Erweitern Sie die pom.xml des neuen MvnTestJar2-Projekts um eine Dependency zum MvnTestJar1-Projekt, indem Sie folgenden Block einfügen:
<dependency>
<groupId>de.meinefirma.meinprojekt</groupId>
<artifactId>MvnTestJar1</artifactId>
<version>1.0-SNAPSHOT</version>
<scope>test</scope>
</dependency>
Wenn Sie erneut "mvn test" ausführen, erhalten Sie weiterhin die Fehlermeldung:
[ERROR] COMPILATION ERROR : ...\AppTest.java: cannot find ... MeinWichtigesTestUtil
Der Grund ist, dass die Testhilfsklasse MeinWichtigesTestUtil nicht im Auslieferartefakt MvnTestJar1-1.0-SNAPSHOT.jar enthalten ist, da sie nur für JUnit-Tests benötigt wird.
Jetzt kommt der Trick dieses Programmierbeispiels:
Um wichtige Testhilfsklassen auch in Tests in anderen Modulen verwenden zu können,
werden sie in gesonderten Auslieferartefakten weitergegeben, wie im Folgenden beschrieben wird.
Ändern Sie in der pom.xml des neuen MvnTestJar2-Projekts folgendermaßen die MvnTestJar1-Dependency:
<dependency>
<groupId>de.meinefirma.meinprojekt</groupId>
<artifactId>MvnTestJar1</artifactId>
<version>1.0-SNAPSHOT</version>
<type>test-jar</type>
<scope>test</scope>
</dependency>
Beachten Sie die "<type>test-jar</type>"-Zeile.
Fügen Sie in der pom.xml des ersteren MvnTestJar1-Projekts folgendermaßen das maven-jar-plugin mit dem test-jar-Goal hinzu:
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<version>3.0.2</version>
<executions>
<execution>
<goals>
<goal>test-jar</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
Führen Sie im MvnTestJar1-Projekt erneut "mvn install" aus:
cd ..\MvnTestJar1
mvn install
dir %MVN_REPO%\de\meinefirma\meinprojekt\MvnTestJar1\1.0-SNAPSHOT
Diesmal erhalten Sie zwei Ergebnis-Jar-Archive:
MvnTestJar1-1.0-SNAPSHOT-tests.jar
MvnTestJar1-1.0-SNAPSHOT.jar
Jetzt funktionieren auch im MvnTestJar2-Projekt die Tests (inkl. MeinWichtigesTestUtil):
cd ..\MvnTestJar2
mvn test
Das maven-jar-plugin kann noch Vieles mehr, siehe beispielsweise: Ausführbare Jar-Datei und REST-Client mit REST-JUnit-Test.
Eine Alternative zu JUnit 4 ist das modernere JUnit 5. Es nutzt die Vorteile von Java 8, z.B. die Funktionale Programmierung mit Lambda-Ausdrücken und das Stream-API.
Wechseln Sie in Ihr Projekte-Verzeichnis und erzeugen Sie ein neues Projekt:
cd \MeinWorkspace
md MvnJUnit5
cd MvnJUnit5
md src\main\java\de\meinefirma\meinprojekt
md src\test\java\de\meinefirma\meinprojekt
tree /F
Erstellen Sie im MvnJUnit5-Projektverzeichnis die Projektkonfigurationsdatei: pom.xml
<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>de.meinefirma.meinprojekt</groupId>
<artifactId>MvnJUnit5</artifactId>
<version>1.0-SNAPSHOT</version>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.6.1</version>
<configuration>
<source>8</source>
<target>8</target>
</configuration>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<version>5.0.0-M4</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-engine</artifactId>
<version>5.0.0-M4</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.junit.platform</groupId>
<artifactId>junit-platform-runner</artifactId>
<version>1.0.0-M4</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>
Überprüfen Sie unter junit-jupiter-api, ob es mittlerweile eine neuere JUnit-5-Version gibt.
Erstellen Sie im src\main\java\de\meinefirma\meinprojekt-Verzeichnis die Anwendungsklasse: App.java
package de.meinefirma.meinprojekt;
public class App
{
public static void main( String[] args ) {
if( args != null && args.length > 1 ) {
System.out.println( args[0] + " / " + args[1] + " = " +
calc( Long.valueOf( args[0] ), Long.valueOf( args[1] ) ) );
}
}
public static long calc( long val1, long val2 ) {
return val1 / val2;
}
}
Erstellen Sie im src\test\java\de\meinefirma\meinprojekt-Verzeichnis die JUnit5-Testklasse: AppTest.java
package de.meinefirma.meinprojekt;
import java.util.stream.Stream;
import org.junit.jupiter.api.*;
import org.junit.platform.runner.JUnitPlatform;
import org.junit.runner.RunWith;
import static org.junit.jupiter.api.Assertions.*;
@RunWith( JUnitPlatform.class )
public class AppTest
{
@BeforeAll
static void beforeAll() {
System.out.println( "Vor allen Tests ..." );
}
@AfterAll
static void afterAll() {
System.out.println( "... fertig" );
}
@BeforeEach
void beforeEach() {
System.out.println( "Vor jedem einzelnen Test ..." );
}
@Test @DisplayName( "Teste App.main()" )
void testeAppMain() {
App.main( new String[] { "7", "3" } );
}
@Test @DisplayName( "Teste 3 / 2" )
void testeCalc() {
System.out.println( "3 / 2 ..." );
assertEquals( 1, App.calc( 3, 2 ), "Ergebnis muss 1 sein" );
}
@Test @DisplayName( "Teste Exception nach Division by zero" )
void testeExeption() {
System.out.println( "1 / 0 ..." );
App app = new App();
ArithmeticException ex = assertThrows( ArithmeticException.class, () -> App.calc( 1, 0 ) );
assertEquals( "/ by zero", ex.getMessage(), "Exception-Message" );
}
@Test @DisplayName( "Mehrere Tests zusammengefasst" )
void testeAssertAll() {
System.out.println( "20 / ?? ..." );
assertAll( "Mehrere Tests",
() -> assertEquals( 6, App.calc( 20, 3 ) ),
() -> assertEquals( 5, App.calc( 20, 4 ) ),
() -> assertEquals( 4, App.calc( 20, 5 ) ) );
}
@TestFactory @DisplayName( "DynamicTest mit TestFactory" )
Stream<DynamicTest> testeDynamicTest() {
System.out.println( "1, 2, 3 / 2 ..." );
return Stream.of( 1, 2, 3 ).map( i -> DynamicTest.dynamicTest( "i=" + i,
() -> assertTrue( i > App.calc( i, 2 ) ) ) );
}
}
Sehen Sie sich zu den JUnit-5-Ausdrücken die JUnit-5-API-Doku an.
Ihr Projekteverzeichnis sieht jetzt so aus:
[\MeinWorkspace\MvnJUnit5] |- [src] | |- [main] | | '- [java] | | '- [de] | | '- [meinefirma] | | '- [meinprojekt] | | '- App.java | '- [test] | '- [java] | '- [de] | '- [meinefirma] | '- [meinprojekt] | '- AppTest.java '- pom.xml
Führen Sie die fünf Testmethoden aus:
cd \MeinWorkspace\MvnJUnit5
mvn test
Sie erhalten beispielsweise (die Reihenfolge kann variieren):
------------------------------------------------------- T E S T S ------------------------------------------------------- Running de.meinefirma.meinprojekt.AppTest Vor allen Tests ... Vor jedem einzelnen Test ... 7 / 3 = 2 Vor jedem einzelnen Test ... 3 / 2 ... Vor jedem einzelnen Test ... 1 / 0 ... Vor jedem einzelnen Test ... 20 / ?? ... Vor jedem einzelnen Test ... 1, 2, 3 / 2 ... ... fertig Tests run: 7, Failures: 0, Errors: 0, Skipped: 0 [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESS [INFO] ------------------------------------------------------------------------
Die per @DisplayName() gesetzten Texte werden beispielsweise angezeigt, wenn Sie die Tests in JetBrains IntelliJ IDEA ausführen.
Eine weitere Alternative zu JUnit ist TestNG. Hierzu gibt es auch Unterstützung durch das bereits bekannte maven-surefire-plugin, womit im Folgenden die Parallelisierung von Tests demonstriert wird.
Wechseln Sie in Ihr Projekte-Verzeichnis und erzeugen Sie ein neues Projekt:
cd \MeinWorkspace
mvn archetype:generate -DinteractiveMode=false -DgroupId=de.meinefirma.meinprojekt -DartifactId=MvnTestNG
cd MvnTestNG
tree /F
[\MeinWorkspace\MvnTestNG] |- [src] | |- [main] | | '- [java] | | '- [de] | | '- [meinefirma] | | '- [meinprojekt] | | '- App.java | '- [test] | '- [java] | '- [de] | '- [meinefirma] | '- [meinprojekt] | '- AppTest.java '- pom.xml
Ersetzen Sie den Inhalt der pom.xml durch:
<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>de.meinefirma.meinprojekt</groupId>
<artifactId>MvnTestNG</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>MvnTestNG</name>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.19.1</version>
<configuration>
<parallel>methods</parallel>
<threadCount>10</threadCount>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.5.1</version>
<configuration>
<source>1.7</source>
<target>1.7</target>
</configuration>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>org.testng</groupId>
<artifactId>testng</artifactId>
<version>6.9.9</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>
Ersetzen Sie im src\main\java\de\meinefirma\meinprojekt-Verzeichnis den Inhalt der App.java durch:
package de.meinefirma.meinprojekt;
import java.text.SimpleDateFormat;
import java.util.Date;
public class App
{
public static void main( String[] args ) throws InterruptedException
{
final SimpleDateFormat dfHhMmSsS = new SimpleDateFormat( "HH:mm:ss.S" );
String s = ( args != null && args.length > 0 ) ? args[0] : ".";
System.out.println( "\n" + dfHhMmSsS.format( new Date() ) + " " + Thread.currentThread().getName() + " Start" );
for( int i = 0; i < 10; i++ ) {
Thread.sleep( 100 );
System.out.print( s );
Thread.sleep( 100 );
}
System.out.println( "\n" + dfHhMmSsS.format( new Date() ) + " " + Thread.currentThread().getName() + " Ende" );
}
}
Löschen Sie im src\test\java\de\meinefirma\meinprojekt-Verzeichnis die AppTest.java und legen Sie in diesem Verzeichnis folgende Testklassen an:
App1Test.java
package de.meinefirma.meinprojekt;
import org.testng.annotations.Test;
public class App1Test
{
@Test public void testApp() throws InterruptedException
{
App.main( new String[] { "1" } );
}
}
App2Test.java
package de.meinefirma.meinprojekt;
import org.testng.annotations.Test;
public class App2Test
{
@Test public void testApp() throws InterruptedException
{
App.main( new String[] { "2" } );
}
}
App3Test.java
package de.meinefirma.meinprojekt;
import org.testng.annotations.Test;
public class App3Test
{
@Test public void testApp3() throws InterruptedException
{
App.main( new String[] { "3" } );
}
@Test public void testApp4() throws InterruptedException
{
App.main( new String[] { "4" } );
}
@Test public void testApp5() throws InterruptedException
{
App.main( new String[] { "5" } );
}
}
Ihr Projekteverzeichnis sieht jetzt so aus:
[\MeinWorkspace\MvnTestNG] |- [src] | |- [main] | | '- [java] | | '- [de] | | '- [meinefirma] | | '- [meinprojekt] | | '- App.java | '- [test] | '- [java] | '- [de] | '- [meinefirma] | '- [meinprojekt] | '- App1Test.java | '- App2Test.java | '- App3Test.java '- pom.xml
Führen Sie die fünf Testmethoden in den drei Testklassen aus:
cd \MeinWorkspace\MvnTestNG
mvn test
Sie erhalten beispielsweise:
------------------------------------------------------- T E S T S ------------------------------------------------------- 11:22:33.0 pool-1-thread-1 Start 11:22:33.0 pool-1-thread-4 Start 11:22:33.0 pool-1-thread-2 Start 11:22:33.0 pool-1-thread-5 Start 11:22:33.0 pool-1-thread-3 Start 31245134521342513245312541354231524135423154231254 11:22:35.0 pool-1-thread-1 Ende 11:22:35.0 pool-1-thread-5 Ende 11:22:35.0 pool-1-thread-3 Ende 11:22:35.0 pool-1-thread-2 Ende 11:22:35.0 pool-1-thread-4 Ende Tests run: 5, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 2.1 sec [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESS [INFO] ------------------------------------------------------------------------
Wie Sie gut erkennen können, werden die fünf Testmethoden in fünf parallelen Threads ausgeführt.
Bitte beachten Sie:
Durch die Einstellung <parallel>methods</parallel> werden nicht nur Klassen,
sondern auch die Methoden innerhalb der Klasse App3Test.java parallel ausgeführt.
Ersetzen Sie testweise in der pom.xml die Zeile
<parallel>methods</parallel>
durch
<parallel>false</parallel>
und führen Sie die Tests erneut aus: Während bei ersterer paralleler Testausführung als Gesamttestzeit ("Time elapsed") ein Wert knap über 2 Sekunden gemeldet wurde, wird diesmal mit serieller Ausführung ein Wert über 10 Sekunden gemeldet, also fast das fünffache.
Wenn Sie TestNG-Tests in Eclipse ausführen wollen, müssen Sie das TestNG-Eclipse-Plug-in installieren, siehe http://testng.org/doc/eclipse.html und http://beust.com/eclipse/.
JMockit ist ein Mocking-Framework, welches während Testausführungen Methoden anderer Klassen simuliert und ersetzt und bestimmte Ergebnisse vortäuscht. Das Besondere an JMockit ist, dass es auch Konstruktoren sowie statische und finale Methoden mocken kann.
Alternativen zu JMockit sind Mockito und EasyMock sowie die Erweiterung PowerMock.
Wechseln Sie in Ihr Projekte-Verzeichnis und erzeugen Sie ein neues Projekt:
cd \MeinWorkspace
md MvnJMockit
cd MvnJMockit
md src\main\java\de\meinefirma\meinprojekt
md src\test\java\de\meinefirma\meinprojekt
Erzeugen Sie im Projektverzeichnis die Projektkonfigurationsdatei: pom.xml
<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>de.meinefirma.meinprojekt</groupId>
<artifactId>MvnJMockit</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>com.googlecode.jmockit</groupId>
<artifactId>jmockit</artifactId>
<version>1.7</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>
Beachten Sie, dass jmockit vor junit in den dependencies eingetragen sein muss.
Erzeugen Sie im src\main\java\de\meinefirma\meinprojekt-Verzeichnis die zu testende Klasse: Mittagspausenzeit.java
package de.meinefirma.meinprojekt;
import java.time.LocalDateTime;
public class Mittagspausenzeit
{
public static boolean isMittagspause()
{
int stunde = LocalDateTime.now().getHour();
return stunde >= 12 && stunde <= 13;
}
}
Erzeugen Sie im src\test\java\de\meinefirma\meinprojekt-Verzeichnis die Testklasse: MittagspausenzeitTest.java
package de.meinefirma.meinprojekt;
import java.time.LocalDateTime;
import mockit.*;
import org.junit.*;
public class MittagspausenzeitTest
{
@Test
public void test12uhr( @Mocked final LocalDateTime dateTime )
{
new Expectations() {{
LocalDateTime.now(); result = dateTime;
dateTime.getHour(); result = Integer.valueOf( 12 );
}};
boolean isMittagspause = Mittagspausenzeit.isMittagspause();
Assert.assertTrue( isMittagspause );
}
}
Damit der Test zu jeder Tageszeit ausgeführt werden kann, wird als Ergebnis von LocalDateTime.now().getHour() 12 Uhr vorgetäuscht.
Sehen Sie sich das JMockit Testing Toolkit Tutorial und die JMockit Toolkit API Doku an, sowie @Mocked und Expectations.
Ihr Projekteverzeichnis sieht jetzt so aus:
[\MeinWorkspace\MvnJMockit] |- [src] | |- [main] | | '- [java] | | '- [de] | | '- [meinefirma] | | '- [meinprojekt] | | '- Mittagspausenzeit.java | '- [test] | '- [java] | '- [de] | '- [meinefirma] | '- [meinprojekt] | '- MittagspausenzeitTest.java '- pom.xml
Führen Sie die den Test aus:
cd \MeinWorkspace\MvnJMockit
mvn test
Das folgende Beispiel enthält zwei verschiedene Testarten, die beide automatisiert ausgeführt werden können:
Erläuterungen zu den verschiedenen Testarten "Komponententest" und "Integrationstest" finden Sie unter java-fit.htm#Testebenen.
Zum besseren Verständnis und um es einfach zu halten sind in diesem Beispiel Komponententests und Integrationstests in einem einzigen Maven-Projekt vereint. In realen Projekten kann es manchmal sinnvoll sein, die Integrationstests in einem getrennten Maven-Projekt zu realisieren.
Die Verwendung von sowohl HtmlUnit als auch HttpUnit zusammen in einem Projekt ist normalerweise nicht sinnvoll, da beide Testframeworks ähnliche Ziele abdecken. Insbesondere im folgenden Beispiel ist der einzige Sinn, beides demonstrieren zu können.
Öffnen Sie ein Kommandozeilenfenster, wechseln Sie in Ihr Projekte-Verzeichnis (z.B. \MeinWorkspace) und erzeugen Sie eine Webapp-Projektstruktur:
cd \MeinWorkspace
mvn archetype:generate -DinteractiveMode=false -DarchetypeArtifactId=maven-archetype-webapp -DgroupId=de.meinefirma.meinprojekt -DartifactId=MvnHtmlIntTest
cd MvnHtmlIntTest
md src\main\java\de\meinefirma\meinprojekt
md src\test\java\de\meinefirma\meinprojekt
md src\test\java\integrationtest
rd src\main\resources
tree /F
Sie erhalten:
[\MeinWorkspace\MvnHtmlIntTest] |- [src] | |- [main] | | |- [java] | | | '- [de] | | | '- [meinefirma] | | | '- [meinprojekt] | | '- [webapp] | | |- [WEB-INF] | | | '- web.xml | | '- index.jsp | '- [test] | '- [java] | |- [de] | | '- [meinefirma] | | '- [meinprojekt] | '- [integrationtest] '- pom.xml
Ersetzen Sie im Projektverzeichnis den Inhalt der pom.xml durch:
<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>de.meinefirma.meinprojekt</groupId>
<artifactId>MvnHtmlIntTest</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>war</packaging>
<name>MvnHtmlIntTest: Webapp mit Integrationstest</name>
<build>
<finalName>${project.artifactId}</finalName>
<plugins>
<plugin>
<!-- Die Versionen 8.1.16.v20140903 und 9.2.2.v20140723 funktionieren,
aber 9.2.3.v20140905 und 9.3.10.v20160621 funktionieren nicht: -->
<groupId>org.eclipse.jetty</groupId>
<artifactId>jetty-maven-plugin</artifactId>
<version>9.2.2.v20140723</version>
<configuration>
<scanIntervalSeconds>10</scanIntervalSeconds>
<stopPort>9999</stopPort>
<stopKey>geheim</stopKey>
<stopWait>1</stopWait>
<webAppConfig>
<contextPath>/${project.artifactId}</contextPath>
</webAppConfig>
</configuration>
<executions>
<execution>
<id>start-jetty</id>
<phase>pre-integration-test</phase>
<goals>
<goal>run</goal>
</goals>
<configuration>
<scanIntervalSeconds>0</scanIntervalSeconds>
<daemon>true</daemon>
</configuration>
</execution>
<execution>
<id>stop-jetty</id>
<phase>post-integration-test</phase>
<goals>
<goal>stop</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.19.1</version>
<configuration>
<systemPropertyVariables>
<port>8080</port>
</systemPropertyVariables>
<excludes>
<exclude>**/integrationtest/*Test.java</exclude>
</excludes>
</configuration>
<executions>
<execution>
<id>integration-tests</id>
<phase>integration-test</phase>
<goals>
<goal>test</goal>
</goals>
<configuration>
<skip>false</skip>
<excludes>
<exclude>none</exclude>
</excludes>
<includes>
<include>**/integrationtest/*Test.java</include>
</includes>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>net.sourceforge.htmlunit</groupId>
<artifactId>htmlunit</artifactId>
<version>2.20</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.httpunit</groupId>
<artifactId>httpunit</artifactId>
<version>1.7.2</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>
Erläuterungen zu den Konfigurationsoptionen des Jetty-Plugins finden Sie unter http://eclipse.org/jetty/documentation/current/jetty-maven-plugin.html (sehen Sie sich insbesondere scanIntervalSeconds und daemon an).
Erläuterungen zu den Optionen des Surefire-Test-Plugins finden Sie unter http://maven.apache.org/plugins/maven-surefire-plugin/.
Ersetzen Sie im src\main\webapp-Verzeichnis den Inhalt der index.jsp durch:
<html> <head><title>Startseite</title></head> <body> <h2>Startseite</h2> <p><a name="BerechnungsFormular" href="BerechnungsFormular.jsp">Berechnungsformular</a></p> </body> </html>
Fügen Sie im src\main\webapp-Verzeichnis folgende BerechnungsFormular.jsp hinzu:
<%@ page import="de.meinefirma.meinprojekt.MeineBean" %>
<html>
<head><title>Webseite mit Berechnungsformular</title></head>
<body>
<h2>Webseite mit Berechnungsformular</h2>
<% String wert1 = request.getParameter( "wert1" );
String wert2 = request.getParameter( "wert2" );
if( wert1 == null ) { wert1 = ""; }
if( wert2 == null ) { wert2 = ""; }
String ergebnis = (new MeineBean()).berechne( wert1, wert2 ); %>
<form name="meinFormular" method="post"><pre>
Wert1 <input type="text" name="wert1" value='<%= wert1 %>' size=10 maxlength=10><br>
Wert2 <input type="text" name="wert2" value='<%= wert2 %>' size=10 maxlength=10><br>
<input type="submit" name="berechne" value="berechne"> <input type="text" name="ergebnis" value='<%= ergebnis %>' size=10 readonly><br>
</pre></form>
</body>
</html>
Erstellen Sie im src\main\java\de\meinefirma\meinprojekt-Verzeichnis eine JavaBean: MeineBean.java
package de.meinefirma.meinprojekt;
public class MeineBean
{
public String berechne( String d1, String d2 )
{
try {
return "" + (Double.parseDouble( d1 ) + Double.parseDouble( d2 ));
} catch( Exception ex ) {
return "";
}
}
}
Erstellen Sie im src\test\java\de\meinefirma\meinprojekt-Verzeichnis einen Komponenten-JUnit-Test: MeineBeanTest.java
package de.meinefirma.meinprojekt;
import org.junit.*;
public class MeineBeanTest
{
@Test
public void testMeineBean()
{
MeineBean meineBean = new MeineBean();
Assert.assertEquals( "3.0", meineBean.berechne( "1", "2" ) );
}
}
Erstellen Sie im src\test\java\integrationtest-Verzeichnis einen HtmlUnit-Integrationstest: HtmlUnitTest.java
package integrationtest;
import org.junit.*;
import com.gargoylesoftware.htmlunit.WebClient;
import com.gargoylesoftware.htmlunit.html.*;
public class HtmlUnitTest
{
@Test
public void test() throws Exception
{
String port = System.getProperty( "port" );
test( port, "1", "2", "3.0" );
}
public String test( String port, String wert1, String wert2, String ergebnis ) throws Exception
{
WebClient webClient = new WebClient();
HtmlPage page = (HtmlPage) webClient.getPage( "http://localhost:" + port + "/MvnHtmlIntTest/" );
Assert.assertEquals( "Titel: ", "Startseite", page.getTitleText() );
page = (HtmlPage) page.getAnchorByName( "BerechnungsFormular" ).click();
Assert.assertEquals( "Titel: ", "Webseite mit Berechnungsformular", page.getTitleText() );
HtmlForm form = page.getFormByName( "meinFormular" );
form.getInputByName( "wert1" ).setValueAttribute( wert1 );
form.getInputByName( "wert2" ).setValueAttribute( wert2 );
page = (HtmlPage) form.getInputByName( "berechne" ).click();
String e = page.getFormByName( "meinFormular" ).getInputByName( "ergebnis" ).getValueAttribute();
if( ergebnis != null ) { Assert.assertEquals( "Ergebnis: ", ergebnis, e ); }
return e;
}
}
Erstellen Sie im src\test\java\integrationtest-Verzeichnis einen HttpUnit-Integrationstest: HttpUnitTest.java
package integrationtest;
import org.junit.*;
import com.meterware.httpunit.*;
public class HttpUnitTest
{
@Test
public void test() throws Exception
{
String port = System.getProperty( "port" );
test( port, "1", "2", "3.0" );
}
public String test( String port, String wert1, String wert2, String ergebnis ) throws Exception
{
WebConversation conversation = new WebConversation();
WebRequest request = new GetMethodWebRequest( "http://localhost:" + port + "/MvnHtmlIntTest/" );
WebResponse response = conversation.getResponse( request );
Assert.assertEquals( "ReturnCode: ", 200, response.getResponseCode() );
Assert.assertEquals( "ReturnMsg: ", "OK", response.getResponseMessage() );
Assert.assertEquals( "Titel: ", "Startseite", response.getTitle() );
response = response.getLinkWithName( "BerechnungsFormular" ).click();
Assert.assertEquals( "Titel: ", "Webseite mit Berechnungsformular", response.getTitle() );
WebForm form = response.getFormWithName( "meinFormular" );
form.setParameter( "wert1", wert1 );
form.setParameter( "wert2", wert2 );
form.getSubmitButton( "berechne" ).click();
response = conversation.getCurrentPage();
form = response.getFormWithName( "meinFormular" );
String e = form.getParameterValue( "ergebnis" );
if( ergebnis != null ) { Assert.assertEquals( "Ergebnis: ", ergebnis, e ); }
return e;
}
}
Die Abfrage if( ergebnis != null ) erscheint im Moment noch etwas unsinnig: Sie wird erst später in MeinFixture im HTML-Akzeptanztest mit Fit benötigt.
Die Projektstruktur sieht jetzt so aus (überprüfen Sie es mit tree /F):
[\MeinWorkspace\MvnHtmlIntTest] |- [src] | |- [main] | | |- [java] | | | '- [de] | | | '- [meinefirma] | | | '- [meinprojekt] | | | '- MeineBean.java | | '- [webapp] | | |- [WEB-INF] | | | '- web.xml | | |- BerechnungsFormular.jsp | | '- index.jsp | '- [test] | '- [java] | |- [de] | | '- [meinefirma] | | '- [meinprojekt] | | '- MeineBeanTest.java | '- [integrationtest] | |- HtmlUnitTest.java | '- HttpUnitTest.java '- pom.xml
Manueller Test im Webbrowser:
cd \MeinWorkspace\MvnHtmlIntTest
mvn jetty:run
Warten Sie bis "Started Jetty Server" erscheint und rufen Sie dann im Webbrowser auf:
http://localhost:8080/MvnHtmlIntTest
Klicken Sie auf den Berechnungsformular-Link, tragen Sie auf der folgenden Webseite zwei Zahlen ein und betätigen Sie "berechne": Sie erhalten die Summe.
Beenden Sie Jetty mit "Strg + C".
Testen verschiedener Maven-Kommandos:
Normaler Build (MvnHtmlIntTest.war wird im target-Verzeichnis erzeugt):
mvn clean package
dir target\*.war
Nur einen einzelnen bestimmten Komponententest ausführen:
mvn test -Dtest=de.meinefirma.meinprojekt.MeineBeanTest
Build ohne Tests:
mvn package -Dmaven.test.skip=true
Manueller Aufruf einzelner bestimmter Integrationstests:
Versuchen Sie zuerst testweise einen Integrationstest ohne laufenden Jetty aufzurufen und sehen Sie sich die Fehlermeldung in target\surefire-reports\integrationtest.HtmlUnitTest.txt an:
mvn test -Dtest=integrationtest.HtmlUnitTest
type target\surefire-reports\integrationtest.HtmlUnitTest.txt
Starten Sie jetzt in einem Kommandozeilenfenster Jetty mit der Webanwendung:
mvn jetty:run
Starten Sie in einem zweiten Kommandozeilenfenster die Integrationstests (diesmal ohne Fehlermeldung):
cd \MeinWorkspace\MvnHtmlIntTest
mvn test -Dtest=integrationtest.HtmlUnitTest
mvn test -Dtest=integrationtest.HttpUnitTest
mvn test -Dtest=integrationtest.*Test
Beenden Sie Jetty mit "Strg + C".
Automatisierter Integrationstest:
Der wichtigste Trick in diesem Beispiel ist die vollständig automatisierte Ausführung der Integrationstests inklusive automatischem Start des Jetty-Servers in einem zusätzlichen Hintergrund-Thread (über <daemon>true</daemon>), Ausführung der Integrationstests und anschließend der automatischen Beendigung von Jetty.
Sie sollten normalerweise nicht "mvn integration-test", sondern stattdessen "mvn verify" verwenden, damit auch die "post-integration-test"-Phase ausgeführt wird:
mvn clean verify
Sie erhalten zwei Testphasen, zuerst default-test und dann integration-tests:
... [INFO] --- maven-surefire-plugin:2.19.1:test (default-test) @ MvnHtmlIntTest --- ... ------------------------------------------------------- T E S T S ------------------------------------------------------- Running de.meinefirma.meinprojekt.MeineBeanTest Tests run: 1, Failures: 0, Errors: 0, Skipped: 0 ... [INFO] --- jetty-maven-plugin:9.2.2.v20140723:run (start-jetty) @ MvnHtmlIntTest --- ... [INFO] Started Jetty Server [INFO] [INFO] --- maven-surefire-plugin:2.19.1:test (integration-tests) @ MvnHtmlIntTest --- ... ------------------------------------------------------- T E S T S ------------------------------------------------------- Running integrationtest.HtmlUnitTest Tests run: 1, Failures: 0, Errors: 0, Skipped: 0 Running integrationtest.HttpUnitTest Tests run: 1, Failures: 0, Errors: 0, Skipped: 0 Results : Tests run: 2, Failures: 0, Errors: 0, Skipped: 0 ... [INFO] --- jetty-maven-plugin:9.2.2.v20140723:stop (stop-jetty) @ MvnHtmlIntTest --- ... [INFO] Server reports itself as stopped [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESS [INFO] ------------------------------------------------------------------------
Dependencies:
Lassen Sie sich folgendermaßen einen Dependency-Baum anzeigen und sehen Sie sich an, wie Maven automatisch Versionskonflikte bei den Abhängigkeiten gelöst hat:
mvn dependency:tree -Dverbose
Eclipse:
Um Maven-Projekte in Eclipse bearbeiten zu können, müssen Sie verfahren wie oben unter
Maven mit Eclipse beschrieben ist.
Ein besonderer Vorteil des Jetty-Plugins ist, dass Sie über das
scanIntervalSeconds-Attribut
steuern können, ob Änderungen direkt in den Webcontainer übernommen werden, ohne dass ein Redeployment notwendig ist.
Testen Sie dies, indem Sie zuerst Jetty über "mvn jetty:run" starten und anschließend in Eclipse Änderungen
zum Beispiel an BerechnungsFormular.jsp, MeineBean.java oder anderen Dateien durchführen.
Infos zu HttpUnit und HtmlUnit:
Ein weiteres Programmierbeispiel zu HttpUnit finden Sie unter
java-httpunit.htm.
Weiteres zu HttpUnit finden Sie unter
http://httpunit.sourceforge.net und
http://httpunit.sourceforge.net/doc/api/.
Weiteres zu HtmlUnit finden Sie unter
http://htmlunit.sourceforge.net und
http://htmlunit.sourceforge.net/apidocs/.
Erweiterungen:
Wie Sie Ihre Integrationstests mit
Fit und
Cargo
erweitern, erfahren Sie weiter unten.
Um die Datenbank mit bestimmten Inhalten vorzubereiten, können Sie das
DbUnit Maven Plugin verwenden.
Wenn Sie erweiterte Möglichkeiten für Integrationstests benötigen, sollten Sie sich das
Maven Failsafe Plugin ansehen.
Siehe hierzu auch den Sonatype-Blog-Eintrag
Part 1
und zur Testabdeckung in Integrationstests mit emma4it den
Part 2.
JWebUnit leistet Ähnliches wie HtmlUnit und HttpUnit, aber ist oft einfacher und übersichtlicher.
Voraussetzung für das folgende Beispiel ist die Durchführung des vorherigen Beispiels Automatisierter Integrationstest mit Jetty, HtmlUnit und HttpUnit (im Folgenden MvnHtmlIntTest genannt).
Erzeugen Sie ein neues Projektverzeichnis MvnJWebUnitIntTest und kopieren Sie dorthin das MvnHtmlIntTest-Projekt:
cd \MeinWorkspace
md MvnJWebUnitIntTest
cd MvnJWebUnitIntTest
xcopy ..\MvnHtmlIntTest\*.* /S
Entfernen Sie in der pom.xml im MvnJWebUnitIntTest-Projektverzeichnis die beiden <dependency>...-Blöcke zu htmlunit und httpunit und fügen Sie stattdessen folgenden neuen <dependency>...-Block ein:
<dependency>
<groupId>net.sourceforge.jwebunit</groupId>
<artifactId>jwebunit-htmlunit-plugin</artifactId>
<version>3.3</version>
<scope>test</scope>
</dependency>
Löschen Sie im src\test\java\integrationtest-Verzeichnis die beiden Dateien HtmlUnitTest.java und HttpUnitTest.java und erzeugen Sie stattdessen im selben Verzeichnis die neue Testklasse JWebUnitTest.java:
package integrationtest;
import net.sourceforge.jwebunit.junit.WebTestCase;
public class JWebUnitTest extends WebTestCase
{
public void test()
{
setBaseUrl( "http://localhost:8080/MvnHtmlIntTest/" );
beginAt( "/index.jsp" );
assertTitleEquals( "Startseite" );
clickLinkWithText( "Berechnungsformular" );
assertTitleEquals( "Webseite mit Berechnungsformular" );
setTextField( "wert1", "1" );
setTextField( "wert2", "2" );
submit();
assertTextFieldEquals( "ergebnis", "3.0" );
}
}
Falls Sie die JWebUnit-XPath-Methoden probieren wollen:
Den Ergebniswert können Sie beispielsweise abfragen mit:
getElementAttributeByXPath( "//input[lower-case(@type)='text' and @name='ergebnis']", "value" );
Die Projektstruktur sieht jetzt so aus (überprüfen Sie es mit tree /F):
[\MeinWorkspace\MvnJWebUnitIntTest] |- [src] | |- [main] | | |- [java] | | | '- [de] | | | '- [meinefirma] | | | '- [meinprojekt] | | | '- MeineBean.java | | '- [webapp] | | |- [WEB-INF] | | | '- web.xml | | |- BerechnungsFormular.jsp | | '- index.jsp | '- [test] | '- [java] | |- [de] | | '- [meinefirma] | | '- [meinprojekt] | | '- MeineBeanTest.java | '- [integrationtest] | '- JWebUnitTest.java '- pom.xml
Führen Sie den Integrationstest aus (wieder mit Jetty im Hintergrund-Thread):
cd \MeinWorkspace\MvnJWebUnitIntTest
mvn clean verify
Weiteres zu JWebUnit finden Sie unter http://jwebunit.sourceforge.net, http://jwebunit.sourceforge.net/apidocs/ und http://jwebunit.sourceforge.net/apidocs/net/sourceforge/jwebunit/junit/WebTestCase.html.
Mit Selenium können Sie über automatisierte Integrationstests Webanwendungen über einen Webbrowser testen. Dies hat den Vorteil, dass JavaScript und Ajax leichter und realitätsnäher getestet werden. Allerdings gibt es auch einen Nachteil: Da die Installation eines Webbrowsers vorausgesetzt wird (außer bei Benutzung des HtmlUnitDriver), ist die Ausführung auf beliebigen PCs und Betriebssystemen nicht mehr so einfach zu gewährleisten und die Ausführung in Continuous-Integration-Systemen könnte unsicherer sein. Falls Sie nur einfache HTML-Anwendungen ohne DHTML, JavaScript und Ajax testen wollen, können HtmlUnit und HttpUnit besser geeignet sein.
Bitte beachten Sie die drei grundsätzlich verschiedenen Selenium-Versionen:
Selenium 1, auch Selenium RC (Remote Control) genannt:
Selenium 1 (RC) ist der Vorgänger von Selenium 2 (WebDriver) und sollte möglichst nicht mehr für neue Anwendungen verwendet werden. Selenium 1 (RC) basiert auf der Verwendung eines für den Test gestarteten Proxy-Servers (Selenium-Server), welcher den gewünschten Webbrowser bedient. Die Testprogrammierung beginnt typischerweise mit zwei Zeilen ähnlich zu:
Selenium selenium = new DefaultSelenium( "localhost", 4444, "*firefox", "http://www.meintesthost.de" ); selenium.start();
Siehe: Selenium 1 (Selenium RC) und Migrating From Selenium RC to Selenium WebDriver.
Selenium 2, auch Selenium WebDriver genannt:
Anders als Selenium 1 verwendet Selenium 2 (WebDriver) keinen Proxy-Server, sondern spricht den gewünschten Webbrowser direkt an, über browserspezifische WebDriver. Beispielsweise für den Firefox-Webbrowser könnte das Testprogramm mit einer Zeile beginnen ähnlich zu:
WebDriver webDriver = new FirefoxDriver();
Siehe: Selenium WebDriver und Selenium-Doku.
Das unten gezeigte Beispiel demonstriert, wie zur Laufzeit der gewünschten Webbrowser gewählt werden kann.
Selenium 2 (WebDriver) bietet ein neues und verbessertes Programmier-API. Für Migrationszwecke kann aber auch in Selenium 2 auf viele Funktionen des alten Selenium-1-Programmier-APIs zurückgegriffen werden, indem folgendermaßen das alte Selenium-Objekt erzeugt wird:
Selenium selenium = new WebDriverBackedSelenium( webDriver, "http://www.meintesthost.de" );
Selenium IDE:
Selenium IDE ist eine Erweiterung (Plug-in) für den Firefox-Webbrowser, womit schnell und einfach im Firefox-Webbrowser ablauffähige Skripte zu Benutzerinteraktionen erstellt und abgespielt werden können (record-and-playback), beispielsweise zum Reproduzieren von Fehlersituationen oder zur Vorbereitung von automatisierten Tests (Prototyping). Die mit Selenium IDE generierbaren Skripte sind nicht für Integrations- und Regressionstests vorgesehen, wo hohe Stabilität und Reproduzierbarkeit wichtig ist.
Siehe: Selenium IDE Übersicht und Selenium IDE Doku.
Das folgende Beispiel verwendet ausschließlich Selenium 2 (WebDriver).
Sehen Sie sich die Selenium-Doku, das Interface WebDriver und die Packages org.openqa.selenium und org.openqa.selenium.support.ui an.
Legen Sie ein neues Projekt an:
cd \MeinWorkspace
md MvnSelenium
cd MvnSelenium
md src\test\java\integrationtest
Erzeugen Sie im Projektverzeichnis die Projektkonfiguration: pom.xml
<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>de.meinefirma.meinprojekt</groupId>
<artifactId>MvnSelenium</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>MvnSelenium</name>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.5.1</version>
<configuration>
<source>1.7</source>
<target>1.7</target>
</configuration>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>org.seleniumhq.selenium</groupId>
<artifactId>selenium-java</artifactId>
<version>2.52.0</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.seleniumhq.selenium</groupId>
<artifactId>selenium-htmlunit-driver</artifactId>
<version>2.52.0</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>
Erzeugen Sie im src\test\java\integrationtest-Verzeichnis den WebDriver-Wrapper: WebDriverWrapper.java
package integrationtest;
import org.openqa.selenium.*;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.edge.EdgeDriver;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.openqa.selenium.htmlunit.HtmlUnitDriver;
import org.openqa.selenium.ie.InternetExplorerDriver;
import org.openqa.selenium.safari.SafariDriver;
/**
* Wrapper fuer Selenium-WebDriver fuer waehlbaren Webbrowser und als AutoCloseable
*/
public class WebDriverWrapper implements AutoCloseable
{
private WebDriver webDriver;
/**
* Selenium-WebDriver fuer waehlbaren Webbrowser instanziieren.
* @param browserName leer fuer HtmlUnitDriver oder
* FF, Chrome, Edge, IE oder Safari fuer gewuenschten Webbrowser.
* @param webDriverExePath leer fuer HtmlUnitDriver, FF und Safari;
* fuer Chrome und IE wird Pfad zum externen WebDriver.exe benoetigt,
* z.B. zu chromedriver.exe, iexploredriver.exe bzw. MicrosoftWebDriver.exe.
*/
public WebDriverWrapper( String browserName, String webDriverExePath )
{
if( browserName != null ) {
String brwsr = browserName.trim().toLowerCase();
String wbdrv = ( webDriverExePath != null ) ? webDriverExePath.trim() : null;
if( brwsr.contains( "firefox" ) || brwsr.contains( "ff" ) ) {
webDriver = new FirefoxDriver();
} else if( brwsr.contains( "chrome" ) ) {
if( wbdrv != null ) { System.setProperty( "webdriver.chrome.driver", wbdrv ); }
webDriver = new ChromeDriver();
} else if( brwsr.contains( "edge" ) ) {
if( wbdrv == null ) {
wbdrv = "C:\\Program Files (x86)\\Microsoft Web Driver\\MicrosoftWebDriver.exe";
}
System.setProperty( "webdriver.edge.driver", wbdrv );
webDriver = new EdgeDriver();
} else if( brwsr.contains( "internetexplorer" ) || brwsr.contains( "ie" ) ) {
if( wbdrv != null ) { System.setProperty( "webdriver.ie.driver", wbdrv ); }
webDriver = new InternetExplorerDriver();
} else if( brwsr.contains( "safari" ) ) {
webDriver = new SafariDriver();
}
}
if( webDriver == null ) {
webDriver = new HtmlUnitDriver();
}
}
public WebDriver getWebDriver()
{
return webDriver;
}
@Override
public void close()
{
webDriver.quit();
webDriver = null;
}
}
Erzeugen Sie im src\test\java\integrationtest-Verzeichnis die Testklasse: SeleniumSimpleTest.java
package integrationtest;
import org.junit.*;
import org.openqa.selenium.*;
import org.openqa.selenium.support.ui.*;
/**
* Einfacher Selenium-Test mit der Wikipedia-Webseite.<br>
* Wahlweise ausfuehrbar mit manueller main()-Methode
* oder automatisiert als JUnit-Test.
*/
public class SeleniumSimpleTest
{
public static final String BROWSERNAME_KEY = "_BROWSERNAME";
public static final String WEBDRIVEREXEPATH_KEY = "_WEBDRIVEREXEPATH";
/**
* Manuell ausfuehrbarer Selenium-Test.<br>
* @param args 1. Parameter leer fuer HtmlUnitDriver oder
* FF, Chrome, Edge, IE oder Safari fuer gewuenschten Webbrowser.<br>
* 2. Parameter leer fuer HtmlUnitDriver, FF und Safari;
* fuer Chrome und IE wird Pfad zum externen WebDriver.exe benoetigt,
* z.B. zu chromedriver.exe, iexploredriver.exe bzw. MicrosoftWebDriver.exe.<br>
*/
public static void main( String[] args )
{
String browserName = null, webDriverExePath = null;
if( args != null ) {
if( args.length > 0 ) { browserName = args[0]; }
if( args.length > 1 ) { webDriverExePath = args[1]; }
}
testSelenium( browserName, webDriverExePath );
}
/**
* Automatisiert ausfuehrbarer JUnit-Selenium-Test.<br>
* Falls die Umgebungsvariablen _BROWSERNAME und _WEBDRIVEREXEPATH
* gesetzt sind, kann darueber der gewuenschte Webbrowser definiert werden.<br>
* _BROWSERNAME: leer fuer HtmlUnitDriver oder
* FF, Chrome, Edge, IE oder Safari fuer gewuenschten Webbrowser.<br>
* _WEBDRIVEREXEPATH: leer fuer HtmlUnitDriver, FF und Safari;
* fuer Chrome und IE wird Pfad zum externen WebDriver.exe benoetigt,
* z.B. zu chromedriver.exe, iexploredriver.exe bzw. MicrosoftWebDriver.exe.<br>
*/
@Test
public void testSelenium()
{
String browserName = System.getProperty( BROWSERNAME_KEY );
String webDriverExePath = System.getProperty( WEBDRIVEREXEPATH_KEY );
Assert.assertTrue( testSelenium( browserName, webDriverExePath ) );
}
private static boolean testSelenium( String browserName, String webDriverExePath )
{
final String url = "http://de.wikipedia.org";
final String ttl = "Selenium \u2013 Wikipedia";
// WebDriver starten:
try( WebDriverWrapper wdwrap = new WebDriverWrapper( browserName, webDriverExePath ) ) {
WebDriver webDriver = wdwrap.getWebDriver();
WebDriverWait wait = new WebDriverWait( webDriver, 10 );
// Webseite laden, Daten eintragen und Antwort anfordern:
webDriver.get( url );
WebElement element = wait.until( ExpectedConditions.presenceOfElementLocated( By.id( "searchInput" ) ) );
String titelAbfrageseite = webDriver.getTitle();
element.sendKeys( "Selenium" );
element = webDriver.findElement( By.name( "go" ) );
element.click();
// Ergebnisse pruefen:
boolean ok = wait.until( ExpectedConditions.titleIs( ttl ) ).booleanValue();
String titelErgebnisseite = webDriver.getTitle();
String hauptueberschrift = webDriver.findElement( By.id( "firstHeading" ) ).getText();
ok &= ttl.equals( titelErgebnisseite ) && "Selenium".equals( hauptueberschrift );
System.out.println( "\n------------------------------------------------------------" );
if( browserName != null ) {
System.out.println( "Webbrowsername: " + browserName );
}
System.out.println( "WebDriver: " + webDriver.getClass().getSimpleName() );
System.out.println( "Test-URL: " + url );
System.out.println( "Titel der Abfrage-Seite: " + titelAbfrageseite );
System.out.println( "Titel der Ergebnis-Seite: " + titelErgebnisseite );
System.out.println( "Hauptueberschrift: " + hauptueberschrift );
System.out.println( ( ok ) ? "OK" : "Fehler" );
System.out.println( "------------------------------------------------------------\n" );
return ok;
}
}
}
Der Test startet einen Selenium-WebDriver im WebDriverWrapper, öffnet die Wikipedia-Startseite in webDriver.get( url ), sucht das Input-Textfeld "searchInput", trägt den Suchbegriff "Selenium" ein und überprüft die Ergebnis-Webseite.
Die Projektstruktur sieht jetzt so aus (überprüfen Sie es mit tree /F):
[\MeinWorkspace\MvnSelenium] |- [src] | '- [test] | '- [java] | '- [integrationtest] | |- SeleniumSimpleTest.java | '- WebDriverWrapper.java '- pom.xml
Starten Sie den Integrationstest ohne Angabe eines Webbrowsers:
cd \MeinWorkspace\MvnSelenium
mvn clean test
Sie erhalten einige Fehlermeldungen zur HTML-Seite und zuletzt die Erfolgsmeldung:
------------------------------------------------------------ WebDriver: HtmlUnitDriver Test-URL: http://de.wikipedia.org Titel der Abfrage-Seite: Wikipedia – Die freie Enzyklopädie Titel der Ergebnis-Seite: Selenium – Wikipedia Hauptueberschrift: Selenium OK ------------------------------------------------------------
Als WebDriver wurde HtmlUnitDriver verwendet, der keine Webbrowser-Installation voraussetzt.
Falls Sie Mozilla Firefox installiert haben, schließen Sie alle Firefox-Fenster, und starten Sie den Integrationstest folgendermaßen:
mvn clean test -D_BROWSERNAME=ff
Der Firefox-Webbrowser wird gestartet, Sie können die Seitenaufrufe verfolgen, und es wird gemeldet, dass der FirefoxDriver-WebDriver verwendet wurde:
... WebDriver: FirefoxDriver ...
Falls Sie Windows 10 installiert haben, schließen Sie alle Edge-Webbrowser-Fenster, und starten Sie den Integrationstest folgendermaßen:
mvn clean test -D_BROWSERNAME=Edge
Der Edge-Webbrowser wird gestartet, Sie können die Seitenaufrufe verfolgen, und es wird gemeldet, dass der EdgeDriver-WebDriver verwendet wurde:
... WebDriver: EdgeDriver ...
Voraussetzung hierfür ist die einmalige Installation des Microsoft-WebDrivers MicrosoftWebDriver.exe über die Installationsdatei MicrosoftWebDriver.msi, welche Sie über https://www.microsoft.com/en-us/download/details.aspx?id=48212 erhalten.
Ausführliche Infos zu Fit finden Sie in java-fit.htm.
Wechseln Sie in Ihr Projekte-Verzeichnis und erzeugen Sie das neue Projekt MvnFitTest:
cd \MeinWorkspace
md MvnFitTest
cd MvnFitTest
md src\main\java\de\meinefirma\meinprojekt
md src\test\fit
md src\test\java\fixtures
tree /F
[\MeinWorkspace\MvnFitTest]
'- [src]
|- [main]
| '- [java]
| '- [de]
| '- [meinefirma]
| '- [meinprojekt]
'- [test]
|- [fit]
'- [java]
'- [fixtures]
Erzeugen Sie im MvnFitTest-Projektverzeichnis die Projektkonfigurationsdatei: pom.xml
<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>de.meinefirma.meinprojekt</groupId>
<artifactId>MvnFitTest</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>MvnFitTest</name>
<build>
<plugins>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>fit-maven-plugin</artifactId>
<version>2.0-beta-3</version>
<executions>
<execution>
<id>fixture</id>
<phase>integration-test</phase>
<configuration>
<sourceDirectory>src/test/fit</sourceDirectory>
<caseSensitive>true</caseSensitive>
<sourceIncludes>**/*FitTest.html</sourceIncludes>
<parseTags>
<parseTag>table</parseTag>
<parseTag>tr</parseTag>
<parseTag>td</parseTag>
</parseTags>
<outputDirectory>target/fit</outputDirectory>
<ignoreFailures>false</ignoreFailures>
</configuration>
<goals>
<goal>run</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>com.c2.fit</groupId>
<artifactId>fit</artifactId>
<version>1.1</version>
</dependency>
</dependencies>
</project>
Erläuterungen zu den fit-maven-plugin-<configuration>-Optionen finden Sie unter http://mojo.codehaus.org/fit-maven-plugin/run-mojo.html.
Falls Sie die Fit-Tests nicht mit HTML-Seiten, sondern mit Wiki-Seiten steuern wollen, finden Sie Konfigurationshinweise unter http://mojo.codehaus.org/fit-maven-plugin/usage.html.
Erzeugen Sie im src\main\java\de\meinefirma\meinprojekt-Verzeichnis die (schon bekannte) Bean: MeineBean.java
package de.meinefirma.meinprojekt;
public class MeineBean
{
public String berechne( String d1, String d2 )
{
try {
return "" + (Double.parseDouble( d1 ) + Double.parseDouble( d2 ));
} catch( Exception ex ) {
return "";
}
}
}
Erzeugen Sie im src\test\java\fixtures-Verzeichnis die Fit-Fixture-Klasse: MeinFixture.java
package fixtures;
public class MeinFixture extends fit.ColumnFixture
{
public String wert1;
public String wert2;
public String berechne()
{
return (new de.meinefirma.meinprojekt.MeineBean()).berechne( wert1, wert2 );
}
}
Die Fit-Testbeschreibung erfolgt als HTML-Tabelle (erste Zeile: Fixture-Angabe, zweite Zeile: Eingabeparameter und erwartete zu berechnende Ausgabewerte, weitere Zeilen: Testfälle).
Erzeugen Sie im src\test\fit-Verzeichnis die Fit-Testklasse: MeinFitTest.html
<!doctype html public "-//w3c//dtd html 4.0 transitional//en"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1"> <title>Mein Fit-Test</title> </head> <body> <h2>Mein Fit-Test</h2> <table border="1" cellspacing="0" cellpadding="3"> <tr><td colspan="3"> fixtures.MeinFixture </td></tr> <tr><td> wert1 </td><td> wert2 </td><td> berechne() </td></tr> <tr><td> 0 </td><td> </td><td> </td></tr> <tr><td> 1 </td><td> 2 </td><td> 3.0 </td></tr> <tr><td> +1 </td><td> -1 </td><td> 0.0 </td></tr> <tr><td> -42 </td><td> 13 </td><td> -29.0 </td></tr> <tr><td> 1.234 </td><td> 5.678 </td><td> 6.912 </td></tr> </table> <br> <table border="1" cellspacing="0" cellpadding="3"> <tr><td colspan="2">fit.Summary</td></tr> </table> </body> </html>
Sehen Sie sich die Testfall-Beschreibungen an:
start src\test\fit\MeinFitTest.html
| fixtures.MeinFixture | ||
| wert1 | wert2 | berechne() |
| 0 | ||
| 1 | 2 | 3.0 |
| +1 | -1 | 0.0 |
| -42 | 13 | -29.0 |
| 1.234 | 5.678 | 6.912 |
Überprüfen Sie Ihre Projektstruktur mit tree /F:
[\MeinWorkspace\MvnFitTest] |- [src] | |- [main] | | '- [java] | | '- [de] | | '- [meinefirma] | | '- [meinprojekt] | | '- MeineBean.java | '- [test] | |- [fit] | | '- MeinFitTest.html | '- [java] | '- [fixtures] | '- MeinFixture.java '- pom.xml
Führen Sie den Akzeptanztest als Maven-Integrationstest aus:
cd \MeinWorkspace\MvnFitTest
mvn clean verify
Sie erhalten:
[INFO] --- fit-maven-plugin:2.0-beta-3:run (fixture) @ MvnFitTest --- [INFO] Running Fixture with input file src\test\fit\MeinFitTest.html and output file target\fit\MeinFitTest.html [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESS [INFO] ------------------------------------------------------------------------
Sehen Sie sich das Ergebnis als HTML-Seite an (grün bedeutet "ok"):
start target\fit\MeinFitTest.html
| fixtures.MeinFixture | ||
| wert1 | wert2 | berechne() |
| 0 | null | |
| 1 | 2 | 3.0 |
| +1 | -1 | 0.0 |
| -42 | 13 | -29.0 |
| 1.234 | 5.678 | 6.912 |
| fit.Summary | |
| counts | 4 right, 0 wrong, 0 ignored, 0 exceptions |
Ändern Sie in src\test\fit\MeinFitTest.html einen der Vorgabewerte in der berechne()-Spalte, führen Sie den Akzeptanztest erneut aus und sehen Sie sich die Fehlermeldungen im Kommandozeilenfenster und in der Ergebnis-HTML-Seite an, zum Beispiel so:
[INFO] [fit:run {execution: fixture}]
[INFO] Running Fixture with input file src\test\fit\MeinFitTest.html and output file target\fit\MeinFitTest.html
[INFO] ------------------------------------------------------------------------
[ERROR] BUILD ERROR
[INFO] ------------------------------------------------------------------------
[INFO] Failed to execute FitRunner
Embedded error: Fixture failed with counts: 3 right, 1 wrong, 0 ignored, 0 exceptions
| fixtures.MeinFixture | ||
| wert1 | wert2 | berechne() |
| 0 | null | |
| 1 | 2 | 4.0 expected 3.0 actual |
| +1 | -1 | 0.0 |
| -42 | 13 | -29.0 |
| 1.234 | 5.678 | 6.912 |
| fit.Summary | |
| counts | 3 right, 1 wrong, 0 ignored, 0 exceptions |
Im letzten Beispiel hat das Fit-Fixture direkt die Berechnungs-Bean angesprochen. Das folgende Beispiel setzt stattdessen auf einer höheren Ebene an und ermittelt das Ergebnis über die HTML-Webseite.
Voraussetzung für das folgende Beispiel ist die Durchführung der beiden obigen Beispiele Automatisierter Integrationstest mit Jetty, HtmlUnit und HttpUnit und Automatisierter Integrationstest mit Fit.
Erzeugen Sie ein neues Projektverzeichnis MvnHtmlFitTest und kopieren Sie dorthin Teile der beiden Projekte:
cd \MeinWorkspace
md MvnHtmlFitTest
cd MvnHtmlFitTest
xcopy ..\MvnHtmlIntTest\*.* /S
xcopy ..\MvnFitTest\src\test\*.* src\test\ /S
tree /F
Ihre Projektstruktur sieht jetzt so aus:
[\MeinWorkspace\MvnHtmlFitTest] |- [src] | |- [main] | | |- [java] | | | '- [de] | | | '- [meinefirma] | | | '- [meinprojekt] | | | '- MeineBean.java | | '- [webapp] | | |- [WEB-INF] | | | '- web.xml | | |- BerechnungsFormular.jsp | | '- index.jsp | '- [test] | |- [fit] | | '- MeinFitTest.html | '- [java] | |- [de] | | '- [meinefirma] | | '- [meinprojekt] | | '- MeineBeanTest.java | |- [fixtures] | | '- MeinFixture.java | '- [integrationtest] | |- HtmlUnitTest.java | '- HttpUnitTest.java '- pom.xml
Fügen Sie aus der pom.xml des MvnFitTest-Projekts sowohl den <plugin>... als auch den <dependency>...-Block ein in die pom.xml des MvnHtmlFitTest-Projekts.
Ändern Sie im src\test\java\fixtures-Verzeichnis die MeinFixture.java zu:
package fixtures;
public class MeinFixture extends fit.ColumnFixture
{
public String wert1;
public String wert2;
public String berechne() throws Exception
{
return (new integrationtest.HtmlUnitTest()).test( "8080", wert1, wert2, null );
}
}
Statt HtmlUnitTest könnten Sie genauso gut auch HttpUnitTest nehmen.
Bitte beachten Sie, dass das Fit-Fixture jetzt nicht mehr direkt die Berechnungs-Bean anspricht, sondern über die HTML-Webseite das Ergebnis ermittelt.
Führen Sie die Tests aus:
cd \MeinWorkspace\MvnHtmlFitTest
mvn clean verify
start target\fit\MeinFitTest.html
Sie erhalten die bereits oben gezeigten Erfolgsmeldungen.
Installationsbeschreibungen finden Sie unter Oracle WebLogic.
Downloaden Sie den JBoss Application Server von
http://jboss.org/jbossas
(z.B. jboss-as-distribution-6.1.0.Final.zip).
Entzippen Sie das JBoss-Archive zum Beispiel nach
\Tools\JBoss.
Testen Sie die JBoss-Installation (passen Sie den Pfad zu Ihrer JBoss-Installation an):
cd \Tools\JBoss\bin
run.bat (bzw. standalone.bat)
Warten Sie bis "... JBoss ... Started ..." erscheint.
start http://localhost:8080
Eine JBoss-Übersichtsseite erscheint.
Beenden Sie JBoss mit "Strg + C".
Weitere Installationshinweise (z.B. Datasource) finden Sie unter jee-ejb2.htm#InstallationJBoss.
Downloaden Sie den WildFly Application Server von
http://www.wildfly.org
(z.B. wildfly-8.0.0.Beta1.zip).
Entzippen Sie das WildFly-Archive zum Beispiel nach
\Tools\WildFly.
Testen Sie die WildFly-Installation (passen Sie den Pfad zu Ihrer WildFly-Installation an):
cd \Tools\WildFly\bin
standalone.bat
Warten Sie bis "... WildFly ... Started ..." erscheint.
start http://localhost:8080
Eine WildFly-Welcome-Übersichtsseite erscheint.
Beenden Sie WildFly mit "Strg + C".
Zum Tomcat finden Sie eine Installationsbeschreibung unter jsp-install.htm#InstallationUnterWindows.
Voraussetzung für das folgende Beispiel ist die Installation von WebLogic, JBoss, WildFly, Tomcat oder eines anderen Servers, den Cargo unterstützt.
Eine weitere Voraussetzung ist die Durchführung (oder des Downloads) des obigen Beispiels Automatisierter Integrationstest mit Jetty, HtmlUnit und HttpUnit.
Erzeugen Sie ein neues Projekt mit dem Projektverzeichnis MvnAppSrvIntTest:
cd \MeinWorkspace
md MvnAppSrvIntTest
cd MvnAppSrvIntTest
xcopy ..\MvnHtmlIntTest\*.* /S
Ändern Sie Folgendes in der pom.xml:
Entfernen Sie den gesamten folgenden Jetty-<plugin>-Block (aber nicht den maven-surefire-plugin-Block):
<plugin>
<groupId>org.eclipse.jetty</groupId>
<artifactId>jetty-maven-plugin</artifactId>
...
</plugin>
Fügen Sie stattdessen folgenden Cargo-<plugin>-Block ein:
<plugin>
<groupId>org.codehaus.cargo</groupId>
<artifactId>cargo-maven2-plugin</artifactId>
<version>1.5.0</version>
<configuration>
<container>
<containerId>${appsrv.containerId}</containerId>
<home>${appsrv.srvhome}</home>
</container>
<configuration>
<type>existing</type>
<home>${appsrv.dmnhome}</home>
<properties>
<!-- Falls WebLogic: Anpassen: -->
<cargo.weblogic.administrator.user>weblogic</cargo.weblogic.administrator.user>
<cargo.weblogic.administrator.password>weblogic0</cargo.weblogic.administrator.password>
<cargo.weblogic.server>AdminServer</cargo.weblogic.server>
<cargo.servlet.port>${port}</cargo.servlet.port>
</properties>
</configuration>
<wait>false</wait>
</configuration>
<executions>
<execution>
<id>start-container</id>
<phase>pre-integration-test</phase>
<goals>
<goal>start</goal>
</goals>
</execution>
<execution>
<id>stop-container</id>
<phase>post-integration-test</phase>
<goals>
<goal>stop</goal>
</goals>
</execution>
</executions>
</plugin>
Ersetzen Sie die Zeile
<port>8080</port>
durch:
<port>${port}</port>
Fügen Sie vor dem </project>-Ende-Tag ein (passen Sie die Pfade an Ihre Application-Server-Installation an):
<profiles>
<profile>
<id>WebLogic</id>
<activation>
<property>
<name>env.APPSRV</name>
<value>WebLogic</value>
</property>
</activation>
<properties>
<!-- Falls WebLogic: Anpassen: -->
<appsrv.containerId>weblogic122x</appsrv.containerId>
<appsrv.srvhome>C:\WebLogic\wlserver</appsrv.srvhome>
<appsrv.dmnhome>C:\WebLogic\user_projects\domains\MeineDomain</appsrv.dmnhome>
<port>7001</port>
</properties>
</profile>
<profile>
<id>JBoss</id>
<activation>
<property>
<name>env.APPSRV</name>
<value>JBoss</value>
</property>
</activation>
<properties>
<!-- Falls JBoss: Anpassen: -->
<appsrv.containerId>jboss61x</appsrv.containerId>
<appsrv.srvhome>D:\Tools\JBoss</appsrv.srvhome>
<appsrv.dmnhome>${appsrv.srvhome}/server/default</appsrv.dmnhome>
<port>8080</port>
</properties>
</profile>
<profile>
<id>WildFly</id>
<activation>
<property>
<name>env.APPSRV</name>
<value>WildFly</value>
</property>
</activation>
<properties>
<!-- Falls WildFly: Anpassen: -->
<appsrv.containerId>wildfly8x</appsrv.containerId>
<appsrv.srvhome>D:\Tools\WildFly</appsrv.srvhome>
<appsrv.dmnhome>${appsrv.srvhome}/standalone</appsrv.dmnhome>
<port>8080</port>
</properties>
</profile>
<profile>
<id>Tomcat</id>
<activation>
<property>
<name>env.APPSRV</name>
<value>Tomcat</value>
</property>
</activation>
<properties>
<!-- Falls Tomcat: Anpassen: -->
<appsrv.containerId>tomcat8x</appsrv.containerId>
<appsrv.srvhome>D:\Tools\Tomcat</appsrv.srvhome>
<appsrv.dmnhome>${appsrv.srvhome}</appsrv.dmnhome>
<port>8080</port>
</properties>
</profile>
</profiles>
Natürlich können Sie analog auch andere Application Server einbinden.
Lassen Sie sich anzeigen, welche Profile zur Verfügung stehen:
cd \MeinWorkspace\MvnAppSrvIntTest
mvn help:all-profiles
Führen Sie für Ihren App-Server (automatisiert) die Schritte des Integrationstests aus (Vorbereitung, App-Server-Start, Deployment, Integrationstest, App-Server-Stopp):
mvn verify -P WebLogic
mvn verify -P JBoss
mvn verify -P WildFly
mvn verify -P Tomcat
Bitte beachten Sie, dass der App-Server automatisch hoch- und heruntergefahren wird.
Falls Sie eine Fehlermeldung erhalten ähnlich zu:
10.4.5 404 Not Found
The server has not found anything matching the Request-URI.
com.gargoylesoftware.htmlunit.FailingHttpStatusCodeException: 404 Not Found for http://localhost:7001/MvnHtmlIntTest/
Dann fügen Sie im fehlgeschlagenen Integrationstest (z.B. HtmlUnitTest.java) vor der Zeile "WebClient webClient = new WebClient();" die zusätzliche Zeile "Thread.sleep( 3000 );" ein, damit der Webserver das Deployment vollständig fertigstellen kann.
Im Falle des JBoss Application Servers erhalten Sie:
... [INFO] --- maven-surefire-plugin:2.19.1:test (default-test) @ MvnHtmlIntTest --- ------------------------------------------------------- T E S T S ------------------------------------------------------- Running de.meinefirma.meinprojekt.MeineBeanTest Tests run: 1, Failures: 0, Errors: 0, Skipped: 0 ... [INFO] [stalledLocalDeployer] Deploying [\MeinWorkspace\MvnAppSrvIntTest\target\MvnHtmlIntTest.war] to [\Tools\JBoss/server/default/deploy]... ... [INFO] [talledLocalContainer] JBoss 6.1.0 started on port [8080] ... [INFO] --- maven-surefire-plugin:2.19.1:test (integration-tests) @ MvnHtmlIntTest --- [INFO] Surefire report directory: \MeinWorkspace\MvnAppSrvIntTest\target\surefire-reports ------------------------------------------------------- T E S T S ------------------------------------------------------- Running integrationtest.HtmlUnitTest Tests run: 1, Failures: 0, Errors: 0, Skipped: 0 Running integrationtest.HttpUnitTest Tests run: 1, Failures: 0, Errors: 0, Skipped: 0 Results : Tests run: 2, Failures: 0, Errors: 0, Skipped: 0 ... [INFO] [talledLocalContainer] JBoss 6.1.0 is stopped [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESS [INFO] ------------------------------------------------------------------------
Das .war-Archiv wurde in Autodeploy-Verzeichnisse unterhalb von ${appsrv.dmnhome} kopiert:
Im Falle von WebLogic nach: ${appsrv.dmnhome}\autodeploy,
im Falle von JBoss nach: ${appsrv.dmnhome}\deploy,
im Falle von WildFly nach: ${appsrv.dmnhome}\deployments und
im Falle von Tomcat nach: ${appsrv.dmnhome}\webapps.
Unter selenium.htm finden Sie weitere Cargo-Beispiele, zum Beispiel mit dem zipUrlInstaller, mit dem Sie die Installation von Servern automatisieren können.
Cargo bietet einige weitere interessante Optionen, beispielsweise das Mergen von WAR-Dateien und die Möglichkeit, Tomcat im Security Mode zu starten. Weiters zum Cargo-Maven-Plugin finden Sie unter https://codehaus-cargo.github.io/cargo/Maven2+plugin und https://codehaus-cargo.github.io/cargo/Maven2+Plugin+Reference+Guide.
Sehen Sie sich auch die Beispiele zu Tests mit OpenEJB und Arquillian an.
Häufige Anforderungen an Integrationstests im Maven-Umfeld sind:
Trennung der verschiedenen Testebenen:
Mit dem Maven Surefire Plugin lassen sich die ersten drei Anforderungen nur umständlich und die letzten beiden Anforderungen so gut wie gar nicht umsetzen. Siehe hierzu das obige Beispiel eines Automatisierten Integrationstests. Der wichtigste Abschnitt in der pom.xml lautet dort (gekürzt):
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.19.1</version>
<configuration>
<excludes>
<exclude>**/integrationtest/*Test.java</exclude>
</excludes>
</configuration>
<executions>
<execution>
<id>integration-tests</id>
<phase>integration-test</phase>
<goals>
<goal>test</goal>
</goals>
<configuration>
<skip>false</skip>
<excludes>
<exclude>none</exclude>
</excludes>
<includes>
<include>**/integrationtest/*Test.java</include>
</includes>
</configuration>
</execution>
</executions>
</plugin>
Mit dem Maven Failsafe Plugin lassen sich alle fünf Anforderungen umsetzen. Dazu muss der maven-surefire-plugin-Block entfernt werden und durch folgenden maven-failsafe-plugin-Block ersetzt werden:
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-failsafe-plugin</artifactId>
<version>2.19.1</version>
<executions>
<execution>
<goals>
<goal>integration-test</goal>
<goal>verify</goal>
</goals>
</execution>
</executions>
</plugin>
Außerdem müssen für die Dateinamen folgende Konventionen beachtet werden (die auch anders konfiguriert werden können):
Defaultmäßig werden beim "mvn install"-Kommando die Integrationstests immer vorher ausgeführt (integration-test- und verify-Phasen). Bei Verwendung des Failsafe-Plugins können die Integrationstests übergangen werden mit: "mvn install -DskipITs".
Folgendermaßen können Sie obigen Automatisierten Integrationstest mit Cargo auf das Failsafe-Plugin umstellen:
Entfernen Sie aus der pom.xml den kompletten maven-surefire-plugin-Block und fügen Sie stattdessen einen maven-failsafe-plugin-Block ein. Allerdings müssen Sie dabei für dieses spezielle Beispiel die Konfiguration der Portnummer über die System-Environmentvariable übernehmen:
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-failsafe-plugin</artifactId>
<version>2.19.1</version>
<configuration>
<systemPropertyVariables>
<port>${port}</port>
</systemPropertyVariables>
</configuration>
<executions>
<execution>
<goals>
<goal>integration-test</goal>
<goal>verify</goal>
</goals>
</execution>
</executions>
</plugin>
Im src\test\java\integrationtest-Verzeichnis müssen zu HtmlUnitTest.java und HttpUnitTest.java sowohl die beiden Dateinamen als auch in beiden Dateien die Klassennamen umbenannt werden in HtmlUnitIT bzw. HttpUnitIT.
Die Projektstruktur sieht jetzt so aus (überprüfen Sie es mit tree /F):
[\MeinWorkspace\MvnAppSrvFailsaveIntTest] |- [src] | |- [main] | | |- [java] | | | '- [de] | | | '- [meinefirma] | | | '- [meinprojekt] | | | '- MeineBean.java | | '- [webapp] | | |- [WEB-INF] | | | '- web.xml | | |- BerechnungsFormular.jsp | | '- index.jsp | '- [test] | '- [java] | |- [de] | | '- [meinefirma] | | '- [meinprojekt] | | '- MeineBeanTest.java | '- [integrationtest] | |- HtmlUnitIT.java | '- HttpUnitIT.java '- pom.xml
Führen Sie folgende Kommandos aus (bitte Profilnamen entsprechend Ihres App-Servers wählen):
| mvn test | Es werden nur die auf "Test" endenden "schnellen Unittests" ausgeführt. | |
| mvn verify -P WebLogic | Es werden die Unittests und die beiden auf "IT" endenden Integrationstests ausgeführt. | |
| mvn install -P WebLogic | Vor der Installation des Ergebnisartefakts im lokalen Repository werden die Unittests und die Integrationstests ausgeführt. | |
| mvn install -P WebLogic -DskipITs | Vor der Installation des Ergebnisartefakts im lokalen Repository werden nur die Unittests ausgeführt,
die Integrationstests werden ausgelassen. Es erscheint die Meldung: maven-failsafe-plugin: Tests are skipped. |
Ändern Sie src\test\java\integrationtest\HttpUnitIT.java so ab, dass der Test fehlschlägt. Führen Sie wieder "mvn verify -P WebLogic" aus: Anders als mit dem Surefire-Plugin wird trotz des fehlschlagenden Tests zuerst der WebLogic ordentlich heruntergefahren, bevor das Maven-Kommando in der verify-Phase den Fehler meldet und abbricht.
Grundsätzlich sollten Sie immer das gewählte Character-Encoding in der pom.xml definieren (so vermeiden Sie auch die Warnungen des Failsafe-Plugins wegen fehlender Angaben zum Encoding), zum Beispiel so (passen Sie das Encoding an):
<properties>
<project.build.sourceEncoding>ISO-8859-1</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
</properties>
Mit Apache Wicket können komponentenbasierte Webanwendungen erstellt werden, inklusive AJAX-Unterstützung. Der Entwickler hat dabei nur mit Java und HTML zu tun und benötigt kein JSP, JSF und JavaScript. Weiteres zu Wicket finden Sie unter http://wicket.apache.org und http://wicket.sourceforge.net/apidocs.
Das Maven-Archetype-Plugin bietet Unterstützung für Apache Wicket.
Das folgende Beispiel implementiert wieder das bereits bekannte Webformular, welches wieder über eine MeineBean.berechne()-Methode zwei Zahlen addiert (stellvertretend für Businesslogik).
Generieren Sie ein Wicket-Projekt:
cd \MeinWorkspace
mvn archetype:generate -DinteractiveMode=false -DarchetypeGroupId=org.apache.wicket -DarchetypeArtifactId=wicket-archetype-quickstart -DgroupId=de.meinefirma.meinprojekt -DartifactId=MvnWicket
cd MvnWicket
tree /F
[\MeinWorkspace\MvnWicket] |- [src] | |- [main] | | |- [java] | | | '- [de] | | | '- [meinefirma] | | | '- [meinprojekt] | | | |- HomePage.html | | | |- HomePage.java | | | '- WicketApplication.java | | |- [resources] | | | '- log4j2.xml | | '- [webapp] | | |- [WEB-INF] | | | '- web.xml | | '- logo.png | | '- style.css | '- [test] | |- [java] | | '- [de] | | '- [meinefirma] | | '- [meinprojekt] | | |- Start.java | | '- TestHomePage.java | |- [jetty] | | |- jetty-http.xml | | |- jetty-https.xml | | |- jetty-ssl.xml | | '- jetty.xml | '- [resources] | '- keystore '- pom.xml
Testen Sie die vorläufige Quickstart-Webanwendung:
mvn jetty:run
start http://localhost:8080
-->
... Congratulations! Your quickstart works! ...
Beenden Sie Jetty mit "Strg + C".
Fügen Sie im src\main\java\de\meinefirma\meinprojekt-Verzeichnis in der HomePage.html an geeigneter Stelle (z.B. hinter der "<h2>Congratulations!</h2>"-Zeile) folgende Zeile hinzu:
<p><wicket:link><a href="BerechnungsFormular.html">Mein Berechnungsformular</a></wicket:link></p>
Erzeugen Sie im src\main\java\de\meinefirma\meinprojekt-Verzeichnis folgende BerechnungsFormular.html:
<html>
<head><title>Webseite mit Berechnungsformular</title></head>
<body>
<h2>Webseite mit Berechnungsformular</h2>
<form wicket:id="meinFormular" method="post"><pre>
Wert1 <input wicket:id="wert1" type="text" size=10 maxlength=10><br>
Wert2 <input wicket:id="wert2" type="text" size=10 maxlength=10><br>
<input wicket:id="berechne" type="submit" value="berechne"> <input wicket:id="ergebnis" type="text" size=10 readonly><br>
</pre></form>
<span wicket:id="FehlerFeedback"/>
</body>
</html>
Erzeugen Sie im src\main\java\de\meinefirma\meinprojekt-Verzeichnis folgende BerechnungsFormular.java:
package de.meinefirma.meinprojekt;
import java.io.Serializable;
import org.apache.wicket.markup.html.WebPage;
import org.apache.wicket.markup.html.form.*;
import org.apache.wicket.markup.html.panel.FeedbackPanel;
import org.apache.wicket.model.CompoundPropertyModel;
public class BerechnungsFormular extends WebPage
{
public BerechnungsFormular()
{
Form<MeinDatenModel> form = new Form<MeinDatenModel>( "meinFormular" ) {
private static final long serialVersionUID = 1L;
@Override protected void onSubmit() {
MeinDatenModel datenModel = getModelObject();
datenModel.ergebnis = (new MeineBean()).berechne( datenModel.wert1, datenModel.wert2 );
}
};
form.setModel( new CompoundPropertyModel<MeinDatenModel>( new MeinDatenModel() ) );
form.add( new RequiredTextField<Double>( "wert1" ) );
form.add( new RequiredTextField<Double>( "wert2" ) );
form.add( new Button( "berechne" ) );
form.add( new TextField<Double>( "ergebnis" ) );
add( form );
add( new FeedbackPanel( "FehlerFeedback" ) );
}
class MeinDatenModel implements Serializable
{
private static final long serialVersionUID = 1L;
public Double wert1, wert2, ergebnis;
}
}
Erzeugen Sie im src\main\java\de\meinefirma\meinprojekt-Verzeichnis MeineBean.java:
package de.meinefirma.meinprojekt;
public class MeineBean
{
public Double berechne( Number d1, Number d2 )
{
return ( d1 == null || d2 == null ) ? null
: new Double( d1.doubleValue() + d2.doubleValue() );
}
}
Testen Sie die Wicket-Webanwendung:
mvn clean jetty:run
start http://localhost:8080
Klicken Sie auf Mein Berechnungsformular, tragen Sie zwei Zahlen ein und lassen Sie die Summe berechnen. Sie können auch Dezimalzahlen eingeben: Dabei müssen Sie als Dezimalpunkt bei deutscher Webbrowser-Einstellung ein Komma (und keinen Punkt) verwenden.
Lassen Sie ein Feld leer, tragen Sie in das andere Feld Buchstaben ein und sehen Sie sich die Fehlermeldungen an.
Beenden Sie Jetty mit "Strg + C".
Vert.x ist ein reaktives, modulares, nachrichtenorientiertes, polyglottes Framework, mit dem sich klassische Anwendungen, Webanwendungen und Microservices realisieren lassen.
Infos zu Vert.x finden Sie in der Vert.x Documentation und im Vert.x Tutorial von Jakob Jenkov.
Das folgende Beispiel zeigt:
Führen Sie folgende Schritte aus:
Legen Sie ein Projektverzeichnis MvnVertxHelloWorld an und erzeugen Sie darin folgende Verzeichnisstruktur:
cd \MeinWorkspace
md MvnVertxHelloWorld
cd MvnVertxHelloWorld
md src\main\java\de\meinefirma\meinprojekt
Erzeugen Sie im MvnVertxHelloWorld-Projektverzeichnis folgende Projektkonfigurationsdatei: pom.xml
<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>de.meinefirma.meinprojekt</groupId>
<artifactId>MvnVertxHelloWorld</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<exec.mainClass>de.meinefirma.meinprojekt.HelloWorldVertx</exec.mainClass>
</properties>
<dependencies>
<dependency>
<groupId>io.vertx</groupId>
<artifactId>vertx-core</artifactId>
<version>3.3.2</version>
</dependency>
</dependencies>
<build>
<pluginManagement>
<plugins>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.5.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</pluginManagement>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<version>2.4.3</version>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>shade</goal>
</goals>
<configuration>
<transformers>
<transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
<manifestEntries>
<Main-Class>${exec.mainClass}</Main-Class>
</manifestEntries>
</transformer>
<transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
<resource>META-INF/services/io.vertx.core.spi.VerticleFactory</resource>
</transformer>
</transformers>
<artifactSet>
</artifactSet>
<outputFile>${project.build.directory}/${project.artifactId}-${project.version}-fat.jar</outputFile>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>
Erzeugen Sie im src\main\java\de\meinefirma\meinprojekt-Verzeichnis folgende Vert.x-Klasse: HelloWorldVertx.java
package de.meinefirma.meinprojekt;
import io.vertx.core.Vertx;
public class HelloWorldVertx
{
public static void main( String[] args )
{
Vertx.vertx().createHttpServer().requestHandler( req -> req.response().end( "Hello World." ) ).listen( 8080 );
}
}
Ihre Projektverzeichnisstruktur sieht jetzt so aus:
tree /F
[\MeinWorkspace\MvnVertxHelloWorld] |- [src] | '- [main] | '- [java] | '- [de] | '- [meinefirma] | '- [meinprojekt] | '- HelloWorldVertx.java '- pom.xml
Rufen Sie im Kommandozeilenfenster auf::
cd \MeinWorkspace\MvnVertxHelloWorld
mvn clean package
java -jar target/MvnVertxHelloWorld-1.0-SNAPSHOT-fat.jar
start http://localhost:8080
Es wird ein Webserver mit der Vert.x-Webanwendung gestartet und Sie erhalten im Webbrowser:
Hello World.
In realen Vert.x-Anwendungen werden statt der hier gezeigten einfachen Variante die Funktionalitäten normalerweise in Verticles aufgeteilt.
OSGi ist ein leistungsfähiges dynamisches Komponentensystem für Java.
Im Folgenden wird anhand eines kurzen Beispiels gezeigt, wie mit dem Maven-Bundle-Plugin des Apache-Felix-Projekts ein OSGi-Bundle erstellt werden kann.
Falls Sie noch kein OSGi installiert haben:
Sie können wahlweise eine komplette OSGi-Umgebung installieren, zum Beispiel wie für
Eclipse Equinox
beschrieben.
Für dieses einfache Beispiel genügt es, wenn Sie alternativ lediglich eine einzelne OSGi-jar-Bibliothek downloaden
und in Ihr Projektverzeichnis kopieren, nämlich die
org.eclipse.osgi_3.9.1.v20140110-1610.jar von
http://archive.eclipse.org/equinox/drops/R-KeplerSR2-201402211700.
Achtung: Bei neueren OSGi-Framework-Versionen lässt sich leider nicht mehr ganz so einfach wie im folgenden Beispiel
die Konsole starten, siehe hierzu:
"Incompatibilities" / "5. Built-in Equinox OSGi console removed".
Legen Sie ein Projektverzeichnis MvnOsgi an und erzeugen Sie darin folgende Verzeichnisstruktur:
cd \MeinWorkspace
md MvnOsgi\configuration
md MvnOsgi\src\main\java\de\meinefirma\meinprojekt
cd MvnOsgi
tree /F
[\MeinWorkspace\MvnOsgi] |- [configuration] |- [src] | '- [main] | '- [java] | '- [de] | '- [meinefirma] | '- [meinprojekt] '- org.eclipse.osgi_3.9.1.v20140110-1610.jar [falls keine andere OSGi-Installation]
Erzeugen Sie im MvnOsgi-Projektverzeichnis folgende Projektkonfigurationsdatei: pom.xml
<project>
<modelVersion>4.0.0</modelVersion>
<groupId>de.meinefirma.meinprojekt</groupId>
<artifactId>MvnOsgi</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>bundle</packaging>
<name>MvnOsgi</name>
<build>
<plugins>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
<version>3.0.1</version>
<extensions>true</extensions>
<configuration>
<instructions>
<!-- Falls Sie etwas zu exportieren haben:
<Export-Package>de.meinefirma.meinprojekt.intf...</Export-Package> -->
<Private-Package>de.meinefirma.meinprojekt.*</Private-Package>
<Bundle-Activator>de.meinefirma.meinprojekt.Activator</Bundle-Activator>
</instructions>
</configuration>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>org.apache.felix</groupId>
<artifactId>org.osgi.core</artifactId>
<version>1.4.0</version>
</dependency>
</dependencies>
</project>
Erzeugen Sie im configuration-Verzeichnis folgende OSGi-Konfigurationsdatei: config.ini
osgi.console.enable.builtin=true
Erzeugen Sie im src\main\java\de\meinefirma\meinprojekt-Verzeichnis folgende Bundle-Java-Klasse: Activator.java
package de.meinefirma.meinprojekt;
import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;
public class Activator implements BundleActivator
{
@Override
public void start( BundleContext context ) throws Exception
{
System.out.println( context.getBundle().getSymbolicName() + ": Hallo OSGi-Welt." );
}
@Override
public void stop( BundleContext context ) throws Exception
{
System.out.println( context.getBundle().getSymbolicName() + ": Tschau OSGi-Welt." );
}
}
Ihre Projektverzeichnisstruktur sieht jetzt so aus:
tree /F
[\MeinWorkspace\MvnOsgi] |- [configuration] | '- config.ini |- [src] | '- [main] | '- [java] | '- [de] | '- [meinefirma] | '- [meinprojekt] | '- Activator.java |- org.eclipse.osgi_3.9.1.v20140110-1610.jar [falls keine andere OSGi-Installation] '- pom.xml
Geben Sie im Kommandozeilenfenster (und in der OSGi-Konsole) Folgendes ein (passen Sie den OSGi-Dateinamen an):
cd \MeinWorkspace\MvnOsgi
mvn package
java -jar org.eclipse.osgi_3.9.1.v20140110-1610.jar -console -clean
install file:target\MvnOsgi-1.0-SNAPSHOT.jar start
ss
uninstall 1
close
Sie erhalten:
osgi> install file:target\MvnOsgi-1.0-SNAPSHOT.jar start
Bundle id is 1
de.meinefirma.meinprojekt.MvnOsgi: Hallo OSGi-Welt.
osgi> ss
id State Bundle
0 ACTIVE org.eclipse.osgi_3.9.1.v20140110-1610
1 ACTIVE de.meinefirma.meinprojekt.MvnOsgi_1.0.0.SNAPSHOT
osgi> uninstall 1
de.meinefirma.meinprojekt.MvnOsgi: Tschau OSGi-Welt.
osgi> close
Falls Sie nicht die org.eclipse.osgi_3.9.1.v20140110-1610.jar downgeloaded haben, sondern eine andere OSGi-Installation verwenden wollen, müssen Sie das java...-Kommando entsprechend ändern, zum Beispiel für eine Installation entsprechend der Beschreibung zu Eclipse Equinox folgendermaßen (passen Sie den Pfad und den OSGi-Dateinamen an):
java -jar C:\Tools\equinox-SDK\plugins\org.eclipse.osgi_3.9.1.v20140110-1610.jar -console -clean
Bei Problemen sehen Sie sich die .log-Datei im configuration-Unterverzeichnis an.
Erläuterungen finden Sie beim nahezu identischen OSGi-HelloWorld-Programmierbeispiel. Dort sind auch weitere ausführbare Kommandos und weitere OSGi-Programmierbeispiele aufgeführt.
Das Java-basierende Lucene zählt zu den bekanntesten Text-Suchmaschinen. Lucene ist Open Source, sehr leistungsfähig und enthält viele Features.
Das folgende "Lucene-HelloWorld-Programmierbeispiel" zeigt eine einfache Textsuche über Dateien in einem Verzeichnis inklusive der Unterverzeichnisse.
Legen Sie ein Projektverzeichnis MvnLucene an und erzeugen Sie darin folgende Verzeichnisstruktur:
cd \MeinWorkspace
md MvnLucene\src\main\java\de\meinefirma\meinprojekt
md MvnLucene\src\test\java\de\meinefirma\meinprojekt
cd MvnLucene
tree /F
[\MeinWorkspace\MvnLucene]
'- [src]
|- [main]
| '- [java]
| '- [de]
| '- [meinefirma]
| '- [meinprojekt]
'- [test]
'- [java]
'- [de]
'- [meinefirma]
'- [meinprojekt]
Erzeugen Sie im MvnLucene-Projektverzeichnis folgende Projektkonfigurationsdatei: pom.xml
<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>de.meinefirma.meinprojekt</groupId>
<artifactId>MvnLucene</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>MvnLucene</name>
<build>
<plugins>
<plugin>
<artifactId>maven-assembly-plugin</artifactId>
<version>2.6</version>
<configuration>
<descriptorRefs>
<descriptorRef>jar-with-dependencies</descriptorRef>
</descriptorRefs>
<archive>
<manifest>
<mainClass>de.meinefirma.meinprojekt.LuceneSimpleUtil</mainClass>
</manifest>
</archive>
</configuration>
<executions>
<execution>
<id>make-assembly</id>
<phase>package</phase>
<goals>
<goal>single</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>org.apache.lucene</groupId>
<artifactId>lucene-core</artifactId>
<version>4.10.4</version>
</dependency>
<dependency>
<groupId>org.apache.lucene</groupId>
<artifactId>lucene-queryparser</artifactId>
<version>4.10.4</version>
</dependency>
<dependency>
<groupId>org.apache.lucene</groupId>
<artifactId>lucene-analyzers-common</artifactId>
<version>4.10.4</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>
Erzeugen Sie im src\main\java\de\meinefirma\meinprojekt-Verzeichnis folgende Java-Klasse: LuceneSimpleUtil.java
package de.meinefirma.meinprojekt;
import java.io.*;
import java.nio.charset.Charset;
import java.util.*;
import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.*;
import org.apache.lucene.index.*;
import org.apache.lucene.index.IndexWriterConfig.OpenMode;
import org.apache.lucene.queryparser.classic.QueryParser;
import org.apache.lucene.search.*;
import org.apache.lucene.store.*;
import org.apache.lucene.util.Version;
public class LuceneSimpleUtil
{
public static void main( String[] args ) throws Exception
{
if( args.length != 2 && args.length != 3 ) {
System.out.println(
"\nIndizieren mit 3 Parametern:\n" +
" PfadZuDokumenten CharacterEncoding PfadZumIndex\n" +
"Suchen mit 2 Parametern:\n" +
" PfadZumIndex SuchWort\n" );
}
if( args.length == 3 ) {
System.out.println( "\nIndexerstellung im Verzeichnis: " + args[2] );
System.out.println( "Zu indizierende Dateien im Verzeichnis: " + args[0] );
System.out.println( "Character-Encoding: " + args[1] );
System.out.println( "Indizierte Dateien:" );
System.out.println( LuceneSimpleUtil.indexFiles( args[0], args[1], args[2], true ) );
}
if( args.length == 2 ) {
System.out.println( "\nIndex im Verzeichnis: " + args[0] );
System.out.println( "Suchwort '" + args[1] + "' gefunden in:" );
List<Document> docs = LuceneSimpleUtil.searchFiles( args[0], args[1], 100 );
for( int i = 0; i < docs.size(); i++ ) {
System.out.println( docs.get( i ).get( "path" ) );
}
}
}
public static List<Document> searchFiles( String indexPath, String queryString, int maxResults ) throws Exception
{
if( queryString == null || queryString.trim().length() == 0 ) { return null; }
List<Document> docs = new ArrayList<Document>();
IndexReader reader = DirectoryReader.open( FSDirectory.open( new File( indexPath ) ) );
IndexSearcher searcher = new IndexSearcher( reader );
Analyzer analyzer = new StandardAnalyzer( Version.LUCENE_4_9 );
QueryParser parser = new QueryParser( Version.LUCENE_4_9, "contents", analyzer );
Query query = parser.parse( queryString.trim() );
TopDocs results = searcher.search( query, maxResults );
ScoreDoc[] hits = results.scoreDocs;
for( ScoreDoc scoreDoc : hits ) {
docs.add( searcher.doc( scoreDoc.doc ) );
}
reader.close();
analyzer.close();
return docs;
}
public static List<File> indexFiles( String docsPath, String charEncoding, String indexPath, boolean createNew ) throws IOException
{
if( docsPath == null ) { return null; }
final File docDir = new File( docsPath );
if( !docDir.exists() || !docDir.canRead() ) { return null; }
Directory dir = FSDirectory.open( new File( indexPath ) );
Analyzer analyzer = new StandardAnalyzer( Version.LUCENE_4_9 );
IndexWriterConfig iwc = new IndexWriterConfig( Version.LUCENE_4_9, analyzer );
iwc.setOpenMode( ( createNew ) ? OpenMode.CREATE : OpenMode.CREATE_OR_APPEND );
IndexWriter writer = new IndexWriter( dir, iwc );
List<File> filesIndexed = indexDocs( writer, docDir, Charset.forName( charEncoding ) );
writer.close();
analyzer.close();
dir.close();
return filesIndexed;
}
private static List<File> indexDocs( IndexWriter writer, File file, Charset charEnc ) throws IOException
{
List<File> filesIndexed = new ArrayList<File>();
if( file.canRead() ) {
if( file.isDirectory() ) {
String[] files = file.list();
if( files != null ) {
for( int i = 0; i < files.length; i++ ) {
filesIndexed.addAll( indexDocs( writer, new File( file, files[i] ), charEnc ) );
}
}
} else {
BufferedReader fileReader;
try {
fileReader = new BufferedReader( new InputStreamReader( new FileInputStream( file ), charEnc ) );
} catch( FileNotFoundException fnfe ) {
return filesIndexed;
}
try {
Document doc = new Document();
Field pathField = new StringField( "path", file.getPath(), Field.Store.YES );
doc.add( pathField );
doc.add( new LongField( "modified", file.lastModified(), Field.Store.NO ) );
doc.add( new TextField( "contents", fileReader ) );
if( writer.getConfig().getOpenMode() == OpenMode.CREATE ) {
writer.addDocument( doc );
} else {
writer.updateDocument( new Term( "path", file.getPath() ), doc );
}
filesIndexed.add( file );
} finally {
fileReader.close();
}
}
}
return filesIndexed;
}
}
Sehen Sie sich hierzu die Lucene-API-Doku an: Lucene core API.
Erzeugen Sie im src\test\java\de\meinefirma\meinprojekt-Verzeichnis folgende Modultest-Klasse: LuceneSimpleUtilTest.java
package de.meinefirma.meinprojekt;
import static org.junit.Assert.*;
import java.io.File;
import java.nio.charset.StandardCharsets;
import java.util.List;
import org.apache.lucene.document.Document;
import org.junit.Test;
public class LuceneSimpleUtilTest
{
@Test
public void testLuceneSearch() throws Exception
{
String docsPath = "src";
String indexPath = "target/LuceneIndex";
String charEnc = StandardCharsets.UTF_8.toString();
String suchWort = "Lucene";
System.out.println( "Indexerstellung im Verzeichnis: " + indexPath );
System.out.println( "Zu indizierende Dateien im Verzeichnis: " + docsPath );
System.out.println( "Character-Encoding: " + charEnc );
System.out.println( "Indizierte Dateien:" );
List<File> filesIndexed = LuceneSimpleUtil.indexFiles( docsPath, charEnc, indexPath, true );
System.out.println( filesIndexed );
assertNotNull( filesIndexed );
assertEquals( 2, filesIndexed.size() );
System.out.println( "Suchwort '" + suchWort + "' gefunden in:" );
List<Document> docs = LuceneSimpleUtil.searchFiles( indexPath, suchWort, 100 );
for( Document doc : docs ) {
System.out.println( doc.get( "path" ) );
}
assertEquals( 1, docs.size() );
}
}
Ihre Projektverzeichnisstruktur sieht jetzt so aus:
tree /F
[\MeinWorkspace\MvnLucene] |- [src] | |- [main] | | '- [java] | | '- [de] | | '- [meinefirma] | | '- [meinprojekt] | | '- LuceneSimpleUtil.java | '- [test] | '- [java] | '- [de] | '- [meinefirma] | '- [meinprojekt] | '- LuceneSimpleUtilTest.java '- pom.xml
In dem JUnit-Test LuceneSimpleUtilTest wird gezeigt, wie Sie Lucene programmatisch ansprechen können. Geben Sie im Kommandozeilenfenster Folgendes ein:
cd \MeinWorkspace\MvnLucene
mvn test
Sie erhalten:
Running de.meinefirma.meinprojekt.LuceneSimpleUtilTest Indexerstellung im Verzeichnis: target/LuceneIndex Zu indizierende Dateien im Verzeichnis: src Character-Encoding: UTF-8 Indizierte Dateien: [src\main\java\de\meinefirma\meinprojekt\LuceneSimpleUtil.java, src\test\java\de\meinefirma\meinprojekt\LuceneSimpleUtilTest.java] Suchwort 'Lucene' gefunden in: src\test\java\de\meinefirma\meinprojekt\LuceneSimpleUtilTest.java
Sie können LuceneSimpleUtil auch per Kommandozeilenfenster aufrufen. Im folgenden Beispiel wird wieder in allen Dateien in allen Verzeichnissen unter src nach Lucene gesucht:
cd \MeinWorkspace\MvnLucene
mvn package
java -jar target\MvnLucene-1.0-SNAPSHOT-jar-with-dependencies.jar
-->
Indizieren mit 3 Parametern: PfadZuDokumenten CharacterEncoding PfadZumIndex Suchen mit 2 Parametern: PfadZumIndex SuchWort
Indizierung durch Angabe von "PfadZuDokumenten CharacterEncoding PfadZumIndex":
java -jar target\MvnLucene-1.0-SNAPSHOT-jar-with-dependencies.jar src ISO-8859-1 LuceneIndex
-->
Indexerstellung im Verzeichnis: LuceneIndex Zu indizierende Dateien im Verzeichnis: src Character-Encoding: ISO-8859-1 Indizierte Dateien: [src\main\java\de\meinefirma\meinprojekt\LuceneSimpleUtil.java, src\test\java\de\meinefirma\meinprojekt\LuceneSimpleUtilTest.java]
Suchen durch Angabe von "PfadZumIndex SuchWort":
java -jar target\MvnLucene-1.0-SNAPSHOT-jar-with-dependencies.jar LuceneIndex Lucene
-->
Index im Verzeichnis: LuceneIndex Suchwort 'Lucene' gefunden in: src\test\java\de\meinefirma\meinprojekt\LuceneSimpleUtilTest.java
Indizieren Sie statt in src alle Dateien in einem anderen Verzeichnis und testen Sie andere Suchwörter.
Maven-Projekte für die Java Enterprise Edition finden Sie zum Beispiel unter:
Beispiele zur Verwendung von Docker mit Maven finden Sie unter:
In Firmennetzwerken ist häufig der direkte Internetzugang für Tools wie Maven gesperrt. Um dennoch benötigte Libs aus den Maven-Repositories im Internet verwenden zu können, kann der Cntlm Authentication Proxy verwendet werden (wenn die IT-Abteilung das erlaubt). Er steht für verschiedene Betriebssysteme zur Verfügung. Hier folgt eine Kurzanleitung für Windows-Workstations, die übers Firmennetzwerk nur über eine NTLM-Authentifizierung ins Internet gelangen.
Installieren Sie Cntlm wie beschrieben unter
Eclipse-Updates über Firmen-Firewalls mit dem Cntlm Authentication Proxy
(die Eclipse-spezifischen Einstellungen können Sie weglassen).
Erweitern Sie Ihre lokale %M2_HOME%\conf\settings.xml zum Beispiel so (passen Sie den Pfad an und setzen Sie als Portnummer dieselbe wie bei Cntlm ein):
<?xml version="1.0" encoding="UTF-8"?>
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
<localRepository>D:\Tools\Maven3-Repo</localRepository>
<proxies>
<proxy>
<active>true</active>
<protocol>http</protocol>
<host>127.0.0.1</host>
<port>3128</port>
</proxy>
</proxies>
</settings>
Wenn nur ein festes Repertoire an Libs mehreren Entwicklern zur Verfügung gestellt werden soll, können Sie ein Maven-Repository als einfaches Verzeichnis einstellen. Allerdings werden so keine fehlenden Libs übers Internet nachgeladen.
Erweitern Sie Ihre lokale settings.xml zum Beispiel so:
<?xml version="1.0" encoding="UTF-8"?>
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
<localRepository>D:\Tools\Maven3-Repo</localRepository>
<mirrors>
<mirror>
<id>MeineMirrorId</id>
<mirrorOf>central</mirrorOf>
<url>file://\\<MeinPC>\<MeinFreigabeName>\m2-Central-Repository</url>
</mirror>
</mirrors>
</settings>
Falls ein Repository-Manager (im Beispiel: Archiva) installiert ist, können Sie ihn über folgenden Eintrag in der settings.xml einstellen:
<?xml version="1.0" encoding="UTF-8"?>
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
<localRepository>D:\Tools\Maven3-Repo</localRepository>
<mirrors>
<mirror>
<id>archiva</id>
<mirrorOf>*</mirrorOf>
<url>http://<ArchivaServer>:<ArchivaPort>/archiva/repository/internal</url>
</mirror>
</mirrors>
</settings>
Archiva ist einer der bekanntesten Repository-Manager.
Installieren Sie ihn wie beschrieben unter
System Administrators Guide to Apache Archiva.
Einige eventuell benötigte Schritte sind auch im Folgenden aufgeführt.
Falls Sie unter 64-bit-Windows installieren: Der Archiva-Wrapper funktioniert zurzeit nur mit einem 32-bit-JDK. Dieses muss installiert (z.B. nach C:\Program Files (x86)\Java\jdk1.7-32bit) und bei Archiva eingetragen werden. Hierzu in der \Tools\Archiva\conf\wrapper.conf die Zeile
wrapper.java.command=java
ändern zu:
wrapper.java.command=C:\Program Files (x86)\Java\jdk1.7-32bit\bin\java
Außerdem können einige Archiva-Kommandos (z.B. "bin\archiva.bat install") nur in einem Kommandozeilenfenster mit Administratorrechten ausgeführt werden: Start | Alle Programme | Zubehör | "Eingabeaufforderung" mit rechter Maustaste und "Als Administrator ausführen".
Starten Sie Archiva über:
\Tools\Archiva\bin\archiva.bat console
Wenn "Started SelectChannelConnector@0.0.0.0:4422" erscheint, starten Sie die Archiva-Weboberfläche:
| Identifier: | MeineNetworkProxyID |
| Protocol: | http |
| Hostname: | 127.0.0.1 |
| Port: | 3128 |
| Username: | |
| Password: |
<networkProxies>
<networkProxy>
<id>MeineNetworkProxyID</id>
<host>127.0.0.1</host>
<port>3128</port>
<username/>
<password/>
</networkProxy>
</networkProxies>
| Network Proxy: | MeineNetworkProxyID |
<proxyConnector>
...
<proxyId>MeineNetworkProxyID</proxyId>
...
</proxyConnector>
| Identifier: | maven1-repository.dev.java.net |
| Name: | Java.net Repository for Maven 1 |
| URL: | http://download.java.net/maven/1/ |
| Type: | Maven 1.x Repository |
| Network Proxy: | MeineNetworkProxyID |
| Managed Repository: | internal |
| Remote Repository: | maven1-repository.dev.java.net |
| Cache failures: | yes |
| Releases: | once |
| Checksum: | fix |
| Snapshots: | never |
\Tools\Archiva\bin\archiva.bat install
Wenn Sie jetzt Windows neu starten, läuft Archiva automatisch als Dienst.
Steuern können Sie dies unter:
"Start" | "Systemsteuerung" | ["System und Sicherheit"] | "Verwaltung" | "Dienste"
(oder alternativ: rechter Mausklick auf "Computer" bzw. "Arbeitsplatz" | "Verwalten" | "Dienste und Anwendungen" | "Dienste").
Für kleine Teams in Firmen kann praktisch sein, dass der so installierte Archiva-Dienst bereits funktionsfähig und von anderen PCs aus erreichbar läuft, ohne dass sich jemand auf dem Archiva-Server im Firmennetzwerk anmelden muss.
Falls Sie bei korrekt installiertem Archiva-Dienst nur den Archiva-Dienst stoppen oder starten wollen, können Sie das net-Kommando verwenden:
net stop archiva
net start archiva
Mit mvn install kopieren Sie Ihre Ergebnisartefakte in Ihr lokales Maven-Repository. Falls Sie im Team arbeiten und Ihre Kollegen Ihre Ergebnisartefakte verwenden können sollen, müssen Sie diese mit mvn deploy in ein gemeinsam genutzes Remote Repository kopieren. Dies kann ein projektspezifisches, teamspezifisches, firmenspezifisches oder ein übers Internet erreichbares sein. Im Folgenden werden die dafür benötigten Einstellungen am Beispiel des Archiva-Repository-Managers aufgeführt.
Archiva einrichten wie oben beschrieben.
Der Archiva-Administrator legt in Archiva die Benutzer für das Distribution-Deployment an (im Folgenden "<DeployerName>" genannt):
Der Entwickler/Deployer ändert das Kennwort und kontrolliert den Archiva-Account:
Auf dem Deployer-PC die %M2_HOME%\conf\settings.xml erweitern (dabei korrekte Archiva-URL und korrekten Deployer-Benutzer eintragen):
<?xml version="1.0" encoding="UTF-8"?>
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
<localRepository>D:\Tools\Maven3-Repo</localRepository>
<mirrors>
<mirror>
<id>archiva</id>
<mirrorOf>*</mirrorOf>
<url>http://<ArchivaServer>:<ArchivaPort>/archiva/repository/internal</url>
</mirror>
</mirrors>
<servers>
<server>
<id>archiva</id>
<username>..._DeployerName_...</username>
<password>....................</password>
</server>
</servers>
</settings>
Auf dem Deployer-PC ein Testprojekt anlegen:
cd \MeinWorkspace
mvn archetype:generate -DinteractiveMode=false -DgroupId=test1 -DartifactId=Test1
cd Test1
Auf dem Deployer-PC für den Test die pom.xml des Test1-Projekts erweitern (dabei korrekte Archiva-URL eintragen):
<distributionManagement>
<repository>
<id>archiva</id>
<url>http://<ArchivaServer>:<ArchivaPort>/archiva/repository/internal</url>
</repository>
<snapshotRepository>
<id>archiva</id>
<url>http://<ArchivaServer>:<ArchivaPort>/archiva/repository/snapshots</url>
</snapshotRepository>
</distributionManagement>
Diese POM-Einstellung erfolgt am besten in einer "Corporate POM (oder Projekt-Master-POM)".
Snapshot-Deployment:
cd \MeinWorkspace\Test1
mvn deploy
Release-Deployment:
In der pom.xml die Zeile
<version>1.0-SNAPSHOT</version>
ändern zu:
<version>1.0</version>
und aufrufen:
mvn deploy
Kontrolle:
http://<ArchivaServer>:<ArchivaPort>/archiva/browse aufrufen und beide deployte Artefakte überprüfen.
Doku zum Maven-Deploy-Plugin:
http://maven.apache.org/plugins/maven-deploy-plugin und
http://maven.apache.org/plugins/maven-deploy-plugin/usage.html
Sehen Sie sich auch die Hinweise zum Release-Auslieferungsprozess an.
Alternativ zu Archiva können Sie auch Nexus verwenden:
Sehen Sie sich die Nexus-Referenzdoku an.
Downloaden Sie Nexus OSS (als Zipdatei, z.B. nexus-2.10.0-02-bundle.zip) und entzippen Sie das Archiv, z.B. nach \Tools\Nexus.
Der Nexus-Default-Port ist 8081. Da dieser Port auch von vielen anderen Anwendungen bevorzugt wird, sollten Sie einen anderen Port einstellen, beispielsweise 4422. Tragen Sie die gewünschte Portnummer bei application-port=... in der \Tools\Nexus\conf\nexus.properties ein.
Öffnen Sie ein Kommandozeilenfenster mit Admin-Rechten und verzweigen Sie in das Nexus-bin-Verzeichnis, z.B.: \Tools\Nexus\bin.
Um Nexus für einen ersten Test zu starten, führen Sie aus (und warten, bis "Started SelectChannelConnector@0.0.0.0:4422" oder "Started InstrumentedSelectChannelConnector@0.0.0.0:4422" erscheint):
cd \Tools\Nexus\bin
nexus.bat console
Um Nexus als Windows-Dienst zu installieren und automatisch zu starten, führen Sie aus:
nexus.bat install
net start nexus
Überprüfen Sie die Parameter in der Windows-Registry unter: HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\services\nexus-webapp.
Starten Sie Nexus und sehen Sie sich die Admin-Konsole an:
Starten Sie http://localhost:4422/nexus,
klicken Sie oben rechts auf "Log In" und geben Sie als Username "admin" und als Password "admin123" ein.
Überprüfen Sie die Einstellungen, insbesondere unter
"Views/Repositories" | "Repositories" sowie
"Administration" | "Server".
Beachten Sie, dass Sie je nach Nexus-Konfiguration nicht alle Menüeinträge und Parameter sehen können, wenn Sie sich remote über http://NexusPcName:4422/nexus verbinden. In diesem Fall müssen Sie Nexus direkt lokal auf dem Nexus-PC mit localhost aufrufen, also über http://localhost:4422/nexus.
Falls Ihr Netzwerk nur über einen Proxy ins Internet gelangt (wie es in Firmen häufig der Fall ist),
sehen Sie sich obige Bemerkungen zum Firmen-Proxy an.
Auf der soeben erwähnten Nexus-Admin-Seite können Sie unter
"Administration" | "Server" | "Default HTTP Proxy Settings (optional)"
den Proxy-Host und -Port eintragen.
Falls Sie über "Views/Repositories" | "Repositories" | "Add..." ein neues Repository hinzufügen: Vergessen Sie nicht, das neu angelegte Repository auch der Gruppe "Public Repositories" hinzuzufügen.
Sie sollten für alle Repositories konfigurieren:
File Content Validation = True
Checksum Policy = StrictIfExists
Dies ist vor allem dann wichtig, wenn Sie sich in einem Firmennetzwerk hinter einem Proxy befinden, siehe
http://books.sonatype.com/nexus-book/reference/confignx-sect-manage-repo.html.
Solche Proxys antworten häufig beim Download mit zwischengeschalteten HTML-Seiten.
Falls Sie beim Build auf "unerklärliche Fehler" (z.B. ClassNotFoundException oder NoClassDefFoundError) stoßen:
Überprüfen Sie im Nexus-Datenverzeichnis alle vermeintlichen *.jar-Dateien, ob sie in Wirklichkeit nur HTML-Inhalt haben.
Falls Sie eine solche fehlerhafte *.jar-Datei finden: Löschen Sie das gesamte Verzeichnis dieser Datei und führen Sie "Repair Index" aus.
Falls es keine andere Möglichkeit gibt, als eine .jar-Datei manuell downzuloaden und manuell der Nexus-Datenbank hinzuzufügen:
Denken Sie daran, zusätzlich auch die .jar.sha1-Datei hinzuzufügen und anschließend Nexus neu zu starten.
Außerdem müssen Sie eventuell beim Client-PC in dessen lokalem Maven-Repository alle Verzeichnisse löschen,
welche auf *.lastUpdated endende Dateien enthalten.
Auf den Workstations, auf denen Maven den Nexus-Repository-Server verwenden soll, muss jeweils in der %M2_HOME%\conf\settings.xml der Inhalt des <mirrors>-Tags ersetzt werden durch (siehe auch Configuring Maven):
<mirror>
<id>nexus</id>
<mirrorOf>*</mirrorOf>
<url>http://__NEXUS_SERVER__:__NEXUS_PORT__/nexus/content/groups/public</url>
</mirror>
<!-- Wird fuer Distribution-Deployment ins Remote-Maven-Repository benoetigt
(siehe "<distributionManagement>" in Master-POM)
(nur einfuegen, wenn Account wirklich existiert): -->
<servers>
<server>
<id>nexus</id>
<username>__MEIN_NEXUS_BENUTZERNAME__</username>
<password>__MEIN_NEXUS_KENNWORT__</password>
</server>
</servers>
Dabei "__NEXUS_SERVER__:__NEXUS_PORT__" durch korrekte Werte ersetzen, zum Beispiel "localhost:4422".
Falls Sie eigene Artefakte
(z.B. JDBC-Treiber oder JPA-Provider)
ins Nexus-Repository deployen wollen, loggen Sie sich als Admin ein und wählen Sie:
links Menüpunkt: "Repositories" | Mitte oben Zeile: "Releases" | Mitte unten Reiter: "Artifact Upload" | ...
Falls Sie folgende Fehlermeldung erhalten: "[ERROR] Plugin ... or one of its dependencies could not be resolved: Failed to read artifact descriptor for ...: Could not transfer artifact ... from/to nexus: Not authorized, ReasonPhrase:Unauthorized: Dann überprüfen Sie sehr genau die <server>-Account-Daten.
Falls Sie folgende Fehlermeldung erhalten: "[ERROR] Failed to execute goal on project ...: Could not resolve dependencies for project ...: Failure to find ... in ... was cached in the local repository, resolution will not be reattempted until the update interval of nexus has elapsed or updates are forced -> [Help 1]", und falls Sie die Wartezeit nicht abwarten wollen: Löschen Sie vor einem neuen Versuch im lokalen Maven-Repository alle Verzeichnisse, welche auf *.lastUpdated endende Dateien enthalten.
Falls Sie folgende Fehlermeldung erhalten:
"Unable to update index for Nexus ...":
In Nexus als admin einloggen und
entweder unter Views/Repositories | Repositories mit der rechten Maustaste auf Public Repositories und "Repair Index" klicken
oder unter Administration | Scheduled Tasks die Task "Repair Repositories Index" einrichten und ausführen.
Falls Sie Eclipse und das
M2Eclipse-Plugin
installiert haben, müssen Sie eventuell zusätzlich Eclipse schließen und den Cache unter
%M2_REPO%\.cache\m2e
(z.B. %USERPROFILE%\.m2\repository\.cache\m2e
oder
\Tools\Maven3-Repo\.cache\m2e)
löschen.
Falls Sie beim Start des Nexus-Servers als Windows-Dienst diese Fehlermeldung erhalten:
Der Dienst ... konnte nicht gestartet werden. Fehler 1067: Der Prozess wurde unerwartet beendet.
und in der \Tools\Nexus\logs\wrapper.log steht:
wrapper | Unable to execute Java command. Das System kann die angegebene Datei nicht finden. (0x2)
wrapper | "java" -... ...
wrapper | Critical error: wait for JVM process failed
Dann ersetzen Sie in der \Tools\Nexus\bin\jsw\conf\wrapper.conf die Zeile
wrapper.java.command=java
durch
wrapper.java.command=C:\Program Files\Java\jdk1.7\bin\java
Continuous Integration mit Jenkins oder Hudson ermöglicht die kontinuierliche Überwachung, ob Systeme funktionsfähig sind, sowie ob die ins Versionskontrollsystem (= "VCS", = "SCM", = Source Code Management, z.B. Git, Mercurial, Subversion, CVS) eingecheckten Module kompilierfähig sind, zusammenpassen und ob alle Tests (auch Integrationstests) fehlerfrei durchlaufen werden.
Im Folgenden werden einige wichtige Schritte kurz beschrieben, um Jenkins für Maven-3-Projekte einzurichten. Die meisten Hinweise gelten genau so auch für Hudson.
Die folgende Beschreibung geht von einem installierten Maven 3 und von bereits vorhanden und ins VCS/SCM eingecheckten Modulen aus.
Jenkins legt seine Arbeitsdateien defaultmäßig in einem .jenkins-Unterverzeichnis im <user-home>-Verzeichnis (z.B. C:\Users\%USERNAME%) ab. Zumindest in Firmen sollten Sie dies vermeiden, weil häufig das <user-home>-Verzeichnis bei jedem PC-Herunterfahren gesichert und beim Starten wiederhergestellt wird, was unnötig Backup-Speicherplatz kosten und diese Vorgänge verlangsamen würde.
Um dies zu vermeiden, erzeugen Sie ein neues Verzeichnis und übergeben dies als Umgebungsvariable, zum Beispiel so:
md C:\Tools\Jenkins
set JENKINS_HOME=C:\Tools\Jenkins
Downloaden Sie die Jenkins-Installations-WAR-Datei (z.B. jenkins-1.556.war) von http://jenkins-ci.org, zum Beispiel in das bei %JENKINS_HOME% definierte Verzeichnis (z.B. C:\Tools\Jenkins).
Um zukünftige Updates zu erleichtern und um die mitgelieferten Skripte verwenden zu können, sollten Sie die Versionsnummer aus dem Dateinamen entfernen. Umbenennen Sie die downgeloadete Datei in jenkins.war.
Prüfen Sie, ob die gewünschte Portnummer (z.B. 4424) noch frei ist:
netstat -a
netstat -an | find ":4424"
Wechseln Sie in das Verzeichnis mit der jenkins.war-Datei und rufen Sie auf (eventuell statt mit 4424 mit anderer Portnummer):
cd C:\Tools\Jenkins
start "Jenkins" java -jar jenkins.war --httpPort=4424
Warten Sie, bis "Completed initialization" erscheint.
start http://localhost:4424
Wählen Sie im Jenkins-Hauptmenü "Jenkins verwalten" | "System konfigurieren":
Wählen Sie im Jenkins-Hauptmenü "Neuen Job anlegen":
Jenkins setzt einige Jenkins Environment Variables, die Sie während der Jenkins-Jobs verwenden können. Einige der Werte können innerhalb der Jenkins-Job-Beschreibungen hilfreich sein, zum Beispiel um Kopierkommandos zu formulieren (z.B. WORKSPACE und JOB_NAME, s.o.). Andere Werte können auch zur Laufzeit interessant sein (z.B. BUILD_ID, BUILD_NUMBER und CVS_BRANCH). Sie können sie während des Buildprozesses automatisch in Properties-Dateien oder in die MANIFEST.MF eintragen.
Die bereits im Betriebssystem konfigurierten Environment Variablen (Umgebungsvariablen) stehen innerhalb der Jenkins-Jobs nicht so ohne weiteres zur Verfügung. Wenn Sie bestimmte Umgebungsvariablen benötigen, beispielsweise NLS_LANG für Oracle SqlPlus, dann müssen Sie diese Umgebungsvariablen entweder innerhalb Jenkins global setzen (Jenkins verwalten | System konfigurieren | Globale Eigenschaften | Umgebungsvariablen) oder innerhalb der einzelnen Jenkins-Jobs setzen (notfalls z.B. per "set NLS_LANG=German_Germany.AL32UTF8"). Alternativ können Sie Umgebungsvariablen auch mit speziellen Jenkins-Plugins konfigurieren.
Jenkins sorgt normalerweise dafür, dass alle vom Jenkins-Job gestarteten Prozesse automatisch am Ende des Jenkins-Jobs beendet werden. Dies ist normalerweise das gewünschte Verhalten. Falls Sie in einem Jenkins-Job Prozesse starten wollen, die nicht von Jenkins beendet werden sollen, können Sie dies erreichen, indem Sie in diesem Job die Umgebungsvariable BUILD_ID setzen, zum Beispiel so: "set BUILD_ID=dontKillMe". Siehe hierzu: https://wiki.jenkins-ci.org/display/JENKINS/ProcessTreeKiller. Falls Sie den von Jenkins gesetzten Inhalt der BUILD_ID während des Jobs verwenden wollen, müssen Sie die BUILD_ID vorher in eine andere Umgebungsvariable retten.
Falls Sie CVS verwenden:
Ein CVS-Kommandozeilenclient muss installiert sein, zum Beispiel per cvsnt_setup.exe aus WinCvs2_0_2-4.zip (der cvsnt-Server-Teil kann während der Installation deaktiviert werden und WinCvs braucht nicht installiert werden).
Falls Sie folgende Fehlermeldung erhalten: "cvs checkout: Empty password used - try 'cvs login' with a real password": Dann führen Sie (unter dem richtigen Benutzer) einmalig einen Login ins CVS per Kommandozeile durch, z.B. so:
cvs.exe -d:pserver:<Benutzername>@<CvsServerUrl>:<Pfad> login
Dabei entsteht entweder im C:\Users\%USERNAME%-Verzeichnis die Passwortdatei .cvspass oder in der Windows-Registry ein cvspass-Eintrag entweder unter HKEY_CURRENT_USER\Software\cvsnt oder unter HKEY_USERS\.DEFAULT\Software\cvsnt.
Falls Sie von Jenkins aus SonarQube-Reports erstellen wollen, Maven 3 verwenden und Schwierigkeiten mit dem SonarQube-Plugin (https://wiki.jenkins-ci.org/display/JENKINS/SonarQube+plugin) haben, dann können Sie SonarQube auch leicht ohne das SonarQube-Plugin in Jenkins einbinden:
Installieren und starten Sie den SonarQube-Server, wie oben unter Sourcecodeanalyse mit SonarQube beschrieben ist (am besten als automatisch startender Dienst).
Klicken Sie im Jenkins-Hauptmenü auf den gewünschten "Job" und wählen Sie "Konfigurieren":
"Buildverfahren", "Build-Schritt hinzufügen", "Maven Goals aufrufen",
bei "Maven Version" den oben eingetragen Namen (z.B. "Maven 3"),
"Goals" "clean install sonar:sonar".
Falls Sie viele Jenkins-Jobs haben, kann es sinnvoll sein, mit dem "Nested View Plugin" zusätzliche Gliederungsebenen einzuführen. Dabei wird in der summarischen Ansicht angezeigt, ob es innerhalb der Ordner Fehlschläge gibt, oder ob alles ok ist.
Normalerweise empfiehlt es sich, Jenkins als automatisch beim Booten startenden Dienst einzurichten. Dann läuft Jenkins bereits, ohne dass sich ein Benutzer anmelden muss. Unter Windows erfolgt dies folgendermaßen:
Bei neueren Jenkins-Versionen können Sie folgendermaßen verfahren:
Starten Sie Jenkins (wie oben beschrieben) und klicken Sie unter "Jenkins verwalten" auf den Menüpunkt "Als Windows-Dienst installieren".
Falls dieser Menüpunkt "Als Windows-Dienst installieren" bei Ihrer Jenkins/Hudson-Version fehlt (z.B. in Hudson 1.398), verfahren Sie folgendermaßen:
Entzippen Sie in einem temporären Verzeichnis Ihre hudson-...war-Datei (z.B. hudson-1.398.war).
Dann entzippen Sie die darin enthaltene WEB-INF\lib\hudson-core-1.398.jar.
Anschließend kopieren Sie aus dem darin enthaltenen windows-service-Verzeichnis die hudson.exe und hudson.xml ins HUDSON_HOME-Verzeichnis.
Öffnen Sie die jenkins.xml im Jenkins-Home-Verzeichnis (z.B. C:\Tools\Jenkins).
Suchen Sie nach dem Eintrag zur jenkins-...war-Datei (z.B. jenkins.war) und
korrigieren Sie diesen Eintrag entsprechend dem Namen Ihrer jenkins-...war-Datei (also z.B. zu jenkins.war).
Suchen Sie weiter nach "--httpPort" und tragen Sie dort die gewünschte Portnummer ein (z.B. 4424).
Suchen Sie in der Windows-Diensteverwaltung nach dem jenkins-Dienst über:
"Start" | "Systemsteuerung" | ["System und Sicherheit"] | "Verwaltung" | "Dienste".
Falls es noch keinen jenkins-Dienst gibt, öffnen Sie ein Kommandozeilenfenster mit Administratorrechten über:
Start | Alle Programme | Zubehör | "Eingabeaufforderung" mit rechter Maustaste und "Als Administrator ausführen".
Darin führen Sie aus:
cd C:\Tools\Jenkins
jenkins.exe install
Starten Sie Jenkins entweder erstmalig oder neu über:
"Start" | "Systemsteuerung" | ["System und Sicherheit"] | "Verwaltung" | "Dienste" | Doppelklick auf "jenkins" | "Beenden"/"Starten").
Falls Jenkins-Jobs bestimmte Benutzerrechte benötigen (z.B. für den VCS/SCM-Account), wählen Sie:
"Start" | "Systemsteuerung" | ["System und Sicherheit"] | "Verwaltung" | "Dienste" | Doppelklick auf "jenkins" | Reiter "Anmelden" | "Dieses Konto".
Falls Sie beim Starten des Dienstes diese Fehlermeldung erhalten:
Dienst "jenkins" wurde auf "Lokaler Computer" gestartet und dann angehalten. Einige Dienste werden automatisch angehalten, wenn sie nicht von anderen Diensten oder Programmen verwendet werden.
und die Windows-Ereignisanzeige (unter Start | Systemsteuerung | [System und Sicherheit] | Verwaltung | Computerverwaltung | System | Ereignisanzeige) zeigt an:
Der Dienst kann nicht gestartet werden. System.ComponentModel.Win32Exception: Das System kann die angegebene Datei nicht finden.
Dann ersetzen Sie in der jenkins.xml die Zeile:
<executable>java</executable>durch:
<executable>C:\Program Files\Java\jdk1.7\bin\java</executable>
Falls Sie eine Fehlermeldung erhalten ähnlich zu einer der folgenden:
The system cannot find the file specified.
FATAL: Befehlsausführung fehlgeschlagen.
CreateProcess error=2, Das System kann die angegebene Datei nicht finden.
ERROR: JAVA_HOME not found in your environment.
Dann ersetzen Sie in der config.xml die Zeile:
<jdks/>durch:
<jdks>
<jdk>
<name>jdk1.7</name>
<home>C:\Program Files\Java\jdk1.7</home>
<properties/>
</jdk>
</jdks>
Falls Jenkins beim nächsten Windows-Start nicht automatisch startet, obwohl der Dienste-Starttyp auf "Automatisch" steht,
wählen Sie:
"Start" | "Systemsteuerung" | ["System und Sicherheit"] | "Verwaltung" | "Dienste" | Doppelklick auf "jenkins"
und dann entweder:
"Starttyp: Automatisch (Verzögerter Start)"
oder:
Reiter "Wiederherstellung" | "Bei Fehlern: Dienst neu starten" und eine geeignete Wartezeit einstellen.
Falls Jenkins ohne sichtbare Fehlermeldung und ohne Meldung in den Jenkins-Logdateien nicht automatisch startet,
suchen Sie in der Windows-Ereignisanzeige unter der "Quelle" "Service Control Manager" nach Meldungen zu Jenkins,
etwa nach folgenden Fehlermeldungen:
Das Zeitlimit (30000 ms) wurde beim Verbindungsversuch mit dem Dienst jenkins erreicht.
Der Dienst "jenkins" wurde aufgrund folgenden Fehlers nicht gestartet:
Der Dienst antwortete nicht rechtzeitig auf die Start- oder Steuerungsanforderung.
Modifizieren Sie entsprechend der Meldung die Startparameter.
Falls Sie bei korrekt installiertem Jenkins-Dienst nur den Jenkins-Dienst stoppen oder starten wollen, können Sie das net-Kommando verwenden:
net stop jenkins
net start jenkins
Falls Sie den Jenkins-Dienst deinstallieren wollen: Dies können Sie wahlweise über
jenkins.exe uninstall
oder
sc delete jenkins