Apache IVY - Guía rápida

Apache Ivy es una herramienta de gestión de dependencias muy popular y muy poderosa que se utiliza para gestionar dependencias en proyectos basados ​​en ANT de la misma forma que Apache Maven gestiona las dependencias.

Apache Ivy está basado en Apache ANT, sigue los mismos principios de diseño, es un subproyecto de Apache ANT y es administrado y respaldado activamente por Apache ANT Community.

Caracteristicas

A continuación se muestran las características importantes de Apache Ivy.

  • ANT Based- Apache Ivy proporciona una capacidad de gestión de dependencias para proyectos basados ​​en ANT. También es muy sencillo de usar.

  • Dependency Reports - Apache Ivy proporciona opciones para imprimir gráficos de dependencias en html así como en formato de informes.

  • Non-intrusive- Apache Ivy no impone restricciones como parte de la distribución. Incluso los archivos de compilación no dependen de Apache Ivy.

  • Highly Flexible - Apache Ivy proporciona muchas configuraciones predeterminadas y se puede configurar según el requisito muy fácilmente.

  • Extendible- Apache Ivy se puede ampliar fácilmente. Puede definir su propio repositorio, solucionadores de conflictos y última estrategia.

  • Performance- Apache Ivy está diseñado para el rendimiento. Mantiene un caché de la biblioteca ya descargada. Primero busca en los repositorios locales para resolver las dependencias que en otros repositorios.

  • Transitive Dependencies - Apache Ivy gestiona automáticamente las dependencias transitivas si un proyecto o biblioteca depende de otra biblioteca que puede necesitar otra biblioteca.

  • Maven Repository- Apache Ivy sigue convenciones similares a las convenciones del repositorio de Maven. Apache Ivy puede resolver dependencias utilizando el repositorio global de maven.

  • Maven 2 POMs- Apache Ivy puede leer los POM de Maven 2 como descriptores de módulo, puede establecer ivy como descriptor de módulo. Por lo tanto, facilita la migración de proyectos existentes a proyectos administrados por IVY.

  • Publishing - Apache Ivy brinda soporte para publicar su proyecto y simplifica el proceso de implementación del entorno de múltiples proyectos.

  • Free to Use - Apache Ivy es de código abierto y de uso gratuito.

  • Documentation - Apache Ivy tiene una documentación muy detallada y tutoriales disponibles para aprender.

Apache Ivy necesita Java y ANT instalados en su máquina como único requisito.

Apache Ant se distribuye bajo la licencia de software Apache, una licencia de código abierto de pleno derecho certificada por la iniciativa de código abierto.

La última versión de Apache Ant, incluido su código fuente completo, archivos de clase y documentación, se puede encontrar en http://ant.apache.org.

Instalación de Apache Ant

Se asume que ya ha descargado e instalado Java Development Kit (JDK) en su computadora. Si no es así, siga las instrucciones aquí .

  • Asegúrese de que la variable de entorno JAVA_HOME esté configurada en la carpeta donde está instalado su JDK.

  • Descarga los binarios de https://ant.apache.org

  • Descomprima el archivo zip en una carpeta c: \ de ubicación conveniente. utilizando Winzip, winRAR, 7-zip o herramientas similares.

  • Cree una nueva variable de entorno llamada ANT_HOME que apunta a la carpeta de instalación de Ant, en este caso c:\apache-ant-1.9.14-bin carpeta.

  • Agregue la ruta del archivo por lotes Apache Ant a la variable de entorno PATH. En nuestro caso este sería elc:\apache-ant-1.9.14-bin\bin carpeta.

Verificación de la instalación de Apache Ant

Para verificar la instalación exitosa de Apache Ant en su computadora, escriba ant en el símbolo del sistema.

Debería ver una salida similar a:

C:\>ant -version
Apache Ant(TM) version 1.9.14 compiled on March 12 2019

Si no ve el resultado anterior, verifique que haya seguido los pasos de instalación correctamente.

Instalación de Apache Ivy

  • Descarga los binarios de https://ant.apache.org/ivy

  • Descomprima el archivo zip en una carpeta c: \ de ubicación conveniente. utilizando Winzip, winRAR, 7-zip o herramientas similares.

  • Copie el archivo ivy-2.5.0.jar a c:\apache-ant-1.9.14-bin/lib carpeta.

Verificación de la instalación de Apache Ivy

Para verificar la instalación exitosa de Apache Ivy en su computadora, cree el siguiente archivo de compilación en una carpeta E:> ivy.

<project name="test ivy installation" 
   default="test" xmlns:ivy="antlib:org.apache.ivy.ant">
   <target name="test" description="Test ivy installation">
      <ivy:settings />
   </target>
</project>

Debería ver una salida similar a:

C:\>ant
Buildfile: E:\ivy\build.xml
test:
BUILD SUCCESSFUL
Total time: 2 seconds

Instalación de Eclipse

Este tutorial también cubre la integración de Ant con Eclipse IDE. Por lo tanto, si aún no ha instalado Eclipse, descargue e instale Eclipse

Para instalar Eclipse:

  • Descargue los binarios de Eclipse más recientes de www.eclipse.org

  • Descomprima los archivos binarios de Eclipse en una ubicación conveniente, diga c: \ carpeta

  • Ejecute Eclipse desde c: \ eclipse \ eclipse.exe

Considere el siguiente ejemplo de ivy.xml para comprender la terminología de Ivy.

