Apache Ant Cheat Sheet

Installation

Plattform	Befehl
Ubuntu/Debian	`sudo apt update && sudo apt install ant`
RHEL/CentOS/Fedora	`sudo yum install ant` or `sudo dnf install ant`
Arch Linux	`sudo pacman -S apache-ant`
macOS (Homebrew)	`brew install ant`
Windows (Chocolatey)	`choco install ant`
Manual (All Platforms)	Download from apache.org, extract, set `ANT_HOME` and add `bin/` to `PATH`
`JAVA_HOME`Umgebungsvariable.

Grundlegende Befehle

Befehl	Beschreibung
`ant -version`	Zeige Ant-Version, Java-Version und Betriebssysteminformationen
`ant`	Führe Standardziel aus, das in build.xml angegeben ist
`ant compile`	Führen Sie das “compile”-Ziel aus build.xml aus
`ant clean`	Führen Sie das “clean” Target aus (typischerweise entfernt Build-Artefakte)
`ant -projecthelp`	Alle verfügbaren Ziele mit Beschreibungen auflisten
`ant -p`	Kurzform von -projecthelp
`ant -f custom-build.xml`	Verwende alternative Builddatei anstelle von build.xml
`ant -buildfile mybuild.xml compile`	Geben Sie Buildfile und Ziel zum Ausführen an
`ant -verbose compile`	Detaillierte Ausführungsinformationen anzeigen
`ant -v test`	Kurzform von -verbose
`ant -debug package`	Maximale Ausführlichkeit für die Fehlersuche
`ant -d deploy`	Kurze Form von -debug
`ant -quiet test`	Minimale Ausgabe, nur Fehler anzeigen
`ant -q build`	Kurze Form von -quiet
`ant -logfile build.log compile`	Ausgabe in angegebene Logdatei umleiten
`ant -l output.log test`	Kurzform von -logfile

Erweiterte Verwendung

Befehl	Beschreibung
`ant -Denv=production deploy`	Eigenschaftswert in der Befehlszeile festlegen
`ant -Dversion=1.2.3 -Dbuild.number=456 package`	Mehrere Eigenschaften festlegen
`ant -propertyfile custom.properties build`	Eigenschaften aus externer Datei laden
`ant -find`	Übergeordnete Verzeichnisse nach build.xml durchsuchen
`ant -s`	-f
`ant -keep-going test`	Fahre mit der Ausführung unabhängiger Ziele nach einem Fehler fort
`ant -k test`	Kurzform von -keep-going
`ant -diagnostics`	Systemeinformationen und Konfigurationsdetails anzeigen
`ant -listener org.apache.tools.ant.listener.Log4jListener compile`	Benutzerdefinierten Build-Ereignislistener hinzufügen
`ant -logger org.apache.tools.ant.NoBannerLogger compile`	Benutzerdefinierte Logger-Implementierung verwenden
`ant -inputhandler org.apache.tools.ant.input.SecureInputHandler deploy`	Verwenden Sie einen benutzerdefinierten Eingabehandler für sichere Eingabe
`ant -noclasspath compile`	CLASSPATH-Umgebungsvariable ignorieren
`ant -autoproxy download`	Automatisch Java-Proxy-Einstellungen konfigurieren
`ant -lib /path/to/jars compile`	Verzeichnis von JARs zum Classpath von Ant hinzufügen
`ant -Dant.executor.class=org.apache.tools.ant.helper.ParallelExecutor build`	Parallele Taskausführung aktivieren
`ant compile test package`	Mehrere Ziele nacheinander ausführen
`ant -Dskip.tests=true package`	Bedingt Aufgaben basierend auf Eigenschaft überspringen

Konfiguration

Grundlegende build.xml-Struktur

<?xml version="1.0" encoding="UTF-8"?>
<project name="MyProject" default="build" basedir=".">
    
    <!-- Properties -->
    <property name="src.dir" value="src"/>
    <property name="build.dir" value="build"/>
    <property name="dist.dir" value="dist"/>
    <property name="lib.dir" value="lib"/>
    
    <!-- Classpath -->
    <path id="classpath">
        <fileset dir="${lib.dir}">
            <include name="**/*.jar"/>
        </fileset>
    </path>
    
    <!-- Clean target -->
    <target name="clean" description="Remove build artifacts">
        <delete dir="${build.dir}"/>
        <delete dir="${dist.dir}"/>
    </target>
    
    <!-- Init target -->
    <target name="init" depends="clean">
        <mkdir dir="${build.dir}"/>
        <mkdir dir="${dist.dir}"/>
    </target>
    
    <!-- Compile target -->
    <target name="compile" depends="init" description="Compile source code">
        <javac srcdir="${src.dir}" 
               destdir="${build.dir}"
               classpathref="classpath"
               includeantruntime="false"
               debug="true"
               source="11"
               target="11"/>
    </target>
    
    <!-- Build target -->
    <target name="build" depends="compile" description="Build JAR file">
        <jar destfile="${dist.dir}/${ant.project.name}.jar" 
             basedir="${build.dir}">
            <manifest>
                <attribute name="Main-Class" value="com.example.Main"/>
            </manifest>
        </jar>
    </target>
    
