Guide rapide des fourmis

ANT signifie Another Neat Tool. Il s'agit d'un outil de construction basé sur Java d'Apache. Avant d'entrer dans les détails d'Apache Ant, voyons d'abord pourquoi nous avons besoin d'un outil de construction en premier lieu.

Besoin d'un outil de construction

En moyenne, un développeur passe beaucoup de temps à effectuer des tâches banales telles que la construction et le déploiement, notamment:

  • Compiler le code
  • Empaquetage des binaires
  • Déploiement des binaires sur le serveur de test
  • Tester les changements
  • Copier le code d'un emplacement à un autre

Pour automatiser et simplifier les tâches ci-dessus, Apache Ant est utile. Il s'agit d'un outil de création et de déploiement de système d'exploitation qui peut être exécuté à partir de la ligne de commande.

Histoire d'Apache Ant

  • Ant a été créé par James Duncan Davidson (l'auteur original de Tomcat).

  • Il a été utilisé à l'origine pour construire Tomcat et a été intégré dans la distribution Tomcat.

  • Ant est né des problèmes et des complexités associés à l'outil Apache Make.

  • Ant a été promu en tant que projet indépendant dans Apache en 2000. La dernière version d'Apache Ant en mai 2014 est la 1.9.4.

Caractéristiques d'Apache Ant

  • Ant est l'outil de création et de déploiement Java le plus complet disponible.

  • Ant est indépendant de la plate-forme et peut gérer des propriétés spécifiques à la plate-forme, telles que les séparateurs de fichiers.

  • Ant peut être utilisé pour effectuer des tâches spécifiques à la plate-forme telles que la modification de l'heure de modification d'un fichier à l'aide de la commande «tactile».

  • Les scripts Ant sont écrits en utilisant du XML brut. Si vous êtes déjà familiarisé avec XML, vous pouvez apprendre Ant assez rapidement.

  • Ant est doué pour automatiser les tâches répétitives complexes.

  • Ant est livré avec une grande liste de tâches prédéfinies.

  • Ant fournit une interface pour développer des tâches personnalisées.

  • Ant peut être facilement appelé à partir de la ligne de commande et s'intégrer aux IDE gratuits et commerciaux.

Apache Ant Ant est distribué sous la licence logicielle Apache, une licence open source à part entière certifiée par l'initiative open source.

La dernière version d'Apache Ant, y compris son code source complet, ses fichiers de classe et sa documentation, est disponible sur http://ant.apache.org.

Installer Apache Ant

On suppose que vous avez déjà téléchargé et installé Java Development Kit (JDK) sur votre ordinateur. Sinon, veuillez suivre les instructions ici .

  • Assurez-vous que la variable d'environnement JAVA_HOME est définie sur le dossier dans lequel votre JDK est installé.

  • Téléchargez les binaires depuis http://ant.apache.org

  • Décompressez le fichier zip dans un emplacement pratique dans le dossier c: \. en utilisant Winzip, winRAR, 7-zip ou des outils similaires.

  • Créez une nouvelle variable d'environnement appelée ANT_HOME qui pointe vers le dossier d'installation Ant, dans ce cas c:\apache-ant-1.8.2-bin dossier.

  • Ajoutez le chemin du fichier de commandes Apache Ant à la variable d'environnement PATH. Dans notre cas, ce serait lec:\apache-ant-1.8.2-bin\bin dossier.

Vérification de l'installation d'Apache Ant

Pour vérifier la réussite de l'installation d'Apache Ant sur votre ordinateur, tapez ant sur votre invite de commande.

Vous devriez voir une sortie similaire à:

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

Si vous ne voyez pas la sortie ci-dessus, veuillez vérifier que vous avez correctement suivi les étapes d'installation.

Installer Eclipse

Ce didacticiel couvre également l'intégration d'Ant avec Eclipse IDE. Par conséquent, si vous n'avez pas déjà installé Eclipse, veuillez télécharger et installer Eclipse

Pour installer Eclipse:

  • Téléchargez les derniers binaires Eclipse sur www.eclipse.org

  • Décompressez les binaires Eclipse dans un emplacement pratique, par exemple le dossier c: \

  • Exécutez Eclipse à partir de c: \ eclipse \ eclipse.exe

En règle générale, le fichier de construction d'Ant, appelé build.xmldoit résider dans le répertoire de base du projet. Cependant, il n'y a aucune restriction sur le nom du fichier ou son emplacement. Vous êtes libre d'utiliser d'autres noms de fichiers ou d'enregistrer le fichier de construction dans un autre emplacement.

Pour cet exercice, créez un fichier appelé build.xml n'importe où sur votre ordinateur avec le contenu suivant:

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

Notez qu'il ne doit y avoir aucune ligne ou espace (s) vide (s) avant la déclaration xml. Si vous les autorisez, le message d'erreur suivant s'affiche lors de l'exécution de la génération de fourmi -

La cible de l'instruction de traitement correspondant à "[xX] [mM] [lL]" n'est pas autorisée. Tous les fichiers de construction nécessitent leproject élément et au moins un target élément.

L'élément XML project a trois attributs:

Les attributs La description
Nom Le nom du projet. (Optionnel)
défaut La cible par défaut du script de construction. Un projet peut contenir n'importe quel nombre de cibles. Cet attribut spécifie quelle cible doit être considérée comme la cible par défaut. (Obligatoire)
basedir Le répertoire de base (ou) le dossier racine du projet. (Optionnel)

Une cible est un ensemble de tâches que vous souhaitez exécuter comme une seule unité. Dans notre exemple, nous avons une cible simple pour fournir un message d'information à l'utilisateur.

Les cibles peuvent avoir des dépendances sur d'autres cibles. Par exemple, undeploy la cible peut avoir une dépendance sur le package cible, le package la cible peut avoir une dépendance sur le compilecible et ainsi de suite. Les dépendances sont indiquées à l'aide dudependsattribut. Par exemple:

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

L'élément cible a les attributs suivants:

Les attributs La description
Nom Le nom de la cible (obligatoire)
dépend Liste séparée par des virgules de toutes les cibles dont dépend cette cible. (Optionnel)
la description Une brève description de la cible. (optionnel)
si Permet l'exécution d'une cible basée sur la justesse d'un attribut conditionnel. (optionnel)
sauf si Ajoute la cible à la liste de dépendances du point d'extension spécifié. Un point d'extension est similaire à une cible, mais il n'a aucune tâche. (Optionnel)

le echoLa tâche dans l'exemple ci-dessus est une tâche triviale qui imprime un message. Dans notre exemple, il imprime le message Hello World .

Pour exécuter le fichier de construction ant, ouvrez l'invite de commande et accédez au dossier dans lequel réside le fichier build.xml, puis tapez ant info. Vous pouvez également taperantau lieu. Les deux fonctionneront, carinfoest la cible par défaut dans le fichier de construction. Vous devriez voir la sortie suivante:

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

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

BUILD SUCCESSFUL
Total time: 0 seconds

C:\>

Les fichiers de construction Ant sont écrits en XML, ce qui ne permet pas de déclarer des variables comme vous le faites dans votre langage de programmation préféré. Cependant, comme vous l'avez peut-être imaginé, il serait utile que Ant autorise la déclaration de variables telles que le nom du projet, le répertoire source du projet, etc.

Ant utilise le propertyélément qui vous permet de spécifier des propriétés. Cela permet aux propriétés d'être modifiées d'une construction à une autre ou d'un environnement à un autre.

Par défaut, Ant fournit les propriétés prédéfinies suivantes qui peuvent être utilisées dans le fichier de construction:

Propriétés La description
ant.fichier L'emplacement complet du fichier de construction.
ant.version La version de l'installation d'Apache Ant.
basedir Le basedir de la construction, comme spécifié dans le basedir attribut du project élément.
ant.java.version La version du JDK utilisée par Ant.
ant.project.name Le nom du projet, tel que spécifié dans le name atrribut de la project élément.
ant.project.default-target La cible par défaut du projet actuel.
ant.project.invoked-cibles Liste séparée par des virgules des cibles qui ont été appelées dans le projet en cours.
ant.core.lib L'emplacement complet du fichier jar Ant.
fourmi. Le répertoire de base de l'installation de Ant.
ant.library.dir Le répertoire de base des fichiers de la bibliothèque Ant - généralement le dossier ANT_HOME / lib.

Ant rend également les propriétés système (exemple: file.separator) disponibles pour le fichier de construction.

En plus de ce qui précède, l'utilisateur peut définir des propriétés supplémentaires à l'aide du propertyélément. L'exemple suivant montre comment définir une propriété appeléesitename:

<?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'exécution de Ant sur le fichier de construction ci-dessus produit la sortie suivante:

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

La définition des propriétés directement dans le fichier de construction est très bien, si vous travaillez avec une poignée de propriétés. Cependant, pour un grand projet, il est judicieux de stocker les propriétés dans un fichier de propriétés distinct.

Le stockage des propriétés dans un fichier séparé offre les avantages suivants:

  • Il vous permet de réutiliser le même fichier de construction, avec des paramètres de propriété différents pour différents environnements d'exécution. Par exemple, le fichier de propriétés de construction peut être géré séparément pour les environnements DEV, TEST et PROD.

  • C'est utile lorsque vous ne connaissez pas les valeurs d'une propriété (dans un environnement particulier) à l'avance. Cela vous permet d'effectuer la génération dans d'autres environnements où la valeur de la propriété est connue.

Il n'y a pas de règle absolue, mais généralement le fichier de propriétés est nommé build.properties et est placé le long du build.xmlfichier. Vous pouvez créer plusieurs fichiers de propriétés de construction en fonction des environnements de déploiement, tels quebuild.properties.dev et build.properties.test.

Le contenu du fichier de propriétés de construction est similaire au fichier de propriétés java normal. Ils contiennent une propriété par ligne. Chaque propriété est représentée par un nom et une paire de valeurs. Les paires nom et valeur sont séparées par un signe égal (=). Il est fortement recommandé que les propriétés soient annotées avec des commentaires appropriés. Les commentaires sont répertoriés à l'aide du caractère dièse (#).

L'exemple suivant montre un build.xml fichier et son associé build.properties fichier:

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

Dans l'exemple ci-dessus, sitenameest une propriété personnalisée qui est mappée au nom du site Web. Vous pouvez déclarer un nombre illimité de propriétés personnalisées de cette manière. Une autre propriété personnalisée répertoriée dans l'exemple ci-dessus est labuildversion, qui, dans ce cas, fait référence à la version de la construction.

En plus de ce qui précède, Ant est livré avec un certain nombre de propriétés de construction prédéfinies, qui sont répertoriées dans la section précédente, mais sont à nouveau représentées ci-dessous.

Propriétés La description
ant.fichier L'emplacement complet du fichier de construction.
ant.version La version de l'installation d'Apache Ant.
basedir Le basedir de la construction, comme spécifié dans le basedir attribut du project élément.
ant.java.version La version du JDK utilisée par Ant.
ant.project.name Le nom du projet, tel que spécifié dans le name atrribut de la project élément.
ant.project.default-target La cible par défaut du projet actuel.
ant.project.invoked-cibles Liste séparée par des virgules des cibles qui ont été appelées dans le projet en cours.
ant.core.lib L'emplacement complet du fichier jar Ant.
fourmi. Le répertoire de base de l'installation de Ant.
ant.library.dir Le répertoire de base des fichiers de la bibliothèque Ant - généralement le dossier ANT_HOME / lib.

L'exemple présenté dans ce chapitre utilise le ant.version propriété intégrée.

Ant fournit un certain nombre de types de données prédéfinis. Ne confondez pas le terme «types de données» avec ceux qui sont disponibles dans le langage de programmation, mais considérez-les plutôt comme un ensemble de services déjà intégrés au produit.

Les types de données suivants sont fournis par Apache Ant.

Ensemble de fichiers

Les types de données de l'ensemble de fichiers représentent une collection de fichiers. Il est utilisé comme filtre pour inclure ou exclure des fichiers qui correspondent à un modèle particulier.

Par exemple, reportez-vous au code suivant. Ici, l'attribut src pointe vers le dossier source du projet.

L'ensemble de fichiers sélectionne tous les fichiers .java dans le dossier source, à l'exception de ceux qui contiennent le mot «Stub». Le filtre sensible à la casse est appliqué à l'ensemble de fichiers, ce qui signifie qu'un fichier portant le nom Samplestub.java ne sera pas exclu de l'ensemble de fichiers.

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

Ensemble de motifs

Un jeu de modèles est un modèle qui permet de filtrer facilement des fichiers ou des dossiers en fonction de certains modèles. Les modèles peuvent être créés à l'aide des méta caractères suivants:

  • ? - Correspond à un seul caractère.

  • * - Correspond à zéro ou plusieurs caractères.

  • ** - Correspond à zéro ou plusieurs répertoires de manière récursive.

L'exemple suivant illustre l'utilisation d'un jeu de modèles.

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

Le patternset peut ensuite être réutilisé avec un ensemble de fichiers comme suit:

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

Liste des fichiers

Le type de données de la liste de fichiers est similaire à l'ensemble de fichiers, à l'exception des différences suivantes:

  • filelist contient des listes de fichiers explicitement nommées et ne prend pas en charge les caractères génériques.

  • Le type de données filelist peut être appliqué pour des fichiers existants ou non existants.

Voyons l'exemple suivant du type de données filelist. Ici, l'attributwebapp.src.folder pointe vers le dossier source de l'application Web du projet.

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

Ensemble de filtres

En utilisant un type de données de jeu de filtres avec la tâche de copie, vous pouvez remplacer certains textes dans tous les fichiers qui correspondent au modèle par une valeur de remplacement.

Un exemple courant consiste à ajouter le numéro de version au fichier de notes de publication, comme indiqué dans le code suivant.

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

Dans ce code:

  • L'attribut output.dir pointe vers le dossier de sortie du projet.

  • L'attribut releasenotes.dir pointe vers le dossier des notes de publication du projet.

  • L'attribut current.version pointe vers le dossier de la version actuelle du projet.

  • La tâche de copie, comme son nom l'indique, est utilisée pour copier des fichiers d'un emplacement à un autre.

Chemin

le pathle type de données est couramment utilisé pour représenter un chemin de classe. Les entrées du chemin sont séparées par des points-virgules ou des deux-points. Cependant, ces caractères sont remplacés lors de l'exécution par le caractère séparateur de chemin du système en cours d'exécution.

Le classpath est défini sur la liste des fichiers jar et des classes du projet, comme illustré dans l'exemple ci-dessous.

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

Dans ce code:

  • L'attribut env.J2EE_HOME pointe vers la variable d'environnement J2EE_HOME.

  • L'attribut j2ee.jar pointe vers le nom du fichier jar J2EE dans le dossier de base J2EE.

Maintenant que nous avons appris les types de données dans Ant, il est temps de mettre ces connaissances en action. Nous allons construire un projet dans ce chapitre. Le but de ce chapitre est de construire un fichier Ant qui compile les classes java et les place dans le dossier WEB-INF \ classes.

Considérez la structure de projet suivante:

  • Les scripts de base de données sont stockés dans le db dossier.

  • Le code source java est stocké dans le src dossier.

  • Les images, js, META-INF, styles (css) sont stockés dans le war dossier.

  • Les JSP sont stockées dans le jsp dossier.

  • Les fichiers JAR tiers sont stockés dans le lib dossier.

  • Les fichiers de classe Java sont stockés dans le WEB-INF\classes dossier.

Ce projet constitue le Hello World Application de télécopie pour le reste de ce didacticiel.

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

Voici le build.xml requis pour ce projet. Considérons-le morceau par morceau.

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

Tout d'abord, déclarons quelques propriétés pour les dossiers source, web et build.

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

Dans cet exemple:

  • src.dir fait référence au dossier source du projet dans lequel se trouvent les fichiers source java.

  • web.dir fait référence au dossier source Web du projet, où vous pouvez trouver les fichiers JSP, web.xml, css, javascript et autres fichiers Web liés

  • build.dir fait référence au dossier de sortie de la compilation du projet.

Les propriétés peuvent faire référence à d'autres propriétés. Comme le montre l'exemple ci-dessus, lebuild.dir propriété fait référence à la web.dir propriété.

Dans cet exemple, le src.dir fait référence au dossier source du projet.

La cible par défaut de notre projet est la compilecible. Mais regardons d'abord leclean cible.

La cible propre, comme son nom l'indique, supprime les fichiers du dossier de construction.

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

Le master-classpath contient les informations de classpath. Dans ce cas, il inclut les classes dans le dossier build et les fichiers jar dans le dossier lib.

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

Enfin, la cible de construction pour construire les fichiers. Tout d'abord, nous créons le répertoire de construction, s'il n'existe pas. Ensuite, nous exécutons la commande javac (en spécifiant jdk1.5 comme compilation cible). Nous fournissons le dossier source et le chemin de classe à la tâche javac et lui demandons de déposer les fichiers de classe dans le dossier de construction.

<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'exécution de Ant sur ce fichier compile les fichiers source java et place les classes dans le dossier de construction.

Le résultat suivant est le résultat de l'exécution du fichier Ant:

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

BUILD SUCCESSFUL
Total time: 6.3 seconds

Les fichiers sont compilés et placés dans le build.dir dossier.

La documentation est un must dans tout projet. La documentation joue un grand rôle dans la maintenance d'un projet. Java facilite la documentation grâce à l'utilisation dujavadocoutil. Ant rend les choses encore plus faciles en générant la documentation à la demande.

Comme vous le savez, l'outil javadoc est très flexible et permet un certain nombre d'options de configuration. Ant expose ces options de configuration via la tâche javadoc. Si vous n'êtes pas familier avec les javadocs, nous vous suggérons de commencer par ce didacticiel de documentation Java .

La section suivante répertorie les options javadoc les plus couramment utilisées dans Ant.

Les attributs

La source peut être spécifiée en utilisant sourcepath, sourcepathref ou sourcefiles.

  • sourcepath est utilisé pour pointer vers le dossier des fichiers source (par exemple le dossier src).

  • sourcepathref est utilisé pour faire référence à un chemin référencé par l'attribut path (par exemple, Deleg.src.dir).

  • sourcefiles est utilisé lorsque vous souhaitez spécifier les fichiers individuels sous forme de liste séparée par des virgules.

Le chemin de destination est spécifié à l'aide du destdir dossier (par exemple build.dir).

Vous pouvez filtrer le javadoctâche en spécifiant les noms de packages à inclure. Ceci est réalisé en utilisant lepackagenames attribut, une liste de fichiers de package séparés par des virgules.

Vous pouvez filtrer le processus javadoc pour afficher uniquement les classes et membres publics, privés, de package ou protégés. Ceci est réalisé en utilisant leprivate, public, package et protected les attributs.

Vous pouvez également indiquer à la tâche javadoc d'inclure les informations sur l'auteur et la version à l'aide des attributs respectifs.

Vous pouvez également regrouper les packages en utilisant le group attribut, de sorte qu'il devient facile de naviguer.

Mettre tous ensemble

Continuons notre thème de la Hello worldApplication de télécopie. Ajoutons une cible de documentation à notre projet d'application Fax.

Vous trouverez ci-dessous un exemple de tâche javadoc utilisée dans notre projet. Dans cet exemple, nous avons spécifié le javadoc pour utiliser lesrc.dir comme répertoire source, et doc comme cible.

Nous avons également personnalisé le titre de la fenêtre, l'en-tête et les informations de pied de page qui apparaissent sur les pages de documentation java.

De plus, nous avons créé trois groupes:

  • un pour les classes utilitaires dans notre dossier source,
  • un pour les classes d'interfaces utilisateur, et
  • un pour les classes liées à la base de données.

Vous remarquerez peut-être que le groupe de packages de données contient deux packages -– faxapp.entity et 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>

Exécutons la tâche Ant javadoc. Il génère et place les fichiers de documentation java dans le dossier doc.

Quand le javadoc target est exécuté, il produit le résultat suivant: 

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

java doc has been generated!

BUILD SUCCESSFUL
Total time: 10.63 second

Les fichiers de documentation java sont maintenant présents dans le doc dossier.

En règle générale, les fichiers javadoc sont générés dans le cadre de la version ou du package cibles.

La prochaine étape logique après la compilation de vos fichiers source java, est de créer l'archive java, c'est-à-dire le fichier JAR. La création de fichiers JAR avec Ant est assez simple avec lejartâche. Les attributs couramment utilisés de la tâche jar sont les suivants:

Les attributs La description
basedir Le répertoire de base du fichier JAR de sortie. Par défaut, il est défini sur le répertoire de base du projet.
compresse Conseille à Ant de compresser le fichier lors de la création du fichier JAR.
garder la compression Tandis que le compress est applicable aux fichiers individuels, le keepcompression L'attribut fait la même chose, mais il s'applique à toute l'archive.
destfile Le nom du fichier JAR de sortie.
dupliquer Indique à Ant ce qu'il faut faire lorsque des fichiers en double sont trouvés. Vous pouvez ajouter, conserver ou échouer les fichiers en double.
exclut Conseille à Ant de ne pas inclure ces listes de fichiers séparés par des virgules dans le package.
exclutfile Idem que ci-dessus, sauf que les fichiers d'exclusion sont spécifiés à l'aide d'un modèle.
comprend Inverse des exclus.
inclutfile Inverse de excludesfile.
mettre à jour Conseille à Ant d'écraser les fichiers dans le fichier JAR déjà créé.

Poursuivant notre Hello WorldProjet d'application de télécopie, ajoutons une nouvelle cible pour produire les fichiers jar. Mais avant cela, considérons la tâche jar donnée ci-dessous.

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

Ici le web.dirproperty pointe vers le chemin des fichiers source Web. Dans notre cas, c'est là que l'util.jar sera placé.

le build.dir La propriété de cet exemple pointe vers le dossier de construction où se trouvent les fichiers de classe pour l'util.jar.

Dans cet exemple, nous créons un fichier jar appelé util.jar en utilisant les classes du faxapp.util.*paquet. Cependant, nous excluons les classes qui se terminent par le nom Test. Le fichier jar de sortie sera placé dans le dossier lib de l'application Web.

Si nous voulons faire du util.jar un fichier jar exécutable, nous devons ajouter le manifest avec le Main-Class méta attribut.

Par conséquent, l'exemple ci-dessus sera mis à jour comme:

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

Pour exécuter la tâche jar, enveloppez-la dans une cible, le plus souvent, la cible de compilation ou de package, et exécutez-les.

<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'exécution de Ant sur ce fichier crée le fichier util.jar pour nous.

Le résultat suivant est le résultat de l'exécution du fichier Ant: 

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

BUILD SUCCESSFUL
Total time: 1.3 seconds

Le fichier util.jar est maintenant placé dans le dossier de sortie.

La création de fichiers WAR avec Ant est extrêmement simple et très similaire à la tâche de création de fichiers JAR. Après tout, le fichier WAR, comme le fichier JAR, n'est qu'un autre fichier ZIP.

La tâche WAR est une extension de la tâche JAR, mais elle a quelques ajouts intéressants pour manipuler ce qui va dans le dossier WEB-INF / classes et générer le fichier web.xml. La tâche WAR est utile pour spécifier une disposition particulière du fichier WAR.

La tâche WAR étant une extension de la tâche JAR, tous les attributs de la tâche JAR s'appliquent à la tâche WAR.

Les attributs La description
webxml Chemin du fichier web.xml
lib Un groupement pour spécifier ce qui va dans le dossier WEB-INF \ lib.
Des classes Un groupement pour spécifier ce qui va dans le dossier WEB-INF \ classes.
metainf Spécifie les instructions de génération du fichier MANIFEST.MF.

Poursuivant notre Hello WorldProjet d'application de télécopie, ajoutons une nouvelle cible pour produire les fichiers jar. Mais avant cela, considérons la tâche de guerre. Prenons l'exemple suivant:

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

Comme dans les exemples précédents, le web.dir variable fait référence au dossier Web source, c'est-à-dire au dossier qui contient les fichiers JSP, css, javascript, etc.

le build.dirvariable fait référence au dossier de sortie - C'est là que se trouvent les classes du package WAR. En règle générale, les classes seront regroupées dans le dossier WEB-INF / classes du fichier WAR.

Dans cet exemple, nous créons un fichier war appelé fax.war. Le fichier WEB.XML est obtenu à partir du dossier source Web. Tous les fichiers du dossier «WebContent» sous Web sont copiés dans le fichier WAR.

Le dossier WEB-INF / lib contient les fichiers jar du dossier thirdpartyjars. Cependant, nous excluons le portlet.jar car il est déjà présent dans le dossier lib du serveur d'applications. Enfin, nous copions toutes les classes du dossier Web du répertoire de construction et les plaçons dans le dossier WEB-INF / classes.

Enveloppez la tâche de guerre dans une cible Ant (généralement un package) et exécutez-la. Cela créera le fichier WAR à l'emplacement spécifié.

Il est tout à fait possible d'imbriquer les directeurs de classes, lib, metainf et webinf afin qu'ils vivent dans des dossiers dispersés n'importe où dans la structure du projet. Mais les meilleures pratiques suggèrent que votre projet Web doit avoir la structure de contenu Web qui est similaire à la structure du fichier WAR. Le projet d'application de télécopie a sa structure décrite en utilisant ce principe de base.

Pour exécuter la tâche war, enveloppez-la dans une cible, le plus souvent, la cible de construction ou de package, et exécutez-les.

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

Exécuter Ant sur ce fichier créera le fax.war fichier pour nous.

Le résultat suivant est le résultat de l'exécution du fichier Ant: 

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

BUILD SUCCESSFUL
Total time: 12.3 seconds

Le fichier fax.war est maintenant placé dans le dossier de sortie. Le contenu du fichier war sera:

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

Nous avons appris les différents aspects de Ant en utilisant le Hello World Application Web de télécopie en morceaux.

Il est maintenant temps de tout rassembler pour créer un fichier build.xml complet et complet. Considérerbuild.properties et build.xml fichiers comme suit:

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>

Dans cet exemple:

  • Nous déclarons d'abord le chemin d'accès au dossier webapps dans Tomcat dans le fichier de propriétés de construction en tant que deploy.path variable.

  • Nous déclarons également le dossier source des fichiers java dans le src.dir variable.

  • Ensuite, nous déclarons le dossier source des fichiers Web dans le web.dir variable. javadoc.dir est le dossier de stockage de la documentation java, et build.dir est le chemin pour stocker les fichiers de sortie de construction.

  • Ensuite, nous déclarons le nom de l'application Web, qui est fax dans notre cas.

  • Nous définissons également le chemin de la classe maître qui contient les fichiers JAR présents dans le dossier WEB-INF / lib du projet.

  • Nous incluons également les fichiers de classe présents dans le build.dir dans le chemin de la classe de maître.

  • La cible Javadoc produit le javadoc requis pour le projet et la cible d'utilisation est utilisée pour imprimer les cibles communes présentes dans le fichier de construction.

L'exemple ci-dessus montre deux cibles de déploiement: deploy et deploywar.

La cible de déploiement copie les fichiers du répertoire Web vers le répertoire de déploiement en préservant l'horodatage de la dernière modification. Ceci est utile lors du déploiement sur un serveur prenant en charge le déploiement à chaud.

La cible propre efface tous les fichiers précédemment créés.

La cible deploywar crée le fichier war, puis copie le fichier war dans le répertoire de déploiement du serveur d'applications.

Dans le chapitre précédent, nous avons appris comment empaqueter une application et la déployer dans un dossier.

Dans ce chapitre, nous allons déployer l'application Web directement dans le dossier de déploiement du serveur d'applications, puis nous allons ajouter quelques cibles Ant pour démarrer et arrêter les services. Continuons avec leHello Worldapplication Web de télécopie. Ceci est une continuation du chapitre précédent, les nouveaux composants sont mis en évidence en gras.

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>

Dans cet exemple, nous avons utilisé Tomcat comme serveur d'application. Tout d'abord, dans le fichier de propriétés de construction, nous avons défini des propriétés supplémentaires.

  • le appserver.home pointe vers le chemin d'installation vers le serveur d'applications Tomcat.

  • le appserver.lib pointe vers les fichiers de bibliothèque dans le dossier d'installation de Tomcat.

  • le deploy.path La variable pointe maintenant vers le dossier webapp dans Tomcat.

Les applications dans Tomcat peuvent être arrêtées et démarrées à l'aide de l'application de gestionnaire Tomcat. L'URL de l'application du gestionnaire, le nom d'utilisateur et le mot de passe sont également spécifiés dans le fichier build.properties. Ensuite, nous déclarons un nouveau CLASSPATH qui contient lecatalina-ant.jar. Ce fichier jar est requis pour exécuter les tâches Tomcat via Apache Ant.

Le catalina-ant.jar fournit les tâches suivantes:

Propriétés La description
InstallTask Installe une application Web. Nom de la classe: org.apache.catalina.ant.InstallTask
RechargerTâche Rechargez une application Web. Nom de la classe: org.apache.catalina.ant.ReloadTask
ListeTâche Répertorie toutes les applications Web. Nom de la classe: org.apache.catalina.ant.ListTask
StartTask Démarre une application Web. Nom de la classe: org.apache.catalina.ant.StartTask
StopTask Arrête une application Web. Nom de la classe: org.apache.catalina.ant.StopTask
RechargerTâche Recharge une application Web sans s'arrêter. Nom de la classe: org.apache.catalina.ant.ReloadTask

La tâche de rechargement nécessite les paramètres supplémentaires suivants:

  • URL de l'application du gestionnaire
  • Nom d'utilisateur pour redémarrer l'application Web
  • Mot de passe pour redémarrer l'application Web
  • Nom de l'application Web à redémarrer

Laissez-nous publier le deploy-warpour copier la webapp dans le dossier Tomcat webapps, puis rechargerons l'application Fax Web. Le résultat suivant est le résultat de l'exécution du fichier 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

Une fois la tâche ci-dessus exécutée, l'application Web est déployée et l'application Web est rechargée.

Vous pouvez utiliser Ant pour exécuter du code Java. Dans l'exemple suivant, la classe java prend un argument (adresse e-mail de l'administrateur) et envoie 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
   { 
	   //......
   }
}