<?xml version="1.0" encoding="ISO-8859-1"?>
<ivy-module version="2.0"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:noNamespaceSchemaLocation="http://ant.apache.org/ivy/schemas/ivy.xsd">
   <info organisation="com.tutorialspoint" module="ivy-test" status="integration">
   </info>
   <dependencies>
      <dependency org="commons-lang" name="commons-lang" rev="2.6" />
   </dependencies>
</ivy-module>

Términos de Ivy

A continuación se presentan los términos importantes de Ivy Eco-System.

  • Organisation- Como sugiere el nombre, se refiere al nombre de la empresa, desarrollador individual o nombre del equipo que crea el proyecto o biblioteca. Por ejemplo, com.tutorialspoint.

  • Module- Como su nombre indica, se refiere a la unidad o módulo reutilizable. Un módulo generalmente tiene una versión adjunta. Por ejemplo commons-lang, o ivy-test, etc.

  • Module Descriptor- El descriptor de módulo se refiere al archivo ivy.xml que describe un módulo. Un descriptor de módulo contiene el identificador (organización, nombre, rama y versión), artefactos publicados, configuraciones y dependencias.

  • Artifact- Artefacto se refiere a un solo archivo como entregable. Por ejemplo, un archivo jar. El artefacto puede ser de tipo: zip, gz, etc. Jar, Source Jar, Javadoc Jar son varios artefactos de un módulo.

  • Type - El tipo identifica la categoría de artefactos como jar, war, src, doc, etc.

  • Artifact file name extension - Extensión de artefactos como .jar, zip, .gz, etc.

  • Module Revision - Un número de revisión único del módulo o su número de versión.

  • Status of Revision- El estado de revisión indica la estabilidad de la revisión. A continuación se muestran los valores importantes del estado:

    • integration - Representa desarrollo continuo, construcción nocturna, etc.

    • milestone - Representa una distribución pero no finalizada.

    • release - Representa probado y completado, una versión principal.

  • Repository - Similar a los repositorios de Maven, el repositorio representa un sitio de distribución donde ivy puede buscar una biblioteca, artefactos, módulos, etc. Un repositorio puede ser público, privado o compartido.

  • Ivy Settings- Apache Ivy sigue los principios de Maven y viene con muchas configuraciones predeterminadas. La configuración predeterminada se puede anular definiendo un archivo ivysettings.xml.

Apache Ivy sigue los principios de Maven y viene con muchas configuraciones predeterminadas. La configuración predeterminada se puede anular definiendo un archivo ivysettings.xml.

<ivysettings>
	<properties file="${ivy.settings.dir}/ivysettings-file.properties" /> <settings defaultCache="${cache.dir}" defaultResolver="ibiblio" checkUpToDate="false" />
	<resolvers>
		<ibiblio name="ibiblio" />
		<filesystem name="internal">
			<ivy pattern="${repository.dir}/[module]/ivy-[revision].xml" /> <artifact pattern="${repository.dir}/[module]/[artifact]-[revision].[ext]" />
		</filesystem>
	</resolvers>
	<modules>
		<module organisation="tutorialspoint" name=".*" resolver="internal" />
	</modules>
</ivysettings>

Etiquetas del archivo de configuración de Ivy

A continuación se muestran las etiquetas importantes del archivo Ivy Setting.

  • property- Para establecer una variable de hiedra. Cardinalidad: 0..n

  • properties- Para establecer variables de hiedra usando el archivo de propiedades. Cardinalidad: 0..n

  • settings- Para configurar ivy con valores predeterminados. Cardinalidad: 0..1

  • include- Para incluir otro archivo de configuración. Cardinalidad: 0..n

  • classpath- Para agregar una ubicación en la ruta de clases utilizada para cargar complementos. Cardinalidad: 0..n

  • typedef- Definir nuevos tipos de hiedra. Cardinalidad: 0..n

  • lock-strategies- Definir estrategias de bloqueo. Cardinalidad: 0..1

  • caches- Definir gestores de caché de repositorios. Cardinalidad: 0..1

  • latest-strategies- Definir las últimas estrategias. Cardinalidad: 0..1

  • parsers- Definir analizadores de descriptores de módulos. Cardinalidad: 0..1

  • version-matchers- Definir nuevos comparadores de versiones. Cardinalidad: 0..1

  • triggers- Para registrar desencadenantes en eventos de hiedra. Cardinalidad: 0..1

  • namespaces- Para definir nuevos espacios de nombres. Cardinalidad: 0..1

  • macrodef- Definir un nuevo solucionador de macros. Cardinalidad: 0..n

  • resolvers- Definir resolutores de dependencia. Cardinalidad: 0..1

  • conflict-managers- Definir gestores de conflictos. Cardinalidad: 0..1

  • modules- Definir reglas entre módulos y solucionadores de dependencias. Cardinalidad: 0..1

  • outputters- Definir la lista de salidas de informes disponibles. Cardinalidad: 0..1

  • statuses- Definir la lista de estados disponibles. Cardinalidad: 0..1

IvyDE es un complemento de Eclipse proporcionado por Apache. Para instalar IvyDE, inicie Eclipse y vaya a Ayuda> Instalar nuevo software. Muestra la ventana de Software disponible. Ingrese al sitio de actualización de IvyDE http://www.apache.org/dist/ant/ivyde/updatesite/y presione la tecla enter. Muestra los siguientes complementos.

Haga clic en Siguiente y verá la siguiente pantalla.

Si tiene algún error al instalar el complemento, simplemente reinicie el proceso. Después de una instalación exitosa, verá el complemento en eclipe.

Ahora puede realizar la gestión de dependencias utilizando Eclipse e Ivy.

La tarea de resolución se utiliza para resolver las dependencias descritas en ivy.xml, descargarlas y guardarlas en la caché de ivy.

