Ant Guida rapida

ANT sta per Another Neat Tool. È uno strumento di compilazione basato su Java di Apache. Prima di entrare nei dettagli di Apache Ant, dobbiamo prima capire perché abbiamo bisogno di uno strumento di compilazione in primo luogo.

Necessità di uno strumento di costruzione

In media, uno sviluppatore trascorre una notevole quantità di tempo in attività banali come la creazione e la distribuzione che includono:

  • Compilazione del codice
  • Pacchettizzare i binari
  • Distribuzione dei file binari al server di prova
  • Testare le modifiche
  • Copiare il codice da una posizione a un'altra

Per automatizzare e semplificare le attività di cui sopra, Apache Ant è utile. È uno strumento di creazione e distribuzione del sistema operativo che può essere eseguito dalla riga di comando.

Storia di Apache Ant

  • Ant è stato creato da James Duncan Davidson (l'autore originale di Tomcat).

  • È stato originariamente utilizzato per creare Tomcat ed è stato fornito in bundle come parte della distribuzione di Tomcat.

  • Ant è nato dai problemi e dalle complessità associati allo strumento Apache Make.

  • Ant è stato promosso come progetto indipendente in Apache nel 2000. L'ultima versione di Apache Ant a maggio 2014 è 1.9.4.

Caratteristiche di Apache Ant

  • Ant è lo strumento di creazione e distribuzione Java più completo disponibile.

  • Ant è indipendente dalla piattaforma e può gestire proprietà specifiche della piattaforma come i separatori di file.

  • Ant può essere utilizzato per eseguire attività specifiche della piattaforma come la modifica dell'ora modificata di un file utilizzando il comando "touch".

  • Gli script Ant sono scritti utilizzando XML semplice. Se hai già familiarità con XML, puoi imparare Ant abbastanza rapidamente.

  • Ant è brava ad automatizzare complicate attività ripetitive.

  • Ant viene fornito con un ampio elenco di attività predefinite.

  • Ant fornisce un'interfaccia per sviluppare attività personalizzate.

  • Ant può essere facilmente richiamato dalla riga di comando e può essere integrato con IDE gratuiti e commerciali.

Apache Ant Ant è distribuito con la licenza software Apache, una licenza open source a tutti gli effetti certificata dall'iniziativa open source.

L'ultima versione di Apache Ant, compreso il codice sorgente completo, i file di classe e la documentazione, è disponibile all'indirizzo http://ant.apache.org.

Installazione di Apache Ant

Si presume che tu abbia già scaricato e installato Java Development Kit (JDK) sul tuo computer. In caso contrario, segui le istruzioni qui .

  • Assicurati che la variabile d'ambiente JAVA_HOME sia impostata sulla cartella in cui è installato JDK.

  • Scarica i binari da http://ant.apache.org

  • Decomprimere il file zip in una posizione comoda nella cartella c: \. utilizzando Winzip, winRAR, 7-zip o strumenti simili.

  • Crea una nuova variabile d'ambiente chiamata ANT_HOME che punta alla cartella di installazione di Ant, in questo caso c:\apache-ant-1.8.2-bin cartella.

  • Aggiungi il percorso del file batch di Apache Ant alla variabile d'ambiente PATH. Nel nostro caso questo sarebbe il filec:\apache-ant-1.8.2-bin\bin cartella.

Verifica dell'installazione di Apache Ant

Per verificare la corretta installazione di Apache Ant sul tuo computer, digita ant nel prompt dei comandi.

Dovresti vedere un output simile a:

C:\>ant -version
Apache Ant(TM) version 1.8.2 compiled on December 20 2010

Se non vedi l'output sopra, verifica di aver seguito correttamente i passaggi di installazione.

Installazione di Eclipse

Questo tutorial copre anche l'integrazione di Ant con Eclipse IDE. Quindi, se non hai già installato Eclipse, scarica e installa Eclipse

Per installare Eclipse:

  • Scarica gli ultimi binari di Eclipse da www.eclipse.org

  • Decomprimere i binari di Eclipse in una posizione comoda, ad esempio cartella c: \

  • Esegui Eclipse da c: \ eclipse \ eclipse.exe

Tipicamente, il file build di Ant, chiamato build.xmldovrebbe risiedere nella directory di base del progetto. Tuttavia non ci sono restrizioni sul nome del file o sulla sua posizione. Sei libero di usare altri nomi di file o di salvare il file di build in qualche altra posizione.

Per questo esercizio, crea un file chiamato build.xml ovunque nel tuo computer con i seguenti contenuti:

<?xml version="1.0"?>
   <project name="Hello World Project" default="info">
   <target name="info">
      <echo>Hello World - Welcome to Apache Ant!</echo>
   </target>
</project>

Nota che non dovrebbero esserci righe o spazi vuoti prima della dichiarazione xml. Se li consenti, viene visualizzato il seguente messaggio di errore durante l'esecuzione di ant build:

La corrispondenza della destinazione dell'istruzione di elaborazione "[xX] [mM] [lL]" non è consentita. Tutti i file di build richiedono l'estensioneproject elemento e almeno uno target elemento.

L'elemento XML project ha tre attributi:

Attributi Descrizione
nome Il nome del progetto. (Opzionale)
predefinito La destinazione predefinita per lo script di build. Un progetto può contenere un numero qualsiasi di obiettivi. Questo attributo specifica quale target deve essere considerato come predefinito. (Obbligatorio)
basedir La directory di base (o) la cartella principale del progetto. (Opzionale)

Un obiettivo è una raccolta di attività che si desidera eseguire come un'unità. Nel nostro esempio, abbiamo un semplice obiettivo per fornire un messaggio informativo all'utente.

Le destinazioni possono avere dipendenze da altre destinazioni. Ad esempio, adeploy target può avere una dipendenza da package target, il package target può avere una dipendenza da compileobiettivo e così via. Le dipendenze sono indicate utilizzando ildependsattributo. Per esempio:

<target name="deploy" depends="package">
  ....
</target>
<target name="package" depends="clean,compile">
  ....
</target>
<target name="clean" >
  ....
</target>
<target name="compile" >
  ....
</target>

L'elemento di destinazione ha i seguenti attributi:

Attributi Descrizione
nome Il nome del target (obbligatorio)
dipende Elenco separato da virgole di tutti i target da cui dipende questo target. (Opzionale)
descrizione Una breve descrizione del target. (opzionale)
Se Consente l'esecuzione di un obiettivo basato sull'esattezza di un attributo condizionale. (opzionale)
salvo che Aggiunge la destinazione all'elenco delle dipendenze del punto di estensione specificato. Un punto di estensione è simile a un obiettivo, ma non ha alcuna attività. (Opzionale)

Il echotask nell'esempio precedente è un'attività banale che stampa un messaggio. Nel nostro esempio, stampa il messaggio Hello World .

Per eseguire il file di build ant, apri il prompt dei comandi e vai alla cartella in cui risiede build.xml e digita ant info. Puoi anche digitareantanziché. Entrambi funzioneranno, perchéinfoè la destinazione predefinita nel file di build. Dovresti vedere il seguente output:

C:\>ant
Buildfile: C:\build.xml

info: [echo] Hello World - Welcome to Apache Ant!

BUILD SUCCESSFUL
Total time: 0 seconds

C:\>

I file di build Ant sono scritti in XML, che non consente di dichiarare le variabili come fai nel tuo linguaggio di programmazione preferito. Tuttavia, come potresti aver immaginato, sarebbe utile se Ant consentisse di dichiarare variabili come il nome del progetto, la directory di origine del progetto, ecc.

Ant utilizza l'estensione propertyelemento che consente di specificare le proprietà. Ciò consente di modificare le proprietà da una build all'altra o da un ambiente a un altro.

Per impostazione predefinita, Ant fornisce le seguenti proprietà predefinite che possono essere utilizzate nel file di build:

Proprietà Descrizione
file ant La posizione completa del file di build.
ant.version La versione dell'installazione di Apache Ant.
basedir Il basedir della build, come specificato in basedir attributo del project elemento.
ant.java.version La versione del JDK utilizzata da Ant.
ant.project.name Il nome del progetto, come specificato nel file name atrribute di project elemento.
ant.project.default-target La destinazione predefinita del progetto corrente.
ant.project.invoked-target Elenco separato da virgole dei target che sono stati richiamati nel progetto corrente.
ant.core.lib La posizione completa del file jar Ant.
ant.home La home directory dell'installazione di Ant.
ant.library.dir La home directory per i file della libreria Ant, in genere la cartella ANT_HOME / lib.

Ant rende anche le proprietà di sistema (Esempio: file.separator) disponibili per il file di build.

Oltre a quanto sopra, l'utente può definire proprietà aggiuntive utilizzando il propertyelemento. L'esempio seguente mostra come definire una proprietà chiamatasitename:

<?xml version="1.0"?>
<project name="Hello World Project" default="info">
   <property name="sitename" value="www.tutorialspoint.com"/>
   <target name="info">
      <echo>Apache Ant version is ${ant.version} - You are 
         at ${sitename} </echo>
   </target>
</project>

L'esecuzione di Ant sul file di build precedente produce il seguente output:

C:\>ant
Buildfile: C:\build.xml

info: [echo] Apache Ant version is Apache Ant(TM) version 1.8.2  
      compiled on December 20 2010 - You are at www.tutorialspoint.com

BUILD SUCCESSFUL
Total time: 0 seconds
C:\>

L'impostazione delle proprietà direttamente nel file di build va bene, se stai lavorando con una manciata di proprietà. Tuttavia, per un progetto di grandi dimensioni, ha senso memorizzare le proprietà in un file di proprietà separato.

La memorizzazione delle proprietà in un file separato offre i seguenti vantaggi:

  • Ti consente di riutilizzare lo stesso file di build, con diverse impostazioni di proprietà per diversi ambienti di esecuzione. Ad esempio, il file delle proprietà di compilazione può essere mantenuto separatamente per gli ambienti DEV, TEST e PROD.

  • È utile quando non si conoscono i valori di una proprietà (in un particolare ambiente) in anticipo. Ciò consente di eseguire la compilazione in altri ambienti in cui è noto il valore della proprietà.

Non esiste una regola rigida e veloce, ma in genere il file delle proprietà è denominato build.properties e si trova accanto al build.xmlfile. È possibile creare più file delle proprietà di compilazione in base agli ambienti di distribuzione, ad esempiobuild.properties.dev e build.properties.test.

Il contenuto del file delle proprietà di compilazione è simile al normale file delle proprietà java. Contengono una proprietà per riga. Ogni proprietà è rappresentata da un nome e una coppia di valori. Le coppie nome e valore sono separate da un segno di uguale (=). Si consiglia vivamente di annotare le proprietà con commenti appropriati. I commenti sono elencati utilizzando il carattere cancelletto (#).

L'esempio seguente mostra un file build.xml file e i suoi associati build.properties file:

build.xml

<?xml version="1.0"?>
<project name="Hello World Project" default="info">
   <property file="build.properties"/>
      <target name="info">
         <echo>Apache Ant version is ${ant.version} - You are 
            at ${sitename} </echo>
      </target>
</project>

build.properties

# The Site Name
sitename=www.tutorialspoint.com
buildversion=3.3.2

Nell'esempio sopra, sitenameè una proprietà personalizzata che viene mappata al nome del sito web. È possibile dichiarare un numero qualsiasi di proprietà personalizzate in questo modo. Un'altra proprietà personalizzata elencata nell'esempio precedente èbuildversion, che, in questo caso, si riferisce alla versione della build.

Oltre a quanto sopra, Ant viene fornito con un numero di proprietà di compilazione predefinite, elencate nella sezione precedente, ma rappresentate di seguito ancora una volta.

Proprietà Descrizione
file ant La posizione completa del file di build.
ant.version La versione dell'installazione di Apache Ant.
basedir Il basedir della build, come specificato in basedir attributo del project elemento.
ant.java.version La versione del JDK utilizzata da Ant.
ant.project.name Il nome del progetto, come specificato nel file name atrribute di project elemento.
ant.project.default-target La destinazione predefinita del progetto corrente.
ant.project.invoked-target Elenco separato da virgole dei target che sono stati richiamati nel progetto corrente.
ant.core.lib La posizione completa del file jar Ant.
ant.home La home directory dell'installazione di Ant.
ant.library.dir La home directory per i file della libreria Ant, in genere la cartella ANT_HOME / lib.

L'esempio presentato in questo capitolo utilizza il ant.version proprietà incorporata.

Ant fornisce una serie di tipi di dati predefiniti. Non confondere il termine "tipi di dati" con quelli disponibili nel linguaggio di programmazione, considerali invece come un insieme di servizi già integrati nel prodotto.

I seguenti tipi di dati sono forniti da Apache Ant.

Set di file

I tipi di dati del set di file rappresentano una raccolta di file. Viene utilizzato come filtro per includere o escludere file che corrispondono a un modello particolare.

Ad esempio, fare riferimento al codice seguente. Qui, l'attributo src punta alla cartella di origine del progetto.

Il set di file seleziona tutti i file .java nella cartella di origine tranne quelli che contengono la parola "Stub". Il filtro con distinzione tra maiuscole e minuscole viene applicato al set di file, il che significa che un file con il nome Samplestub.java non verrà escluso dal set di file.

<fileset dir="${src}" casesensitive="yes">
   <include name="**/*.java"/>
   <exclude name="**/*Stub*"/>
</fileset>

Set di pattern

Un set di pattern è un pattern che consente di filtrare facilmente file o cartelle in base a determinati pattern. I modelli possono essere creati utilizzando i seguenti meta caratteri:

  • ? - Corrisponde a un solo carattere.

  • * - Corrisponde a zero o molti caratteri.

  • ** - Corrisponde a zero o molte directory in modo ricorsivo.

Il seguente esempio illustra l'utilizzo di un set di pattern.

<patternset id="java.files.without.stubs">
   <include name="src/**/*.java"/>
   <exclude name="src/**/*Stub*"/>
</patternset>

Il patternset può quindi essere riutilizzato con un set di file come segue:

<fileset dir="${src}" casesensitive="yes">
   <patternset refid="java.files.without.stubs"/>
</fileset>

Elenco dei file

Il tipo di dati filelist è simile al set di file tranne le seguenti differenze:

  • filelist contiene elenchi di file con nomi espliciti e non supporta i caratteri jolly.

  • Il tipo di dati filelist può essere applicato a file esistenti o non esistenti.

Vediamo il seguente esempio del tipo di dati filelist. Qui, l'attributowebapp.src.folder punta alla cartella di origine dell'applicazione Web del progetto.

<filelist id="config.files" dir="${webapp.src.folder}">
   <file name="applicationConfig.xml"/>
   <file name="faces-config.xml"/>
   <file name="web.xml"/>
   <file name="portlet.xml"/>
</filelist>

Set di filtri

Utilizzando un tipo di dati di un set di filtri insieme all'attività di copia, è possibile sostituire un determinato testo in tutti i file che corrisponde al modello con un valore di sostituzione.

Un esempio comune consiste nell'aggiungere il numero di versione al file delle note sulla versione, come mostrato nel codice seguente.

<copy todir="${output.dir}">
   <fileset dir="${releasenotes.dir}" includes="**/*.txt"/>
   <filterset>
      <filter token="VERSION" value="${current.version}"/>
   </filterset>
</copy>

In questo codice:

  • L'attributo output.dir punta alla cartella di output del progetto.

  • L'attributo releasenotes.dir punta alla cartella delle note di rilascio del progetto.

  • L'attributo current.version punta alla cartella della versione corrente del progetto.

  • L'attività di copia, come suggerisce il nome, viene utilizzata per copiare i file da una posizione a un'altra.

Sentiero

Il pathil tipo di dati è comunemente usato per rappresentare un percorso di classe. Le voci nel percorso vengono separate mediante punto e virgola o due punti. Tuttavia, questi caratteri vengono sostituiti in fase di esecuzione dal carattere separatore di percorso del sistema in esecuzione.

Il percorso di classe è impostato sull'elenco di file jar e classi nel progetto, come mostrato nell'esempio seguente.

<path id="build.classpath.jar">
   <pathelement path="${env.J2EE_HOME}/${j2ee.jar}"/>
   <fileset dir="lib">
      <include name="**/*.jar"/>
   </fileset>
</path>

In questo codice:

  • L'attributo env.J2EE_HOME punta alla variabile d'ambiente J2EE_HOME.

  • L'attributo j2ee.jar punta al nome del file jar J2EE nella cartella di base J2EE.

Ora che abbiamo imparato a conoscere i tipi di dati in Ant, è tempo di mettere in pratica questa conoscenza. Costruiremo un progetto in questo capitolo. Lo scopo di questo capitolo è costruire un file Ant che compili le classi java e le inserisca nella cartella WEB-INF \ classes.

Considera la seguente struttura del progetto:

  • Gli script del database vengono archiviati nel file db cartella.

  • Il codice sorgente java è archiviato nel file src cartella.

  • Le immagini, js, META-INF, stili (css) sono archiviate nel file war cartella.

  • I JSP vengono archiviati in jsp cartella.

  • I file jar di terze parti vengono archiviati nel file lib cartella.

  • I file di classe java sono archiviati in WEB-INF\classes cartella.

Questo progetto costituisce il Hello World Applicazione fax per il resto di questo tutorial.

C:\work\FaxWebApplication>tree
Folder PATH listing
Volume serial number is 00740061 EC1C:ADB1
C:.
+---db
+---src
.  +---faxapp
.  +---dao
.  +---entity
.  +---util
.  +---web
+---war
   +---images
   +---js
   +---META-INF
   +---styles
   +---WEB-INF
      +---classes
      +---jsp
      +---lib

Ecco il build.xml richiesto per questo progetto. Consideriamolo pezzo per pezzo.

<?xml version="1.0"?>
<project name="fax" basedir="." default="build">
   <property name="src.dir" value="src"/>
   <property name="web.dir" value="war"/>
   <property name="build.dir" value="${web.dir}/WEB-INF/classes"/>
   <property name="name" value="fax"/>

   <path id="master-classpath">
      <fileset dir="${web.dir}/WEB-INF/lib">
         <include name="*.jar"/>
      </fileset>
      <pathelement path="${build.dir}"/>
   </path>

   <target name="build" description="Compile source tree java files">
      <mkdir dir="${build.dir}"/>
      <javac destdir="${build.dir}" source="1.5" target="1.5">
         <src path="${src.dir}"/>
         <classpath refid="master-classpath"/>
      </javac>
   </target>
 
   <target name="clean" description="Clean output directories">
      <delete>
         <fileset dir="${build.dir}">
            <include name="**/*.class"/>
         </fileset>
      </delete>
   </target>
</project>

Innanzitutto, dichiariamo alcune proprietà per le cartelle di origine, Web e build.

<property name="src.dir" value="src"/>
<property name="web.dir" value="war"/>
<property name="build.dir" value="${web.dir}/WEB-INF/classes"/>

In questo esempio:

  • src.dir fa riferimento alla cartella di origine del progetto in cui è possibile trovare i file di origine java.

  • web.dir fa riferimento alla cartella delle sorgenti web del progetto, dove puoi trovare i file JSP, web.xml, css, javascript e altri file relativi al web

  • build.dir si riferisce alla cartella di output della compilation del progetto.

Le proprietà possono fare riferimento ad altre proprietà. Come mostrato nell'esempio sopra, ilbuild.dir fa riferimento al file web.dir proprietà.

In questo esempio, il src.dir fa riferimento alla cartella di origine del progetto.

L'obiettivo predefinito del nostro progetto è il compilebersaglio. Ma prima diamo un'occhiata al fileclean bersaglio.

Il target pulito, come suggerisce il nome, elimina i file nella cartella build.

<target name="clean" description="Clean output directories">
   <delete>
      <fileset dir="${build.dir}">
         <include name="**/*.class"/>
      </fileset>
   </delete>
</target>

Il percorso classe master contiene le informazioni sul percorso classe. In questo caso, include le classi nella cartella build e i file jar nella cartella lib.

<path id="master-classpath">
   <fileset dir="${web.dir}/WEB-INF/lib">
      <include name="*.jar"/>
   </fileset>
   <pathelement path="${build.dir}"/>
</path>

Infine, l'obiettivo di compilazione per creare i file. Prima di tutto, creiamo la directory build, se non esiste. Quindi eseguiamo il comando javac (specificando jdk1.5 come compilazione di destinazione). Forniamo la cartella di origine e il percorso di classe all'attività javac e gli chiediamo di rilasciare i file di classe nella cartella build.

<target name="build" description="Compile main source tree java files">
   <mkdir dir="${build.dir}"/>
   <javac destdir="${build.dir}" source="1.5" target="1.5" debug="true"
      deprecation="false" optimize="false" failonerror="true">
      <src path="${src.dir}"/>
      <classpath refid="master-classpath"/>
   </javac>
</target>

L'esecuzione di Ant su questo file compila i file sorgente java e inserisce le classi nella cartella build.

Il seguente risultato è il risultato dell'esecuzione del file Ant:

C:\>ant
Buildfile: C:\build.xml

BUILD SUCCESSFUL
Total time: 6.3 seconds

I file vengono compilati e inseriti nel file build.dir cartella.

La documentazione è un must in qualsiasi progetto. La documentazione gioca un ruolo importante nella manutenzione di un progetto. Java semplifica la documentazione grazie all'uso del filejavadocattrezzo. Ant lo rende ancora più semplice generando la documentazione su richiesta.

Come sapete, lo strumento javadoc è altamente flessibile e consente una serie di opzioni di configurazione. Ant espone queste opzioni di configurazione tramite l'attività javadoc. Se non hai familiarità con javadocs, ti suggeriamo di iniziare con questo tutorial sulla documentazione di Java .

La sezione seguente elenca le opzioni javadoc più comunemente utilizzate che vengono utilizzate in Ant.

Attributi

La sorgente può essere specificata usando sourcepath, sourcepathref o sourcefiles.

  • sourcepath è usato per puntare alla cartella dei file di origine (es. cartella src).

  • sourcepathref viene utilizzato per fare riferimento a un percorso a cui fa riferimento l'attributo path (ad esempio, delegates.src.dir).

  • sourcefiles viene utilizzato quando si desidera specificare i singoli file come elenco separato da virgole.

Il percorso di destinazione viene specificato utilizzando il destdir cartella (ad esempio build.dir).

Puoi filtrare il file javadocattività specificando i nomi dei pacchetti da includere. Ciò si ottiene utilizzando ilpackagenames attributo, un elenco separato da virgole di file di pacchetto.

È possibile filtrare il processo javadoc per mostrare solo le classi ei membri pubblici, privati, del pacchetto o protetti. Ciò si ottiene utilizzando ilprivate, public, package e protected attributi.

Si potrebbe anche dire all'attività javadoc di includere le informazioni sull'autore e sulla versione utilizzando i rispettivi attributi.

Puoi anche raggruppare i pacchetti usando il file group attributo, in modo che diventi facile da navigare.

Mettere tutto insieme

Continuiamo il nostro tema del Hello worldApplicazione fax. Aggiungiamo un obiettivo di documentazione al nostro progetto di applicazione Fax.

Di seguito è riportato un esempio di attività javadoc utilizzata nel nostro progetto. In questo esempio, abbiamo specificato il javadoc per utilizzare ilsrc.dir come directory di origine e doc come bersaglio.

Abbiamo anche personalizzato il titolo della finestra, l'intestazione e le informazioni sul piè di pagina che appaiono nelle pagine della documentazione di Java.

Inoltre, abbiamo creato tre gruppi:

  • uno per le classi di utilità nella nostra cartella dei sorgenti,
  • uno per le classi delle interfacce utente e
  • uno per le classi relative al database.

È possibile notare che il gruppo di pacchetti di dati ha due pacchetti: faxapp.entity e faxapp.dao.

<target name="generate-javadoc">
   <javadoc packagenames="faxapp.*" sourcepath="${src.dir}" 
      destdir="doc" version="true" windowtitle="Fax Application">
      <doctitle><![CDATA[= Fax Application =]]></doctitle>
      <bottom>
         <![CDATA[Copyright © 2011. All Rights Reserved.]]>
      </bottom>
      <group title="util packages" packages="faxapp.util.*"/>
      <group title="web packages" packages="faxapp.web.*"/>
      <group title="data packages" 
         packages="faxapp.entity.*:faxapp.dao.*"/>
   </javadoc>
   <echo message="java doc has been generated!" />
</target>

Eseguiamo il task javadoc Ant. Genera e inserisce i file di documentazione java nella cartella doc.

Quando il javadoc target viene eseguito, produce il seguente risultato: 

C:\>ant generate-javadoc
Buildfile: C:\build.xml

java doc has been generated!

BUILD SUCCESSFUL
Total time: 10.63 second

I file di documentazione java sono ora presenti in doc cartella.

In genere, i file javadoc vengono generati come parte del rilascio o delle destinazioni del pacchetto.

Il passaggio logico successivo dopo aver compilato i file di origine java è creare l'archivio java, ovvero il file JAR. Creare file JAR con Ant è abbastanza semplice con l'estensionejarcompito. Gli attributi comunemente usati dell'attività jar sono i seguenti:

Attributi Descrizione
basedir La directory di base per il file JAR di output. Per impostazione predefinita, questo è impostato sulla directory di base del progetto.
comprimere Consiglia ad Ant di comprimere il file mentre crea il file JAR.
keepcompression Mentre il compress l'attributo è applicabile ai singoli file, il keepcompression attributo fa la stessa cosa, ma si applica all'intero archivio.
destfile Il nome del file JAR di output.
duplicare Consiglia Ant su cosa fare quando vengono trovati file duplicati. È possibile aggiungere, conservare o fallire i file duplicati.
esclude Consiglia ad Ant di non includere questi elenchi di file separati da virgole nel pacchetto.
esclude file Come sopra, tranne per i file di esclusione specificati utilizzando un modello.
inlcudes Inverso di esclude.
includefile Inverso di exclesfile.
aggiornare Consiglia ad Ant di sovrascrivere i file nel file JAR già creato.

Continuando il nostro Hello WorldProgetto applicazione fax, aggiungiamo un nuovo target per produrre i file jar. Ma prima, consideriamo il compito del vaso indicato di seguito.

<jar destfile="${web.dir}/lib/util.jar"
   basedir="${build.dir}/classes"
   includes="faxapp/util/**"
   excludes="**/Test.class"
/>

Qui, il web.dirproprietà punta al percorso dei file di origine web. Nel nostro caso, è qui che verrà posizionato util.jar.

Il build.dir in questo esempio punta alla cartella build in cui è possibile trovare i file di classe per util.jar.

In questo esempio, creiamo un file jar chiamato util.jar utilizzando le classi di faxapp.util.*pacchetto. Tuttavia, escludiamo le classi che terminano con il nome Test. Il file jar di output verrà inserito nella cartella lib dell'applicazione web.

Se vogliamo rendere util.jar un file jar eseguibile, dobbiamo aggiungere il file manifest con il Main-Class meta attributo.

Pertanto, l'esempio sopra verrà aggiornato come:

<jar destfile="${web.dir}/lib/util.jar"
   basedir="${build.dir}/classes"
   includes="faxapp/util/**"
   excludes="**/Test.class">
   <manifest>
      <attribute name="Main-Class" value="com.tutorialspoint.util.FaxUtil"/>
   </manifest>
</jar>

Per eseguire l'attività jar, racchiudila in una destinazione, più comunemente, la build o la destinazione del pacchetto, ed eseguili.

<target name="build-jar">
<jar destfile="${web.dir}/lib/util.jar"
   basedir="${build.dir}/classes"
   includes="faxapp/util/**"
   excludes="**/Test.class">
   <manifest>
      <attribute name="Main-Class" value="com.tutorialspoint.util.FaxUtil"/>
   </manifest>
</jar>
</target>

L'esecuzione di Ant su questo file crea il file util.jar per noi.

Il seguente risultato è il risultato dell'esecuzione del file Ant: 

C:\>ant build-jar
Buildfile: C:\build.xml

BUILD SUCCESSFUL
Total time: 1.3 seconds

Il file util.jar è ora posizionato nella cartella di output.

La creazione di file WAR con Ant è estremamente semplice e molto simile all'attività di creazione di file JAR. Dopotutto, il file WAR, come il file JAR, è solo un altro file ZIP.

L'attività WAR è un'estensione dell'attività JAR, ma ha alcune belle aggiunte per manipolare ciò che va nella cartella WEB-INF / classes e generare il file web.xml. L'attività WAR è utile per specificare un particolare layout del file WAR.

Poiché l'attività WAR è un'estensione dell'attività JAR, tutti gli attributi dell'attività JAR si applicano all'attività WAR.

Attributi Descrizione
webxml Percorso del file web.xml
lib Un raggruppamento per specificare cosa va nella cartella WEB-INF \ lib.
classi Un raggruppamento per specificare cosa va nella cartella WEB-INF \ classes.
metainf Specifica le istruzioni per la generazione del file MANIFEST.MF.

Continuando il nostro Hello WorldProgetto applicazione fax, aggiungiamo un nuovo target per produrre i file jar. Ma prima consideriamo il compito di guerra. Considera il seguente esempio:

<war destfile="fax.war" webxml="${web.dir}/web.xml">
   <fileset dir="${web.dir}/WebContent">
      <include name="**/*.*"/>
   </fileset>
   <lib dir="thirdpartyjars">
      <exclude name="portlet.jar"/>
   </lib>
   <classes dir="${build.dir}/web"/>
</war>

Come negli esempi precedenti, il web.dir variabile fa riferimento alla cartella web di origine, ovvero la cartella che contiene i file JSP, css, javascript ecc.

Il build.dirla variabile fa riferimento alla cartella di output: qui è possibile trovare le classi per il pacchetto WAR. In genere, le classi verranno raggruppate nella cartella WEB-INF / classes del file WAR.

In questo esempio, stiamo creando un file war chiamato fax.war. Il file WEB.XML si ottiene dalla cartella di origine web. Tutti i file dalla cartella "WebContent" sotto il web vengono copiati nel file WAR.

La cartella WEB-INF / lib viene popolata con i file jar dalla cartella jars di terze parti. Tuttavia, stiamo escludendo portlet.jar poiché è già presente nella cartella lib del server delle applicazioni. Infine, stiamo copiando tutte le classi dalla cartella web della directory build e inserendole nella cartella WEB-INF / classes.

Avvolgi il compito di guerra all'interno di un bersaglio Ant (di solito pacchetto) ed eseguilo. Questo creerà il file WAR nella posizione specificata.

È del tutto possibile annidare i direttori di classi, lib, metainf e webinf in modo che risiedano in cartelle sparse ovunque nella struttura del progetto. Tuttavia, le migliori pratiche suggeriscono che il progetto Web dovrebbe avere la struttura del contenuto Web simile alla struttura del file WAR. Il progetto Fax Application ha la sua struttura delineata utilizzando questo principio di base.

Per eseguire l'attività di guerra, racchiudila in un obiettivo, più comunemente, l'obiettivo di compilazione o pacchetto, ed eseguili.

<target name="build-war">
   <war destfile="fax.war" webxml="${web.dir}/web.xml">
   <fileset dir="${web.dir}/WebContent">
      <include name="**/*.*"/>
   </fileset>
   <lib dir="thirdpartyjars">
      <exclude name="portlet.jar"/>
   </lib>
   <classes dir="${build.dir}/web"/>
   </war>
</target>

L'esecuzione di Ant su questo file creerà il file fax.war file per noi.

Il seguente risultato è il risultato dell'esecuzione del file Ant: 

C:\>ant build-war
Buildfile: C:\build.xml

BUILD SUCCESSFUL
Total time: 12.3 seconds

Il file fax.war si trova ora nella cartella di output. Il contenuto del file war sarà:

fax.war:
   +---jsp             This folder contains the jsp files
   +---css             This folder contains the stylesheet files
   +---js              This folder contains the javascript files
   +---images          This folder contains the image files
   +---META-INF        This folder contains the Manifest.Mf
   +---WEB-INF
      +---classes   This folder contains the compiled classes
      +---lib       Third party libraries and the utility jar files
      WEB.xml       Configuration file that defines the WAR package

Abbiamo imparato i diversi aspetti di Ant utilizzando il Hello World Applicazione web fax a pezzi.

Ora è il momento di mettere tutto insieme per creare un file build.xml completo e completo. Ritenerebuild.properties e build.xml file come segue:

build.properties

deploy.path=c:\tomcat6\webapps

build.xml

<?xml version="1.0"?>

<project name="fax" basedir="." default="usage">
   <property file="build.properties"/>
   <property name="src.dir" value="src"/>
   <property name="web.dir" value="war"/>
   <property name="javadoc.dir" value="doc"/>
   <property name="build.dir" value="${web.dir}/WEB-INF/classes"/>
   <property name="name" value="fax"/>

   <path id="master-classpath">
      <fileset dir="${web.dir}/WEB-INF/lib">
         <include name="*.jar"/>
      </fileset>
      <pathelement path="${build.dir}"/>
   </path>
    
   <target name="javadoc">
      <javadoc packagenames="faxapp.*" sourcepath="${src.dir}" 
         destdir="doc" version="true" windowtitle="Fax Application">
      <doctitle><![CDATA[<h1>= Fax Application =</h1>]]>
      </doctitle>
      <bottom><![CDATA[Copyright © 2011. All Rights Reserved.]]>
      </bottom>
      <group title="util packages" packages="faxapp.util.*"/>
      <group title="web packages" packages="faxapp.web.*"/> 
      <group title="data packages" 
         packages="faxapp.entity.*:faxapp.dao.*"/>
      </javadoc>
   </target>

   <target name="usage">
      <echo message=""/>
      <echo message="${name} build file"/>
      <echo message="-----------------------------------"/>
      <echo message=""/>
      <echo message="Available targets are:"/>
      <echo message=""/>
      <echo message="deploy    --> Deploy application as directory"/>
      <echo message="deploywar --> Deploy application as a WAR file"/>
      <echo message=""/>
   </target>

   <target name="build" description="Compile main 
      source tree java files">
   <mkdir dir="${build.dir}"/>
      <javac destdir="${build.dir}" source="1.5" 
         target="1.5" debug="true"
         deprecation="false" optimize="false" failonerror="true">
      <src path="${src.dir}"/>
      <classpath refid="master-classpath"/>
      </javac>
   </target>

   <target name="deploy" depends="build" 
      description="Deploy application">
   <copy todir="${deploy.path}/${name}" 
      preservelastmodified="true">
      <fileset dir="${web.dir}">
         <include name="**/*.*"/>
      </fileset>
   </copy>
   </target>

   <target name="deploywar" depends="build" 
      description="Deploy application as a WAR file">
      <war destfile="${name}.war"
         webxml="${web.dir}/WEB-INF/web.xml">
         <fileset dir="${web.dir}">
            <include name="**/*.*"/>
         </fileset>
      </war>
      <copy todir="${deploy.path}" preservelastmodified="true">
         <fileset dir=".">
            <include name="*.war"/>
         </fileset>
      </copy>
   </target>
    

   <target name="clean" description="Clean output directories">
      <delete>
         <fileset dir="${build.dir}">
            <include name="**/*.class"/>
         </fileset>
      </delete>
   </target>
</project>

In questo esempio:

  • Per prima cosa dichiariamo il percorso della cartella webapps in Tomcat nel file delle proprietà di build come deploy.path variabile.

  • Dichiariamo anche la cartella di origine per i file java in src.dir variabile.

  • Quindi dichiariamo la cartella di origine per i file Web nel file web.dir variabile. javadoc.dir è la cartella per l'archiviazione della documentazione java e build.dir è il percorso per l'archiviazione dei file di output della build.

  • Quindi dichiariamo il nome dell'applicazione web, che è fax nel nostro caso.

  • Definiamo anche il master class path che contiene i file JAR presenti nella cartella WEB-INF / lib del progetto.

  • Includiamo anche i file di classe presenti nel file build.dir nel percorso della master class.

  • Il target Javadoc produce il javadoc richiesto per il progetto e il target di utilizzo viene utilizzato per stampare i target comuni presenti nel file di build.

L'esempio precedente mostra due obiettivi di distribuzione: deploy e deploywar.

La destinazione di distribuzione copia i file dalla directory Web alla directory di distribuzione mantenendo l'ultima modifica data e ora. Ciò è utile durante la distribuzione su un server che supporta la distribuzione a caldo.

La destinazione pulita cancella tutti i file creati in precedenza.

La destinazione deploywar crea il file war e quindi copia il file war nella directory deploy del server delle applicazioni.

Nel capitolo precedente abbiamo imparato come creare un pacchetto di un'applicazione e distribuirla in una cartella.

In questo capitolo, distribuiremo l'applicazione Web direttamente nella cartella di distribuzione del server delle applicazioni, quindi aggiungeremo alcune destinazioni Ant per avviare e arrestare i servizi. Continuiamo con ilHello Worldapplicazione web fax. Questa è una continuazione del capitolo precedente, i nuovi componenti sono evidenziati in grassetto.

build.properties

# Ant properties for building the springapp

appserver.home=c:\\install\\apache-tomcat-7.0.19
# for Tomcat 5 use $appserver.home}/server/lib
# for Tomcat 6 use $appserver.home}/lib
appserver.lib=${appserver.home}/lib

deploy.path=${appserver.home}/webapps

tomcat.manager.url=http://www.tutorialspoint.com:8080/manager
tomcat.manager.username=tutorialspoint
tomcat.manager.password=secret

build.xml

<?xml version="1.0"?>

<project name="fax" basedir="." default="usage">
   <property file="build.properties"/>
   <property name="src.dir" value="src"/>
   <property name="web.dir" value="war"/>
   <property name="javadoc.dir" value="doc"/>
   <property name="build.dir" value="${web.dir}/WEB-INF/classes"/>
   <property name="name" value="fax"/>

   <path id="master-classpath">
      <fileset dir="${web.dir}/WEB-INF/lib">
         <include name="*.jar"/>
      </fileset>
   <pathelement path="${build.dir}"/>
   </path>
    
   <target name="javadoc">
   <javadoc packagenames="faxapp.*" sourcepath="${src.dir}" 
      destdir="doc" version="true" windowtitle="Fax Application">
      <doctitle><![CDATA[<h1>= Fax Application 
         =</h1>]]></doctitle>
      <bottom><![CDATA[Copyright © 2011. All 
         Rights Reserved.]]></bottom>
      <group title="util packages" packages="faxapp.util.*"/>
      <group title="web packages" packages="faxapp.web.*"/>
      <group title="data packages" packages="faxapp.entity.*:faxapp.dao.*"/>
   </javadoc>
   </target>

   <target name="usage">
   <echo message=""/>
   <echo message="${name} build file"/>
   <echo message="-----------------------------------"/>
   <echo message=""/>
   <echo message="Available targets are:"/>
   <echo message=""/>
   <echo message="deploy    --> Deploy application as directory"/>
   <echo message="deploywar --> Deploy application as a WAR file"/>
   <echo message=""/>
   </target>

   <target name="build" description="Compile main 
      source tree java files">
   <mkdir dir="${build.dir}"/>
   <javac destdir="${build.dir}" source="1.5" target="1.5" debug="true"
      deprecation="false" optimize="false" failonerror="true">
      <src path="${src.dir}"/>
      <classpath refid="master-classpath"/>
   </javac>
   </target>

   <target name="deploy" depends="build" description="Deploy application">
      <copy todir="${deploy.path}/${name}" 
         preservelastmodified="true">
         <fileset dir="${web.dir}">
            <include name="**/*.*"/>
         </fileset>
      </copy>
   </target>

   <target name="deploywar" depends="build" 
      description="Deploy application as a WAR file">
      <war destfile="${name}.war"
         webxml="${web.dir}/WEB-INF/web.xml">
         <fileset dir="${web.dir}">
            <include name="**/*.*"/>
         </fileset>
      </war>
      <copy todir="${deploy.path}" preservelastmodified="true">
         <fileset dir=".">
            <include name="*.war"/>
         </fileset>
      </copy>
   </target>
    

   <target name="clean" description="Clean output directories">
      <delete>
         <fileset dir="${build.dir}">
            <include name="**/*.class"/>
         </fileset>
      </delete>
   </target>
<!-- ============================================================ -->
<!-- Tomcat tasks -->
<!-- ============================================================ -->

<path id="catalina-ant-classpath">
<!-- We need the Catalina jars for Tomcat -->
<!--  * for other app servers - check the docs -->
   <fileset dir="${appserver.lib}">
      <include name="catalina-ant.jar"/>
   </fileset>
</path>

<taskdef name="install" classname="org.apache.catalina.ant.InstallTask">
   <classpath refid="catalina-ant-classpath"/>
</taskdef>
<taskdef name="reload" classname="org.apache.catalina.ant.ReloadTask">
   <classpath refid="catalina-ant-classpath"/>
</taskdef>
<taskdef name="list" classname="org.apache.catalina.ant.ListTask">
   <classpath refid="catalina-ant-classpath"/>
</taskdef>
<taskdef name="start" classname="org.apache.catalina.ant.StartTask">
   <classpath refid="catalina-ant-classpath"/>
</taskdef>
<taskdef name="stop" classname="org.apache.catalina.ant.StopTask">
   <classpath refid="catalina-ant-classpath"/>
</taskdef>

<target name="reload" description="Reload application in Tomcat">
   <reload url="${tomcat.manager.url}"username="${tomcat.manager.username}"
      password="${tomcat.manager.password}" path="/${name}"/>
</target>
</project>

In questo esempio, abbiamo utilizzato Tomcat come server delle applicazioni. Innanzitutto, nel file delle proprietà di compilazione, abbiamo definito alcune proprietà aggiuntive.

  • Il appserver.home punta al percorso di installazione del server delle applicazioni Tomcat.

  • Il appserver.lib punta ai file di libreria nella cartella di installazione di Tomcat.

  • Il deploy.path variabile ora punta alla cartella webapp in Tomcat.

Le applicazioni in Tomcat possono essere interrotte e avviate utilizzando l'applicazione di gestione Tomcat. L'URL per l'applicazione del gestore, il nome utente e la password sono specificati anche nel file build.properties. Successivamente, dichiariamo un nuovo CLASSPATH che contiene l'estensionecatalina-ant.jar. Questo file jar è necessario per eseguire le attività Tomcat tramite Apache Ant.

Il catalina-ant.jar fornisce le seguenti attività:

Proprietà Descrizione
InstallTask Installa un'applicazione web. Nome classe: org.apache.catalina.ant.InstallTask
ReloadTask Ricarica un'applicazione web. Nome classe: org.apache.catalina.ant.ReloadTask
ListTask Elenca tutte le applicazioni web. Nome classe: org.apache.catalina.ant.ListTask
StartTask Avvia un'applicazione web. Nome classe: org.apache.catalina.ant.StartTask
StopTask Arresta un'applicazione web. Nome classe: org.apache.catalina.ant.StopTask
ReloadTask Ricarica un'applicazione web senza fermarsi. Nome classe: org.apache.catalina.ant.ReloadTask

L'attività di ricarica richiede i seguenti parametri aggiuntivi:

  • URL all'applicazione di gestione
  • Nome utente per riavviare l'applicazione web
  • Password per riavviare l'applicazione web
  • Nome dell'applicazione web da riavviare

Emettiamo il file deploy-warcomando per copiare la webapp nella cartella webapps di Tomcat e quindi ricaricare l'applicazione Web Fax. Il seguente risultato è il risultato dell'esecuzione del file Ant:

C:\>ant deploy-war
Buildfile: C:\build.xml

BUILD SUCCESSFUL
Total time: 6.3 seconds

C:\>ant reload
Buildfile: C:\build.xml

BUILD SUCCESSFUL
Total time: 3.1 seconds

Una volta eseguita l'attività di cui sopra, l'applicazione Web viene distribuita e l'applicazione Web viene ricaricata.

Puoi usare Ant per eseguire codice Java. Nell'esempio seguente, la classe java accetta un argomento (indirizzo e-mail dell'amministratore) e invia un'e-mail.

public class NotifyAdministrator
{
   public static void main(String[] args)
   {
      String email = args[0];
      notifyAdministratorviaEmail(email);
      System.out.println("Administrator "+email+" has been notified");
   }
   public static void notifyAdministratorviaEmail(String email
   { 
	   //......
   }
}

Ecco una semplice build che esegue questa classe java.

<?xml version="1.0"?>
<project name="sample" basedir="." default="notify">
   <target name="notify">
      <java fork="true" failonerror="yes" classname="NotifyAdministrator">
         <arg line="[email protected]"/>
      </java>
   </target>
</project>

Quando la compilazione viene eseguita, produce il seguente risultato: 

C:\>ant
Buildfile: C:\build.xml

notify: [java] Administrator [email protected] has been notified

BUILD SUCCESSFUL
Total time: 1 second

In questo esempio, il codice java fa una cosa semplice: inviare un'e-mail. Avremmo potuto utilizzare il compito integrato nell'ant per farlo. Tuttavia, ora che hai l'idea, puoi estendere il tuo file di build per chiamare il codice java che esegue cose complicate, ad esempio: crittografa il tuo codice sorgente.

Se hai già scaricato e installato Eclipse, hai ben poco da fare per iniziare. Eclipse viene fornito in bundle con il plug-in Ant, pronto per l'uso.

Segui i semplici passaggi per integrare Ant in Eclipse.

  • Assicurati che build.xml faccia parte del tuo progetto java e non risieda in una posizione esterna al progetto.

  • Abilita Ant View seguendo Window > Show View > Other > Ant > Ant.

  • Apri Project Explorer, trascina il file build.xml in Ant View.

La tua visualizzazione Ant è simile a:

Facendo clic sui target, build / clean / usage eseguirà Ant con il target.

Facendo clic su "fax" verrà eseguito il target predefinito - usage.

Il plugin Ant Eclipse include anche un buon editor per modificare i file build.xml. L'editor conosce lo schema build.xml e può aiutarti con il completamento del codice.

Per utilizzare l'editor Ant, fai clic con il pulsante destro del mouse su build.xml (da Project Explorer) e seleziona Apri con> Ant Editor. L'editor Ant dovrebbe avere un aspetto simile a:

L'editor Ant elenca i bersagli sul lato destro. L'elenco di destinazione funge da segnalibro che consente di passare direttamente alla modifica di un determinato obiettivo.

JUnit è il framework di unit test comunemente utilizzato per gli sviluppi basati su Java. È facile da usare e facile da estendere. Sono disponibili numerose estensioni JUnit. Se non hai familiarità con JUnit, dovresti scaricarlo da www.junit.org e leggere il suo manuale.

Questo capitolo mostra come eseguire i test JUnit utilizzando Ant. Ant rende semplice l'operazione JUnit.

Gli attributi dell'attività JUnit sono presentati di seguito:

Proprietà Descrizione
dir Da dove richiamare la VM. Questo viene ignorato quandofork è disabilitato.
jvm Comando utilizzato per richiamare la JVM. Questo viene ignorato quandofork è disabilitato.
forchetta Esegue il test in una JVM separata
errorproperty Il nome della proprietà da impostare in caso di errore JUnit
proprietà fallimento Il nome della proprietà da impostare se si verifica un errore JUnit
haltonerror Arresta l'esecuzione quando si verifica un errore di prova
haltonfailure Arresta l'esecuzione quando si verifica un errore
riepilogo della stampa Consiglia ad Ant di visualizzare semplici statistiche per ogni test
showoutput Consiglia ad Ant di inviare l'output ai suoi log e formattatori
tempdir Percorso del file temporaneo che Ant utilizzerà
tempo scaduto Esce dai test che richiedono più tempo rispetto a questa impostazione (in millisecondi).

Continuiamo il tema del Hello World Invia fax all'applicazione Web e aggiungi una destinazione JUnit.

L'esempio seguente mostra una semplice esecuzione di test JUnit:

<target name="unittest">
   <junit haltonfailure="true" printsummary="true">
      <test name="com.tutorialspoint.UtilsTest"/>
   </junit>
</target>

Questo esempio mostra l'esecuzione di JUnit sulla classe junit com.tutorialspoint.UtilsTest. L'esecuzione del codice precedente produce il seguente output:

test:
[echo] Testing the application
[junit] Running com.tutorialspoint.UtilsTest
[junit] Tests run: 12, Failures: 0, Errors: 0, Time elapsed: 16.2 sec
BUILD PASSED

Ant viene fornito con una serie predefinita di attività, tuttavia puoi creare le tue attività, come mostrato nell'esempio seguente.

Le attività formiche personalizzate dovrebbero estendere l'estensione org.apache.tools.ant.Taskclasse e dovrebbe estendere il metodo execute (). Di seguito è riportato un semplice esempio:

package com.tutorialspoint.ant;
import org.apache.tools.ant.Task;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.BuildException;
public class MyTask extends Task {
   String message;
   public void execute() throws BuildException {
      log("Message: " + message, Project.MSG_INFO);
   }
   public void setMessage(String message) {
      this.message= message;
   }
}

Per eseguire l'attività personalizzata, è necessario aggiungere quanto segue al file Hello World Applicazione web fax:

<target name="custom">
   <taskdef name="custom" classname="com.tutorialspoint.ant.MyTask" />
   <custom message="Hello World!"/>
</target>

L'esecuzione dell'attività personalizzata precedente stampa il messaggio "Hello World!"

c:\>ant custom
test:
[custom] Message : Hello World!
elapsed: 0.2 sec
BUILD PASSED

Questo è solo un semplice esempio, puoi usare la potenza di Ant per fare tutto ciò che vuoi per migliorare il tuo processo di creazione e distribuzione.

Stampa