Ant im Detail

Schulung

„Ant im Detail“
© 2008 - 2009 Jörn Dinkla

joern@dinkla.com

http://www.dinkla.com

© 2008 - 2009 Jörn Dinkla, http://www.dinkla.com

Vorstellung
• Dipl.-Inform. Jörn Dinkla
• Schwerpunkte
• Java Entwicklung (J2SE, JEE)
• Moderne Programmiersprachen
• Groovy, Ruby, Haskell, Scala
• Modellgetriebene Entwicklung
• Automatisierung
• Eclipse-Plugin-Entwicklung
• CUDA, OpenCL
• Business-Intelligence
• Hobbies
• Musik, Literatur

© 2008 - 2009 Jörn Dinkla, http://www.dinkla.com 2

Überblick


Überblick
• Einführung und Kennenlernen
• Überblick über Build-Prozesse
• Ant-Grundkurs
• Java-Projekt zum Kennenlernen
• Ant auf der Kommandozeile
• Die Datentypen von Ant
• Die Tasks von Ant
• Ant und IDEs
• Ant erweitern

• Zwischendurch
• Hands-on
• Gemeinsam mit Ant entwickeln

Build-Prozesse und -Tools


Was ist ein Build-Prozess ?
• Von den Artifakten zum installierten Produkt
• Graph mit Abhängigkeiten (DAG)
• Workflow

UML Java

XML Generieren JSP Kompilieren
... ...
Fehler-
Testen
Reports

Ausführen Installieren Packen


Automatisierung von Build-Prozessen
• Warum ?
• Zeitersparnis
• Es gibt bessere Dinge zu tun
• Sicherheit, da manuelle Ausführung fehleranfällig ist
• „Durch Langeweile entstehen Fehler“
• Welche Prozesse ?
• Daumenregel: Wenn mehr als zweimal durchgeführt
• Und man diese genau genug kennt
• Welche Arten ?
• befehlsgesteuert
• zeitgesteuert
• ereignisgesteuert

Automatisierung von Build-Prozessen
• Wann ?
• hängt vom Prozess und der Situation ab
• Zeitdauer
• die benötigten Ressourcen
• Sollten so oft wie möglich laufen

• Was wird benötigt ?
• Versionsverwaltung
• Automatisierte Tests
• Skripte (Installation, etc.)
• Rückmeldung
• Email, Web-Seiten, Lavalampen


Das Ideal: CRISP
• CRISP-Builds
• vollständig („complete“)
• von Grund auf neu erstellt
• keine manuell hinzugefügten Dateien
• wiederholbar („repeatable“)
• durch Versionskontrolle jederzeit konsistent
• informativ („informative“)
• Gesundheitszustand der Software, Tests
• planbar („schedulable“)
• Rund um die Uhr lauffähig -> frühe Fehlerentdeckung
• portable („portable“)
• Keine Abhängigkeiten an speziellen Rechner


Build-Tools
• Sind „Programmiersprachen“ für
• die Erstellung
• und die Ausführung von Build-Prozessen

• Die bekanntesten sind
• Make
• sehr alt (1977, Bell Labs)
• sehr viele Varianten
• Ant
• Maven
• MSBuild (VisualStudio)
• nur Windows


Make
• Tool aus der Unix-Welt
• Ursprünglich für die Entwicklung in C
• Transformationen von Dateien mit externen Programmen
• Daher plattformabhängig
• Tab‘s an bestimmten Stellen notwendig
• Hier ein Ausschnitt aus dem Manual von GNUmake
• „generiert aus *.c Datei ein Makefile *.d“
%.d: %.c
@set -e; rm -f $@;
$(CC) -M $(CPPFLAGS) $< > $@.$$$$;
sed 's,($*).o[ :]*,1.o $@ : ,g' < $@.$$$$ > $@;
rm -f $@.$$$$
• siehe http://www.gnu.org/software/make/manual/
make.html

Maven
• Ist wie Ant ein Apache-Projekt
• „Project management and comprehension tool“
• „comprehension“ = Begreifen, Erfassen, Verstehen
• Maven bietet
• Einheitliches Build-System
• Informations-Infrastruktur
• Bibliotheken, Test-Reports, Abhängigkeiten
• Richtlinien für „Best Practices“
• Maven erfordert
• Einhaltung der „Best practices“ und Projektstruktur
• Bei Abweichungen ist viel Arbeit notwendig
• Übergang von „Benutzer von Maven“ zu „Plugin-
Maintainer“ kann hart und zeitintensiv sein