Primero creemos un archivo java Tester.java en E: > ivy > src > com > tutorialspoint carpeta que actuará como carpeta de origen para el proyecto ant.

Application.java

package com.tutorialspoint;
import org.apache.commons.lang.StringUtils;
public class Application {
   public static void main(String[] args) {
      String string = StringUtils.upperCase("Ivy Beginner Guide");
      System.out.println(string);
   }
}

La clase anterior está usando la biblioteca lang de apache commons para usar su clase StringUtils. Ivy debe descargar esta biblioteca y, por lo tanto, debe definirse en la sección de dependencias en ivy.xml. A continuación se muestra el archivo ivy.xml creado en E: > ivy carpeta.

ivy.xml

<?xml version="1.0" encoding="ISO-8859-1"?>
<ivy-module version="2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:noNamespaceSchemaLocation="http://ant.apache.org/ivy/schemas/ivy.xsd">
   <info
      organisation="com.tutorialspoint"
      module="test"
      status="integration">
   </info>
   <dependencies>
      <dependency org="org.apache.commons" name="commons-lang3" rev="3.9"/>
   </dependencies>
</ivy-module>

Los siguientes son los términos importantes.

  • ivy-module - Elemento raíz para identificar la versión de Ivy, el espacio de nombres, etc.

  • info - elemento para identificar el proyecto como entidad única.

    • organisation - nombre de la organización

    • module - nombre del módulo

    • status - estado como lanzamiento, integración o hito.

  • dependencies - elemento para contener dependencias del proyecto como etiquetas de dependencia que tiene los siguientes atributos.

    • org - nombre de la organización de la dependencia

    • name - nombre de la dependencia.

    • rev - versión de la dependencia.

build.xml

<project name="test" default="resolve" xmlns:ivy="antlib:org.apache.ivy.ant">
   <target name="resolve" description="resolve dependencies">
      <ivy:resolve />
   </target>
</project<

Los siguientes son los términos importantes.

  • project - Elemento raíz para identificar el nombre del proyecto, el espacio de nombres de tareas predeterminado para Ivy, etc.

  • target- elemento de destino para crear una nueva tarea y su descripción. Esto contiene una tarea de resolución de hiedra. Cuando ant construye el proyecto, ejecuta la tarea de resolución de ivy que luego resuelve las dependencias usando ivy.

Construyendo el proyecto

Ya que tenemos todos los archivos listos. Solo ve a la consola. Navegar aE: > ivy carpeta y ejecute el comando ant.

E:\ivy > ant

Ivy entrará en acción, resolviendo las dependencias, verás el siguiente resultado.

Buildfile: E:\ivy\build.xml
resolve:
[ivy:resolve] :: Apache Ivy 2.5.0 - 20191020104435 :: https://ant.apache.org/ivy
/ ::
[ivy:resolve] :: loading settings :: url = jar:file:/E:/Apache/apache-ant-1.9.14
/lib/ivy-2.5.0.jar!/org/apache/ivy/core/settings/ivysettings.xml
[ivy:resolve] :: resolving dependencies :: com.tutorialspoint#test;working@Acer-
PC
[ivy:resolve]   confs: [default]
[ivy:resolve]   found commons-lang#commons-lang;2.6 in public
[ivy:resolve]   found junit#junit;3.8.1 in public
[ivy:resolve] :: resolution report :: resolve 375ms :: artifacts dl 79ms
      ---------------------------------------------------------------------
      |                  |            modules            ||   artifacts   |
      |       conf       | number| search|dwnlded|evicted|| number|dwnlded|
      ---------------------------------------------------------------------
      |      default     |   2   |   2   |   0   |   0   ||   4   |   0   |
      ---------------------------------------------------------------------
[ivy:retrieve] :: retrieving :: com.tutorialspoint#test [sync]
[ivy:retrieve]  confs: [default]
[ivy:retrieve]  0 artifacts copied, 2 already retrieved (0kB/101ms)
BUILD SUCCESSFUL
Total time: 1 second
E:\ivy>

Resolver salida

Los siguientes son los términos importantes.

  • conf - configuración, en nuestro caso estamos usando la configuración por defecto.

  • modules - indica el número total de módulos, módulos descargados, etc.

  • artifacts - indica el número total de artefactos, artefactos descargados, etc.

Puede verificar los archivos descargados en la ubicación predeterminada de la caché de Ivy en ${ivy.default.ivy.user.dir} > .ivy2 > cachecarpeta. Y $ {ivy.default.ivy.user.dir} es la casa de usuario predeterminada: $ HOME.

La tarea de instalación se utiliza para instalar un módulo y sus dependencias en un resolutor. Se utiliza cuando un artefacto público se va a descargar y utilizar en un repositorio privado. De forma predeterminada, el repositorio local de un usuario es su repositorio privado y está presente en $ {ivy.default.ivy.user.dir} / local.

Creemos Tester.java, build.xml y ivy.xml como se describe en el capítulo IVY - Resolver tarea .

Actualice build.xml para utilizar la tarea de instalación de ivy.

build.xml

<project name="test" default="resolve" xmlns:ivy="antlib:org.apache.ivy.ant">
   <target name="resolve" description="resolve dependencies">
      <ivy:resolve />
   </target>
   <target name="install" description="install dependencies">
      <ivy:install organisation="commons-lang" module="commons-lang" 
         revision="2.6" transitive="true" overwrite="false" 
         from="public" to="local" />
   </target>
</project>

