Apache IVY - Guia rápido

Apache Ivy é uma ferramenta de gerenciamento de dependência muito popular e poderosa usada para gerenciar dependências em projetos baseados em ANT da mesma maneira que o Apache Maven gerencia dependências.

Apache Ivy é baseado em Apache ANT, segue os mesmos princípios de design, é um subprojeto do Apache ANT e é ativamente gerenciado e suportado pela Comunidade Apache ANT.

Características

A seguir estão os recursos importantes do Apache Ivy.

  • ANT Based- Apache Ivy fornece uma capacidade de gerenciamento de dependências para projetos baseados em ANT. Também é muito simples de usar.

  • Dependency Reports - Apache Ivy oferece opções para imprimir gráficos de dependências em html, bem como em formato de relatórios.

  • Non-intrusive- O Apache Ivy não impõe nenhuma restrição quanto a fazer parte da distribuição. Mesmo os arquivos de construção não dependem do Apache Ivy.

  • Highly Flexible - O Apache Ivy fornece muitas configurações padrão e pode ser configurado de acordo com os requisitos com muita facilidade.

  • Extendible- Apache Ivy pode ser estendido facilmente. Você pode definir seu próprio repositório, resolvedores de conflito e estratégia mais recente.

  • Performance- O Apache Ivy é construído para desempenho. Ele mantém um cache da biblioteca já baixada. Examina repositórios locais primeiro para resolver dependências do que em outros repositórios.

  • Transitive Dependencies - O Apache Ivy gerencia automaticamente as dependências transitivas se um projeto ou biblioteca depende de outra biblioteca que pode precisar de outra biblioteca.

  • Maven Repository- O Apache Ivy segue convenções semelhantes às convenções do repositório Maven. O Apache Ivy pode resolver dependências usando o repositório global maven.

  • Maven 2 POMs- Apache Ivy pode ler Maven 2 POMs como descritores de módulo, pode definir ivy como descritor de módulo. Assim, facilita a migração de projetos existentes para projetos gerenciados pelo IVY.

  • Publishing - Apache Ivy fornece suporte para publicar seu projeto e simplifica o processo de implantação de ambiente de vários projetos.

  • Free to Use - Apache Ivy é um software livre e de uso gratuito.

  • Documentation - Apache Ivy tem uma documentação e tutoriais muito detalhados disponíveis para aprender.

O Apache Ivy precisa de Java e ANT instalados em sua máquina como o único requisito.

O Apache Ant é distribuído sob a Apache Software License, uma licença de código aberto totalmente desenvolvida, certificada pela iniciativa de código aberto.

A versão mais recente do Apache Ant, incluindo seu código-fonte completo, arquivos de classe e documentação pode ser encontrada em http://ant.apache.org.

Instalando Apache Ant

Presume-se que você já tenha baixado e instalado o Java Development Kit (JDK) em seu computador. Caso contrário, siga as instruções aqui .

  • Certifique-se de que a variável de ambiente JAVA_HOME esteja configurada para a pasta onde seu JDK está instalado.

  • Baixe os binários de https://ant.apache.org

  • Descompacte o arquivo zip em um local conveniente c: \ pasta. usando Winzip, winRAR, 7-zip ou ferramentas semelhantes.

  • Crie uma nova variável de ambiente chamada ANT_HOME que aponta para a pasta de instalação do Ant, neste caso c:\apache-ant-1.9.14-bin pasta.

  • Anexe o caminho para o arquivo em lote Apache Ant na variável de ambiente PATH. No nosso caso, seria oc:\apache-ant-1.9.14-bin\bin pasta.

Verificando a instalação do Apache Ant

Para verificar a instalação bem-sucedida do Apache Ant em seu computador, digite ant no prompt de comando.

Você deve ver uma saída semelhante a -

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

Se você não vir a saída acima, verifique se seguiu as etapas de instalação corretamente.

Instalando Apache Ivy

  • Baixe os binários de https://ant.apache.org/ivy

  • Descompacte o arquivo zip em um local conveniente c: \ pasta. usando Winzip, winRAR, 7-zip ou ferramentas semelhantes.

  • Copie o ivy-2.5.0.jar para c:\apache-ant-1.9.14-bin/lib pasta.

Verificando a instalação do Apache Ivy

Para verificar a instalação bem-sucedida do Apache Ivy em seu computador, crie o seguinte arquivo de compilação em uma pasta 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>

Você deve ver uma saída semelhante a -

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

Instalando Eclipse