</project>

build.properties-Datei

# Project configuration
project.name=MyApplication
project.version=1.0.0

# Directory structure
src.dir=src/main/java
test.dir=src/test/java
resources.dir=src/main/resources
build.dir=target/classes
dist.dir=dist

# Compiler settings
java.source.version=11
java.target.version=11
javac.debug=true
javac.deprecation=true

# Dependencies
lib.dir=lib

Laden von Eigenschaften in build.xml

<property file="build.properties"/>
<property file="build-${env}.properties"/>
<property environment="env"/>

Häufige Dateisets und Muster

<!-- Include all Java files -->
<fileset dir="${src.dir}" includes="**/*.java"/>

<!-- Exclude test files -->
<fileset dir="${src.dir}">
    <include name="**/*.java"/>
    <exclude name="**/*Test.java"/>
</fileset>

<!-- Pattern sets for reuse -->
<patternset id="source.patterns">
    <include name="**/*.java"/>
    <include name="**/*.properties"/>
    <exclude name="**/*Test.java"/>
</patternset>

Häufige Anwendungsfälle

Anwendungsfall: Vollständiger Java-Anwendungs-Build

# Clean previous builds
ant clean

# Compile, test, and package in one command
ant compile test package

# Build with specific environment properties
ant -Denv=production -propertyfile prod.properties package

# Create distribution with documentation
ant clean compile test package javadoc dist

build.xml-Ziele:

<target name="test" depends="compile">
    <junit printsummary="yes" haltonfailure="yes">
        <classpath>
            <path refid="classpath"/>
            <pathelement location="${build.dir}"/>
        </classpath>
        <batchtest fork="yes">
            <fileset dir="${test.dir}">
                <include name="**/*Test.java"/>
            </fileset>
        </batchtest>
    </junit>
</target>

<target name="javadoc">
    <javadoc sourcepath="${src.dir}" 
             destdir="${dist.dir}/docs"
             packagenames="com.example.*"/>
</target>

Anwendungsfall: WAR-Datei-Erstellung für Webanwendung

# Build and package web application
ant clean compile war

# Deploy to application server
ant -Dserver.path=/opt/tomcat/webapps deploy

build.xml-Konfiguration:

<target name="war" depends="compile">
    <war destfile="${dist.dir}/${project.name}.war" 
         webxml="web/WEB-INF/web.xml">
        <classes dir="${build.dir}"/>
        <lib dir="${lib.dir}"/>
        <fileset dir="web">
            <include name="**/*.jsp"/>
            <include name="**/*.html"/>
            <include name="**/*.css"/>
            <include name="**/*.js"/>
        </fileset>
    </war>
</target>

<target name="deploy" depends="war">
    <copy file="${dist.dir}/${project.name}.war" 
          todir="${server.path}"/>
</target>

Anwendungsfall: Multi-Modul-Projekt-Build

# Build all modules in parallel
ant -Dant.executor.class=org.apache.tools.ant.helper.ParallelExecutor build-all

# Build specific module
ant -Dmodule=core build-module

# Build and run integration tests
ant build-all integration-test

build.xml mit Unterprojekten:

<target name="build-all">
    <subant target="build">
        <fileset dir="." includes="*/build.xml"/>
    </subant>
</target>

<target name="build-module">
    <ant dir="${module}" target="build" inheritAll="false"/>
</target>

Anwendungsfall: Bedingte Builds mit Eigenschaftsprüfung

# Skip tests during build
ant -Dskip.tests=true package

# Build only if sources changed
ant -Dincremental=true compile

# Production build with optimizations
ant -Doptimize=true -Ddebug=false production-build

build.xml mit Bedingungen:

<target name="compile">
    <javac srcdir="${src.dir}" 
           destdir="${build.dir}"
           debug="${debug}"
           optimize="${optimize}">
        <classpath refid="classpath"/>
    </javac>
</target>

<target name="test" unless="skip.tests">
    <junit printsummary="yes">
        <classpath>
            <path refid="classpath"/>
            <pathelement location="${build.dir}"/>
        </classpath>
        <batchtest>
            <fileset dir="${test.dir}" includes="**/*Test.java"/>
        </batchtest>
    </junit>
</target>

<target name="package" depends="compile,test">
    <jar destfile="${dist.dir}/${ant.project.name}.jar" 
         basedir="${build.dir}"/>
</target>

Anwendungsfall: Datenbank-Migration und -Bereitstellung

# Run database migrations
ant -propertyfile db-config.properties db-migrate

# Deploy application with database updates
ant -Denv=staging db-migrate deploy

# Rollback database changes
ant -Dversion=1.2.0 db-rollback

build.xml mit SQL-Aufgaben:

<target name="db-migrate">
    <sql driver="${db.driver}"
         url="${db.url}"
         userid="${db.user}"
         password="${db.password}"
         src="migrations/migrate-${version}.sql"
         print="yes"
         output="migration.log"/>
</target>