Los siguientes son los términos importantes.

  • organisation - nombre de la organización.

  • module - nombre del módulo del proyecto.

  • revision - versión del proyecto.

  • from - del tipo de repositorio.

  • to - al tipo de repositorio.

Construyendo el proyecto

Ya que tenemos todos los archivos listos. Solo ve a la consola. Navegar aE: > ivy carpeta y ejecute el comando ant.

E:\ivy > ant install

Ivy entrará en acción, resolviendo las dependencias, verás el siguiente resultado.

E:\ivy > ant install
Buildfile: E:\ivy\build.xml
install:
[ivy:install] :: Apache Ivy 2.5.0 - 20191020104435 :: https://ant.apache.org/ivy
/ ::
[ivy:install] :: loading settings :: url = jar:file:/E:/Apache/apache-ant-1.9.14
/lib/ivy-2.5.0.jar!/org/apache/ivy/core/settings/ivysettings.xml
[ivy:install] :: installing commons-lang#commons-lang;2.6 ::
[ivy:install] :: resolving dependencies ::
[ivy:install]   found commons-lang#commons-lang;2.6 in public
[ivy:install]   found junit#junit;3.8.1 in public
[ivy:install] :: downloading artifacts to cache ::
[ivy:install] :: installing in local ::
[ivy:install]   published commons-lang to C:\Users\Acer\.ivy2\local\commons-lang
\commons-lang\2.6.part\sources\commons-lang.jar
[ivy:install]   published commons-lang to C:\Users\Acer\.ivy2\local\commons-lang
\commons-lang\2.6.part\jars\commons-lang.jar
[ivy:install]   published commons-lang to C:\Users\Acer\.ivy2\local\commons-lang
\commons-lang\2.6.part\javadocs\commons-lang.jar
[ivy:install]   published ivy to C:\Users\Acer\.ivy2\local\commons-lang\commons-
lang\2.6.part\ivys\ivy.xml
[ivy:install]   publish committed: moved C:\Users\Acer\.ivy2\local\commons-lang\
commons-lang\2.6.part
[ivy:install]           to C:\Users\Acer\.ivy2\local\commons-lang\commons-lang\2
.6
[ivy:install]   published junit to C:\Users\Acer\.ivy2\local\junit\junit\3.8.1.p
art\jars\junit.jar
[ivy:install]   published ivy to C:\Users\Acer\.ivy2\local\junit\junit\3.8.1.par
t\ivys\ivy.xml
[ivy:install]   publish committed: moved C:\Users\Acer\.ivy2\local\junit\junit\3
.8.1.part
[ivy:install]           to C:\Users\Acer\.ivy2\local\junit\junit\3.8.1
[ivy:install] :: install resolution report ::
[ivy:install] :: resolution report :: resolve 0ms :: artifacts dl 21ms
      ---------------------------------------------------------------------
      |                  |            modules            ||   artifacts   |
      |       conf       | number| search|dwnlded|evicted|| number|dwnlded|
      ---------------------------------------------------------------------
      |      default     |   2   |   0   |   0   |   0   ||   4   |   0   |
      ---------------------------------------------------------------------
BUILD SUCCESSFUL
Total time: 43 seconds

Puede verificar los archivos descargados en la ubicación del repositorio local predeterminado de la caché de Ivy ${ivy.default.ivy.user.dir} > .ivy2 > local directory.

retrieve task is used to resolve dependencies to a specified location in project workspace.

Let's create Tester.java, build.xml and ivy.xml as described in IVY - Resolve Task chapter.

Update the build.xml to use the ivy retrieve task.

build.xml

<project name="test" default="resolve" xmlns:ivy="antlib:org.apache.ivy.ant">
   <target name="resolve" description="resolve dependencies">
      <ivy:resolve />
      <ivy:retrieve sync="true" type="jar" />
   </target>
</project>

Following are the important terms.

  • sync − sync true ensure that lib directory is up-to-date and any extra file gets deleted.

  • type − type directs ivy to copy only specified type of artifacts like jar. Source jar, javadoc jar will be ignored. type for source jar is src or source and doc or bundle for javadoc jar.

retrieve tasks copies the resolved dependencies in the lib directory of the project by default and can be changed using pattern attribute.

Building the project

As we've all the files ready. Just go the console. Navigate to E: > ivy folder and run the ant command.

E:\ivy > ant

Ivy will come into action, resolving the dependencies, you will see the following result.

Buildfile: E:\ivy\build.xml
resolve:
[ivy:resolve] :: Apache Ivy 2.5.0 - 20191020104435 :: https://ant.apache.org/ivy
/ ::
[ivy:resolve] :: loading settings :: url = jar:file:/E:/Apache/apache-ant-1.9.14
/lib/ivy-2.5.0.jar!/org/apache/ivy/core/settings/ivysettings.xml
[ivy:resolve] :: resolving dependencies :: com.tutorialspoint#test;working@Acer-
PC
[ivy:resolve]   confs: [default]
[ivy:resolve]   found commons-lang#commons-lang;2.6 in public
[ivy:resolve]   found junit#junit;3.8.1 in public
[ivy:resolve] :: resolution report :: resolve 316ms :: artifacts dl 18ms
      ---------------------------------------------------------------------
      |                  |            modules            ||   artifacts   |
      |       conf       | number| search|dwnlded|evicted|| number|dwnlded|
      ---------------------------------------------------------------------
      |      default     |   2   |   2   |   0   |   0   ||   4   |   0   |
      ---------------------------------------------------------------------
[ivy:retrieve] :: retrieving :: com.tutorialspoint#test [sync]
[ivy:retrieve]  confs: [default]
[ivy:retrieve]  0 artifacts copied, 2 already retrieved (0kB/2756ms)
BUILD SUCCESSFUL
Total time: 31 seconds