Este tutorial também cobre a integração do Ant com o IDE Eclipse. Portanto, se você ainda não instalou o Eclipse, baixe e instale o Eclipse

Para instalar o Eclipse -

  • Baixe os binários mais recentes do Eclipse em www.eclipse.org

  • Descompacte os binários do Eclipse em um local conveniente, digamos c: \ pasta

  • Execute o Eclipse em c: \ eclipse \ eclipse.exe

Considere o seguinte exemplo ivy.xml para entender a terminologia 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>

Termos da Ivy

A seguir estão os termos importantes do Ivy Eco-System.

  • Organisation- Como o nome sugere, refere-se ao nome da empresa, desenvolvedor individual ou nome da equipe que cria o projeto ou biblioteca. Por exemplo, com.tutorialspoint.

  • Module- Como o nome sugere, refere-se à unidade ou módulo reutilizável. Um módulo geralmente tem uma versão anexada a ele. Por exemplo commons-lang, ou ivy-test etc.

  • Module Descriptor- O descritor do módulo refere-se ao arquivo ivy.xml que descreve um módulo. Um descritor de módulo contém o identificador (org, nome, branch e versão), artefatos publicados, configurações e dependências.

  • Artifact- Artefato se refere a um único arquivo como entrega. Por exemplo, um arquivo jar. O artefato pode ser do tipo: zip, gz etc. Jar, Source Jar, Javadoc Jar são vários artefatos de um módulo.

  • Type - O tipo identifica a categoria de artefato como jar, war, src, doc etc.

  • Artifact file name extension - Extensão de artefato como .jar,, zip, .gz etc.

  • Module Revision - Um número de revisão exclusivo do módulo ou seu número de versão.

  • Status of Revision- O status da revisão indica a estabilidade da revisão. A seguir estão os importantes valores de status -

    • integration - Representa o desenvolvimento contínuo, construção noturna etc.

    • milestone - Representa uma distribuição, mas não finalizada.

    • release - Representa testado e concluído, uma versão principal.

  • Repository - Semelhante aos repositórios Maven, o repositório representa um site de distribuição onde ivy pode pesquisar uma biblioteca, artefatos, módulos, etc. Um repositório pode ser público, privado ou compartilhado.

  • Ivy Settings- O Apache Ivy segue os princípios do Maven e vem com várias configurações padrão. As configurações padrão podem ser substituídas definindo um arquivo ivysettings.xml.

O Apache Ivy segue os princípios do Maven e vem com várias configurações padrão. As configurações padrão podem ser substituídas definindo um arquivo 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>

Marcas do arquivo de configurações Ivy

A seguir estão as tags importantes do arquivo Ivy Setting.

  • property- Para definir uma variável ivy. Cardinalidade: 0..n

  • properties- Para definir as variáveis ​​de uma ivy usando o arquivo de propriedades. Cardinalidade: 0..n

  • settings- Para configurar ivy com valores padrão. Cardinalidade: 0..1

  • include- Para incluir outro arquivo de configurações. Cardinalidade: 0..n

  • classpath- Para adicionar um local no caminho de classe usado para carregar plug-ins. Cardinalidade: 0..n

  • typedef- Para definir novos tipos em ivy. Cardinalidade: 0..n

  • lock-strategies- Definir estratégias de bloqueio. Cardinalidade: 0..1

  • caches- Definir gerenciadores de cache de repositório. Cardinalidade: 0..1

  • latest-strategies- Para definir as estratégias mais recentes. Cardinalidade: 0..1

  • parsers- Para definir analisadores do descritor do módulo. Cardinalidade: 0..1

  • version-matchers- Para definir novos matchers de versão. Cardinalidade: 0..1

  • triggers- Para registrar gatilhos em eventos de ivy. Cardinalidade: 0..1

  • namespaces- Para definir novos namespaces. Cardinalidade: 0..1

  • macrodef- Para definir um novo macro resolvedor. Cardinalidade: 0..n

  • resolvers- Para definir resolvedores de dependência. Cardinalidade: 0..1

  • conflict-managers- Definir gerentes de conflitos. Cardinalidade: 0..1

  • modules- Para definir regras entre módulos e resolvedores de dependência. Cardinalidade: 0..1

  • outputters- Definir a lista de emissores de relatório disponíveis. Cardinalidade: 0..1

  • statuses- Para definir a lista de status disponíveis. Cardinalidade: 0..1