Ant
• Apache Ant (http://ant.apache.org/)
• Quasi-Standard in der Java-Welt
• Basiert auf abstrakter Sicht
• Targets, deren Abhängigkeiten
• und Tasks
• Pluspunkte
• Einfach erweiterbar
• Performant
• Lebendige Community, Open Source
• viele Erweiterungen
• Testing integriert
• in viele Entwicklungsumgebungen integriert

Möglichkeiten mit Ant
• Grundsatz: „Alles, was auf der JVM läuft, läuft mit Ant.“
• Vielzahl an Möglichkeiten mit Ant
• Archive
• Datenbanken
• Dateien
• Java
• Netzwerk
• Prozesse
• Softwareentwicklung
• Testing
• Versionsverwaltung
• XML


Möglichkeiten: Archive
• Ant kann folgende Formate erstellen und lesen
• Zip
• Tar
• Jar, War, Ear
• Rpm
• Cab (Microsoft)
• Komprimierungsverfahren
• Gzip
• Bzip2
• Jars können signiert werden


Möglichkeiten: Dateien
• Operationen für Dateien und Verzeichnisse
• Anlegen, Löschen, Kopieren, Bewegen, Umbenennen,
Konkatenieren
• Transformieren
• String-Ersetzungen
• Ersetzung mit regulären Ausdrücken
• Komprimieren
• Checksummen, z. B. MD5
• Zugriffsrechte, Benutzer und Gruppen
• Patch


Möglichkeiten: Java
• Kompilieren
• Sun, Jikes, MS, Kopi, GCJ, Symantec
• Jar, War und Ear-Archive erstellen
• inkl. Erstellung von MANIFEST.MF
• Java-Klassen ausführen
• JUnit-Tests durchführen
• HTML-Reports erstellen
• Javadoc erzeugen
• Verschiedenes
• Dependencies (JDepend)
• Apt (Annotation Processor Tool)
• Rmic (Java RMI stub compiler)

Möglichkeiten: Netzwerk
• Ant kann die meisten Netzwerkprotokolle.
• Zugriff auf Sockets
• FTP
• HTML Get, Post
• Testen: HTML-Clients für JUnit
• Email
• scp
• Prozesse mit ssh ausführen
• Rexec (remote execution)
• Telnet
• WebDAV


Möglichkeiten: Softwareentwicklung
• Support für „Skriptsprachen“
• JavaScript, AWK, Groovy, Haskell, Python, Ruby,
Scheme, Tcl, BeanShell, JLog, NetRexx, Scala, XSLT
und viele mehr
• Parsergeneratoren
• ANTLR, JavaCC
• Code-Qualität
• Checkstyle, PMD, Findbugs, JavaNCSS
• Generierung
• XDoclet
• J(2)EE
• verschiedene Applikationsserver, Apache Tomcat
• EJB2

Möglichkeiten: Testing
• Allgemein
• JUnit („ist integriert“), 3.8 vs. 4.0
• Cobertura (Testabdeckung)
• JMeter (Performance und Lasttest)
• TestNG, Fitnesse
• Datenbank
• DbUnit (Datenbank)
• Applikation Server
• JUnitEE
• Apache Cactus
• Web
• HtmlUnit, HttpUnit, Canoo Web Test
• XMLUnit

Möglichkeiten: Prozesse
• Prozesskontrolle
• Externe Prozesse
• Aufruf von Shell-Kommandos
• Mächtig, aber nicht platformunabhängig
• Java-Klassen ausführen
• können Ant-Prozess überdauern
• Ant-Build-Prozesse
• Aufruf von anderen Ant-Build-Skripts
• Import von Definitionen


Möglichkeiten: Verschiedenes
• Datenbanken
• Die Anbindung erfolgt über JDBC
• SQL Statements absetzen

• Management von Java-Bibliotheken
• Ivy
• Funktionalität ähnlich Maven


Möglichkeiten: Versionsverwaltung
• Versionsverwaltungen
• CVS
• Subversion (SVN)
• ClearCase™
• Continuus™
• Perforce™
• PVCS™
• StarTeam™
• VisualSourceSafe™

• CVS und Subversion sind Open Source.


Möglichkeiten: XML
• XML
• XML Dateien erstellen
• XML-Dateien transformieren
• XSLT
• Validierung
• Nach DTD
• Nach XML-Schema


Ant-Grundlagen


Apache Ant

• Ant-Dateien sind in XML geschrieben.
• Default: build.xml.

<?xml version="1.0"?>

<project name="Tutorial" Projekt
default="build">
Target

<target name="build">

<echo message="Hallo Welt!" /> Task
<echo message="Hallo, nochmal" />

</target>
Task

</project>


Erinnerung: XML

• XML
• Elemente („tags“) und Attribute
• Starttags und Endtags, verkürzter Endtag ‚/>‘
• Hierarchie mit Baumstruktur
• DOM „document object model“
• <project name="Tutorial" default="build">


<echo message="Hallo Welt!" />

</target>

</project>
Elemente Attribute


Erinnerung: XML-Baumstruktur
• <project name="Tutorial" default="build">



</target>

</project> project
name=“Tutorial
“

target
name=“build

echo echo
message=“Hallo, Welt“ message=“Hallo,

Ausführen des Beispiels
• Ausführen des Skripts.
• -f gibt den Dateinamen an, Default ist: build.xml

• Informationen:
• Build-Datei, Targets, Tasks („[echo]“), Status, Dauer

Aufbau
• In einem Build-File befindet sich ein Projekt
• Projekte können andere Projekte importieren
• Ein Projekt besteht aus Targets
• Targets können voneinander abhängig sein
• Ein Target besteht aus Tasks
• Sequentielle oder parallele Abarbeitung
• Ein Task wird in einer Java-Klasse implementiert.
• deshalb ist Ant erweiterbar
• „dynamic XML binding“


Beispiel für Aufbau

<?xml version="1.0"?>

<project name="Tutorial" default="all"> Projekt

<target name="hallo">
Target


</target> Task

<target name="ende">
Target

<echo message="Ende Welt!" />

</target> Task

<target name="all"
depends="hallo, ende" /> Target

</project>
• Attribut default definiert Default-Target
• Attribut depends definiert Abhängigkeiten

Abhängigkeiten
• Targets können als Argument übergeben werden


Abhängigkeiten und Ausführung
• Abhängigkeiten sind transitiv
• Wenn a von b abhängt und b von c,
• dann hängt a auch von c ab.
• a ← b und b ← c, dann a ← c

• Die Bestimmung der Reihenfolge
• geschieht einmalig am Anfang
• topologische Sortierung eines DAGs


Abhängigkeiten visualisieren
• Abhängigkeiten können komplex werden
• Tools, um Ant-Projektdateien zu visualisieren
• Nicht editieren!
• Linguine Maps

• yEd


Komplexe Abhängigkeiten
• Abhängigkeiten können komplex werden.
• Siehe die Build-Datei von Hibernate 3.0


Beispiel für Abhängigkeiten
<target name="a">
<echo>a</echo></target>
<target name="b" depends="a">
<echo>b</echo></target>
<target name="c1" depends="b">
<echo>c1</echo></target>
<target name="c2" depends="a,b">
<target name="c3" depends="b,a">
<target name="d" depends="c2,c1,c3">

<echo>d</echo></target>


Beispiel für Abhängigkeiten
• $ ant c1
• ➙ a, b, c1
• $ ant c2
• ➙ a, b, c2
• $ ant c3
• ➙ a, b, c3
• $ ant d
• ➙ a, b, c2, c1, c3, d

• Aber bei mehreren Targets:
• $ ant b a
• ➙ a, b, a

Mehr als ein Target als Argument
• Bei mehreren Targets auf der
Kommandozeile aufpassen !


Abhängigkeiten und Ausführung
• Aus historischen Gründen (Kompatibilität)
• Mehrere Targets auf der Kommandozeile werden einzeln
ausgeführt
• Deshalb ruft
•$ ant b a
• zuerst b auf (erstes Argument)
• Dieses hängt von a ab.
• Daher wird a aufgerufen.
• Dann wird b ausgeführt.
• Dann kommt das zweite Argument a.
• Daher wird a noch einmal aufgerufen.
• Sequenz: a, b, a


Ant Grundkurs - Beispiel


Eine Beispielanwendung
• Sehr, sehr einfache Version des „Doktors“ des Emacs-
Editors
• Gibt nur einen zufälligen String zurück


Verzeichnisstruktur
• Die Projektstruktur
• build.xml in der Wurzel
• Sourcen in src
• Tests in test
• Bibliotheken in lib
• Klassen in build/classes
• Jar in build
• Distribution in dist


Der Build-Prozess
• Build-Prozess für einfaches Java-Projekt.
• Targets
• Clean zum Saubermachen
• Init
• Compile
• Execute
• JUnit
• Jar
• Dokumentation mit Javadoc
• Packeterstellung mit zip
• Deployment mit Ftp


Verzeichnisse anlegen und löschen
• Verzeichnisse können mit mkdir angelegt werden.
<project name="project" default="compile">
<target name="init">
<mkdir dir="build"/>
<mkdir dir="build/classes"/>
</target>

• Mit delete können sie wieder entfernt werden.

<target name="clean">
<delete dir="build"/>
</target>
</project>


Java kompilieren
• Mit javac können Java-Dateien kompiliert werden.

<target name="compile" depends="init">
<javac srcdir="src" destdir="build/classes"/>
</target>

• Das Attribut srcdir gibt das Quellverzeichnis an.
• Alle *.java Dateien werden kompiliert
• Auch in Unterverzeichnissen
• Das Attribut destdir gibt das Ziel für die *.class Dateien
an.
• Das build-Verzeichnis wird benötigt.
• Deshalb abhängig von init.

Java ausführen
• Zum Testen einfacher Anwendungen nützlich

• <target name="execute" depends="compile">
<java classname="beispiel.Doctor"
classpath="build/classes"/>
</target>

• Target ist abhängig von der Kompilierung
• Das Attribut classname bestimmt die Klasse, deren main()-
Methode aufgerufen wird.
• Das Klassenpfad wird mit classpath bestimmt.


Im Überblick
<delete dir="build"/> Säubern
</target>
<target name="init" depends="clean" >
Verzeichnisse
</target>
<target name="compile" depends="init"> Kompilieren
</target>
<target name="execute" depends="compile">
classpath="build/classes"/> Ausführen
</target>

Redundanzen und DRY
<delete dir="build"/>
</target>
<target name="init" depends="clean" >
</target>
</target>
classpath="build/classes"/>
</target>

Lösung: Properties
<property name="build.dir" location="build"/>
<property name="classes.dir" value="build/classes"/>
<delete dir="${build.dir}"/>
</target>
<target name="init">
<mkdir dir="${build.dir}"/>
<mkdir dir="${classes.dir}"/>
</target>
<javac srcdir="src" destdir="${classes.dir}"/>
</target>
classpath="${classes.dir}"/>
</target>


Properties
<property name="classes.dir" value="build/classes"/>
• location ermittelt die vollen Pfadnamen
• Bei value wird der Wert selbst genommen
• Properties sind Konstanten
• Einmal gesetzt, ändern sie sich nicht mehr
• Ermöglich Steuerung des Skripts von außen
•$ ant -f build1.xml -Dbuild.dir=bauverzeichnis
• Erstellt die Dateien im Verzeichnis bauverzeichnis
• Properties können auch aus Property-Dateien gelesen
werden

• ... später mehr dazu ...

JUnit-Tests
• Wir müssen jetzt die Dateien
in src und test kompilieren.
• Wir benötigen die
JUnit-Jar-Datei.


JUnit-Tests
• Wir führen einen Pfad path ein.

<property name="test.dir" value="test" />
<path id="path.compile">

<path location="${classes.dir}"/>

<path location="lib/junit-3.8.1.jar"/>
</path>

• Ein Pfad ist ein Datentyp von Ant (später mehr).
• Der Pfad besteht aus dem Verzeichnis für die Klassen und
der JUnit-Jar-Datei.


JUnit-Tests
• Diesen definierten Pfad benutzen wir im javac-Task mit
refid.

<javac srcdir="${src.dir}:${test.dir}"
destdir="${classes.dir}">

<classpath refid="path.compile"/>

</javac>
</target>
• In srcdir werden die Properties mit einem Doppelpunkt
getrennt.


Kompilieren in src und test
• Wir überprüfen die Änderungen

• Es werden drei Dateien kompiliert, richtig.


JUnit-Test-Task im Überblick
• Den Pfad benutzen wir wieder.
<target name="junit" depends="compile">
<junit>
<classpath refid="path.compile" />
<formatter type="brief" usefile="false"/>
<batchtest todir=".">
<fileset dir="${classes.dir}">
<include name="**/*Test.class" />
<exclude name="**/Abstract*Test.class" />
</fileset>
</batchtest>
</junit>
</target>

JUnit-Tests
• Für den formatter gibt es: brief und xml.
<formatter type="brief" usefile="false"/>
• Batchtest führt mehrere Tests aus.
</fileset>
</batchtest>
• Ein Fileset ist eine ungeordnete Menge von Dateien.
• Muster mit include und exclude
• ... später dazu mehr ...


JUnit-Tests
• JUnit meldet einen Fehler, Ant meldet SUCCESSFUL

• Aber: Bugs sollen nicht ausgeliefert werden!


JUnit-Tests
• Wir müssen dem JUnit-Task mitteilen, welches Property
er bei einem Error oder bei einer Failure setzen soll.
<target name="junit" depends="compile">
<junit errorproperty="test.failed"
failureproperty="test.failed"> ...
</junit>
<fail message="JUnit tests failed!"
if="test.failed" />
</target>
• Anschliessend wird der Task fail benutzt, falls das
Property gesetzt ist.
• Bedingte Ausführung von Tasks mit if und unless.
• Damit ist der Build gescheitert.

Versagen erwünscht
• Das ist das gewünschte Ergebnis.


JUnit-Tests
• Wir möchten auch einen HTML-Report des JUnit-Tests.
• Wir benötigen ein Verzeichnis für die Dateien.
<property name="junit.dir" value="junit" />
• Wir benutzen den XML-Formatter und schreiben in dieses
Verzeichnis.
...
<formatter type="xml"/>
<batchtest todir="${junit.dir}">
...


JUnit-Tests
• Der JUnit-Prozess schreibt für jede Testklasse eine XML-
Datei TEST-Klassenname.xml.

• Hieraus erzeugen wir einen HTML-Report.
<junitreport todir="${junit.dir}">
<fileset dir="${junit.dir}">
<include name="TEST-*.xml" />
</fileset>
<report format="frames" todir="${junit.dir}" />
</junitreport>


JUnit-Tests
• Das Testergebnis.


Dateien ignorieren
• Wir können den BrokenDoctorTest vom JUnit-Test
ausschließen.
• Hierzu wird im Fileset exclude verwendet.

<exclude name="**/Broken*Test.class" />
</fileset>
</batchtest>

• Nur zur Demonstration. In der Realität sollte man keine
Testfälle einfach ausschließen.

Der JUnit-Test ist ok
• Es ist jetzt alles wieder ok.


Erstellen einer Jar-Datei
• Eine Jar-Datei kann mit dem Task <jar> erstellt werden
<property name="dest.name" value="doctor-0.1" /> ...
<target name="jar" depends="junit">
<jar destfile="${build.dir}/${dest.name}.jar"
basedir="${classes.dir}">
<manifest>
<attribute name="Main-Class"
value="beispiel.Doctor" />
</manifest>
</target>
• Die Main-Klasse wird extra angegeben.
• Bevor dieser Task läuft, muss der JUnit-Test gefixt
werden.

Dokumentation
• Wir benötigen Dokumentation.
<property name="doc.dir" value="doc" />
• Wir müssen das Quellverzeichnis, das Zielverzeichnis und
den Klassenpfad angeben.
<target name="doc" depends="compile">
<javadoc destdir="${doc.dir}"
sourcepath="${src.dir}"
charset="UTF-8" docencoding="UTF-8">
<classpath refid="path.compile" />
</javadoc>
</target>
• Umlaute in UTF-8


Dokumentation
• Die Javadoc.


Erstellen der Distribution
• Wir erstellen eine Zip-Datei mit Jar und Dokumentation
<property name="dest.name" value="doctor-0.1" />
<zip destfile="${dest.name}.zip">
<zipfileset file="${build.dir}/${dest.jar}"
prefix="${dest.name}" />
Jar
<zipfileset dir="${doc.dir}"
prefix="${dest.name}/doc">
<include name="**/*.*"/>
</zipfileset> Doc
</zip>
• Zipfileset ist eine Erweiterung von Fileset.
• Hier kann mit prefix das Verzeichnis bestimmt werden.


Erstellen der Distribution
• Wir machen den Task abhängig von doc und jar
<target name="zip" depends="doc, jar">


Upload der Distribution
• Mit FTP stellen wir die neueste Version zur Verfügung.

<target name="deploy" depends="zip">
<ftp server="${server}" userid="${user}"
password="${password}" action="put"
remotedir=".">
<fileset file="${dist.dir}/${dest.name}.zip" />
</ftp>
</target>

• Die Aktionen werden in action definiert: put, get, del, ...
• Hier wird ein Fileset verwendet, dass nur aus einer Datei
besteht.

Upload der Distribution
• Ausführen ergibt allerdings einen Fehler.

• FTP ist ein„optionaler Task“, wir benötigen eine
zusätzliche Jar-Datei.
• $ ant deploy -lib lib/commons-net-1.4.0.jar


Der gesamte Prozess


Ant-Skripte dokumentieren
• Ein Projekt wird im Element description erläutert.
<project name="beispiel">
<description>
Beschreibung des Projekts.
</description>

• Targets und Tasks lassen sich mit dem description-
Attribut dokumentieren.
<target name="test"
description="Führe den Test durch"...>

• Die Informationen für das Projekt und die Targets werden
mit projecthelp angezeigt.

Ant auf der Kommandozeile


Ant auf der Kommandozeile
• Viele IDEs unterstützen Ant
• Aber:
• Auch hier müssen Argumente angeben werden.
• Darum:
• Die wichtigsten sollte man kennen.

• Der Aufruf von Ant hat die folgende Syntax.
$ ant [options] [target [target2 [target3] ...]]

• Beispiel
$ ant -f b.xml -emacs -Dsrc.dir=src2 compile zip


Optionen: Informationen
• Die folgenden Optionen sind beim Debuggen hilfreich.

-help -h Hilfe zu den Optionen

-version Versionsinformationen

-verbose -v Ausführlichere Informationen

-diagnostics Listet Properties, Jar-Dateien, etc.

-projecthelp -p Kurzinformationen

-emacs Unterdrückt „[Taskname]“

-debug -d Ausführliche Informationen

-logfile FILE Ausgabe in Datei

-logger CLASS Ein anderer Logger


Optionen: Anpassungen
• Die folgenden Optionen sind Anpassungen.

-buildfile FILE -f Benutzt eine andere Build-Datei

-Dproperty=value Setzt das Property auf den Wert

-propertyfile FL Benutzt Properties aus Datei

-lib FILE Fügt Datei dem Klassenpfad hinzu

-noinput Keine Eingabe

-quiet Nur Fehler werden berichtet

-keep-going -k Macht weiter nach Fehlern


Optionen: Anpassungen
• Die folgenden Optionen sind weitere Anpassungen.

-nouserlib Ignoriert $HOME/.ant/lib

-noclasspath Ignoriert CLASSPATH Umgeb.var.

-autoproxy Benutzt die Netzwerkeinstellung für
Proxies des Betriebssystems(Java 1.5)

-inputhandler CL Die Klasse, die auf <input>-Events
reagieren soll

-listener CL Ein Listener, z. B. für Continous-
Integration-Tools
-main CL Alternative Klasse für Ant

Installation von Ant
• Java Software Development Kit (SDK) wird benötigt
• Umgebungsvariable JAVA_HOME muss gesetzt sein
• PATH um $JAVA_HOME/bin erweitern
• Download von http://ant.apache.org
• Die aktuelle Version ist 1.7.1.
• Entpacken in Verzeichnis ohne Leerzeichen
• Umgebungsvariable ANT_HOME muss gesetzt sein
• PATH um $ANT_HOME/bin erweitern
• Sicherstellen, dass CLASSPATH nicht gesetzt ist
• Das kann später Fehler verursachen
• Optional:
• Anpassung mit ANT_OPTS und ANT_ARGS

Die Datentypen von Ant


Motivierendes Beispiel
• Ein Blick in die Dokumentation ...


Unbekannte Fachbegriffe
• Was bedeuten diese Begriffe ?
• „patterns“
• „directory based tasks“
• „fileset“
• „implicit fileset“
• „nested include/exclude elements“
• „nested patternset elements“
• „nested filesets“
• „extended fileset elements“
• „extended groupfileset elements“

• Fazit: Wir benötigen mehr Grundwissen über Ant !


Datentypen
• Projekt
• Targets
• Tasks
• Parameter von Tasks
• Diese Parameter haben einen Datentyp.

• Datatypes / Datentypen
• Das Datenmodell ist gewachsen
• Abwärtskompatibilität
• Nicht immer einheitlich
• Sind in Java-Klassen implementiert.


Datatypes / Datentypen
• Datentypen
• Properties und PropertySets
• Resources und Resource Collections
• Path, FileSet, FileList, DirSet, TarFileSet, ZipFileSet
• Auswahl von Dateien
• Dateinamen: PatternSet
• Eigenschaften: Selektoren
• Transformationen
• Dateinamen: FileMapper
• Inhalt: FilterSet, FilterChains und FilterReader
• Weitere:
• Permissions, Directory-Based Tasks
• I/O-Redirectors, Regexp, XMLCatalog

Properties
• Kennen wir aus dem „Grundkurs“
• Properties haben einen Namen und enthalten Strings.
• Derefenzierung mit ${propertyName}
• Properties sind Konstanten
• Einmal gesetzt, ändern sie sich nicht mehr
• Werden zur Ablaufsteuerung benutzt.
• Falls eine Property keinen Wert besitzt, wird sie als $
{propertyName} ausgegeben.
<echo>${nochNichtDefiniert}</echo>
• ergibt ${nochNichtDefiniert}.
• Es gibt viele vordefinierte Properties.
• <echoproperties/> gibt diese aus.


Deﬁnieren von Properties

• Properties können gesetzt werden. Der Wert ist nicht
änderbar.
<property name="sprachen" value="Ant und Java"/>
• Mit werden Dateien und Pfade zu absoluten Pfaden
umgewandelt (wenn sie nicht im basedir liegen).
• Properties können bei der Definition von Properties
verwendet werden.
<property name="classes.dir"
location="${build.dir}/classes"/>
• Properties können aus Properties-Dateien geladen
werden.
<property file="build.properties"/>

Deﬁnieren von Properties
• Auch in den Properties-Dateien, können Properties in
Definitionen verwendet werden.
build.dir=build
classes.dir=${build.dir}/classes
dist.name=doctor-0.1
dist.jar=${dist.name}.jar
• Diese werden wie die mit value definierten behandelt.
• Umgebungsvariablen können als Properties geladen
werden.
<property environment="env"/>
• Zugriff mit env.VARIABLE, zum Beispiel.
<echo>env.LANG=${env.LANG}</echo>


Steuerung mit Properties: <available>
• Der <available> Task setzt eine Property, wenn eine
spezifizierte Ressource vorhanden ist.
• Klassen, Dateien, Verzeichnisse, JVM-Ressourcen
• <available property="istDa1"
classname="java.lang.String"/>
<available property="istDa2"
classname="java.lang.Xtring"/>
<echo>${istDa1}, ${istDa2}</echo>
• Ergibt true, ${istDa2}
• <available property="istDa" file="a.txt"
type="file"/>
• <available property="istDa" file="/usr/local/lib"
type="dir"/>


Steuerung mit Properties:
• Der <condition> Task setzt eine Property, wenn die
angegebene Bedingung zutrifft.
• Der Task hat die folgenden Attribute
• Das zu setzende property
• Den Wert value
• Den Wert else, der ansonsten zugewiesen wird
• Beispiel
• <condition property="c1" else="X" >
<equals arg1="1" arg2="0"/>
</condition>
• ergibt X


• Bedingungen können geschachtelt werden.
• <condition property="c2" value="Y">
<or>
<not>
</not>
</or>
</condition>
• Ergibt Y


• Ein Auswahl von „core conditions“

<and>, <or>, <not>, <xor> Logische Verknüpfungen
<isset>, <isreference> Ist gesetzt?
<istrue>, <isfalse> Ist wahr, Ist falsch ?
<equals> Sind zwei Strings gleich ?
<contains> Ist String enthalten
<matches> Reguläre Ausdruck
<available> Wie der Task
<filesmatch> Dateivergleich
<isfileselected> Wurde Datei selektiert ?
<socket>, <http> Ist erreichbar ?

PropertySet
• Properties können zu einem PropertySet
zusammengefasst werden
• Seit Ant Version 1.6
• Eher Ant-Intern
• Eventuell für einen eigenen Tasks verwendbar
• Im allgemeinen nicht für Build-Prozesse


Properties und Boolesche Werte
• Ein Property kann einen Booleschen Wert darstellen.

• Wahr sind
• true
• yes
• on

• Falsch sind
• false
• no
• off


Resource und Resource Collections
• Resourcen sind „Datei-ähnliche“ Dinge
• resource, file, javaresource, zipentry, tarentry
• gzipresource, bzip2resource, url, string,
propertyresource

• Eine Resource Collection ist eine Menge von Resourcen
• File resources
• Fileset, Dirset, Filelist
• Path
• Tarfileset, Zipfileset
• PropertySet
• Properties


Path / Pfad
• Auch „path-like-structure“ genannt
• Benutzt für CLASSPATH und PATH Umgebungsvariablen
• Geordnete Liste
• Elemente sind Dateien und Verzeichnisse
• Rekursiv, d.h. ein Pfad kann Unterpfade enthalten
• Beispiel für einen Pfad mit einer Datei.
<path>

<pathelement location="lib/abc.jar"/>

</path>


Path / Pfad
• Beispiel für einen Pfad mit einer Datei und einem
Verzeichnis.
<path>

<pathelement location="lib/abc.jar"/>

<pathelement location="build/classes"/>

</path>
• Kann auch als Unterpfad angegeben werden.
<path>

<pathelement path="lib/abc.jar:build/classes"/>

</path>
• Trennung mit Semikolon oder Doppelpunkt
• Windows „C:“ wird berücksichtigt
• Separatoren: Slash oder Backslash, „/“ oder „“

Path / Pfad
• Abkürzung: Wenn Pfad nur aus einer Location oder einem
Pfad besteht.
<path location="lib/abc.jar"/>
<path path="lib/abc.jar:build/classes"/>
• Die bisherigen Beispiele waren „standalone“.
• Können nicht wiederverwendet werden.
• Mit dem Attribut id kann ein Name zugewiesen werden.
<path id="meinpfad">


</path>
• Mit dem Attribut refid kann er verwendet werden.
<path refid="meinpfad"/>
• Ist der Pfad unbekannt, bricht Ant mit einem Fehler ab.

Path / Pfad
• Pfade können mit Filesets definiert werden.
<path>

<fileset dir="test">
<include name="**/*.txt"
</fileset>

</path>


Fileset
• Ungeordnete Liste
• wie die mathematische Menge („set“)
• Hat ein Verzeichnis als Wurzel
• das ist der Hauptunterschied zum Pfad
• Per Default enthält es alle Dateien und Unterordner
• Inhalt wird bei der ersten Benutzung definiert, nicht bei
der Deklaration!
• Statisch, werden nicht aktualisiert !
• Umfasst nur bereits existierende Elemente

• Ausnahme: die sog. „Defaultexcludes“


Fileset - Defaultexcludes
• Es gibt Dateien, die nicht berücksichtigt werden sollen.
• Backup-Kopien, die Editoren automatisch anlegen, *~
• Dateien der Versionskontrolle CVS, .svn
• Lösung: defaultexcludes
• Folgender Task zeigt die defaultexcludes an.
<defaultexcludes echo="true"/>
• Die Liste ist änderbar. Sehr umsichtig damit umgehen.
Ansonsten „verschwinden“ Dateien.
<defaultexcludes add="**/*.bck"/>
<defaultexcludes remove="**/*~"/>
• Man kann die Voreinstellung wiederherstellen.
<defaultexcludes default="true"/>


Fileset
• Ein Fileset benötigt immer das Attribut dir.
<fileset dir="web"/>
• Alle Dateien und Unterverzeichnisse von web.
• Filesets können auch benannt und wiederverwendet
werden.
<fileset id="auftritt" dir="web"/>
• Filesets können mit Patternsets und mit Selektoren
eingeschränkt werden.
<fileset dir="web">
<include name=es= "**/*.jsp" />
<contains text="WICHTIG"/>


TarFileSet und ZipFileSet
• Erweiterung von Fileset für Archive.
• Dateien in Archiven haben besondere Eigenschaften.
• Entweder das Attribut dir oder src ist notwendig
• Bei dir wird wie vorher ein Verzeichnis benutzt
• Bei src wird aus einem Archiv benutzt
• Attribute
• ZipFileSet
• prefix, filemode, dirmode, encoding
• TarFileSet
• prefix, filemode, dirmode, username, group, uid, gid


Filelist und Dirset
• Werden nicht so häufig verwendet.
• Filelist
• Wie Fileset, aber geordnet
• Die Elemente müssen nicht existieren
• Verwendet in <concat>, <dependset> und <pathconvert>
• Als nested element in <path>
• Dirset
• Wie Fileset, enthält nur Verzeichnisse
• Verwendet in <javadoc> und <pathconvert>
• Als nested element in <path>


Resource Collections
• Resource Collections
• enthalten 0..* Ressourcen
• Es gibt Mengentheoretische Operationen für diese
• <intersect> ist die Schnittmenge
• <sort> sortiert die Elemente
• <union> ist die Vereinigung
• <restrict> ist ein Filter
• Resource Collections sind noch relativ neu
• ab Ant 1.7
• nicht viele Tasks benutzen diese
• eher selten in „normalen“ Build-Dateien


Patternset
• Ein Patternset ist ein Menge von Mustern (Strings)
• Einschränkung eines Filesets nach dem Namen
• Stichwort: „file-matching“
• Kann rekursiv weitere Patternsets enthalten
• Mögliche Einschränkungen
• Include und Exclude
• Exklusion vor Inklusion !
• Unterstütze Muster

* beliebig viele Zeichen (auch keines)
? Ein einzelnes Zeichen
** beliebig viele Verzeichnisse
endet mit / Das gesamte Verzeichnisses mit Inhalt

Patternset
• Explizite Verwendung mit patternset.
<patternset>
<include name="**/*.jsp"/>
<exclude name="*Test.jsp"/>
</patternset>
• Implizite Verwendung im Fileset-Attribut.
<fileset dir="lib" includes="*.jsp" />
• Implizite Verwendung als Fileset-Element.
<fileset>
<include name="*.jsp"/>
</fileset>


Patternset
• Übergabe als Attribute
• includes, excludes, includesfile, excludesfile
• Übergabe als Element
• include, exclude, includesfile, excludesfile
• Elemente können Konditional mit if/unless sein
• Mit den *file-Versionen wird eine Datei angegeben, die die
Muster enthält.

<patternset>
<include name="**/*.jsp"/>
<exclude name="*Test.jsp" if="prod"/>
</patternset>


Selectors / Selektoren
• Einschränkung eines Filesets nach Eigenschaften
• Der Selektor wird auf jede Datei angewendet
• Können in „selector containers“ angewendet werden.
• Es gibt die folgenden Container.
<and> Alle Selektoren müssen matchen.

<or> Mind. ein Selektor muss matchen.

<not> Logisches Nicht für and und or.

<none> Kein Selektor matched.

<selector> Für Definition mit id.

<majority> Mehrheit

• Container können verschachtelt werden.
• Es können eigene definiert werden („custom selectors“)


<contains> Enthält die Datei einen best. Text
<containsregexp> Enthält die Datei einen reg. Ausdruck
<date> Änderungsdatum
<depend> Neuer als in 2. Verzeichnis
<depth> Verzeichnistiefe
<different> Falls unterschiedlich in 2. Verzeichnis
<filename> Wie <patternset>
<modified> Geänderte Dateien bez. Cache
<present> Falls in 2. Verzeichnis existiert
<size> Größe
<type> dir oder file
<scriptselector> Selektor in Skriptsprache

• Das folgende Beispiel enthält nur die Dateien, die
• Mit .xml enden
• Den Text „project“ enthalten
• Und deren Dateiname kein „a“ enthält
<fileset dir=".">
<and>
<filename name="**/*.xml"/>
<contains text="project" />
<none>
<filename name="**/*a*.xml"/>
</none>
</and>
</fileset>

FileMapper
• Abbildung
• Von bestehenden Dateien
• Auf neue Dateinamen
• Benutzt z. B. in
• <apply>, <copy>, <move>
• Das folgende Beispiel benutzt den <globmapper> und kopiert
alle *.xml Dateien und hängt ein *.bak an den
Dateinamen.
<copy todir="backup" >

<fileset dir="." includes="**/*.xml"/>
<globmapper from="*.xml" to="*.xml.bak"/>

</copy>


Mapper

<chained> Sequentielle Ausführung
<composite> Parallele Ausführung

<filter> FilterChain und FilterReader, später ...

<flatten> Entfernt Verzeichnisse

<glob> Einfaches Ersetzen, nur ein *

<identity> Identität, tut nichts

<merge> Alle Dateien kommen in eine Datei

<package> a/b/C.java zu a.b.C.java

<regexp> Wie <glob>, aber reguläre Ausdrücke

<unpackage> a.b.C.java zu a/b/C.java

<scriptmapper> Erweiterung durch Skriptsprache

FilterSet
• Ein FilterSet ist eine Menge von Filtern
• Ein Filter kann Text in Dateien manipulieren
• Suchen & Ersetzen in <copy>
• Sehr schlechte Namensgebung!
• Nicht bei binären Dateien verwenden !
• Texte zwischen Anfangs- und Endtag werden ersetzt
• Anfangs- und Endtags sind frei definierbar
• Default ist „@“
• Zum Beispiel: Zu ersetzen sind
Datum: @DATUM@
Datum: #@$DATUM#+!


Filterset
• Folgendes Beispiel setzt die Werte ein
<copy file="Template.txt" tofile="README.txt">
<filterset>
<filter token="DATUM" value="2999-12-24"/>
</filterset>
<filterset begintoken="#@$" endtoken="#+!">
<filter token="DATUM" value="3999-12-24"/>
</filterset>
</copy>
• Es ergibt sich
Datum: 2999-12-24
Datum: 3999-12-24


FilterChain und FilterReader
• In Unix und Windows gibt es die „Pipes“
• Die Ausgabe des ersten
• ist die Eingabe des zweiten usw.
• Zum Beispiel
• $ ps -ef | grep root | sort -n | lpr
• „Drucke die Liste der Prozesse von Root sortiert nach
Prozess-ID aus“
• Dieses gibt es auch in Ant (allerdings limitiert)
• Eine FilterChain ist eine „Anreihung“ („Kette“) von
FilterReadern.
• Ein FilterReader
• Liest die Eingabe
• Manipuliert diese und gibt sie an die Ausgabe

• FilterReader werden verwendet in
• <concat>, <copy>, <move>, <exec>, <java>, etc.

<fixcrlf> Für das CR/LF-Problem
<headfilter> Wie Unix head, die ersten n Zeilen

<tailfilter> Wie Unix tail, die letzten n Zeilen

<tabstospaces> Ersetzt Tab mit Leerzeichen

<prefixlines> Setzt ein Präfix vor jede Zeile

<linecontains> Filter

<stripjavacomments> Entfernt Kommentare

<striplinecomments> Entfernt Kommentare, z. B. #, //, --

<striplinecomments>

• Das folgende Beispiel
• Entfernt die Kommentare,
• Ersetzt die Tabs
• Und ersetzt die Zeilenbegrenzer auf „n“.

<copy file="${src.dir}/beispiel/Doctor.java"
tofile="Doctor2.java">
<filterchain>
<stripjavacomments/>
<tabstospaces tablength="2"/>
<fixcrlf eol="unix"/>
</filterchain>
</copy>

Argumente als Attribut und Element
• Es gibt oft zwei Möglichkeiten Parameter anzugeben
• Als Attribut
• Als Element
• Zum Beispiel FileSet.
• Die folgenden beiden Statements beschreiben das gleiche
FileSet.
• und
<fileset>

<include name="**/*.xml"/>

</fileset>
• Das Element ist flexibler, es erlaubt „nested elements“.


Implizite Elemente
• Ant beruht auf Java
• Java ist Objekt-orientiert
• Daher gibt es in Ant auch eine Art Vererbung
• Der <javac> Task ist implizit auch ein FileSet.
<javac srcdir="src" destdir="dest">
<include name="**/*.java"/>
<exclude name= "**/Broken*.java" >
</javac>
• Ein FileSet hat ein Wurzelverzeichnis.
• Bei <javac> wird dieses mit dem Attribut srcdir
angegeben.
• <javac> ist ein „directory-based task“


Nicht mehr unbekannte Fachbegriffe
• Was bedeuten diese Begriffe ?
• „patterns“ PatternSet
• „directory based tasks“
• „fileset“
z. B. <javac>
• „implicit fileset“
• „nested include/exclude elements“
• „nested patternset elements“ FileSet, PatternSet
• „nested filesets“
• „extended fileset elements“
• „extended groupfileset elements“ ZipFileSet,

• Fazit: Wir haben Grundwissen über Ant !


Die Tasks von Ant


Typen von Tasks
• Ant unterscheidet
• Core Tasks
• werden mitgeliefert in ant.jar
• Optionale Tasks
• Tasks werden mitgeliefert, z. B. ant-junit.jar
• zusätzliche Jar-Datei muss hinzugefügt werden
• 3rd party
• Werden von anderen entwickelt
• Custom
• Eigenentwicklungen


Core Tasks

Ant-Basis ... viele ...

Archive <ear>, <jar>, <signjar>, <tar>, <war>, <zip>

Dateien <basename>, <bzip2>, <dirname>, <chmod>,
<checksum>, <concat>, <copy>, <delete>, <fixcrlf>,
<genkey>, <gzip>, <mkdir>, <move>, <patch>, <touch>

Java <apt>, <javac>, <javadoc>, <manifest>, <rmic>,

Netzwerk / DB <get>, <mail>, <sql>

Prozesse <apply>, <exec>, <java>, <nice>, <sleep>, <waitfor>

Versionsverwaltung <cvs>, <cvschangelog>, <cvsversion>, ...

XML <xslt>


Optionale Tasks

Archive <cab>, <ejbjar>, <rpm>

Netzwerk <ftp>, <rexec>, <scp>, <setproxy>, <sshexe>,
<telnet>

Sprachen <antlr>, <depend>, <icontract>, <javacc>, <javah>,
<jdepend>, <jspc>, <netrexxc>, <script>,
<scriptdef>, verschiedene EJB 2

Test <junit>, <junitreport>

Text <native2ascii>, <replaceregexp>, <translate>

Utilities <image>, <propertyfile>, <sound>, <splash>

Versionsverwaltung ClearCase, Continuus, Perforce, PVCS, StarTeam,
Visual SourceSafe
XML <schemavalidate>, <xmlvalidate>


Ant-Contrib Tasks
Ant <antcallback>, <antfetch>, <runtarget>,
<relentless>

Kontrollfluß <assert>, <for>, <if>, <switch>, <throw>,
<trycatch>

Plattform, OS <osfamily>, <shellscript>

Properties <math>, <propertycopy>, <var>, <urlencode>,
<sortlist>, <propertyselector>, <pathtofileset>,
<propertyregexp>

Conditions <isgreaterthan>, <islessthan>, <ispropertyfalse>,
<ispropertytrue>

Selektoren <timestampselector>

Netzwerk <post>, <httpClient>, <httpState>

Sonstiges <outofdate>


3rd Party Tasks

Code-Qualität PMD, Checkstyle, Findbugs, JavaNCSS

J(2)EE XDoclet, versch. Applikationsserver, Hibernate

Netzwerk WebDAV

Sprachen AspectJ, Groovy, Scala

Test Cobertura, DbUnit, HtmlUnit, Jakarta Cactus, JMeter,
JUnitEE, TestNG, XMLUnit
Texte Apache FOP

Versionsverwaltung SvnAnt

XML Apache XML Beans, Xjc (JAXB)


Bedingte Ausführung von Tasks
• Tasks lassen sich bedingt ausführen.

<target name="hello" if="isHello">

<echo message="Hallo Welt"/>

</target>

<target name="goodbye" unless="isHello">

<echo message="Tschüss Welt"/>

</target>

• Bei if muss das Property gesetzt sein.
• Bei unless darf es nicht gesetzt sein.


Tasks einbinden
• Tasks
• Sind Java-Klassen
• Erben von org.apache.tools.ant.Task
• Überschreiben der execute() Methode
• Mit <taskdef> wird ein Task definiert
• Der Name wird einer Klasse zugewiesen
<taskdef name="dbunit"
classname="org.dbunit.ant.DbUnitTask"
classpathref="dbunit.path" />
• Oder über Properties
<taskdef resource="checkstyletask.properties"
classpath="${cs.jar}"/>


Tasks einbinden: Suche nach Jars
• Hierzu muss die Klasse in einer Jar-Datei im CLASSPATH
sein.
• Ant sucht an den folgenden Orten nach Jars
• Jedes Jar aus dem $CLASSPATH.
• Wenn nicht -noclasspath angegeben wurde.
• Jedes Jar aus $ANT_HOME/lib
• Jedes Jar aus $HOME/.ant/lib
• Wenn nicht -nouserlib angegeben wurde.
• Jedes Jar, das als Argument von -lib angegeben wurde.
• Tip: Mit dem folgenden Kommando werden alle Jars für
die optionalen Tasks zu $HOME/.ant/lib heruntergeladen.
• $ cd $ANT_HOME
• $ ant -f fetch.xml all -Ddest=USERNAME


Tasks einbinden: Troubleshooting
• Bei optionalen oder 3rd party Tasks gibt es oftmals
mehrere notwendige Jars
• Eine Jar-Datei für den Task selber
• Also die Erweiterung von Ant
• Eine Jar-Datei für das, was über Ant aufgerufen werden
soll
• Also das, um was Ant erweitert werden soll
• Desweiteren werden noch weitere Jars benötigt
• Wie z. B. Logging

Ant Ant Task Erweiterung Hilfs-Jars


• Beispiel der Fehlermeldung, wenn eine Jar-Datei für
einen optionalen Task nicht im CLASSPATH ist.

• Für <scp> löst -lib lib/jsch-0.1.29.jar das Problem.

• Bei der folgenden Meldung wird JRuby vermisst.

• Erkennbar an der ClassNotFoundException

Core Tasks


Core Tasks

Ant-Basis ... viele ...

Archive <ear>, <jar>, <signjar>, <tar>, <war>, <zip>

Dateien <basename>, <bzip2>, <dirname>, <chmod>,
<checksum>, <concat>, <copy>, <delete>, <fixcrlf>,
<genkey>, <gzip>, <mkdir>, <move>, <patch>, <touch>

Java <apt>, <javac>, <javadoc>, <manifest>, <rmic>,

Netzwerk / DB <get>, <mail>, <sql>

Prozesse <apply>, <exec>, <java>, <nice>, <sleep>, <waitfor>

Versionsverwaltu <cvs>, <cvschangelog>, <cvsversion>, ...
ng
XML <xslt>


Sequentiell und Parellel
• Innerhalb eines Targets können Tasks sequentiell und
parallel ausgeführt werden.
• Dieses wird mit <sequential> und <parallel> erreicht.
<parallel>
<sequential>
<echo>1-A</echo>
<echo>1-B</echo>
</sequential>
<sequential>
<echo>2-A</echo>
<echo>2-B</echo>
</sequential>
</parallel>


Sequentiell und Parellel
• Hier das Ergebnis. Die Prozesse 1 und 2 laufen mit
unterschiedlicher „Geschwindigkeit“.


Default-Werte: <presetdef>
• <presetdef> kann Attribute und Elemente vordefinieren.
• Nützlich bei „parameter-intensiven“ Tasks.
• Z. B. <sql> oder <javac>.
• <presetdef name="meinEcho">
<echo message="Halli-Hallo"/>
</presetdef>
• Aufruf mit:
• <meinEcho/>

• Achtung: Die Werte können wieder überschrieben
werden.
<meinEcho message="Guten Tag"/>
• Daher nicht zum „Erzwingen“ von Konventionen geeignet.

Neue Tasks: <macrodef>
• Mit <macrodef> können neue Tasks definiert werden.
• <macrodef name="meins">
<attribute name="arg1" />
<attribute name="arg2" default="default" />
<attribute name="arg3" default="**/*.xml" />
<text name="text" trim="false" optional="true" />
<element name="files" optional="true"/>
<sequential>
<echo>@{arg1}, @{arg2}, @{arg3}</echo>
<echo>Text: @{text}</echo>
<echoxml><z><files/></z></echoxml>
</sequential>
</macrodef>

Neue Tasks: <macrodef>
• Es gibt drei Argumenttypen
• Attribute
<attribute name="arg2" default="default" />
• Textinhalte
<text name="text" trim="false" optional="true" />
• Elemente
<element name="files" optional="true"/>
• Der Aufruf erfolgt z. B. folgendermaßen.
<meins arg1="V" arg2="V2" arg3="**/*.xml:**/*.jsp">
Hier ist ein Text
<files><fileset include="**/*.txt"/></files>
</meins>


Neue Tasks und Datentypen
• Mit <taskdef> können neue Tasks definiert werden.
<taskdef name="ejbdoclet"
classname="xdoclet.modules.ejb.EjbDocletTask"
classpathref="xdoclet.class.path"/>
• Hierfür gibt es bei mehreren optionalen Tasks Beispiele.

• Mit <typedef> können neue Datentypen definiert werden.
<typedef name="datetime"
classname="org.xyz.DateTime"
classpathref="somepathref"/>
• Wird in der Praxis eher selten benutzt.


Große Projeke: <antcall> und <ant>
• Mit <antcall> können Targets aufgerufen werden.
• Das folgende Target soll aufgerufen werden.

<target name="a">

<property name="p1" value="p1"/>

<echo>A ${p1}</echo>

</target>
• Dieses führen wir mit folgenden Statements durch.
<property name="p1" value="x1"/>
<antcall target="a"/>
<antcall target="a" inheritall="false"/>
• Beim zweiten Aufruf werden die Properties nicht „vererbt“.
• Anmerkung: Es gibt keine Rückgabewerte.


Große Projeke: <antcall> und <ant>
• Dieses führt zu dem abgebildeten
Ergebnis.

• Mit <ant> können auch Targets in anderen Build-Dateien
verwendet werden.
• <ant antfile="x.xml" target="a"/>
<ant antfile="x.xml" target="a"
inheritall="off"/>
• Wird antfile nicht angegeben, dann wird build.xml

Große Projeke: <import>
• Build-Dateien können andere mit <import> importieren.
• Dieses Statement kann überall im Dokument als Element
von <project> stehen.
• Wir haben zwei Build-Dateien: imported.xml und
importer.xml. imported.xml definiert die beiden Targets
a und b.
<target name="a">
<echo>Imported A</echo>
</target>
<target name="b">
<echo>Imported B</echo>
</target>


Große Projeke: <import>
• Die Datei importer.xml importiert X.
<import file="imported.xml" />
• Und überschreibt das Target b.

<target name="b">

<echo>Importer B</echo>

</target>
• Der Aufruf von
•$ ant -f importer a b
• zeigt, dass b überschrieben wurde.


Core Tasks: Archive
• <tar> und <zip> schreiben die Dateien aus einem FileSet
in eine Tar bzw. Zip-Datei.

<tar destfile="a.tar" basedir="."
includes="**/*.xml"/>

<zip destfile="a.zip" basedir="."
includes="**/*.xml"/>

• <untar> und <unzip> entpacken Archive.

<untar src="a.tar" dest="testdir1"/>
<unzip src="a.zip" dest="testdir2"/>


Core Tasks: Archive - Jar
• <jar> hat ein implizites FileSet, d.h. ein
Wurzelverzeichnis.
• Dieses wird mit dem Attribut basedir angegeben.
• <ear> und <war> sind Erweiterung von <jar>.
• Deren Funktionalität kann auch mit <jar> und den
Attributen prefix und fullpath erreicht werden
• <war> kennt WEB-INF/lib und WEB-INF/classes
• ZipFileSet Elemente sind vorhanden

• Viele empfehlen duplicate="preserve", damit keine
Elemente mit gleichem Namen in das Archiv kommen.


Core Tasks: Archive - War
• Eine War-Datei enthält Klassen, Webseiten, Jars, etc.
• Diese können als FileSets spezifiert werden.
• <target name="war" depends="compile">
<war destfile="${dist.war}" webxml="${web.xml}">
<classes dir="${classes.dir}">
<include name="**/*.class"/>
<exclude name="**/*Test.class"/>
</classes>
<fileset dir="${web.dir}"/>
</war>
</target>
• Jetzt muss die War-Datei noch deployed werden.


Core Tasks: Archive - War
• Bei Servern, die „Hot-Deployment“ unterstützen, muss die
Datei nur in das richtige Verzeichnis kopiert werden.
• Ist der Server auf einem anderen Rechner: <scp>.
<target name="deploy" depends="war">
<copy todir="${deploy.dir}" file="${dist.war}"/>

</target>

• Anschliessend warten wir, bis die Anwendung gestartet ist.
<target name="wait-deployed">
<waitfor checkevery="1000" maxwait="15000">
<http url="${app.url}" />
</waitfor>
</target>


Core Tasks: Externe Prozesse
• Mit Ant lassen sich externe Prozesse aufrufen und
kontrollieren.
• <apply> ruft ein externes Programm für jede Datei in
einem FileSet auf.
<apply command="ls -l">
<fileset dir="." includes="*.xml"/>
</apply>
• <exec> ruft ein externes Programm mit bestimmten
Argumenten auf.
<exec executable="ls">
<arg value="-l"/>
<arg value="."/>
</exec>


• Beide können mit dem Attribute spawn vom Ant-Prozess
losgelöst werden (ähnlich nohup unter Unix).
• Mit <nice> bekommt der aktuelle Prozess eine neue
„niceness“.
<nice newpriority="+10"/>
• Schlafen mit <sleep>.
<sleep minutes="3" seconds="25"/>
• Mit <waitfor> kann auf die Erfüllung einer Condition warten
bzw. bis ein Timeout auftritt.
<waitfor checkevery="1000" maxwait="5000"
timeoutproperty="not.available" >
<socket server="localhost" port="8080" />
</waitfor>


• Java-Klassen und Jar-Dateien lassen <java> sich mit
aufrufen.
• Mit dem Attribut fork kann eine neue Java Virtual
Machine (JVM) gestartet werden.
• Diese hat einen eigenen Classloader und -Path.
Aufpassen.
<java fork="true" classname="groovy.ui.Console"/>
• Ergibt einen NoClassDefFoundError auch beim Start mit
$ ant target -lib lib/groovy-all-1.5.5.jar
• Entweder man verzichtet auf das Fork.
<java classname="groovy.ui.Console"/>
• Oder man setzt den Classpath.
• <java fork="true" classname="groovy.ui.Console"
classpathref="gpath">

Optionale Tasks


Optionale Tasks

Archive <cab>, <ejbjar>, <rpm>

Netzwerk <ftp>, <rexec>, <scp>, <setproxy>, <sshexe>,
<telnet>

Sprachen <antlr>, <depend>, <icontract>, <javacc>, <javah>,
<jdepend>, <jspc>, <netrexxc>, <script>,
<scriptdef>, verschiedene EJB 2

Test <junit>, <junitreport>

Text <native2ascii>, <replaceregexp>, <translate>

Utilities <image>, <propertyfile>, <sound>, <splash>

Versionsverwaltu ClearCase, Continuus, Perforce, PVCS, StarTeam,
ng Visual SourceSafe
XML <schemavalidate>, <xmlvalidate>


Optionale Tasks: SCP
• SCP benötigt das jsch-Jar.

• Das folgende Statement übertragt ein FileSet.

<scp todir="${user}:${password}@${host}:${rpath}"
sftp="true" verbose="true">
</scp>


Optionale Tasks: XML
• Für XML gibt es zwei Validierungsschemata:
• DTD
• XML-Schema

• Für DTD gibt es den Task <xmlvalidate>.
<xmlvalidate file="${xml.dir}/tabellendaten.xml">
<dtd publicid="TEST" location="dtd/schema.dtd"/>
</xmlvalidate>

• Für XML-Schema den Task <schemavalidate>.
<schemavalidate file="${xml.dir}/tools.xml" />


Optionale Tasks: JDepend
• JDepend erstellt Metriken der Design-Qualität
• siehe http://clarkware.com/software/JDepend.html
• Der JDepend Task analysisiert die Klassen im
classespath. Er erstelle eine XML-Datei.
<jdepend format="xml"
outputfile="jdepend/jdepend-report">
<exclude name="java*"/>
...
<exclude name="junit.*"/>
<classespath>
<pathelement location="${classes.dir}" />
</classespath>
<classpath location="${classes.dir}" />
</jdepend>


• Im zweiten Schritt wird die XML-Datei mit <xslt> in eine
HTML-Datei umgeformt.

• <xslt basedir="jdepend"
destdir="jdepend"
includes="jdepend-report"
style="lib/etc/jdepend.xsl" />


• Hier das Ergebnis von JDepend.


Ant-Contrib Tasks


Ant-Contrib Tasks
Ant <antcallback>, <antfetch>, <runtarget>,
<relentless>

Kontrollfluß <assert>, <for>, <if>, <switch>, <throw>,
<trycatch>

Plattform, OS <osfamily>, <shellscript>

Properties <math>, <propertycopy>, <var>, <urlencode>,
<sortlist>, <propertyselector>, <pathtofileset>,
<propertyregexp>

Conditions <isgreaterthan>, <islessthan>, <ispropertyfalse>,
<ispropertytrue>

Selektoren <timestampselector>

Netzwerk <post>, <httpClient>, <httpState>

Sonstiges <outofdate>


Ant-Contrib Tasks
• Ant-Contrib bietet eine Menge Erweiterung
• Manche sehen diese Erweiterungen als zu „prozedural“
an, denn Ant soll „deklarativ“ verwendet werden

• Ant-Contrib ist als Antlib verwendbar.
• Dieses ist ein recht neuer Packet-Mechanismus von Ant.

• Um es zu verwenden, kann man es z. B. als XML-
Namespace definieren.
<project name="contrib"
xmlns:c="antlib:net.sf.antcontrib">
• Die Tasks sind dann mit <c:XYZ> und </c:XYZ> zu
verwenden.

Ant-Contrib Tasks: <if>
• Wir testen die Erreichbarkeit eines Servers mit <if>.
<c:if>
<http url="${url}"/> 
<c:then>
<echo>Server ist da!</echo>
</c:then>
<c:else>
<echo>Server ist nicht da!</echo>
</c:else>
</c:if>

• <if> erwartet als erstes Argument eine <condition>.

Ant-Contrib Tasks: <switch>
• Mit <switch> kann man z. B. eine Mehrfachabfrage
machen. Wir testen, welche Shell der aktuelle Benutzer
hat.

<property environment="env"/>
<c:switch value="${env.SHELL}">
<c:case value="/bin/bash">
<echo>Benutzer von Bash</echo>
</c:case>
<c:default>
<echo>Sonstige Shell</echo>
</c:default>
</c:switch>


Ant-Contrib Tasks: <foreach>
• Mit <foreach> wird ein Target für jedes Element
aufgerufen.
<target name="kopf">
<c:foreach list="1,2,3,4,5"
target="koerper" param="i" />
</target>
<target name="koerper">
<echo>Schritt ${i}</echo>
</target>
• Es können andere Delimiter mit <delimiter> angeben
werden.
• Achtung: Da jedesmal ein neus Target aufgerufen wird, ist
hier auf die Performance zu achten.


Ant-Contrib Tasks: <foreach>
• Iterieren über die Elemente eines FileSets.
<c:foreach target="koerper" param="i">
<fileset dir="." />
</c:foreach>

• Wir können auch mehrere FileSets benutzen.
<c:foreach target="koerper" param="i">
<path>
<fileset dir="src" />
<fileset dir="test" />
</path>
</c:foreach>


Ant-Contrib Tasks: <for>
• Mit <for> ist das separate Target nicht notwendig.
<c:for list="1,2,3,4,5" param="i">
<sequential>
<echo>Schritt @{i}</echo>
</sequential>
</c:for>

• Intern wird <macrodef> benutzt.
• Daher ist es notwendig, ‚@‘ zu benutzen.


Ant-Contrib Tasks: <for>
• Wir können auch ein FileSet benutzen.
<c:for param="i">
<fileset dir="." />
<sequential>
<echo>Schritt @{i}</echo>
</sequential>
</c:for>


3rd Party Tasks


3rd Party Tasks

Code-Qualität PMD, Checkstyle, Findbugs, JavaNCSS

J(2)EE XDoclet, versch. Applikationsserver, Hibernate

Netzwerk WebDAV

Sprachen AspectJ, Groovy, Scala

Test Cobertura, DbUnit, HtmlUnit, Jakarta Cactus, JMeter,
JUnitEE, TestNG, XMLUnit
Texte Apache FOP

Versionsverwaltung SvnAnt

XML Apache XML Beans, Xjc (JAXB)


DbUnit
• DbUnit ist ein Testwerkzeug für die Datenbank.
• Testdaten werden in XML-Dateien definiert.
• Wir benötigen einen JDBC-Treiber.
<path id="dbunit.path">

<path location="lib/slf4j-api-1.5.0.jar" />

<path location="lib/slf4j-simple-1.5.0.jar" />

<path location="${jdbc.jar}" />

<path location="lib/dbunit-2.2.jar" />

</path>
• Definition des Tasks.
<taskdef name="dbunit"
classname="org.dbunit.ant.DbUnitTask"
classpathref="dbunit.path" />


DbUnit
• Export der DTD des Schemas.
<dbunit driver="${driver}" url="${url}"
userid="${user}" password="${password}">
<export dest="${dbunit.dir}/schema.dtd"
format="dtd" />
</dbunit>
• Export aller Tabellen in eine XML-Datei.
userid="${user}" password="${password}">
<export dest="${dbunit.dir}/tabellendaten.xml" />
</dbunit>
• Beobachtung: Es ist sehr unpraktisch, dbunit zu
verwenden, da immer die vier Parameter übergeben
werden müssen.

DbUnit und <presetdef>
• Lösung: Mit <presetdef> können Default-Parameter an
einen Wrapper-Task gebunden werden.
• <presetdef name="mydbunit">
userid="${user}" password="${password}"/>
</presetdef>
• Jetzt sieht der Export der DTD des Schemas
folgendermaßen aus.
• <mydbunit>
<export dest="${dbunit.dir}/schema.dtd"
format="dtd" />
</mydbunit>


DbUnit und <presetdef>
• Export der Tabelle „farbe“ mit SELECT-Statement und der
Tabelle „osterei“.
• <mydbunit>
<export dest="${dbunit.dir}/partiell.xml">
<query name="Q" sql="SELECT * FROM farbe"/>
<table name="osterei"/>
</export>
</mydbunit>


XDoclet
• XDoclet
• Attribute-Oriented-Programming
• wird bei der EJB 2-Entwicklung angewendet
• XDoclet bietet eine Menge von Ant-Tasks.
• ejbdoclet
• webdoclet
• hibernatedoclet
• springdoclet
• jdodoclet
• jmxdoclet
• und noch einige mehr


XDoclet: <ejbdoclet>
• EJB 2-Anwendungen haben eine gewisse Redundanz an
Interfacen. Diese sind jeweils für den Server und die
Clients anzulegen.
• Mit XDoclet werden im Sourcecode Tags hinterlegt, aus
denen dann die entsprechenden Interfaces und Klassen
generiert werden.
• Der Pfad.
<path id="xdoclet.class.path">
<fileset dir="lib/xdoclet-1.2.3/lib"
includes="*.jar"/>
<fileset dir="lib/xdoclet-1.2.3/samples/lib"
includes="*.jar"/>
</path>


• Der Task.
<taskdef name="ejbdoclet"
classname="xdoclet.modules.ejb.EjbDocletTask"
classpathref="xdoclet.class.path"/>
• Der Aufruf für alle Dateien in src.dir.
<ejbdoclet destdir="${generated.dir}"
excludedtags="@author" ejbspec="2.0"
addedtags="@xdoclet-generated at ${TODAY}">
<fileset dir="${src.dir}"
includes="**/*Bean.java"/>
• Auf der nächsten Seite geht es weiter.


• Wir generieren Remote-, Local- und Home-Interfaces.
• <remoteinterface pattern="{0}"/>
<localinterface pattern="{0}Local"/>
<homeinterface/>
<localhomeinterface/>
<session/>
<utilobject cacheHomes="true" kind="physical"
includeGUID="true"/>
<deploymentdescriptor destdir="${meta.inf}"/>
<jboss version="4.0" destdir="${meta.inf}" />
</ejbdoclet>
• Eine genaue Erklärung wäre Out-of-Scope des Vortrags.


JUnitEE
• JUnitEE ermöglicht Unit-Tests auf dem Applikationsserver.
• Mit <juniteewar> wird eine War-Datei erstellt, die den
Testserver und die zu testenden Klassen enthält.
<juniteewar destFile="${dist.dir}/${junitee.war}">
<lib dir="lib" includes="*.jar>
<classes dir="${classes.dir}"
includes="**/*.class" />
<testcases dir="${classes.dir}"
includes="**/*Test.class" />
</juniteewar>
• Mit <lib> werden die benötigten Bibliotheken und mit
<testcases> die Testklassen angegeben.


JUnitEE
• Die Tests können automatisch mit Ant ausgeführt werden.
<junitee url="${url}" printsummary="true">
<test runall="true" />
</junitee>
• Oder manuell über eine Webseite.


Groovy
• Groovy ist eine dynamische Programmiersprache.
• Es gibt zwei Tasks für Groovy.
• Einen zum Ausführen von Groovy-Code direkt in Ant.
• <taskdef name="groovy"
classname="org.codehaus.groovy.ant.Groovy"
classpath="${groovy.jar}"/>
• Und einen Task zum Kompilieren von Groovy.
<taskdef name="groovyc"
classname="org.codehaus.groovy.ant.Groovyc"
classpath="${groovy.jar}"/>

• Groovy kann auch über die Script-Möglichkeiten von Ant
genutzt werden. Siehe das Kapitel „Ant erweitern“.

Groovy
• Groovy-Programme können direkt in Ant verfasst werden.
• <groovy>
println "Hallo Groovy"
int n = 100
def ks = (0..n).toList().inject(0) { a,b -> a+b }
println "Die Summe von 1..${n} ist ${ks}"
</groovy>


Groovy
• Groovy ist vollständig in
Java integriert.
• Groovy kann Java-Klassen
benutzen und umgekehrt.
<groovy>
import java.text.SimpleDateFormat
def gc = new GregorianCalendar()
gc.time = new Date()
gc.add Calendar.MONTH, 3
def format = new SimpleDateFormat('dd.MM.yyyy')
println "In drei Monaten ist der "
+ format.format(gc.time)
</groovy>

PMD
• PMD ist ein Werkzeug zur Quellcodeanalyse.
• Es kann mögliche Fehler, suboptimalen Code, etc. finden
• Ist mit Regeln konfigurier und erweiterbar
• Wir definieren einen Pfad für die benötigten Jars.
<path id="pmd.class.path">

<path location="lib/jasm-3.1.jar"/>

<path location="lib/jaxen-1.1.1.jar"/>

<path location="lib/pmd-4.2.1.jar"/>

</path>
• Wir definieren den PMD-Task.
<taskdef name="pmd"
classname="net.sourceforge.pmd.ant.PMDTask"
classpath="lib/pmd-4.2.1.jar" />


Ant im Detail

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

En vedette

En vedette (20)

Similaire à Ant im Detail

Similaire à Ant im Detail (20)

Plus de Jörn Dinkla

Plus de Jörn Dinkla (16)

Ant im Detail

Notes de l'éditeur