You can verify the downloaded files in project lib directory.

cachepath task is used to create an ANT classpath with resolved artifacts present in the cache. As ANT needs jars to be classpath to compile java files, Ivy cachepath builds the classpath.

Let's create Tester.java, build.xml and ivy.xml as described in IVY - Resolve Task chapter.

Update the build.xml to use the ivy retrieve task.

build.xml

<project name="test" default="resolve" xmlns:ivy="antlib:org.apache.ivy.ant">
   <target name="resolve" description="resolve dependencies">
      <ivy:resolve />
      <ivy:cachepath pathid="new.classpath" />
   </target>
   <target name="compile" depends="resolve" description="Compile">
      <mkdir dir="build/classes" />
      <javac srcdir="src" destdir="build/classes">
         <classpath refid="new.classpath" />
      </javac>
   </target>
</project>

Following are the important terms.

  • pathid − id of the classpath where cached jars are present.

retrieve tasks copies the resolved dependencies in the lib directory of the project by default and can be changed using pattern attribute.

Building the project

As we've all the files ready. Just go the console. Navigate to E: > ivy folder and run the ant command.

E:\ivy > ant compile

Ivy will come into action, resolving the dependencies, you will see the following result.

Buildfile: E:\ivy\build.xml
resolve:
[ivy:resolve] :: Apache Ivy 2.5.0 - 20191020104435 :: https://ant.apache.org/ivy
/ ::
[ivy:resolve] :: loading settings :: url = jar:file:/E:/Apache/apache-ant-1.9.14
/lib/ivy-2.5.0.jar!/org/apache/ivy/core/settings/ivysettings.xml
[ivy:resolve] :: resolving dependencies :: com.tutorialspoint#test;working@Acer-
PC
[ivy:resolve]   confs: [default]
[ivy:resolve]   found commons-lang#commons-lang;2.6 in public
[ivy:resolve]   found junit#junit;3.8.1 in public
[ivy:resolve] :: resolution report :: resolve 2314ms :: artifacts dl 15ms
      ---------------------------------------------------------------------
      |                  |            modules            ||   artifacts   |
      |       conf       | number| search|dwnlded|evicted|| number|dwnlded|
      ---------------------------------------------------------------------
      |      default     |   2   |   2   |   0   |   0   ||   4   |   0   |
      ---------------------------------------------------------------------
compile:
   [javac] E:\ivy\build.xml:13: warning: 'includeantruntime' was not set, defau
lting to build.sysclasspath=last; set to false for repeatable builds
   [javac] Compiling 1 source file to E:\ivy\build\classes
BUILD SUCCESSFUL
Total time: 3 seconds

You can verify the compiled class file in project build directory.

publish task is used to publish current artifacts and its resolved descriptor files to mentioned repository.

Let's create Tester.java, build.xml and ivy.xml as described in IVY - Resolve Task chapter.

Update the build.xml to use the ivy publish task. First we'll create a jar file and then publish it.

build.xml

<project name="test" default="resolve" xmlns:ivy="antlib:org.apache.ivy.ant">
   <property name = "build.dir" value = "build"/>
   <target name="resolve" description="resolve dependencies">
      <ivy:resolve />
   </target>
   <target name = "jar">
      <jar destfile = "${build.dir}/lib/application.jar"
         basedir = "${build.dir}/classes"> <manifest> <attribute name = "Main-Class" value = "com.tutorialspoint.Application"/> </manifest> </jar> </target> <target name="publish" depends="jar"> <ivy:resolve /> <ivy:publish resolver="local" pubrevision="1.0" overwrite="true"> <artifacts pattern="${build.dir}/lib/[artifact].[ext]" />
      </ivy:publish>   
   </target>
</project>

Following are the important terms.

  • resolver − resolver to be used for publication.

  • pattern − pattern to locate the artifact.

Here publish task first build the jar, then resolve the dependencies, set the information and then publish the artifact to local repository.

Building the project

As we've all the files ready. Just go the console. Navigate to E: > ivy folder and run the ant command.

E:\ivy > ant publish

Ivy will come into action, resolving the dependencies, you will see the following result.

E:\ivy > ant publish
Buildfile: E:\ivy\build.xml
jar:
publish:
[ivy:resolve] :: Apache Ivy 2.5.0 - 20191020104435 :: https://ant.apache.org/ivy
/ ::
[ivy:resolve] :: loading settings :: url = jar:file:/E:/Apache/apache-ant-1.9.14
/lib/ivy-2.5.0.jar!/org/apache/ivy/core/settings/ivysettings.xml
[ivy:resolve] :: resolving dependencies :: com.tutorialspoint#test;1.0.0
[ivy:resolve]   confs: [default]
[ivy:resolve]   found commons-lang#commons-lang;2.6 in public
[ivy:resolve]   found junit#junit;3.8.1 in public
[ivy:resolve] :: resolution report :: resolve 121ms :: artifacts dl 15ms
      ---------------------------------------------------------------------
      |                  |            modules            ||   artifacts   |
      |       conf       | number| search|dwnlded|evicted|| number|dwnlded|
      ---------------------------------------------------------------------
      |      default     |   2   |   2   |   0   |   0   ||   4   |   0   |
      ---------------------------------------------------------------------
[ivy:publish] :: publishing :: com.tutorialspoint#test
[ivy:publish]   published application to C:\Users\Acer\.ivy2\local\com.tutorials
point\test\1.0\jars\application.jar
[ivy:publish]   published ivy to C:\Users\Acer\.ivy2\local\com.tutorialspoint\te
st\1.0\ivys\ivy.xml
BUILD SUCCESSFUL
Total time: 1 second

