Unterschiede zwischen Ant und Maven [geschlossen]

Könnte mir jemand die Unterschiede zwischen Ant und Maven erzählen? Ich habe auch nie benutzt. Ich verstehe, dass sie verwendet werden, um das Erstellen von Java-Projekten zu automatisieren, aber ich weiß nicht, wo ich anfangen soll.

In Maven: The Definitive Guide habe ich in der Einleitung über die Unterschiede zwischen Maven und Ant geschrieben. Der Titel des Abschnitts lautet "Die Unterschiede zwischen Ant und Maven" . Hier ist eine Antwort, die eine Kombination der Informationen in dieser Einführung mit einigen zusätzlichen Hinweisen ist.

Ein einfacher Vergleich

Ich zeige Ihnen dies nur, um die Idee zu veranschaulichen, dass Maven auf der einfachsten Ebene integrierte Konventionen hat. Hier ist eine einfache Ant-Build-Datei:

<project name="my-project" default="dist" basedir=".">
    <description>
        simple example build file
    </description>   
    <!-- set global properties for this build -->   
    <property name="src" location="src/main/java"/>
    <property name="build" location="target/classes"/>
    <property name="dist"  location="target"/>

    <target name="init">
      <!-- Create the time stamp -->
      <tstamp/>
      <!-- Create the build directory structure used by compile -->
      <mkdir dir="${build}"/>   
    </target>

    <target name="compile" depends="init"
        description="compile the source " >
      <!-- Compile the java code from ${src} into ${build} -->
      <javac srcdir="${src}" destdir="${build}"/>  
    </target>

    <target name="dist" depends="compile"
        description="generate the distribution" >
      <!-- Create the distribution directory -->
      <mkdir dir="${dist}/lib"/>

      <!-- Put everything in ${build} into the MyProject-${DSTAMP}.jar file
-->
      <jar jarfile="${dist}/lib/MyProject-${DSTAMP}.jar" basedir="${build}"/>
   </target>

   <target name="clean"
        description="clean up" >
     <!-- Delete the ${build} and ${dist} directory trees -->
     <delete dir="${build}"/>
     <delete dir="${dist}"/>
   </target>
 </project>

In diesem einfachen Ant-Beispiel können Sie sehen, wie Sie Ant genau sagen müssen, was zu tun ist. Es gibt ein Kompilierungsziel, das die Javac-Task enthält, die die Quelle im Verzeichnis src / main / java in das Verzeichnis target / classes kompiliert. Sie müssen Ant genau mitteilen, wo sich Ihre Quelle befindet, wo der resultierende Bytecode gespeichert werden soll und wie dies alles in eine JAR-Datei gepackt werden soll. Während es einige neuere Entwicklungen gibt, die dazu beitragen, Ant weniger prozedural zu machen, besteht die Erfahrung eines Entwicklers mit Ant darin, eine in XML geschriebene prozedurale Sprache zu codieren.

Vergleichen Sie das vorherige Ant-Beispiel mit einem Maven-Beispiel. Um in Maven eine JAR-Datei aus einer Java-Quelle zu erstellen, müssen Sie lediglich eine einfache pom.xml erstellen, Ihren Quellcode in $ {basedir} / src / main / java ablegen und dann mvn install über die Befehlszeile ausführen . Das Beispiel Maven pom.xml, das die gleichen Ergebnisse erzielt.

<project>
  <modelVersion>4.0.0</modelVersion>
  <groupId>org.sonatype.mavenbook</groupId>
  <artifactId>my-project</artifactId>
  <version>1.0</version>
</project>

Das ist alles was du in deiner pom.xml brauchst. Wenn Sie mvn install über die Befehlszeile ausführen, werden Ressourcen verarbeitet, die Quelle kompiliert, Komponententests ausgeführt, eine JAR erstellt und die JAR in einem lokalen Repository zur Wiederverwendung in anderen Projekten installiert. Ohne Änderung können Sie mvn site ausführen und dann eine index.html-Datei in target / site finden, die Links zu JavaDoc und einige Berichte über Ihren Quellcode enthält.