IvyDE é um plugin do Eclipse fornecido pela Apache. Para instalar o IvyDE, inicie o Eclipse e navegue até Ajuda> Instalar Novo Software. Ele exibe a janela de Softwares Disponíveis. Entrar no site de atualização da IvyDE http://www.apache.org/dist/ant/ivyde/updatesite/e pressione a tecla Enter. Ele exibe os seguintes plug-ins.

Clique em Avançar e você verá a tela a seguir.

Se você encontrar algum erro ao instalar o plugin, reinicie o processo. Após a instalação bem-sucedida, você verá o plugin no eclipe.

Agora você pode fazer o gerenciamento de dependências usando Eclipse e Ivy.

A tarefa de resolução é usada para resolver dependências descritas em ivy.xml, baixe e coloque-as no cache ivy.

Vamos primeiro criar um arquivo java Tester.java em E: > ivy > src > com > tutorialspoint pasta que atuará como pasta de origem para o projeto formiga.

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

A classe acima está usando a biblioteca Apache commons lang para usar sua classe StringUtils. Ivy deve baixar esta biblioteca e, portanto, deve ser definida na seção de dependências em ivy.xml. A seguir está o ivy.xml criado em E: > ivy pasta.

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>

A seguir estão os termos importantes.

  • ivy-module - Elemento raiz para identificar a versão ivy, namespace etc.

  • info - elemento para identificar o projeto como uma entidade única.

    • organisation - nome da organização

    • module - nome do módulo

    • status - status como lançamento, integração ou marco.

  • dependencies - elemento para conter dependências do projeto como tags de dependência que tem os seguintes atributos.

    • org - nome da organização da dependência

    • name - nome da dependência.

    • rev - versão da dependência.

build.xml

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

A seguir estão os termos importantes.

  • project - Elemento raiz para identificar o nome do projeto, namespace de tarefa padrão para ivy etc.

  • target- elemento de destino para criar uma nova tarefa e sua descrição. Contém uma tarefa de resolução de ivy. Quando o ant constrói o projeto, ele executa a tarefa de resolução de ivy, que então resolve as dependências usando ivy.

Construindo o projeto

Como temos todos os arquivos prontos. Vá para o console. Navegar paraE: > ivy pasta e execute o comando ant.

E:\ivy > ant

Ivy entrará em ação, resolvendo as dependências, você verá o seguinte 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 saída

A seguir estão os termos importantes.

  • conf - configuração, no nosso caso estamos usando a configuração padrão.

  • modules - indica o número total de módulos, módulos baixados, etc.

  • artifacts - indica o número total de artefatos, artefatos baixados etc.

Você pode verificar os arquivos baixados no local padrão do cache de ivy em ${ivy.default.ivy.user.dir} > .ivy2 > cachepasta. E $ {ivy.default.ivy.user.dir} é por padrão a home do usuário: $ HOME.

A tarefa de instalação é usada para instalar um módulo e suas dependências em um resolvedor. É usado quando um artefato público deve ser baixado e usado em um repositório privado. Por padrão, um repositório local do usuário é o seu repositório privado e está presente em $ {ivy.default.ivy.user.dir} / local.

Vamos criar Tester.java, build.xml e ivy.xml conforme descrito no capítulo IVY - Resolver Tarefa .

Atualize o build.xml para usar a tarefa de instalação 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>

A seguir estão os termos importantes.

  • organisation - nome da organização.

  • module - nome do módulo do projeto.

  • revision - versão do projeto.

  • from - do tipo de repositório.

  • to - para o tipo de repositório.

Construindo o projeto

Como temos todos os arquivos prontos. Vá para o console. Navegar paraE: > ivy pasta e execute o comando ant.

E:\ivy > ant install

Ivy entrará em ação, resolvendo as dependências, você verá o seguinte 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

Você pode verificar os arquivos baixados no local do repositório local padrão do cache de ivy ${ivy.default.ivy.user.dir} > .ivy2 > local diretório.

a tarefa de recuperação é usada para resolver dependências de um local especificado no espaço de trabalho do projeto.

Vamos criar Tester.java, build.xml e ivy.xml conforme descrito no capítulo IVY - Resolver Tarefa .

Atualize o build.xml para usar a tarefa de recuperação ivy.

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>

A seguir estão os termos importantes.

  • sync - sync true garante que o diretório lib esteja atualizado e qualquer arquivo extra seja excluído.

  • type- o tipo direciona ivy para copiar apenas o tipo especificado de artefatos como jar. Jar de origem, jar do javadoc será ignorado. o tipo para jar de origem é src ou fonte e doc ou pacote para jar de javadoc.

retrieve tasks copia as dependências resolvidas no diretório lib do projeto por padrão e pode ser alterado usando o atributo pattern.

Construindo o projeto

Como temos todos os arquivos prontos. Vá para o console. Navegar paraE: > ivy pasta e execute o comando ant.

E:\ivy > ant

Ivy entrará em ação, resolvendo as dependências, você verá o seguinte 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 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

Você pode verificar os arquivos baixados no diretório lib do projeto.

A tarefa cachepath é usada para criar um caminho de classe ANT com artefatos resolvidos presentes no cache. Como ANT precisa de jars para ser classpath para compilar arquivos java, Ivy cachepath constrói o classpath.

Vamos criar Tester.java, build.xml e ivy.xml conforme descrito no capítulo IVY - Resolver Tarefa .

Atualize o build.xml para usar a tarefa de recuperação ivy.

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>

A seguir estão os termos importantes.

  • pathid - id do classpath onde os jars em cache estão presentes.

retrieve tasks copia as dependências resolvidas no diretório lib do projeto por padrão e pode ser alterado usando o atributo pattern.

Construindo o projeto

Como temos todos os arquivos prontos. Vá para o console. Navegar paraE: > ivy pasta e execute o comando ant.

E:\ivy > ant compile

Ivy entrará em ação, resolvendo as dependências, você verá o seguinte 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 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

Você pode verificar o arquivo de classe compilado no diretório de construção do projeto.

A tarefa de publicação é usada para publicar artefatos atuais e seus arquivos descritores resolvidos no repositório mencionado.

Vamos criar Tester.java, build.xml e ivy.xml conforme descrito no capítulo IVY - Resolver Tarefa .

Atualize o build.xml para usar a tarefa de publicação ivy. Primeiro, vamos criar um arquivo jar e depois publicá-lo.

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>

A seguir estão os termos importantes.

  • resolver - resolvedor a ser usado para publicação.

  • pattern - padrão para localizar o artefato.

Aqui, publique a tarefa primeiro, construa o jar, depois resolva as dependências, defina as informações e publique o artefato no repositório local.

Construindo o projeto

Como temos todos os arquivos prontos. Vá para o console. Navegar paraE: > ivy pasta e execute o comando ant.

E:\ivy > ant publish

Ivy entrará em ação, resolvendo as dependências, você verá o seguinte resultado.

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

Você pode verificar os artefatos de ivy de publicação no repositório local.

A tarefa info é usada para definir informações específicas de ivy em um arquivo e pode ser usada sem qualquer resolução de dependência.

Vamos criar Tester.java, build.xml e ivy.xml conforme descrito no capítulo IVY - Resolver Tarefa .

Atualize o build.xml para usar a tarefa de publicação ivy. Primeiro, vamos criar um arquivo jar e depois publicá-lo. Antes de publicar a tarefa, definimos as informações de ivy necessárias usando a tarefa de informações.

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>

Aqui, publique a tarefa, primeiro construa o jar, em seguida, defina as informações usando ivy: info task e, em seguida, publique o artefato no repositório local.

Construindo o projeto

Como temos todos os arquivos prontos. Vá para o console. Navegar paraE: > ivy pasta e execute o comando ant.

E:\ivy > ant publish

Ivy entrará em ação, resolvendo as dependências, você verá o seguinte resultado.

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

Se não colocarmos a tarefa de informação, a tarefa de publicação não funcionará. Use o build.xml modificado abaixo e veja o erro de atributo de organização ausente e assim por diante.

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>

Navegar para E: > ivy pasta e execute o comando ant.

E:\ivy > ant publish

Ivy entrará em ação, resolvendo as dependências, você verá o seguinte resultado.

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 são usados ​​para encontrar locais de onde uma biblioteca deve ser baixada. Um resolvedor de dependências também lida com tarefas comuns. A Ivy oferece dois tipos de Resolvers.

  • Composite - Um resolvedor que usa outros resolvedores para fazer suas tarefas.

  • Standard - Um resolvedor executa as tarefas necessárias.

Resolvedores Padrão

A tabela a seguir lista os resolvedores padrão e seu uso.

Sr. Não. Nome (tipo) e descrição
1

IvyRep (Standard)

Localiza arquivos Ivy em ivyrep e artefatos em ibiblio.
2

IBiblio (Standard)

Localiza artefatos no ibiblio.
3

BinTray (Standard)

Localiza artefatos na bandeja do compartimento.
4

Packager (Standard)

Localiza arquivos Ivy e instruções de empacotamento por meio de URLs, cria artefatos usando instruções.
5

FileSystem (Standard)

Localiza arquivos e artefatos Ivy no sistema de arquivos local.
6

URL (Standard)

Localiza arquivos e artefatos Ivy em repositórios que podem ser acessados ​​usando URLs.
7

MirroredURL (Standard)

Localiza arquivos e artefatos Ivy em repositórios que podem ser acessados ​​usando URLs de uma lista de espelho.
8

VFS (Standard)

Localiza arquivos e artefatos Ivy em repositórios que podem ser acessados ​​usando o Apache Commons VFS.
9

SSH (Standard)

Localiza arquivos e artefatos Ivy em repositórios que podem ser acessados ​​usando SSH.
10

SFTP (Standard)

Localiza arquivos e artefatos Ivy em repositórios que podem ser acessados ​​usando SFTP.
11

Jar (Standard)

Localiza arquivos e artefatos Ivy em repositórios dentro de um jar.
12

Chain (Composite)

Delega a pesquisa a uma cadeia de sub-resolvedores.
13

Dual (Composite)

Delega a pesquisa a um resolvedor e artefatos a outro.
14

OBR (Standard)

Resolva os módulos como pacotes configuráveis ​​OSGi listados por um OSGi obr.xml.
15

Eclipse updatesite (Standard)

Resolva os módulos como pacotes configuráveis ​​OSGi que são hospedados em um site de atualização do Eclipse.
16

OSGi-agg (Composite)

Delega a pesquisa a uma cadeia de sub-resolvedores que oferecem suporte a pacotes OSGi.

Vamos criar Tester.java, build.xml e ivy.xml em um novo projeto em E: > ivy2pasta semelhante à descrita no capítulo IVY - Tarefa de resolução. Crie uma pasta de configurações emE: > ivy2. Crie o ivysettings.xml na pasta de configurações.

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>

Aqui nós adicionamos duas dependências, uma da biblioteca commons-lang e outra como teste, que publicamos no capítulo IVY - Publish Task .

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>

Aqui, criamos um resolvedor composto usando o resolvedor de cadeia que possui dois resolvedores, um nomeado bibliotecas para localizar bibliotecas no repositório local e um nomeado ibiblio no repositório público maven.

Construindo o projeto

Como temos todos os arquivos prontos. Vá para o console. Navegar paraE: > ivy2 pasta e execute o comando ant.

E:\ivy > ant

Ivy entrará em ação, resolvendo as dependências, você verá o seguinte resultado.

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

Nos logs, você pode verificar se usamos os resolvedores de repositório local e público.

Um repositório local é um repositório privado de um usuário. É muito útil no caso de um usuário estar usando uma biblioteca cuja versão foi alterada em outros locais e possui alterações importantes. No caso de repositório local, ivy usará a biblioteca presente no local, se encontrada, e não procurará em repositórios públicos ou compartilhados.

Localização padrão

Por padrão, o repositório local está presente na pasta $ {ivy.default.ivy.user.dir} / local. Se você quiser alterá-lo, use a variável ivy.local.default.root no arquivo ant.

build.xml

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

Outras propriedades como padrão de ivy e padrão de artefato também podem ser personalizadas da seguinte forma -

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>

Substituindo padrões de configuração iv

Por padrão, ivy tem suas configurações em ivysettings.xml presentes em 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 substituir a configuração do repositório local, atualize o conteúdo de 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>

Um repositório compartilhado é um repositório compartilhado de nível de equipe de uma equipe. É muito comum ser substituído nas organizações.

Localização padrão

Por padrão, o repositório compartilhado está presente na pasta $ {ivy.default.ivy.user.dir} / shared. Se você quiser alterá-lo, use a variável ivy.shared.default.root no arquivo ant.

build.xml

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

Outras propriedades como padrão de ivy e padrão de artefato também podem ser personalizadas da seguinte forma -

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>

Substituindo padrões de configuração iv

Por padrão, ivy tem suas configurações em ivysettings.xml presentes em 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 substituir a configuração do repositório compartilhado, atualize o conteúdo 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>

Um repositório público é um repositório acessível através da Internet e possui módulos de terceiros. Por padrão, ibiblio no modo compatível com m2 é o repositório público. Também é referido como repositório público maven 2.

Substituindo padrões de configuração iv

Por padrão, ivy tem suas configurações em ivysettings.xml presentes em 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 substituir a configuração do repositório público, atualize o conteúdo de ivysettings-public.xml ou crie o ivysettings.xml na pasta de configuração do seu projeto.

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>

Atualize o conteúdo padrão 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