You can verify the publish ivy artifacts in local repository.

info task is used to set ivy specific information in a file and can be used without any dependency resolution.

Let's create Tester.java, build.xml and ivy.xml as described in IVY - Resolve Task chapter.

Update the build.xml to use the ivy publish task. First we'll create a jar file and then publish it. Before publish task, we've set the required ivy information using info task.

build.xml

<project name="test" default="resolve" xmlns:ivy="antlib:org.apache.ivy.ant">
   <property name = "build.dir" value = "build"/>
   <target name="resolve" description="resolve dependencies">
      <ivy:resolve />
   </target>
   <target name = "jar">
      <jar destfile = "${build.dir}/lib/application.jar" basedir = "${build.dir}/classes">      
         <manifest>
            <attribute name = "Main-Class" value = "com.tutorialspoint.Application"/>
         </manifest>
      </jar>
   </target>
   <target name="publish" depends="jar">
      <ivy:info file="ivy.xml" />
      <ivy:publish resolver="local" pubrevision="1.0" overwrite="true">
         <artifacts pattern="${build.dir}/lib/[artifact].[ext]" />
      </ivy:publish>   
   </target>
</project>

Here publish task first build the jar, then set the information using ivy:info task and then publish the artifact to local repository.

Building the project

As we've all the files ready. Just go the console. Navigate to E: > ivy folder and run the ant command.

E:\ivy > ant publish

Ivy will come into action, resolving the dependencies, you will see the following result.

Buildfile: E:\ivy\build.xml
jar:
publish:
 [ivy:info] :: Apache Ivy 2.5.0 - 20191020104435 :: https://ant.apache.org/ivy/
::
 [ivy:info] :: loading settings :: url = jar:file:/E:/Apache/apache-ant-1.9.14/l
ib/ivy-2.5.0.jar!/org/apache/ivy/core/settings/ivysettings.xml
[ivy:publish] :: publishing :: com.tutorialspoint#test
[ivy:publish]   published application to C:\Users\Acer\.ivy2\local\com.tutorials
point\test\1.0\jars\application.jar
[ivy:publish]   published ivy to C:\Users\Acer\.ivy2\local\com.tutorialspoint\te
st\1.0\ivys\ivy.xml
BUILD SUCCESSFUL
Total time: 0 seconds

If we do not put the info task then publish task will not work. Use the below modified build.xml and see the error for missing organization attribute and so on.

build.xml

<project name="test" default="resolve" xmlns:ivy="antlib:org.apache.ivy.ant">
   <property name = "build.dir" value = "build"/>
   <target name="resolve" description="resolve dependencies">
      <ivy:resolve />
   </target>
   <target name = "jar">
      <jar destfile = "${build.dir}/lib/application.jar"
         basedir = "${build.dir}/classes"> <manifest> <attribute name = "Main-Class" value = "com.tutorialspoint.Application"/> </manifest> </jar> </target> <target name="publish" depends="jar"> <ivy:publish resolver="local" pubrevision="1.0" overwrite="true"> <artifacts pattern="${build.dir}/lib/[artifact].[ext]" />
      </ivy:publish>   
   </target>
</project>

Navigate to E: > ivy folder and run the ant command.

E:\ivy > ant publish

Ivy will come into action, resolving the dependencies, you will see the following result.

Buildfile: E:\ivy\build.xml
jar:
publish:
[ivy:publish] :: Apache Ivy 2.5.0 - 20191020104435 :: https://ant.apache.org/ivy
/ ::
[ivy:publish] :: loading settings :: url = jar:file:/E:/Apache/apache-ant-1.9.14
/lib/ivy-2.5.0.jar!/org/apache/ivy/core/settings/ivysettings.xml
BUILD FAILED
E:\ivy\build.xml:28: no organisation provided for ivy publish task: It can eithe
r be set explicitly via the attribute 'organisation' or via 'ivy.organisation' p
roperty or a prior call to <resolve/>
Total time: 3 seconds

Resolvers are used to find locations from where a library is to be downloaded. A dependency resolver also handles common tasks. Ivy provides two types of Resolvers.

  • Composite − A resolver which uses other resolvers to do its tasks.

  • Standard − A resolver performs the required tasks.

Standard Resolvers

Following table lists down the standard resolvers and their usage.

Sr.No. Name (Type) & Description
1

IvyRep (Standard)

Locates Ivy files on ivyrep and artifacts on ibiblio.
2

IBiblio (Standard)

Locates artifacts on ibiblio.
3

BinTray (Standard)

Locates artifacts on bintray.
4

Packager (Standard)

Locates Ivy files and packaging instructions via URLs, creates artifacts using instructions.
5

FileSystem (Standard)

Locates Ivy files and artifacts on local file system.
6

URL (Standard)

Locates Ivy files and artifacts on repositories which can be accessed using URLs.
7

MirroredURL (Standard)

Locates Ivy files and artifacts on repositories which can be accessed using URLs from a mirror list.
8

VFS (Standard)

Locates Ivy files and artifacts on repositories which can be accessed using Apache Commons VFS.
9

SSH (Standard)

Locates Ivy files and artifacts on repositories which can be accessed using SSH.
10

SFTP (Standard)

Locates Ivy files and artifacts on repositories which can be accessed using SFTP.
11

Jar (Standard)

Locates Ivy files and artifacts on repositories within a jar.
12

Chain (Composite)

Delegates the search to a chain of sub resolvers.
13

Dual (Composite)