Zugegeben, dies ist das einfachste Beispielprojekt. Ein Projekt, das nur Quellcode enthält und eine JAR erzeugt. Ein Projekt, das den Maven-Konventionen folgt und keine Abhängigkeiten oder Anpassungen erfordert. Wenn wir mit der Anpassung des Verhaltens beginnen möchten, wird unsere pom.xml größer, und in den größten Projekten können Sie Sammlungen sehr komplexer Maven-POMs sehen, die eine Vielzahl von Plugin-Anpassungs- und Abhängigkeitsdeklarationen enthalten. Aber selbst wenn die POM-Dateien Ihres Projekts umfangreicher werden, enthalten sie eine völlig andere Art von Informationen als die Build-Datei eines Projekts ähnlicher Größe mit Ant. Maven-POMs enthalten Deklarationen: "Dies ist ein JAR-Projekt" und "Der Quellcode befindet sich in src / main / java". Ant-Build-Dateien enthalten explizite Anweisungen: "Dies ist ein Projekt", "src/main/java"," In javacdiesem Verzeichnis ausführen "," Ergebnisse einfügen in target/classses"," JAR aus dem ... erstellen "usw. Wo Ant den Prozess explizit beschreiben musste, war in Maven etwas" eingebaut " das wusste nur, wo der Quellcode war und wie er verarbeitet werden sollte.

Hochrangiger Vergleich

Die Unterschiede zwischen Ant und Maven in diesem Beispiel? Ameise...

• Es gibt keine formalen Konventionen wie eine gemeinsame Projektverzeichnisstruktur. Sie müssen Ant genau mitteilen, wo sich die Quelle befindet und wo die Ausgabe abgelegt werden soll. Im Laufe der Zeit haben sich informelle Konventionen herausgebildet, die jedoch nicht im Produkt kodifiziert wurden.
• Ist prozedural, müssen Sie Ant genau sagen, was zu tun ist und wann es zu tun ist. Sie mussten es anweisen, zu kompilieren, dann zu kopieren und dann zu komprimieren.
• hat keinen Lebenszyklus, man musste Ziele und Zielabhängigkeiten definieren. Sie mussten jedem Ziel manuell eine Abfolge von Aufgaben zuordnen.

Wo Maven ...

• hat Konventionen, es wusste bereits, wo Ihr Quellcode war, weil Sie die Konvention befolgt haben. Es hat den Bytecode in target / classes abgelegt und eine JAR-Datei in target erstellt.
• ist deklarativ. Sie mussten lediglich eine pom.xml-Datei erstellen und Ihre Quelle im Standardverzeichnis ablegen. Maven kümmerte sich um den Rest.
• hat einen Lebenszyklus, den Sie bei der Ausführung aufgerufen haben mvn install. Dieser Befehl wies Maven an, eine Reihe von Sequenzschritten auszuführen, bis der Lebenszyklus erreicht war. Als Nebeneffekt dieser Reise durch den Lebenszyklus führte Maven eine Reihe von Standard-Plugin-Zielen aus, mit denen beispielsweise eine JAR kompiliert und erstellt wurde.

Was ist mit Efeu?

Richtig, also wird jemand wie Steve Loughran diesen Vergleich lesen und Foul nennen. Er wird darüber sprechen, wie die Antwort etwas namens Ivy völlig ignoriert und dass Ant die Build-Logik in den neueren Versionen von Ant wiederverwenden kann. Das ist wahr. Wenn Sie eine Menge kluger Leute haben, die Ant + Antlibs + Ivy verwenden, erhalten Sie einen gut gestalteten Build, der funktioniert. Obwohl ich sehr davon überzeugt bin, dass Maven Sinn macht, würde ich Ant + Ivy gerne mit einem Projektteam einsetzen, das einen sehr scharfen Bauingenieur hatte. Abgesehen davon denke ich, dass Sie am Ende eine Reihe wertvoller Plugins wie das Jetty-Plugin verpassen und am Ende eine ganze Reihe von Arbeiten erledigen werden, die Sie im Laufe der Zeit nicht erledigen mussten.

Wichtiger als Maven vs. Ant

