Ant, uno strumento da conoscere

I programmatori attivi su PC spesso legano indissolubilmente l’idea di sviluppo software e l’idea di ambiente integrato di sviluppo.
Su Linux e nello stesso Sdk Microsoft, i progetti più grossi, quelli che si misurano in centinaia o migliaia di file sono gestiti dal compilatore e da script di compilazione, i Makefile.

L’ambiente Java ha portato a un’evoluzione del Makefile con la creazione di Apache Ant.
La differenza fra usare Ant e Make è sostanziale.
Un makefile, infatti, organizza le dipendenze fra i sorgenti e i prodotti di compilazione intermedi e finali e mette in relazione le dipendenze con comandi shell.

I comandi shell traducono in azione le azioni necessarie per risolvere le dipendenze, ad esempio per ricompilare un file oggetto meno recente del sorgente e ripetere il link dell’applicazione.
Ant è diverso perché si basa su un file di direttive scritto in Xml e un ambiente di esecuzione Java, di conseguenza fa lo stesso lavoro di organizzazione delle dipendenze e traduzione delle dipendenze in azioni, ma in modo indipendente dalla piattaforma di svilupppo.
Uno sviluppatore può quindi creare un build file su un Macintosh e utilizzarlo su un sistema Windows.
Un’altro vantaggio di Ant è che la maggior parte dei tool di sviluppo, come Eclipse, NetBeans o XCode su MacOS sanno trattare un progetto basato su un build file di Ant.
Se si organizza un progetto di sviluppo in modo autonomo con Ant, lo si potrà quindi aprire su qualunque piattaforma con l’ambiente di sviluppo preferito.
Un progetto Ant, poi, non ha le limitazioni di un progetto specifico di un ambiente di sviluppo.
Nel caso di un’applicazione complessa, fatta di client e server, magari diviso a sua volta in layer dati e layer di presentazione, può essere conveniente seguire le linee guida delle blueprint di Sun e non limitarsi al perimetro di ciò che è gestito da un Ide in particolare.
Ecco un esempio di buildfile. Leggendo il testo Xml è facile rendersi conto di come sono parametrizzati i nomi delle directory che contengono i sorgenti, l’ambiente di costruzione dell’applicazione e i prodotti distribuibili.
I bersagli del buildfile sono init, l’inizializzazione dell’ambiente, compile, la compilazione dei sorgenti e clean, la cancellazione di tutti i prodotti di compilazione, ad eccezione dei sorgenti naturalmente.
I comandi del buildfile, come

<delete dir="${dist}"/>

Non sono comandi di sistema eseguiti nella shell, ma funzioni esportate da una libreria compatibile con ant installata nel sistema.
Si possono creare task di compilazione personalizzati per coprire terreno nuovo, non ancora nel dominio della ricca collezione di task della libreria base.

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

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