Delegates the search to a one resolver and artifacts to another.
14

OBR (Standard)

Resolve modules as OSGi bundles listed by an OSGi obr.xml.
15

Eclipse updatesite (Standard)

Resolve modules as OSGi bundles which are hosted on an Eclipse update site.
16

OSGi-agg (Composite)

Delegates the search to a chain of sub resolvers supporting OSGi bundles.

Let's create Tester.java, build.xml and ivy.xml in a new project under E: > ivy2 folder similar to as described in IVY - Resolve Task chapter. Create a settings folder under E: > ivy2. Create the ivysettings.xml in the settings folder.

build.xml

<project name="test" default="resolve" xmlns:ivy="antlib:org.apache.ivy.ant">
   <property name = "build.dir" value = "build"/>
   <property name = "base.dir" value = ""/>
   <target name="resolve" description="resolve dependencies">
      <ivy:resolve />
   </target>
   <target name="compile" depends="resolve" description="Compile">
      <mkdir dir="build/classes" />
      <javac srcdir="src" destdir="build/classes">
         <classpath refid="new.classpath" />
      </javac>
   </target>
</project>

ivy.xml

<?xml version="1.0" encoding="ISO-8859-1"?>
<ivy-module version="2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:noNamespaceSchemaLocation="http://ant.apache.org/ivy/schemas/ivy.xsd">
   <info organisation="org.apache" module="chained-resolvers"/>
   <dependencies>
      <dependency org="commons-lang" name="commons-lang" rev="2.6" conf="default"/>
      <dependency org="com.tutorialspoint" name="test" rev="1.0"/>
   </dependencies>
</ivy-module>

Here we've added two dependencies,one of commons-lang library and another as test which we published in IVY - Publish Task chapter.

ivysettings.xml

<ivysettings>
   <settings defaultResolver="multiresolver"/>
   <resolvers>
      <chain name="multiresolver">
         <filesystem name="libraries">
            <artifact pattern="${ivy.settings.dir}/repository/[artifact]-[revision].[ext]"/>
         </filesystem>
         <ibiblio name="ibiblio" m2compatible="true"/>
      </chain>
   </resolvers>
</ivysettings>

Here we've added created a composite resolver using chain resolver which has two resolver, one named libraries to locate libaries on local repository and one named ibiblio on maven public repository.

Building the project

As we've all the files ready. Just go the console. Navigate to E: > ivy2 folder and run the ant command.

E:\ivy > ant

Ivy will come into action, resolving the dependencies, you will see the following result.

Buildfile: E:\ivy2\build.xml
resolve:
[ivy:resolve] :: Apache Ivy 2.5.0 - 20191020104435 :: https://ant.apache.org/ivy
/ ::
[ivy:resolve] :: loading settings :: url = jar:file:/E:/Apache/apache-ant-1.9.14
/lib/ivy-2.5.0.jar!/org/apache/ivy/core/settings/ivysettings.xml
[ivy:resolve] :: resolving dependencies :: org.apache#chained-resolvers;working@
Acer-PC
[ivy:resolve]   confs: [default]
[ivy:resolve]   found commons-lang#commons-lang;2.6 in public
[ivy:resolve]   found com.tutorialspoint#test;1.0 in local
[ivy:resolve]   found junit#junit;3.8.1 in public
[ivy:resolve] downloading C:\Users\Acer\.ivy2\local\com.tutorialspoint\test\1.0\
jars\application.jar ...
[ivy:resolve] .. (1kB)
[ivy:resolve] .. (0kB)
[ivy:resolve]   [SUCCESSFUL ] com.tutorialspoint#test;1.0!application.jar (13ms)
[ivy:resolve] :: resolution report :: resolve 1085ms :: artifacts dl 22ms
      ---------------------------------------------------------------------
      |                  |            modules            ||   artifacts   |
      |       conf       | number| search|dwnlded|evicted|| number|dwnlded|
      ---------------------------------------------------------------------
      |      default     |   3   |   3   |   1   |   0   ||   5   |   1   |
      ---------------------------------------------------------------------
BUILD SUCCESSFUL
Total time: 9 seconds

In the logs you can verify that we have used both local and public repository resolvers.

A local repository is a private repository of a user. It is very useful in case a user is using a library whose version has been changed on other places and have breaking changes. In case of local repository, ivy will use the library present in the local if found and will not look into public or shared repositories.

Default Location

By default, local repository is present in ${ivy.default.ivy.user.dir}/local folder. If you want to change it, the use the ivy.local.default.root variable in ant file.

build.xml

<target name="resolve">
   <property name="ivy.local.default.root" value="/opt/ivy/repository/local"/>
   <ivy:resolve />
</target>

Other properties like ivy pattern and artifact pattern can also be customized as follows −

build.xml

<target name="resolve">
   <property name="ivy.local.default.root" value="/opt/ivy/repository/local"/>
   <property name="ivy.local.default.ivy.pattern" value="[module]/[revision]/ivy.xml"/>
   <property name="ivy.local.default.artifact.pattern" value="[module]/[revision]/[artifact].[ext]"/>
   <ivy:resolve />
</target>

Overriding ivysettings defaults

By default ivy has its configurations in ivysettings.xml present in ivy.jar.

ivysettings.xml

<ivysettings>
   <settings defaultResolver="default"/>
   <include url="${ivy.default.settings.dir}/ivysettings-public.xml"/> <include url="${ivy.default.settings.dir}/ivysettings-shared.xml"/>
   <include url="${ivy.default.settings.dir}/ivysettings-local.xml"/> <include url="${ivy.default.settings.dir}/ivysettings-main-chain.xml"/>
   <include url="${ivy.default.settings.dir}/ivysettings-default-chain.xml"/>