1. Verwenden Sie einen Repository-Manager, um Software-Artefakte zu verfolgen? Ich würde vorschlagen, Nexus herunterzuladen . Sie können Nexus verwenden, um Remote-Repositorys zu vertreten und Ihrem Team einen Platz zum Bereitstellen interner Artefakte zu bieten.
2. Sie haben eine angemessene Modularisierung der Softwarekomponenten. Eine große monolithische Komponente skaliert selten im Laufe der Zeit. Während sich Ihr Projekt entwickelt, möchten Sie das Konzept von Modulen und Untermodulen haben. Maven eignet sich sehr gut für diesen Ansatz.
3. Sie übernehmen einige Konventionen für Ihren Build. Selbst wenn Sie Ant verwenden, sollten Sie sich bemühen, eine Konvention zu übernehmen, die mit anderen Projekten übereinstimmt. Wenn ein Projekt Maven verwendet, bedeutet dies, dass jeder, der mit Maven vertraut ist, den Build aufnehmen und damit beginnen kann, ohne an der Konfiguration herumspielen zu müssen, um herauszufinden, wie das Ding kompiliert werden kann.

Maven ist ein Framework, Ant ist eine Toolbox

Maven ist ein vorgefertigtes Straßenauto, während Ant ein Satz von Autoteilen ist. Mit Ant müssen Sie Ihr eigenes Auto bauen, aber zumindest wenn Sie im Gelände fahren müssen, können Sie den richtigen Autotyp bauen.

Anders ausgedrückt, Maven ist ein Framework, während Ant eine Toolbox ist. Wenn Sie damit zufrieden sind, innerhalb der Grenzen des Frameworks zu arbeiten, ist Maven in Ordnung. Das Problem für mich war, dass ich immer wieder an die Grenzen des Frameworks stieß und es mich nicht rausließ.

XML-Ausführlichkeit

tobrien ist ein Typ, der viel über Maven weiß, und ich denke, er hat einen sehr guten, ehrlichen Vergleich der beiden Produkte geliefert. Er verglich eine einfache Maven-Datei pom.xml mit einer einfachen Ant-Build-Datei und erwähnte, wie Maven-Projekte komplexer werden können. Ich denke, es lohnt sich, einen Vergleich einiger Dateien anzuschauen, die Sie in einem einfachen realen Projekt eher sehen. Die folgenden Dateien stellen ein einzelnes Modul in einem Build mit mehreren Modulen dar.

Zuerst die Maven-Datei:

<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/maven-4_0_0.xsd">

    <parent>
        <groupId>com.mycompany</groupId>
        <artifactId>app-parent</artifactId>
        <version>1.0</version>
    </parent>

    <modelVersion>4.0.0</modelVersion>
    <artifactId>persist</artifactId>
    <name>Persistence Layer</name>

    <dependencies>

        <dependency>
            <groupId>com.mycompany</groupId>
            <artifactId>common</artifactId>
            <scope>compile</scope>
            <version>${project.version}</version>
        </dependency>

        <dependency>
            <groupId>com.mycompany</groupId>
            <artifactId>domain</artifactId>
            <scope>provided</scope>
            <version>${project.version}</version>
        </dependency>

        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate</artifactId>
            <version>${hibernate.version}</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
            <version>${commons-lang.version}</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring</artifactId>
            <version>${spring.version}</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>org.dbunit</groupId>
            <artifactId>dbunit</artifactId>
            <version>2.2.3</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.testng</groupId>
            <artifactId>testng</artifactId>
            <version>${testng.version}</version>
            <scope>test</scope>
            <classifier>jdk15</classifier>
        </dependency>

        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>${commons-dbcp.version}</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>com.oracle</groupId>
            <artifactId>ojdbc</artifactId>
            <version>${oracle-jdbc.version}</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.easymock</groupId>
            <artifactId>easymock</artifactId>
            <version>${easymock.version}</version>
            <scope>test</scope>
        </dependency>

    </dependencies>

</project>

Und die entsprechende Ant-Datei:

<project name="persist" >

    <import file="../build/common-build.xml" />


    <path id="compile.classpath.main">
        <pathelement location="${common.jar}" />
        <pathelement location="${domain.jar}" />
        <pathelement location="${hibernate.jar}" />
        <pathelement location="${commons-lang.jar}" />
        <pathelement location="${spring.jar}" />
    </path>


    <path id="compile.classpath.test">
        <pathelement location="${classes.dir.main}" />
        <pathelement location="${testng.jar}" />
        <pathelement location="${dbunit.jar}" />
        <pathelement location="${easymock.jar}" />
        <pathelement location="${commons-dbcp.jar}" />
        <pathelement location="${oracle-jdbc.jar}" />
        <path refid="compile.classpath.main" />
    </path>


    <path id="runtime.classpath.test">
        <pathelement location="${classes.dir.test}" />
        <path refid="compile.classpath.test" />
    </path>


</project>

tobrien hat sein Beispiel verwendet, um zu zeigen, dass Maven integrierte Konventionen hat, aber das bedeutet nicht unbedingt, dass Sie am Ende weniger XML schreiben. Ich habe das Gegenteil festgestellt. Die pom.xml ist dreimal länger als die build.xml und das ohne von den Konventionen abzuweichen. Tatsächlich wird mein Maven-Beispiel ohne zusätzliche 54 Zeilen angezeigt, die zum Konfigurieren von Plugins erforderlich waren. Diese pom.xml ist für ein einfaches Projekt. Das XML wächst wirklich erheblich, wenn Sie zusätzliche Anforderungen hinzufügen, was für viele Projekte nicht ungewöhnlich ist.

Aber du musst Ant sagen, was zu tun ist

Mein Ameisenbeispiel oben ist natürlich nicht vollständig. Wir müssen noch die Ziele definieren, die zum Bereinigen, Kompilieren, Testen usw. verwendet werden. Diese werden in einer gemeinsamen Build-Datei definiert, die von allen Modulen im Projekt mit mehreren Modulen importiert wird. Was mich zu dem Punkt führt, wie all dieses Zeug explizit in Ant geschrieben werden muss, während es in Maven deklarativ ist.

Es ist wahr, es würde mir Zeit sparen, wenn ich diese Ant-Ziele nicht explizit schreiben müsste. Aber wie viel Zeit? Die übliche Build-Datei, die ich jetzt verwende, habe ich vor 5 Jahren mit nur geringfügigen Verbesserungen geschrieben. Nach meinem zweijährigen Experiment mit Maven zog ich die alte Ant-Build-Datei aus dem Schrank, wischte sie ab und legte sie wieder an die Arbeit. Für mich haben sich die Kosten, Ant explizit mitteilen zu müssen, über einen Zeitraum von 5 Jahren auf weniger als eine Woche summiert.

Komplexität

Der nächste große Unterschied, den ich erwähnen möchte, ist die Komplexität und der reale Effekt, den sie hat. Maven wurde mit der Absicht entwickelt, die Arbeitsbelastung der Entwickler zu verringern, die mit der Erstellung und Verwaltung von Erstellungsprozessen beauftragt sind. Dazu muss es komplex sein. Leider neigt diese Komplexität dazu, ihr beabsichtigtes Ziel zu negieren.

Im Vergleich zu Ant wird der Build-Typ eines Maven-Projekts mehr Zeit verbringen:

• Dokumentation lesen: Es gibt viel mehr Dokumentation zu Maven, weil Sie so viel mehr lernen müssen.
• Schulung der Teammitglieder: Sie finden es einfacher, jemanden zu fragen, der es weiß, als selbst nach Antworten zu suchen.
• Fehlerbehebung beim Build: Maven ist weniger zuverlässig als Ant, insbesondere die Nicht-Core-Plugins. Außerdem sind Maven-Builds nicht wiederholbar. Wenn Sie von einer SNAPSHOT-Version eines Plugins abhängig sind, was sehr wahrscheinlich ist, kann Ihr Build beschädigt werden, ohne dass Sie etwas geändert haben.
• Schreiben von Maven-Plugins: Plugins werden normalerweise für eine bestimmte Aufgabe geschrieben, z. B. zum Erstellen eines Webstart-Bundles, wodurch es schwieriger wird, sie für andere Aufgaben wiederzuverwenden oder zu kombinieren, um ein Ziel zu erreichen. Daher müssen Sie möglicherweise eine eigene schreiben, um Lücken im vorhandenen Plugin-Set zu umgehen.

Im Gegensatz:

• Die Dokumentation von Ant ist präzise, ​​umfassend und an einem Ort.
• Ameise ist einfach. Ein neuer Entwickler, der versucht, Ant zu lernen, muss nur einige einfache Konzepte (Ziele, Aufgaben, Abhängigkeiten, Eigenschaften) verstehen, um den Rest dessen herauszufinden, was er wissen muss.
• Ameise ist zuverlässig. In den letzten Jahren gab es nicht sehr viele Veröffentlichungen von Ant, da dies bereits funktioniert.
• Ant-Builds sind wiederholbar, da sie im Allgemeinen ohne externe Abhängigkeiten wie Online-Repositorys, experimentelle Plugins von Drittanbietern usw. erstellt werden.
• Ameise ist umfassend. Da es sich um eine Toolbox handelt, können Sie die Tools kombinieren, um nahezu jede gewünschte Aufgabe auszuführen. Wenn Sie jemals Ihre eigene benutzerdefinierte Aufgabe schreiben müssen, ist dies sehr einfach.

Vertrautheit

Ein weiterer Unterschied ist der der Vertrautheit. Neue Entwickler benötigen immer Zeit, um sich auf den neuesten Stand zu bringen. Die Vertrautheit mit bestehenden Produkten hilft in dieser Hinsicht und Maven-Unterstützer behaupten zu Recht, dass dies ein Vorteil von Maven ist. Die Flexibilität von Ant bedeutet natürlich, dass Sie beliebige Konventionen erstellen können. Die Konvention, die ich verwende, besteht darin, meine Quelldateien in einem Verzeichnisnamen src / main / java abzulegen. Meine kompilierten Klassen werden in ein Verzeichnis mit dem Namen target / classes verschoben. Klingt vertraut, nicht wahr?

Ich mag die Verzeichnisstruktur von Maven. Ich denke es macht Sinn. Auch ihr Build-Lebenszyklus. Daher verwende ich in meinen Ant-Builds dieselben Konventionen. Nicht nur, weil es Sinn macht, sondern weil es jedem bekannt ist, der Maven schon einmal benutzt hat.

Ant ist hauptsächlich ein Build-Tool.

Maven ist ein Projekt- und Abhängigkeitsmanagement-Tool (das natürlich auch Ihr Projekt erstellt).

Ant + Ivy ist eine ziemlich gute Kombination, wenn Sie Maven vermeiden möchten.

Nur um noch einige Unterschiede aufzulisten:

• Ant hat keine formalen Konventionen. Sie müssen Ant genau sagen, wo sich die Quelle befindet, wo sich die Ausgänge befinden usw.
• Ameise ist prozedural. Sie müssen Ant genau sagen, was zu tun ist; Sagen Sie ihm, er soll kompilieren, kopieren, dann komprimieren usw.
• Ameise hat keinen Lebenszyklus.
• Maven verwendet Konventionen. Es weiß automatisch, wo sich Ihr Quellcode befindet, solange Sie diese Konventionen befolgen. Sie müssen Maven nicht sagen, wo es ist.
• Maven ist deklarativ; Sie müssen lediglich eine pom.xml-Datei erstellen und Ihre Quelle im Standardverzeichnis ablegen. Maven wird sich um den Rest kümmern.
• Maven hat einen Lebenszyklus. Sie rufen einfach mvn install auf und eine Reihe von Sequenzschritten werden ausgeführt.
• Maven hat Informationen über allgemeine Projektaufgaben. Um Tests auszuführen, führen Sie einfach mvn test aus , solange sich die Dateien am Standardspeicherort befinden. In Ant müssten Sie zuerst die JUnit-JAR-Datei is erstellen, dann einen Klassenpfad erstellen, der die JUnit-JAR enthält, dann Ant mitteilen, wo nach Testquellcode gesucht werden soll, ein Ziel schreiben, das die Testquelle kompiliert, und schließlich die Komponententests ausführen mit JUnit.

Aktualisieren:

Dies kam von Maven: The Definitive Guide . Entschuldigung, ich habe total vergessen, es zu zitieren.

Maven oder Ameise? ist eine sehr ähnliche Frage wie diese, die Ihnen bei der Beantwortung Ihrer Fragen helfen soll.

Was ist Maven? auf der offiziellen Seite.

Bearbeiten: Für ein neues / Greenfield-Projekt würde ich die Verwendung von Maven empfehlen: "Konvention über Konfiguration" spart Ihnen einen angemessenen Zeitaufwand beim Schreiben und Einrichten von Build- und Bereitstellungsskripten. Wenn Sie ant verwenden, wächst das Build-Skript im Laufe der Zeit an Länge und Komplexität. Bei bestehenden Projekten kann es schwierig sein, deren Konfiguration / Layout in das Maven-System zu integrieren.

Maven fungiert sowohl als Abhängigkeitsmanagement-Tool - es kann zum Abrufen von Jars aus einem zentralen Repository oder aus einem von Ihnen eingerichteten Repository verwendet werden - als auch als deklaratives Build-Tool. Der Unterschied zwischen einem "deklarativen" Build-Tool und einem traditionelleren wie ant oder make besteht darin, dass Sie konfigurieren, was erledigt werden muss, nicht wie es erledigt wird. Beispielsweise können Sie in einem Maven-Skript sagen, dass ein Projekt als WAR-Datei gepackt werden soll, und Maven weiß, wie man damit umgeht.

Maven stützt sich auf Konventionen über die Anordnung von Projektverzeichnissen, um seine "Deklarativität" zu erreichen. Beispielsweise gibt es eine Konvention, wo Sie Ihren Hauptcode ablegen, wo Sie Ihre web.xml ablegen, Ihre Komponententests usw., aber Sie können sie auch bei Bedarf ändern.

Sie sollten auch bedenken, dass es ein Plugin zum Ausführen von Ant-Befehlen in Maven gibt:

http://maven.apache.org/plugins/maven-ant-plugin/

Die Archetypen von maven machen den Einstieg in ein Projekt sehr schnell. Zum Beispiel gibt es einen Wicket-Archetyp, der einen Maven-Befehl bereitstellt, den Sie ausführen, um ein ganzes, einsatzbereites Hallo-Welt-Projekt zu erhalten.

https://wicket.apache.org/start/quickstart.html

Ich kann eine Person nehmen, die Ant noch nie gesehen hat - seine build.xmlsind ziemlich gut geschrieben - und sie kann verstehen, was los ist. Ich kann dieselbe Person nehmen und ihnen einen Maven POM zeigen, und sie werden keine Ahnung haben, was los ist.

In einer riesigen technischen Organisation schreiben die Leute darüber, dass Ant-Dateien groß und unüberschaubar werden. Ich habe diese Typen geschrieben und Ant-Skripte bereinigt. Es ist wirklich wichtig, im Voraus zu verstehen, was Sie in Zukunft tun müssen, und eine Reihe von Vorlagen zu entwerfen, die über einen Zeitraum von mehr als drei Jahren auf Änderungen und Skalierungen reagieren können.

Wenn Sie kein einfaches Projekt haben, ist das Erlernen der Maven-Konventionen und der Maven-Methode zur Erledigung von Aufgaben ein ziemlicher Arbeitsaufwand.

Letztendlich können Sie den Projektstart mit Ant oder Maven nicht als Faktor betrachten: Es sind wirklich die Gesamtbetriebskosten. Was die Organisation benötigt, um ihr Build-System über einige Jahre zu warten und zu erweitern, ist einer der Hauptfaktoren, die berücksichtigt werden müssen.

Die wichtigsten Aspekte eines Build-Systems sind das Abhängigkeitsmanagement und die Flexibilität beim Ausdrücken des Build-Rezepts. Es muss etwas intuitiv sein, wenn es gut gemacht ist.

Ich würde sagen, es hängt von der Größe Ihres Projekts ab ... Persönlich würde ich Maven für einfache Projekte verwenden, die ein einfaches Kompilieren, Packen und Bereitstellen erfordern. Sobald Sie einige kompliziertere Dinge erledigen müssen (viele Abhängigkeiten, Erstellen von Zuordnungsdateien ...), würde ich zu Ant ...

Maven beherbergt auch ein großes Repository mit häufig verwendeten Open Source-Projekten. Während des Builds kann Maven diese Abhängigkeiten für Sie herunterladen (sowie Ihre Abhängigkeiten Abhängigkeiten :)), um diesen Teil des Erstellens eines Projekts ein wenig übersichtlicher zu gestalten.