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 das veraltete Maven 1.x eingegangen. Diese Version sollten Sie auf keinen Fall für Neuentwicklungen ensetzen, da aktuellere Versionen viele entscheidende Vorteile bieten (z.B. eigenständige Auflösung von transitiven Abhängigkeiten).
Informationen zu aktuelleren Maven-Versionen finden Sie unter Maven 3 und Maven 2.2.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:
Falls Sie Ant bereits kennen und Maven kennenlernen wollen, wird Sie Maven for Ant Users und Migrating from Ant interessieren.
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.6 |
MAVEN_HOME | D:\Tools\Maven-1.0.2 |
Systemvariable erweitern um: | |
Path | <vorherigerPath>;C:\Program Files\Java\jdk1.6\bin;D:\Tools\Maven-1.0.2\bin |
Falls Sie Eclipse einsetzen,
müssen Sie den Eclipse-Classpath erweitern um den Maven-Repository-Pfad 'MAVEN_REPO'
('%MAVEN_HOME_LOCAL%/repository').
Dies geht am einfachsten über das Maven-Goal
'eclipse:add-maven-repo'
über folgenden Kommandozeilenbefehl (bitte Eclipse-Workspace-Pfad anpassen):
maven -Dmaven.eclipse.workspace=D:\MeinWorkspace eclipse:add-maven-repo
Alternativ können Sie in Eclipse über 'Window' | 'Preferences' | '[+] Java' | '[+] Build Path' | 'Classpath Variables' | 'New...' eingeben (bitte Pfad anpassen):
Eclipse Classpath Variables: | |
MAVEN_REPO | C:\Dokumente und Einstellungen\<BenutzerName>\.maven\repository |
Bzw. je nach Konfiguration: | |
MAVEN_REPO | D:\Tools\Maven1-Repo\repository |
Sehen Sie sich "Quick Start - Building a Project with Maven 1" an.
Unterstützung zur Anlage eines Projekts bietet das 'genapp'-Plug-in, siehe Maven Application Generator Plug-in. Im Folgenden wird jedoch von Hand vorgegangen.
Legen Sie eine Verzeichnisstruktur an. Um so näher Sie sich an die Maven Standard Directory Structure halten, um so einfacher wird die Konfiguration. Zum Beispiel so:
cd \MeinWorkspace
md Mvn1Projekt
cd Mvn1Projekt
md src\main\java\meinpackage
md src\main\resources
md src\test\java\meinpackage
md src\test\resources
md xdocs
tree /F
[\MeinWorkspace] '- [Mvn1Projekt] |- [src] | |- [main] | | |- [java] | | | '- [meinpackage] | | '- [resources] | '- [test] | |- [java] | | '- [meinpackage] | '- [resources] '- [xdocs]
Legen Sie im Projektverzeichnis (im Beispiel: '\MeinWorkspace\Mvn1Projekt') eine leere 'LICENSE.txt' an, sonst beschweren sich einige Maven-Plug-ins.
Legen Sie im Projektverzeichnis den 'Maven Project Descriptor' 'project.xml' an, zum Beispiel so:
<project> <groupId>MeinProjektgruppenKurzname</groupId> <artifactId>MeinProjektKurzname</artifactId> <currentVersion>1.0</currentVersion> <dependencies> <dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>1.2.8</version> </dependency> </dependencies> <build> <sourceDirectory>src/main/java</sourceDirectory> <unitTestSourceDirectory>src/test/java</unitTestSourceDirectory> <resources> <resource> <directory>src/main/resources</directory> </resource> </resources> <unitTest> <includes> <include>**/*Test.java</include> </includes> </unitTest> </build> </project>
Direkt unter '<project ...>' werden allgemeine Projekteigenschaften definiert.
Unter '<dependencies ...>' werden Module definiert, von denen das Projekt abhängig ist
(die hier eingetragene 'log4j'-Abhängigkeit wird eigentlich nicht benbötigt,
sie dient nur der Veranschaulichung).
Unter '<build ...>' werden Vorgaben für zur Erzeugung der Projektergebnisse zu verwendender Quelldateien definiert, wie Pfade und Dateinamensmuster.
Weiteres hierzu finden Sie weiter unten unter project.xml.
Steuern Sie das Verhalten der Maven Plug-ins über Attribute in der 'project.properties' im Projektverzeichnis, zum Beispiel so:
maven.compile.debug=true maven.compile.fork=yes maven.compile.source=1.4 maven.compile.target=1.4
Die möglichen Properties der einzelnen Maven-Plug-ins und Erklärungen dazu finden Sie über die weiter unten unter Plug-ins, Properties und Goals genannten Verweise.
Außer in der 'project.properties'-Datei können auch in weiteren Dateien Properties gesetzt werden, siehe unten.
Legen Sie unter 'main' Ihre Java-Klassen an. Als einfaches Beispiel speichern Sie im Unterverzeichnis 'src\main\java\meinpackage' die folgende Java-Datei 'MeineKlasse.java':
package meinpackage; public class MeineKlasse { private String job; public String getJob() { return job; } public void setJob( String job ) { this.job = job; } public double myMethod( double x ) throws Exception { if( "Quadrat".equalsIgnoreCase( job ) ) return x * x; if( "Wurzel".equalsIgnoreCase( job ) ) return Math.sqrt( x ); throw new Exception( "Fehler: Aufgabe nicht korrekt definiert." ); } }
Wir wollen auch sofort unter 'test' einen JUnit-Test hinzufügen. Speichern Sie im Unterverzeichnis 'src\test\java\meinpackage' die folgende Testdatei 'MeineKlasseTest.java':
package meinpackage; import junit.framework.TestCase; public class MeineKlasseTest extends TestCase { MeineKlasse meineKlasse1; public void setUp() throws Exception { meineKlasse1 = new MeineKlasse(); assertEquals( "Anfangs darf kein Job gesetzt sein.", null, meineKlasse1.getJob() ); } public void tearDown() throws Exception { meineKlasse1 = null; } public void testGetAndSetJob() { meineKlasse1.setJob( "Quadrat" ); assertEquals( "Job muss 'Quadrat' sein.", "Quadrat", meineKlasse1.getJob() ); } public void testDoJobs() throws Exception { meineKlasse1.setJob( "Quadrat" ); assertTrue( "Quadrat von '4' muss '16' sein.", 16. == meineKlasse1.myMethod( 4 ) ); meineKlasse1.setJob( "Wurzel" ); assertTrue( "Wurzel von '4' muss '2' sein.", 2. == meineKlasse1.myMethod( 4 ) ); meineKlasse1.setJob( null ); try { meineKlasse1.myMethod( 4 ); fail( "Exception muss geworfen werden, da kein korrekter Job gesetzt." ); } catch( Exception ex ) {/*ok*/} } }
Speichern Sie im 'xdocs'-Unterverzeichnis die folgende Dokumentationsdatei 'index.xml':
<document> <properties> <title>Mein erstes Maven-Projekt</title> <author email="MeinName@MeineFirma.de">MeinName</author> </properties> <body> <section name="Meine erste Überschrift"> <p> Mein erster Text </p> </section> <section name="Meine zweite Überschrift"> <p> Mein zweiter Text </p> </section> </body> </document>
Öffnen Sie ein Kommandozeilenfenster und geben Sie die folgenden Kommandos ein (passen Sie den Pfad an):
cd \MeinWorkspace\Mvn1Projekt
maven clean
maven java:compile
maven test
maven jar
maven site
Zumindest beim ersten Mal wird eine aktive Internetverbindung benötigt, weil Maven für das Projekt benötigte Plug-ins und Module nachlädt ("Plugin cache will be regenerated", z.B. für 'commons-jelly-....jar', 'commons-lang-2.0.jar', 'antlr-2.7.2.jar', 'junit-3.8.1.jar', 'xml-apis-1.0.b2.jar', 'xerces-2.4.0.jar', ...).
Anschließend ist die Verzeichnisstruktur folgendermaßen erweitert:
[\MeinWorkspace] '- [Mvn1Projekt] |- [src] | |- [main] | | |- [java] | | | '- [meinpackage] | | | '- MeineKlasse.java | | '- [resources] | '- [test] | |- [java] | | '- [meinpackage] | | '- MeineKlasseTest.java | '- [resources] |- [target] | |- [classes] | | '- [meinpackage] | | '- MeineKlasse.class | |- [docs] | | |- index.html | | |- ... | |- [test-classes] | | '- [meinpackage] | | '- MeineKlasseTest.class | |- [test-reports] | | |- TEST-meinpackage.MeineKlasseTest.txt | | '- TEST-meinpackage.MeineKlasseTest.xml | |- MeinProjektKurzname-1.0.jar | |- ... |- [xdocs] | '- index.xml |- LICENSE.txt |- project.properties '- project.xml
'maven clean' löscht alle Ergebnisse durch Löschen des kompletten 'target'-Verzeichnisses.
'maven java:compile' compiliert 'MeineKlasse.java' zu 'MeineKlasse.class'.
'maven test' compiliert 'MeineKlasseTest.java' zu 'MeineKlasseTest.class' und führt den JUnit-Test aus. Das Ergebnis finden Sie in 'target\test-reports\TEST-meinpackage.MeineKlasseTest.txt'.
'maven jar' erzeugt 'MeinProjektKurzname-1.0.jar' (der Name wird in der 'project.xml' definiert, siehe oben).
'maven site' erzeugt viele Dokumentationsdateien. Die Zusammenstellung der Ergebnisse finden Sie in 'target\docs\index.html'. Öffnen Sie diese Datei im Webbrowser. Klicken Sie im 'Project Documentation'-Fenster auf 'Project Info' und 'Project Reports' und sehen Sie sich die erstellten Berichte an:
Project Info | |
Dependencies | Liste der Abhängigkeiten |
Project Reports | |
Checkstyle | Checkstyle Analyse der Coding Rules |
PMD Report | Code Analyse |
JCoverage | Testabdeckung |
Unit Tests | Ergebnisse der JUnit-Tests |
JavaDocs | Die für das Projekt erzeugten Javadocs |
Metrics | JDepend Metric Analyse |
Natürlich müssten einige der Berichterstellungsprogramme (insbesondere 'Checkstyle') zuerst an die eigenen Vorgaben angepasst werden (z.B. an die eigenen Java Coding Conventions).
Bei den Kommandozeilenkommandos sind oben zur Veranschaulichung mehrere Einzel-"Goals" aufgerufen, was oft nicht notwendig ist. Zum Beispiel das genannte 'maven jar' ruft die Goals 'java:compile' und 'test' implizit auf. Dies hat zur Folge, dass bei fehlgeschlagenen JUnit-Tests auch keine .jar-Datei erstellt wird. Will man diese in jedem Fall erhalten, kann man mit folgenden Kommandos entweder trotz Fehler fortfahren oder die Tests komplett überspringen:
maven -Dmaven.test.failure.ignore=true jar
maven -Dmaven.test.skip=true jar
Informationen zu REST-Webservices und zu JAX-RS finden Sie in jee-rest.htm. Dort finden Sie auch REST-Webservices-Beispiele sowohl ohne Maven als auch mit Maven 3.
Das folgende Beispiel definiert die Dependencies teilweise etwas unüblich und inkonsistent. Der Grund ist: Es sollen verschiedene Möglichkeiten von Maven 1 demonstriert werden.
Voraussetzung für das folgende Beispiel ist ein installierter App-Server (z.B. Tomcat, GlassFish, JBoss, WebLogic, ...).
Legen Sie eine Verzeichnisstruktur an, zum Beispiel so:
cd \MeinWorkspace
md Mvn1Rest
cd Mvn1Rest
md src\java\minirestwebservice
md src\webapp\WEB-INF\lib
tree /F
[\MeinWorkspace] '- [Mvn1Rest] '- [src] |- [java] | '- [minirestwebservice] '- [webapp] '- [WEB-INF] '- [lib]
Für dieses Beispiel sollen die JAX-RS-Libs nicht aus dem Maven-Repository bezogen werden, sondern manuell dem Projekt hinzugefügt werden.
Downloaden Sie
jersey-archive-1.1.5.1.zip
von http://jersey.java.net oder von
http://download.java.net/maven/2/com/sun/jersey/jersey-archive/1.1.5.1.
Entzippen Sie das Jersey-Archiv in ein temporäres Verzeichnis und kopieren Sie die vier .jar-Libraries
asm-3.1.jar, jersey-core-1.1.5.1.jar, jersey-server-1.1.5.1.jar
und jsr311-api-1.1.1.jar (oder alle Libs) aus dem jersey-archive-1.1.5.1/lib-Verzeichnis in das
src\webapp\WEB-INF\lib-Verzeichnis.
Erzeugen Sie im Mvn1Rest-Projektverzeichnis die Projekt-Properties-Datei: project.properties
maven.jar.override = on maven.jar.jsr311-api = ${basedir}/src/webapp/WEB-INF/lib/jsr311-api-1.1.1.jar maven.war.src = ${basedir}/src/webapp maven.compile.source = 1.5 maven.compile.target = 1.5
maven.jar.override: Schaltet das Überschreiben von Suchpfaden frei (siehe Handling Dependencies in Maven 1).
maven.jar.jsr311-api: Überschreibt den Suchpfad für das jsr311-api-Artefakt (siehe unten die Bemerkungen hierzu).
maven.war.src: Definiert den Pfad zu den Web-Modul-Dateien.
maven.compile...: Definiert Mindest-Java-Versionen
Weitere Hinweise zu Einstellungen in der project.properties finden Sie über die weiter unten unter Plug-ins, Properties und Goals genannten Verweise.
Erzeugen Sie im Mvn1Rest-Projektverzeichnis den 'Maven Project Descriptor': project.xml
<project> <pomVersion>3</pomVersion> <groupId>Mvn1Rest</groupId> <artifactId>Mvn1Rest</artifactId> <currentVersion>0.0.1</currentVersion> <dependencies> <dependency> <!-- Siehe Eintrag in project.properties: --> <groupId>jsr311-api</groupId> <artifactId>jsr311-api</artifactId> <version>1.1.1</version> <type>jar</type> </dependency> <dependency> <!-- Wird dem WAR-Archiv hinzugefuegt (wegen "war.bundle..."): --> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>1.2.8</version> <type>jar</type> <properties> <war.bundle>true</war.bundle> </properties> </dependency> <dependency> <!-- Nur fuer Tests, nicht im WAR-Archiv: --> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>3.8.1</version> <type>jar</type> </dependency> </dependencies> <build> <sourceDirectory>src/java</sourceDirectory> </build> </project>
Bitte beachten Sie, dass in diesem Beispiel nur die Abhängigkeit zu jsr311-api wirklich benötigt wird. Die Abhängigkeiten zu log4j und junit dienen nur zur Demonstration weiterer Möglichkeiten (siehe unten die Bemerkungen hierzu sowie die Doku zu Maven 1 Web Applications und zum Maven 1 War Plugin).
Allgemeine Erläuterungen zur project.xml finden Sie weiter unten unter project.xml und hier.
Erzeugen Sie im Unterverzeichnis 'src\webapp\WEB-INF' die Web-App-Konfigurationsdatei: web.xml
<?xml version="1.0" encoding="UTF-8"?> <web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5"> <display-name>REST</display-name> <servlet> <display-name>JAX-RS REST Servlet</display-name> <servlet-name>REST-Servlet</servlet-name> <servlet-class>com.sun.jersey.spi.container.servlet.ServletContainer</servlet-class> </servlet> <servlet-mapping> <servlet-name>REST-Servlet</servlet-name> <url-pattern>/rest/*</url-pattern> </servlet-mapping> </web-app>
Erzeugen Sie im Unterverzeichnis 'src\java\minirestwebservice' die REST-Webservice-Klasse: HalloWeltService.java
package minirestwebservice; import javax.ws.rs.*; @Path( "/helloworld" ) public class HalloWeltService { @GET @Produces( "text/plain" ) public String halloText( @QueryParam("name") String name ) { return "Hallo " + name; } @GET @Produces( "text/html" ) public String halloHtml( @QueryParam("name") String name ) { return "<html><title>HelloWorld</title><body><h2>Html: Hallo " + name + "</h2></body></html>"; } }
Erzeugen Sie im Unterverzeichnis 'src\webapp' die JSP-Datei: index.jsp
<html> <body> <h2>REST-Schnittstelle</h2> <p>Aufruf zum Beispiel per:<br> <a href="http://localhost:7001/Mvn1Rest/rest/helloworld?name=ich" target="_blank">http://localhost:7001/Mvn1Rest/rest/helloworld?name=ich</a></p> </body> </html>
Bitte ersetzen Sie an beiden Stellen die Portnummer 7001 durch die zu Ihrem App-Server passende Portnummer (häufig z.B. 8080).
Jetzt sieht die Verzeichnisstruktur so aus:
[\MeinWorkspace] '- [Mvn1Rest] |- [src] | |- [java] | | '- [minirestwebservice] | | '- HalloWeltService.java | '- [webapp] | |- [WEB-INF] | | |- [lib] | | | '- asm-3.1.jar | | | '- jersey-core-1.1.5.1.jar | | | '- jersey-server-1.1.5.1.jar | | | '- jsr311-api-1.1.1.jar | | '- web.xml | '- index.jsp |- project.properties '- project.xml
Öffnen Sie ein Kommandozeilenfenster und geben Sie die folgenden Kommandos ein:
cd \MeinWorkspace\Mvn1Rest
maven war
dir target\*.war
Deployen Sie die WAR-Datei in Ihren App-Server (z.B. Tomcat, GlassFish, JBoss, WebLogic, ...) und testen Sie den REST-Webservice (ersetzen Sie "ich" durch Ihren Namen und "7001" durch die zu Ihrem App-Server passende Portnummer):
start "Mvn1Rest-Test" "http://localhost:7001/Mvn1Rest"
start "Mvn1Rest-Test" "http://localhost:7001/Mvn1Rest/rest/helloworld?name=ich"
Falls Sie cURL installiert haben, können Sie auch damit den REST-Webservice testen (ersetzen Sie wieder "ich" durch Ihren Namen und "7001" durch die zu Ihrem App-Server passende Portnummer):
curl "http://localhost:7001/Mvn1Rest/rest/helloworld?name=ich"
Sehen Sie sich an, welche .jar-Libs dem WAR-Archive hinzugefügt wurden:
dir target\Mvn1Rest\WEB-INF\lib
Die Libs aus src\webapp\WEB-INF\lib sind enthalten, sowie log4j-1.2.8.jar, aber nicht junit-3.8.1.jar:
asm-3.1.jar jersey-core-1.1.5.1.jar jersey-server-1.1.5.1.jar jsr311-api-1.1.1.jar log4j-1.2.8.jar
Bemerkungen zu Sichtbarkeiten, Abhängigkeiten, Lib-Quellen und Lib-Zielen:
Kommando | Bedeutung | Erklärung |
---|---|---|
maven -h | Help | Hilfe zu den Kommandozeilenoptionen von Maven |
maven -u | Usage | Projektspezifische Hilfe und projektspezifische Goals (falls in 'maven.xml' vorgesehen) |
maven -g | Goals | Generell zur Verfügung stehende Goals |
maven -P | Plug-ins | Alle zur Verfügung stehende Plug-ins |
maven -P ... | Plug-in ... | Goals eines einzelnen Plug-ins, z.B.: maven -P jar |
maven -D... | Define arg ... | Definiert Property für Ausführung des Goals, z.B.: maven -Dmaven.test.skip=true jar |
maven -X ... | Debug | Produziert zusätzliche Meldetexte während der Ausführung |
Weitere Hilfe finden Sie unter Command Line Reference und unter den unten genannten Links.
Informationen zu Maven-Plug-ins finden Sie unter:
http://maven.apache.org/reference/plugins und
http://maven-plugins.sourceforge.net/projects-overview.html.
Es folgt eine kleine Auswahl daraus:
Plug-in | Properties | Goals | Erklärung |
---|---|---|---|
Eclipse | maven.eclipse.workspace |
eclipse eclipse:external-tools eclipse:add-maven-repo |
Generiert Eclipse-'.project' und -'.classpath'-Dateien Generiert Einträge in 'externaltools.xml' Setzt in Eclipse die Classpath-Variable 'MAVEN_REPO' |
Clean | clean | Löscht Ergebnisse durch Löschen des 'target'-Verzeichnisses | |
Java |
maven.compile.compilerargs maven.compile.debug maven.compile.fork maven.compile.source maven.compile.target maven.build.dest maven.dependency.classpath |
java:compile | Compiliert die Java-Sourcen |
Test |
maven.junit.fork maven.test.skip maven.test.failure.ignore maven.tomcat.home |
test | Startet die JUnit-Tests |
Jar |
maven.jar.final.name maven.jar.excludes maven.jar.includes maven.jar.mainclass maven.repo.local maven.repo.central maven.repo.central.directory maven.username |
jar jar:install jar:deploy |
Erzeugt .jar-Datei Installiert die .jar-Datei in das lokale Maven-Repository Deployt in das zentrale Maven-Repository |
War |
maven.war.src maven.war.final.name |
war war:inplace |
Erzeugt .war-Dateien für Web-Applikationen Erzeugt Webanwendungsverzeichnis zur Einbindung im App-Server |
Ear | maven.ear.final.name |
ear ear:install ear:deploy |
Erzeugt .ear-Datei Installiert die .ear-Datei in das lokale Maven-Repository Deployt in das zentrale Maven-Repository |
EJB |
maven.ejb.includes maven.ejb.excludes maven.ejb.client.generate |
ejb ejb:install ejb:deploy |
EJB-Jar-Datei (plus event. EJB-Client) erzeugen Installiert EJB ins lokale Maven-Repository Deployt EJB in das zentrale Maven-Repository |
Site |
maven.site.deploy.method maven.scp.executable maven.ssh.executable |
site site:deploy |
Erzeugt viele Berichte (in HTML) Kopiert die HTML-Seiten z.B. zu einem Webserver |
Multi-Project | maven.multiproject... | multiproject:... | Multi-Project-Bearbeitung |
SCM |
maven.scm.username maven.scm.password |
scm:checkout scm:update scm:tag |
Source Control Management, z.B. CVS und Subversion |
Beachten Sie, dass außer in der 'project.properties'-Datei auch in weiteren Dateien und per Kommandozeile ('-D...') Properties gesetzt werden können, siehe unten.
Im Folgenden werden diese Abkürzungen verwendet:
'${basedir}' ist das '<ProjektVerzeichnis>',
z.B. '\MeinWorkspace\MeinProjekt';
'${user.home}' ist das Benutzerverzeichnis,
z.B. 'C:\Dokumente und Einstellungen\<MeinName>'
Maven wird über drei Arten von Steuerdateien gesteuert:
Steuerdatei-Art | Verwendung |
---|---|
${basedir}/project.properties (und diverse weitere Properties- Einstellmöglichkeiten, siehe unten) |
Properties (Eigenschaften), z.B. zur Steuerung der Plug-ins, Beispiele siehe oben und hier |
${basedir}/project.xml | 'Project Descriptor' zur Definition des 'POM' (Project Object Model), Beispiele siehe oben und hier |
${basedir}/maven.xml | Definition eigener Goals (mit Jelly), Beispiele siehe unten, hier und hier |
Über Properties (Attribute, Eigenschaften) in der 'project.properties' und an anderen Stellen wird das Verhalten der Maven Plug-ins gesteuert. Die möglichen Properties der einzelnen Maven-Plug-ins und Erklärungen dazu finden Sie über die oben unter Plug-ins, Properties und Goals genannten Verweise.
Ein Beispiel einer 'project.properties' ist oben gezeigt. Ein anderes Beispiel finden Sie hier.
'Properties' können an verschiedenen Stellen definiert werden, nämlich folgendermaßen (mit aufsteigender Priorität):
Quelle | Bedeutung |
---|---|
Built-in Properties, z.B.: defaults.properties, plugin.properties |
Built-in Properties von Maven und den Plug-ins |
${basedir}/project.properties | Projektspezifische, aber für alle Anwender gleiche Einstellungen; Wird ins CVS bzw. SVN eingecheckt; Beispiel siehe oben |
${basedir}/build.properties | Projektspezifische und benutzerabhängige Einstellungen; Wird nicht eingecheckt; Häufig wird hierfür 'build.properties.sample' als Template vorgesehen |
${user.home}/build.properties | Für alle Projekte dieses Benutzers geltende benutzerabhängige Einstellungen; Z.B. remote Repository URL, Proxy-Einstellungen, Dateipfade |
System-Environment-Variablen ('set ...=...') | Für alle Projekte dieses Benutzers geltende benutzerabhängige Einstellungen |
Kommandozeile ('-D...') | Temporäre Einstellung für ein einzelnes Kommando |
Einige wichtige zentrale 'Properties' (Genaueres siehe Properties Reference und Using Repositories):
Property | Default-Wert | Bedeutung |
---|---|---|
maven.repo.remote | http://www.ibiblio.org/maven | Remote online Repository für Artefakte |
maven.plugin.dir | ${maven.home}/plugins | Remote Plug-ins-Verzeichnis |
maven.home.local | ${user.home}/.maven | Lokales Basisverzeichnis für das Plug-ins- und Artifakte-Verzeichnis |
maven.plugin.unpacked.dir | ${maven.home.local}/plugins | Lokales Plug-ins-Verzeichnis |
maven.repo.local | ${maven.home.local}/repository | Lokales Verzeichnis für Artifakte wie z.B. .jar-Dateien |
Weiter unten wird gezeigt, wie diese und andere Properties leicht angezeigt werden können.
Im Projektbasisverzeichnis ('${basedir}', z.B. '\MeinWorkspace\MeinProjekt') wird in der 'Project Descriptor'-Datei 'project.xml' das so genannte 'POM' (Project Object Model) definiert.
Ein Beispiel einer 'project.xml' ist oben gezeigt und ein anderes Beispiel gibt es hier.
Die wichtigsten darin enthaltenen Blöcke sind '<project ...>', '<dependencies ...>' und '<build ...>':
<project> ... <dependencies> ... </dependencies> <build> ... </build> </project>
Direkt unter '<project ...>' werden allgemeine Projekteigenschaften definiert.
Unter '<dependencies ...>' werden Module definiert, von denen das Projekt abhängig ist.
Unter '<build ...>' werden Vorgaben für zur Erzeugung der Projektergebnisse zu verwendender Quelldateien definiert, wie Pfade und Dateinamensmuster.
Außer den genannten gibt es (optional) noch viele weitere Informationsblöcke, wie zum Beispiel 'developers'.
Folgendermaßen kann zum Beispiel die SCM-Verbindung zu einem CVS-Server konfiguriert werden:
<repository> <url> http://cvs.apache.org/viewcvs.cgi/jakarta-cactus/ </url> <connection> scm:cvs:pserver:anoncvs@cvs.apache.org:/home/cvspublic:jakarta-cactus </connection> <developerConnection> scm:cvs:ext:MeinName@MeinHost:/cvs/root:MeinModul </developerConnection> </repository>
Und so für einen Subversion-Server:
<repository> <url> http://svn.apache.org/repos/asf/struts/core/trunk </url> <connection> scm:svn:http://svn.apache.org/repos/asf/struts/core/trunk </connection> <developerConnection> scm:svn:https://svn.apache.org/repos/asf/struts/core/trunk </developerConnection> </repository>
In beiden Fällen bedeutet:
'<url ...>': URL, um das Repository per Webbrowser zu erforschen
'<connection ...>': Nur-Lese-Zugriff
'<developerConnection ...>': Schreibzugriff
Genauere Erklärungen zu diesen und vielen weiteren Tags und Attributen finden Sie in http://maven.apache.org/maven-1.x/reference/project-descriptor.html.
Im Projektbasisverzeichnis ('${basedir}', z.B. '\MeinWorkspace\MeinProjekt') kann die Datei 'maven.xml' angelegt werden. Diese Datei wird normalerweise nicht benötigt. Der Hauptzweck ist die Definition weiterer speziell für dieses Projekt benötigter 'Goals'.
Goals werden über die spezielle Sprache 'Jelly' definiert, zum Beispiel folgendermaßen:
<?xml version="1.0" encoding="UTF-8"?> <project default="java:compile" xmlns:j="jelly:core" xmlns:u="jelly:util"> <goal name="meinGoal1"> <echo>Delete some files...</echo> <delete> <fileset dir="${basedir}/src/test/resources/"> <include name="*Test.*"/> </fileset> </delete> <attainGoal name="meinGoal2"/> </goal> <goal name="meinGoal2"> ... </goal> <preGoal name="ejb:init"> <j:set var="maven.test.skip.orig" value="${maven.test.skip}"/> <j:set var="maven.test.skip" value="true"/> </preGoal> <postGoal name="ejb:ejb"> <j:set var="maven.test.skip" value="${maven.test.skip.orig}"/> <attainGoal name="test:test"/> </postGoal> </project>
Komplette Beispiele einer 'maven.xml' können zum Beispiel hier und hier angesehen werden.
Weiteres hierzu finden Sie unter:
http://maven.apache.org/reference/user-guide.html#maven_xml
http://maven.apache.org/reference/scripting.html
http://jakarta.apache.org/commons/jelly
Falls Unklarheit über Werte von Properties besteht, können diese leicht ausgegeben werden, indem ein entsprechendes Goal definiert wird:
<?xml version="1.0" encoding="UTF-8"?> <project> <goal name="ShowProperties" description="Show some Properties"> <echo>user.home = ${user.home}</echo> <echo>maven.home.local = ${maven.home.local}</echo> <echo>maven.plugin.unpacked.dir = ${maven.plugin.unpacked.dir}</echo> <echo>maven.repo.local = ${maven.repo.local}</echo> <echo>maven.repo.remote = ${maven.repo.remote}</echo> <echo>maven.plugin.dir = ${maven.plugin.dir}</echo> <echo>basedir = ${basedir}</echo> </goal> </project>
Wenn es noch keine 'maven.xml' gibt, wird alles in eine 'maven.xml'-Datei gespeichert. Wenn es schon eine gibt, wird der Goal-Teil von '<goal …>' bis '</goal>' dieser hinzugefügt. Wenn Sie anschließend auf der Kommandozeile 'maven ShowProperties' aufrufen, erhalten Sie eine Ausgabe ähnlich zu:
ShowProperties: [echo] user.home = C:\Dokumente und Einstellungen\MeinName [echo] maven.home.local = C:\Dokumente und Einstellungen\MeinName/.maven [echo] maven.plugin.unpacked.dir = C:\Dokumente und Einstellungen\MeinName/.maven/cache [echo] maven.repo.local = C:\Dokumente und Einstellungen\MeinName/.maven/repository [echo] maven.repo.remote = http://www.ibiblio.org/maven [echo] maven.plugin.dir = D:\Tools\Maven-1.0.2/plugins [echo] basedir = D:\MeinWorkspace\MeinProjekt
Falls Sie Eclipse einsetzen, beachten Sie Folgendes:
Auschecken über Eclipse:
Alternativ Auschecken über ein anderes Tool (z.B. WinCVS):
Falls Sie Maven nicht nur als Anwender nutzen wollen, sondern die Maven-Konfiguration bearbeiten wollen, sollten Sie sich 'Mevenide for Eclipse' ansehen:
http://mevenide.codehaus.org/mevenide-ui-eclipse
Es bietet Unterstützung für: Maven-Konfiguration, Maven Repository Browser, Editieren der project.xml u.a.