</ivysettings>

To override local repository setting, update the contents of ivysettings-local.xml.

ivysettings-local.xml

<ivysettings>
   <property name="ivy.local.default.root" value="${ivy.default.ivy.user.dir}/local" override="false"/>
   <property name="ivy.local.default.ivy.pattern" value="[organisation]/[module]/[revision]/[type]s/[artifact].[ext]" override="false"/>
   <property name="ivy.local.default.artifact.pattern" value="[organisation]/[module]/[revision]/[type]s/[artifact].[ext]" override="false"/>
   <resolvers>
      <filesystem name="local">
         <ivy pattern="${ivy.local.default.root}/${ivy.local.default.ivy.pattern}" />
         <artifact pattern="${ivy.local.default.root}/${ivy.local.default.artifact.pattern}" />
      </filesystem>
   </resolvers>
</ivysettings>

A shared repository is a team level shared repository of a team. It is very common to be overridden in organizations.

Default Location

By default, shared repository is present in ${ivy.default.ivy.user.dir}/shared folder. If you want to change it, the use the ivy.shared.default.root variable in ant file.

build.xml

<target name="resolve">
   <property name="ivy.shared.default.root" value="/opt/ivy/repository/shared"/>
   <ivy:resolve />
</target>

Other properties like ivy pattern and artifact pattern can also be customized as follows −

build.xml

<target name="resolve">
   <property name="ivy.shared.default.root" value="/opt/ivy/repository/shared"/>
   <property name="ivy.shared.default.ivy.pattern" value="[organisation]/[module]/[revision]/ivy.xml"/>
   <property name="ivy.shared.default.artifact.pattern" value="[organisation]/[module]/[revision]/[artifact].[ext]"/>
   <ivy:resolve />
</target>

Anular los valores predeterminados de Ivysettings

De forma predeterminada, ivy tiene sus configuraciones en ivysettings.xml presentes en ivy.jar.

ivysettings.xml

<ivysettings>
   <settings defaultResolver="default"/>
   <include url="${ivy.default.settings.dir}/ivysettings-public.xml"/>
   <include url="${ivy.default.settings.dir}/ivysettings-shared.xml"/> <include url="${ivy.default.settings.dir}/ivysettings-local.xml"/>
   <include url="${ivy.default.settings.dir}/ivysettings-main-chain.xml"/> <include url="${ivy.default.settings.dir}/ivysettings-default-chain.xml"/>
</ivysettings>

Para anular la configuración del repositorio compartido, actualice el contenido de ivysettings-shared.xml.

ivysettings-shared.xml

<ivysettings>
   <property name="ivy.shared.default.root" value="${ivy.default.ivy.user.dir}/shared" override="false"/> <property name="ivy.shared.default.ivy.pattern" value="[organisation]/[module]/[revision]/[type]s/[artifact].[ext]" override="false"/> <property name="ivy.shared.default.artifact.pattern" value="[organisation]/[module]/[revision]/[type]s/[artifact].[ext]" override="false"/> <resolvers> <filesystem name="shared"> <ivy pattern="${ivy.shared.default.root}/${ivy.shared.default.ivy.pattern}" /> <artifact pattern="${ivy.shared.default.root}/${ivy.shared.default.artifact.pattern}" />
      </filesystem>
   </resolvers>
</ivysettings>

Un repositorio público es un repositorio accesible a través de Internet y tiene módulos de terceros. Por defecto, ibiblio en modo compatible m2 es el repositorio público. También se conoce como repositorio público de maven 2.

Anular los valores predeterminados de Ivysettings

De forma predeterminada, ivy tiene sus configuraciones en ivysettings.xml presentes en ivy.jar.

ivysettings.xml

<ivysettings>
   <settings defaultResolver="default"/>
   <include url="${ivy.default.settings.dir}/ivysettings-public.xml"/>
   <include url="${ivy.default.settings.dir}/ivysettings-shared.xml"/> <include url="${ivy.default.settings.dir}/ivysettings-local.xml"/>
   <include url="${ivy.default.settings.dir}/ivysettings-main-chain.xml"/> <include url="${ivy.default.settings.dir}/ivysettings-default-chain.xml"/>
</ivysettings>

Para anular la configuración del repositorio público, actualice el contenido de ivysettings-public.xml o cree ivysettings.xml en la carpeta de configuración de su proyecto.

ivysettings.xml

<ivysettings>
   <settings defaultResolver="default"/>
   <include url="http://customserver/ivy/ivysettings-public.xml"/>
   <include url="${ivy.default.settings.dir}/ivysettings-shared.xml"/> <include url="${ivy.default.settings.dir}/ivysettings-local.xml"/>
   <include url="${ivy.default.settings.dir}/ivysettings-main-chain.xml"/> <include url="${ivy.default.settings.dir}/ivysettings-default-chain.xml"/>
</ivysettings>

Actualice el contenido predeterminado de ivysetting-public.xml.

Original - ivysetting-public.xml

<ivysettings>
   <resolvers>
      <ibiblio name="public" m2compatible="true"/>
   </resolvers>
</ivysettings>

Updated - ivysetting-public.xml

<ivysettings>
   <resolvers>
      <filesystem name="public">
         <ivy pattern="/path/to/my/public/rep/[organisation]/[module]/ivy-[revision].xml" />
         <artifact pattern="/path/to/my/public/rep/[organisation]/[module]/[artifact]-[revision].[ext]" />
      </filesystem>
   </resolvers>
</ivysettings>
ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved