Java-Projekte bauen mit ANT

Build Tools automatisieren den Weg vom Quellcode zum auslieferbaren Programm. Für Java ist ANT das Werkezug der Wahl. In diesem Artikel gehen wir auf die Installation, den Aufbau der Projektdatei und die Modularisierung von ANT ein. Darüber hinaus zeigen wir, wie man ANT auf der Konsole ausführt und wie das Zusammenspiel mit anderen Entwicklungsumgebungen - hier am Beispiel Eclipse - funktioniert.

ANT

ANT ist ein auf der Programmiersprache Java basierendes Build Tool, vergleichbar mit MAKE unter Unix. Das Tool gibt es seit 2000. Es wurde ursprünglich von James Duncan Davidson entwickelt und steht unter der Apache License. ANT ist ein Akronym und steht für "Another Neat Tool", was sich in etwa mit "noch ein hübsches Werkzeug" übersetzen lässt. Gleichzeitig soll mit dem englischen Wort für "Ameise" zum Ausdruck gebracht werden, dass kleine Dinge in der Lage sind, Großes zu vollbringen.

Installation

Die aktuelle Version der Software ist 1.7.1 und kann auf der Homepage des Projekts [1] heruntergeladen werden. Nach dem Entpacken der Zip-Datei muss die Umgebungsvariable ANT_HOME auf das Installationsverzeichnis von ANT gesetzt und das darin enthaltene /bin-Verzeichnis in den Pfad mit aufgenommen werden. Optional kann die Variable JAVA_HOME auf das Installationsverzeichnis von Java gesetzt werden.

Anschließend kann auf der Kommandozeile mit dem Befehl ant -version die korrekte Installation überprüft werden.

Aufbau einer Projekt-Datei

Die Ausführung von ANT wird durch eine XML-Datei mit dem Namen build.xml gesteuert. Diese wird als Projektdatei bezeichnet. Das Root-Element heißt demzufolge auch project. Innerhalb des Projektes kann die Arbeit in mehrere Aufgaben strukturiert werden. Eingeleitet werden diese durch das Element target.

(1) <project name="Meetings" default="deploy" 
(2)	   basedir=".">
(3)	   <description>
(4)	   Dieses Build-File kompiliert die Java-Sourcen, erstellt
(5)	   die Deploy Descriptoren,packt das JAR-File zusammen und
(6)	   deployt das ganze auf dem JBoss-Server.
(7)	   </description>
(8)	
(9)	<!-- Setze globale Properties fuer dieses Build-File -->
(10)   <property name="src" location="src"/>
(11)   <property name="build" location="bin"/>
(12)   <property name="j2eedir" location="C:/jboss-
(13)   4.0.5GA/server/default/lib"/>
(14)   <property name="deploydir" location="C:/jboss-
(15)   4.0.5GA/server/default/deploy"/>
(16)
(17)	<target name="clean" depends="">
(18)		<delete dir="${build}"/>
(19)	</target>
(20)
(21)   <target name="compile" description="Compiliere die Sourcen">
(22)     
(23)		<javac srcdir="${src}" destdir="${build}" 
(24)		classpath="${j2eedir}/jboss-j2ee.jar">
(25)			<include name="**/*.java" />
(26)		</javac>
(27)	</target>	
(28)
(29)	<target name="jar" depends="compile" 
(30)		description="Baut das JAR-File">
(31)		<jar destfile="meetings.jar">
(32)			<fileset dir="${build}">
(33)			  <include 
(34)			  name="de/ordix/meetings/entities/*.class"/>
(35)			  <include 
(36)			  name="de/ordix/meetings/sessions/*.class"/>
(37)			  <include name="META-INF/*"/>
(38)			</fileset>
(39)		</jar>
(40)	</target>
(41)
(42)	<target name="deploy" depends="jar" 
(43)		description="Deployt das JAR-File im JBoss">
(44)		<copy file="meetings.jar" todir="${deploydir}"/>
(45)	</target>
(46)
(47)</project>

(1)	<target name="targetName1">
(2)		<ant antfile="${basedir}/projekt2/build.xml"
(3)			inheritAll="false" target="targetName2">
(5)		</ant>
(6) </target>

ANT bringt einen Werkzeugkasten mit. Dieser enthält Tasks für elementare Operationen, wie kompilieren, kopieren, löschen etc. Dieser Werkzeugkasten kann erweitert werden: Für die Enterprise-Entwicklung werden oftmals Tasks für das Deployment mit der Application Server Software ausgeliefert.

Im Folgenden behandeln wir die wichtigsten Aufgaben, die in einem Java-Projekt anfallen. Als Vorlage dient die XML-Datei aus Abbildung 1. Ein kompletter Überblick über alle Tasks von ANT befindet sich in der Anleitung, die Sie online auf der Internetseite des Projekts finden und die sich zusätzlich im Installationsverzeichnis auf der lokalen Platte befindet.

Globale Variablen

In jeder Datei können mit Hilfe des Elements property globale Variablen definiert werden, die in allen Targets benutzt werden können (siehe Abbildung 1, Zeile 10). Nützlich sind sie vor allem für die Definition von Pfadangaben. So kann die Property mit den Namen src den Ort der Java-Quelldateien festlegen. Auf die Definition kann dann über ${src} zugegriffen werden.

Löschen

Bevor Java-Programme kompiliert werden, müssen die alten Build-Verzeichnisse aufgeräumt bzw. gelöscht werden. Dies lässt sich mit dem clean-Target in Abbildung 1 ab Zeile 17 bewerkstelligen, das mittels delete-Tasks das angegebene Verzeichnis löscht.

Kompilieren

Im Target mit dem Namen compile wird der Task javac benutzt, um alle Sourcen aus dem src-Verzeichnis in Bytecode zu wandeln und im build-Ordner abzulegen (siehe Abbildung 1, Zeile 21). Voraussetzung ist ein installiertes JDK und die Definition der Variablen JAVA_HOME. Optionale Attribute für dieses Element sind unter anderem der Class-path, in dem sich zusätzliche Bibliotheken befinden, die für die Übersetzung benötigt werden. Alle zu kompilierenden Quelldateien werden in einem include-Element angegeben. Dabei kann auch mit Wildcards gearbeitet werden. Eine Alternative ist die Benutzung eines Filesets, wobei ein Verzeichnis angegeben wird, in dem sich alle relevanten Dateien befinden. Als Filter können hier mittels include bzw. exclude die zu verwendenden Files eingeschränkt werden.

Verpacken

Nach dem Kompilieren kann alles in einem Java-Archiv (JAR-File) zusammengepackt werden. Dies übernimmt das hier genannte Target jar in Abbildung 1, ab Zeile 29. Neben dem Archivnamen meeting.jar wird in Filesets die Liste der zu packenden Dateien angegeben.

Entsprechend gibt es Tasks für die Erzeugung von Web- und Enterprise-Archiven (WAR- bzw. EAR-Files). Dort ist es dann auch möglich, die von der JEE-Spezifikation geforderten Verwaltungsverzeichnisse für die Deployment Descriptoren META-INF und WEB-INF anzulegen und zu befüllen.

Verteilen

Nach erfolgreichem Zusammenpacken wird das Archiv - oder auch mehrere - auf dem Application Server "deployed", was im einfachsten Fall einem Kopiervorgang gleichkommt (siehe Abbildung 1, Zeile 42). Dafür existiert der Task copy. Auch hier können einzelne Dateien oder aber ganze Filesets mit Include- bzw. Exclude-Listen angegeben werden.

Ausführung auf der Konsole

Ist die Projektdatei erstellt, kann ANT an die Arbeit gehen. Befindet man sich in einem Verzeichnis, in dem eine build.xml liegt, so reicht ein simples ant auf der Kommandozeile, um die Arbeit mit dem Default Target zu beginnen. Einzelne Targets hingegen lassen sich mittels ant targetname explizit starten. Auch Listen mehrerer Targets sind möglich. Um alle Optionen des Tools auf einen Blick zu bekommen, wird das Kommando ant-help verwendet.

ANT modularisieren

Wenn sich die Java-Projekte häufen und jedes von ihnen eine eigene build.xml besitzt, von denen man gegebenenfalls nur jeweils einzelne Targets ausführen möchte, so besteht die Möglichkeit, ein Buildfile ohne eigene Logik zu schreiben, von dem aus die jeweiligen Ziele der einzelnen Dateien aufgerufen werden. Das Code-Beispiel in Abbildung 2 zeigt einen Ausschnitt aus einem solchen zentralen Build-Skript. Mit Hilfe des Tasks ant wird das Target targetName2 aus der Projektdatei, die im Attibut antfile angegeben ist, ausgeführt.

Auf diese Weise können komplexe Teile in separaten Build-Dateien ausgelagert und gegebenenfalls wiederverwendet werden.

Großer Vorteil des zentralen Skripts ist, dass alle für das Projekt essentiell wichtigen Aufgaben in einer Datei zusammengefasst vorliegen, unabhängig von den tief in den Verzeichnishierarchien versteckten Build-Dateien.

Zusammenspiel mit Eclipse

Neben der klassischen Variante, ANT auf der Kommandozeile zu starten, existieren für eine Reihe von Entwicklungsumgebungen Plugins, um das Werkzeug komfortabel von dort aus zu starten. Dies soll hier exemplarisch an der weit verbreiteten IDE Eclipse [2] demonstriert werden.

Eclipse bietet die Möglichkeit, über das Menü Windows ⇒ Show view ⇒ ANT ein zusätzliches Fenster zu öffnen. Dort können build.xml-Dateien per Drag&Drop importiert oder aber über das Kontextmenü "Add Buildfiles..." ausgewählt und hinzugefügt werden. Jede Build-Datei in der angezeigten Baumstruktur lässt sich auf-/zuklappen, um so die vorhandenen Targets übersichtlich darzustellen. Durch einen Doppelklick auf das jeweilige Target wird dieses sofort ausgeführt. Ein Klick auf die Build-Datei selbst startet das als Default eingestellte Target. Alle bei Ablauf produzierten Ausgaben erscheinen in der Consolen-View von Eclipse, die gegebenenfalls extra eingeschaltet werden muss.

Fazit

Mit ANT steht dem Entwickler ein mächtiges Build Tool zur Verfügung, das etabliert ist und als Quasi-Standard in der Java-Entwicklung eine große Anhängerschaft besitzt. Es ist erweiterbar und in vielen Entwicklungsumgebungen integriert. Einmal erstellte Build-Dateien können durch geringe Anpassungen in fast jedem Folgeprojekt wiederverwendet werden. Dennoch lohnt sich ein Blick auf das als "Nachfolger" gehandelte Werkzeug Maven [3], das auch von Apache stammt [4].

Seitenanfang

Seite drucken

Seite weiterempfehlen