<target name="db-rollback">
    <sql driver="${db.driver}"
         url="${db.url}"
         userid="${db.user}"
         password="${db.password}"
         src="migrations/rollback-${version}.sql"/>
</target>

Best Practices

Eigenschaftsdateien für Konfiguration verwenden: Umgebungsspezifische Einstellungen von Build-Logik trennen. Eigenschaften laden mit <property file="build.properties"/> to keep build.xml clean and reusable.
Define meaningful target descriptions: Add Beschreibung attributes to public targets for better ant -projekthelp output. This serves as built-in documentation for your build process.
Leverage target dependencies: Use abhängig attribute to establish build order and avoid redundant task execution. Ant automatically handles dependency resolution.
Set includeantruntime="false" in javac tasks: Prevents Ant runtime libraries from polluting your application classpath, avoiding potential conflicts and reducing JAR size.
Use filesets and pattern sets for flexibility: Define reusable file patterns with <patternset> and reference them in multiple targets. This makes maintenance easier and reduces duplication.
Implement incremental builds: Use <uptodate> conditions to skip compilation when source files haven’t changed, significantly speeding up development builds.
Version control your build files: Include build.xml, property files, and custom tasks in version control. Exclude generated directories like build/ and dist/ using .gitignore.
Use macros for repeated task sequences: Define <macrodef> elements for common operations performed across multiple modules or targets, promoting DRY principles.
Separate concerns with imported build files: Split large build files into logical components (common-build.xml, test-build.xml) und importieren Sie sie, um die Wartbarkeit zu verbessern.
Dokumentieren Sie komplexe Logik mit Kommentaren: Verwenden Sie XML-Kommentare, um nicht offensichtliche Build-Logik, Eigenschaftsverwendung und Abhängigkeiten zu erklären, insbesondere in gemeinsamen oder Legacy-Projekten.

Fehlerbehebung

Problem	Lösung
`BUILD FAILED: build.xml does not exist`	Run `ant -find` to search parent directories, or specify file with `ant -f path/to/build.xml`
`Unable to locate tools.jar`	Set `JAVA_HOME` to JDK (not JRE) directory. Verify with `echo $JAVA_HOME` and ensure it points to JDK installation
`ClassNotFoundException` for custom tasks	Add JAR to Ant’s classpath using `-lib` option: `ant -lib /path/to/jars compile` or use `<taskdef>` with correct classpath
Compilation fails with encoding errors	Add `encoding="UTF-8"` attribute to `<javac>` task: `<javac srcdir="${src.dir}" encoding="UTF-8"/>`
Out of memory during build	Increase heap size: `export ANT_OPTS="-Xmx1024m -Xms512m"` (Linux/Mac) or `set ANT_OPTS=-Xmx1024m` (Windows)
Target not found error	Verify target name with `ant -projecthelp`. Check for typos and ensure target is defined in active build file
Circular dependency detected	Review `depends` attributes in targets. Ant cannot resolve circular references - redesign target dependencies
Permission denied when writing files	Überprüfen Sie die Verzeichnisberechtigungen und stellen Sie sicher, dass Ant Schreibzugriff hat. Führen Sie das Programm mit entsprechenden Benutzerrechten aus oder passen Sie die Verzeichniseigentümerschaft an
`fork="true"` required but task fails	Some tasks (junit, java) require forking. Ensure `fork="true"` is set and `JAVA_HOME` points to valid JDK
Properties not being overridden	Properties are immutable in Ant - first definition wins. Set properties via command line (`-D`) before build file loads them
Slow builds with large filesets	Use `<uptodate>` conditions for incremental builds. Enable parallel execution with `-Dant.executor.class=org.apache.tools.ant.helper.ParallelExecutor`
JAR file manifest not correct	Use `<manifest>` element within `<jar>` task to specify Main-Class and other attributes explicitly

Referenz für häufige Ant-Aufgaben

Aufgabe	Beschreibung	Beispiel
`<javac>`	Java-Quelldateien kompilieren	`<javac srcdir="src" destdir="build" includeantruntime="false"/>`
`<jar>`	JAR-Archiv erstellen	`<jar destfile="dist/app.jar" basedir="build"/>`
`<war>`	WAR-Archiv erstellen	`<war destfile="dist/app.war" webxml="web/WEB-INF/web.xml"/>`
`<copy>`	Dateien oder Verzeichnisse kopieren	`<copy todir="backup"><fileset dir="src"/></copy>`
`<delete>`	Dateien oder Verzeichnisse löschen	`<delete dir="build"/>`
`<mkdir>`	Verzeichnis erstellen	`<mkdir dir="dist"/>`
`<echo>`	Nachricht drucken	`<echo message="Building version ${version}"/>`
`<exec>`	Systembefehl ausführen	`<exec executable="git" args="rev-parse HEAD"/>`
`<junit>`	JUnit-Tests ausführen	`<junit printsummary="yes" fork="yes"/>`
`<zip>`	ZIP-Archiv erstellen	`<zip destfile="dist/src.zip" basedir="src"/>`
`<sql>`	SQL-Anweisungen ausführen	`<sql driver="${db.driver}" url="${db.url}" src="schema.sql"/>`