Voici une construction simple qui exécute cette 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>

Lorsque la génération est exécutée, elle produit le résultat suivant: 

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

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

BUILD SUCCESSFUL
Total time: 1 second

Dans cet exemple, le code java fait une chose simple: envoyer un e-mail. Nous aurions pu utiliser la tâche intégrée Ant pour faire cela. Cependant, maintenant que vous avez l'idée, vous pouvez étendre votre fichier de construction pour appeler le code java qui effectue des choses compliquées, par exemple: crypte votre code source.

Si vous avez déjà téléchargé et installé Eclipse, vous n'avez pas grand-chose à faire pour commencer. Eclipse est livré avec le plugin Ant, prêt à être utilisé.

Suivez les étapes simples pour intégrer Ant dans Eclipse.

  • Assurez-vous que le fichier build.xml fait partie de votre projet java et ne réside pas à un emplacement externe au projet.

  • Activez Ant View en suivant Window > Show View > Other > Ant > Ant.

  • Ouvrez l'Explorateur de projets, faites glisser le build.xml dans la vue Ant.

Votre vue Ant ressemble à:

En cliquant sur les cibles, build / clean / usage exécutera Ant avec la cible.

Cliquer sur "fax" exécutera la cible par défaut - usage.

Le plugin Ant Eclipse est également livré avec un bon éditeur pour éditer les fichiers build.xml. L'éditeur connaît le schéma build.xml et peut vous aider à compléter le code.

Pour utiliser l'éditeur Ant, cliquez avec le bouton droit sur votre build.xml (depuis l'Explorateur de projet) et sélectionnez Ouvrir avec> Editeur Ant. L'éditeur Ant devrait ressembler à quelque chose de similaire à:

L'éditeur Ant répertorie les cibles sur le côté droit. La liste des cibles sert de signet qui vous permet de passer directement à l'édition d'une cible particulière.

JUnit est le framework de test unitaire couramment utilisé pour les développements basés sur Java. Il est facile à utiliser et à étendre. Il existe un certain nombre d'extensions JUnit disponibles. Si vous n'êtes pas familier avec JUnit, vous devez le télécharger sur www.junit.org et lire son manuel.

Ce chapitre montre comment exécuter des tests JUnit à l'aide d'Ant. Ant simplifie la tâche JUnit.

Les attributs de la tâche JUnit sont présentés ci-dessous:

Propriétés La description
dir Où appeler la VM. Ceci est ignoré lorsquefork est désactivé.
jvm Commande utilisée pour appeler la JVM. Ceci est ignoré lorsquefork est désactivé.
fourchette Exécute le test dans une JVM distincte
erreur propriété Le nom de la propriété à définir en cas d'erreur JUnit
propriété de l'échec Le nom de la propriété à définir en cas d'échec de JUnit
haltonerror Arrête l'exécution lorsqu'une erreur de test se produit
haltonfailure Arrête l'exécution en cas d'échec
résumé Conseille à Ant d'afficher des statistiques simples pour chaque test
showoutput Conseille à Ant d'envoyer la sortie à ses journaux et formateurs
tempdir Chemin vers le fichier temporaire que Ant utilisera
temps libre Quitte les tests dont l'exécution prend plus de temps que ce paramètre (en millisecondes).

Continuons le thème de la Hello World Faxez l'application Web et ajoutez une cible JUnit.

L'exemple suivant montre une exécution de test JUnit simple:

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

Cet exemple montre l'exécution de JUnit sur la classe junit com.tutorialspoint.UtilsTest. L'exécution du code ci-dessus produit la sortie suivante:

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 est livré avec un ensemble prédéfini de tâches, mais vous pouvez créer vos propres tâches, comme indiqué dans l'exemple ci-dessous.

Les tâches Ant personnalisées devraient étendre la org.apache.tools.ant.Taskclass et devrait étendre la méthode execute (). Voici un exemple simple:

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

Pour exécuter la tâche personnalisée, vous devez ajouter les éléments suivants au Hello World Application Web de télécopie:

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

L'exécution de la tâche personnalisée ci-dessus imprime le message "Hello World!"

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

Ceci est juste un exemple simple, vous pouvez utiliser la puissance de Ant pour faire tout ce que vous voulez pour améliorer votre processus de construction et de déploiement.

Impression