Comment configurer Ivy pour Ant build

Tout d'abord, vous devez définir un <taskdef> à point pour le Lierre tâches.

<property environment="env"/>
<property name="ivy.home" value="${env_IVY_HOME}"/>

<taskdef resource="org/apache/ivy/ant/antlib.xml">
    <classpath>
        <fileset dir="${ivy.home}">
            <include name="*.jar"/>
        </fileset>
    </classpath>
</taskdef>

Qui vous donnera accès à l'Ivy tâches. Vous pouvez utiliser ces tâches comme ceci:

<cachepath pathid="main.classpath" conf="compile"/>

Le problème, c'est que votre Lierre tâches noms qui pourraient entrer en conflit avec d'autres tâches Ant. Par exemple, il y a un Lierre tâche <report>. Pour résoudre ce problème, vous pouvez créer un Lierre d'espace de noms. Pour ce faire, vous mettez une référence dans votre espace de noms dans la <project> entité comme ceci:

<project name="my.proj" default="package" basedir="."
    xmlns:ivy="antlib:org.apache.ivy.ant"/>

Maintenant, lorsque vous définissez le Lierre tâches, vous pouvez l'utiliser antlib:org.apache.ivy.ant référence à votre ivy espace de noms. Même taskdef comme avant, mais avec un uri champ:

<property environment="env"/>
<property name="ivy.home" value="${env_IVY_HOME}"/>

<taskdef resource="org/apache/ivy/ant/antlib.xml"
    uri="antlib:org.apache.ivy.ant">
    <classpath>
        <fileset dir="${ivy.home}">
            <include name="*.jar"/>
        </fileset>
    </classpath>
</taskdef>

Par le façon, il n'y a rien de spécial uri. J'aurais pu faire ceci:

<project name="my.proj" default="package" basename="."
   xmlns:ivy="pastrami:with.mustard">

[...]
<taskdef resource="org/apache/ivy/ant/antlib.xml"
    uri="pastrami:with.mustard">
    <classpath>
        <fileset dir="${ivy.home}">
            <include name="*.jar"/>
        </fileset>
    </classpath>
</taskdef>

Le point est maintenant, vous pouvez ajouter un préfixe de vos noms de tâches avec ivy:. Au lieu de cela:

<cachepath pathid="main.classpath" conf="compile"/>

Vous pouvez désormais le faire:

<ivy:cachepath pathid="main.classpath" conf="compile"/>

Et c'est la façon dont vous gagnez de l'accès à votre Lierre tâches Ant.

Maintenant, vous avez accès à votre Lierre tâches Ant, vous devez définir une ivysettings.xml fichier et utiliser la <ivy:settings/> tâche à point:

 <ivy:settings file="${ivy.home}/ivysettings.xml"/>

Il y a un défaut ivysettings.xml de fichiers intégré dans le Lierre qui vous permettra de le world wide repository Maven système. Si vous n'avez pas une échelle de l'entreprise repository Maven, vous pouvez utiliser la valeur par défaut ivysettings.xml fichier:

<ivy:settings/>

C'est assez simple.

Une fois que vous avez fait cela, vous avez besoin pour lire et résoudre votre ivy.xml fichier qui se trouve dans la racine de votre projet dans le même répertoire que votre build.xml fichier.

Fondamentalement, votre ivy.xml fichier contient des références à la troisième partie des bocaux que vous devez apporter à votre projet. Par exemple:

<dependencies>
    <dependency org="log4j"  name="log4j" rev="1.2.17" conf="compile->default"/>
    <dependency org="junit"  name="junit" rev="4.10" conf="test->default"/>
</dependencies>

Ce que c'est dit, c'est que j'ai besoin de la log4j.jar (révision 1.2.17) pour la compilation (et pour la compilation des tests de trop) et j'ai besoin de junit.jar (révision.4.10) pour la compilation de mon code de test.

La compile->default est une cartographie de mon compile de configuration de Maven est default de configuration (qui dit que je veux juste le Pot et autres pots qu'il pourrait en dépendre.

Où est mon compile configuration venir? Je définis dans mon ivy.xml. Il y a dix configurations standard. Cela va aussi dans votre ivy.xml fichier:

<configurations>
  <conf name="default" visibility="public" description="runtime dependencies and master artifact can be used with this conf" extends="runtime,master"/>
  <conf name="master" visibility="public" description="contains only the artifact published by this module itself, with no transitive dependencies"/>
  <conf name="compile" visibility="public" description="this is the default scope, used if none is specified. Compile dependencies are available in all classpaths."/>
  <conf name="provided" visibility="public" description="this is much like compile, but indicates you expect the JDK or a container to provide it. It is only available on the compilation classpath, and is not transitive."/>
  <conf name="runtime" visibility="public" description="this scope indicates that the dependency is not required for compilation, but is for execution. It is in the runtime and test classpaths, but not the compile classpath." extends="compile"/>
  <conf name="test" visibility="private" description="this scope indicates that the dependency is not required for normal use of the application, and is only available for the test compilation and execution phases." extends="runtime"/>
  <conf name="system" visibility="public" description="this scope is similar to provided except that you have to provide the JAR which contains it explicitly. The artifact is always available and is not looked up in a repository."/>
  <conf name="sources" visibility="public" description="this configuration contains the source artifact of this module, if any."/>
  <conf name="javadoc" visibility="public" description="this configuration contains the javadoc artifact of this module, if any."/>
   <conf name="optional" visibility="public" description="contains all optional dependencies"/>
 </configurations>

Vous pouvez utiliser n'importe quel nom de la configuration que vous voulez, mais ils correspondent à la valeur par défaut de Maven configurations et sont largement utilisés.

Une fois que vous avez votre ivy.xml fichier défini, vous pouvez utiliser <ivy.resolve> pour résoudre vos dépendances:

<ivy:resolve/>

---

Donc, nous avons les éléments suivants:

1. Comment utiliser <taskdef> dans votre build.xml à intégrer le Lierre des tâches Ant dans votre build.
2. Comment utiliser le Lierre tâche Ant <ivy:settings> pour configurer le Lierre.
3. Comment utiliser <ivy:resolve/> à lire dans votre ivy.xml fichier et résoudre votre tiers pot dépendances.

Maintenant, vous pouvez réellement utiliser ces fichiers jar. Il y a trois façons de le faire:

 <ivy:cachepath pathid="main.classpath" conf="compile"/>

La <ivy:cachepath/> tâche sera de créer un chemin de classe (dans ce cas appelé principal.classpath) qui pointe vers les pots que vous avez dans votre ivy.xml du fichier compile de configuration. Il est utilisé la plupart du temps.

Si vous avez besoin d'un fileset, vous pouvez utiliser ceci:

 <ivy:cachefileset setid="compile.fileset" conf="compile"/>

Dans ce cas, il va créer un fileset avec un refid de compile.fileset.

Parfois, vous devez mettre les bocaux dans votre projet. Par exemple, si vous créez une guerre ou d'un fichier ear, vous voulez placer vos pots. Dans ce cas, vous pouvez utiliser ceci:

<property name="lib.dir" value="${target.dir}/lib"/>
<ivy:retrieve pattern="${lib.dir}/[artifact].[ext]"
     conf="runtime"/>

Qui va aller chercher vos bocaux dans la ${lib.dir} répertoire, de sorte que vous pouvez les inclure dans des guerres ou des oreilles.

Désolé pour la réponse longue, mais il y a beaucoup d'étapes à couvrir. Je recommande fortement de Manning livre Ant dans l'Action qui a un chapitre entier sur Lierre.