Maven 1.0

+ Maven 3
+ maven.apache.org
+ andere TechDocs
+


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.



Inhalt

  1. Vergleich mit Ant
  2. Installation von Maven 1
  3. Einfaches Projekt mit Maven 1
    Verzeichnisstruktur, project.xml, project.properties, MeineKlasse, MeineKlasseTest, xdocs, Maven-Kommandos, Target, Site
  4. Einfaches REST-Webservices-Projekt
    Start-Verzeichnisstruktur, JAX-RS-Libs, project.properties, project.xml, web.xml, HalloWeltService.java, index.jsp, Fertige Verzeichnisstruktur, Anwendung starten, Bemerkungen zu Sichtbarkeiten, Abhängigkeiten, Lib-Quellen und Lib-Zielen
  5. Hilfe-Kommandos
  6. Plug-ins, Properties und Goals
  7. Konfiguration von Maven
    Steuerdateien, Properties, project.xml, maven.xml
  8. Eclipse
  9. Links


Vergleich mit Ant

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.



Installation von Maven 1

  1. Downloaden Sie ein aktuelles Java SE JDK von http://www.oracle.com/technetwork/java/javase/downloads und installieren Sie es zum Beispiel nach 'C:\Program Files\Java\jdk1.6', so wie beschrieben unter java-install.htm.
  2. Downloaden Sie von http://maven.apache.org die gewünschte Maven-1-Version, zum Beispiel 'maven-1.0.2.exe' von http://maven.apache.org/maven-1.x/start/download.html.
  3. 'maven-1.0.2.exe' ausführen, als Zielverzeichnis zum Beispiel 'D:\Tools\Maven-1.0.2' angeben.
  4. 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_HOMEC:\Program Files\Java\jdk1.6
    MAVEN_HOMED:\Tools\Maven-1.0.2
    Systemvariable erweitern um:
    Path<vorherigerPath>;C:\Program Files\Java\jdk1.6\bin;D:\Tools\Maven-1.0.2\bin
  5. 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_REPOC:\Dokumente und Einstellungen\<BenutzerName>\.maven\repository
    Bzw. je nach Konfiguration:
    MAVEN_REPOD:\Tools\Maven1-Repo\repository
  6. Sehen Sie sich "Quick Start - Building a Project with Maven 1" an.



Einfaches Projekt mit Maven 1

  1. Unterstützung zur Anlage eines Projekts bietet das 'genapp'-Plug-in, siehe Maven Application Generator Plug-in. Im Folgenden wird jedoch von Hand vorgegangen.

  2. 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]
    
  3. Legen Sie im Projektverzeichnis (im Beispiel: '\MeinWorkspace\Mvn1Projekt') eine leere 'LICENSE.txt' an, sonst beschweren sich einige Maven-Plug-ins.

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

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

  6. 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." );
      }
    }
    
  7. 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*/}
      }
    }
    
  8. 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>
    
  9. Ö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', ...).

  10. 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
    DependenciesListe der Abhängigkeiten
    Project Reports
    CheckstyleCheckstyle Analyse der Coding Rules
    PMD ReportCode Analyse
    JCoverageTestabdeckung
    Unit TestsErgebnisse der JUnit-Tests
    JavaDocsDie für das Projekt erzeugten Javadocs
    MetricsJDepend 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



Einfaches REST-Webservices-Projekt

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.

  1. Voraussetzung für das folgende Beispiel ist ein installierter App-Server (z.B. Tomcat, GlassFish, JBoss, WebLogic, ...).

  2. 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]
    
  3. 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.

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

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

  6. 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>
    
  7. 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>";
       }
    }
    
  8. 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).

  9. 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
    
  10. Ö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
    
  11. Bemerkungen zu Sichtbarkeiten, Abhängigkeiten, Lib-Quellen und Lib-Zielen:



Hilfe-Kommandos

KommandoBedeutungErklä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.



Plug-ins, Properties und Goals

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-inPropertiesGoalsErklä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.



Konfiguration von Maven

Steuerdateien

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-ArtVerwendung
${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

Properties

Ü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):

QuelleBedeutung
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):

PropertyDefault-WertBedeutung
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.

project.xml

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.

maven.xml

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


Eclipse

Falls Sie Eclipse einsetzen, beachten Sie Folgendes:

  1. Erweitern Sie den Eclipse-Classpath um den Maven-Repository-Pfad-Eintrag 'MAVEN_REPO', wie oben beschrieben ist.
  2. Um ein Projektmodul erstmalig aus CVS oder Subversion zu laden, führen Sie folgende Schritte aus:

    Auschecken über Eclipse:

    1. Checken Sie das Projektmodul aus wie beschrieben für CVS bzw. Subversion
    2. Führen Sie im Kommandozeilenfenster im Projektmodulverzeichnis aus:
      maven eclipse
    3. Wichtig: Jetzt müssen Sie in Eclipse im 'Package Explorer' die Projektmodule markieren und mit 'F5' einen 'Refresh' ausführen
    4. Erst anschließend die Projekt-'Properties' und die 'Problems' überprüfen

    Alternativ Auschecken über ein anderes Tool (z.B. WinCVS):

    1. Checken Sie das Projektmodul aus
    2. Führen Sie im Kommandozeilenfenster im Projektmodulverzeichnis aus:
      maven eclipse
    3. Importieren Sie das Projektmodul in Eclipse über:
      'File' | 'Import...' | 'Existing Projects into Workspace' | 'Select root directory'
    4. Überprüfen Sie die Projekt-'Properties' und die 'Problems'
  3. Während der üblichen Entwicklungszyklen kann es je nach Projektkonfiguration und Projektabhängigkeiten erforderlich sein, folgende Schritte nach jedem 'Update' des Projektmoduls auszuführen:
    1. 'Update' des Projektmoduls aus CVS bzw. Subversion
    2. Im Kommandozeilenfenster im Projektmodulverzeichnis ausführen:
      maven eclipse
    3. Wichtig: Nach jedem 'maven eclipse'-Aufruf müssen in Eclipse im 'Package Explorer' die Projektmodule markiert werden und muss mit 'F5' ein 'Refresh' ausgeführt werden

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.



Links





Weitere Themen: andere TechDocs | maven.apache.org
© 2007 Torsten Horn, Aachen