Apache IVY - Guida rapida

Apache Ivy è uno strumento di gestione delle dipendenze molto popolare e molto potente utilizzato per gestire le dipendenze in progetti basati su ANT nello stesso modo in cui Apache Maven gestisce le dipendenze.

Apache Ivy è basato su Apache ANT, segue gli stessi principi di progettazione, è un sottoprogetto di Apache ANT ed è attivamente gestito e supportato dalla comunità di Apache ANT.

Caratteristiche

Di seguito sono riportate le caratteristiche importanti di Apache Ivy.

  • ANT Based- Apache Ivy fornisce una capacità di gestione delle dipendenze ai progetti basati su ANT. È anche molto semplice da usare.

  • Dependency Reports - Apache Ivy fornisce opzioni per stampare il grafico delle dipendenze in html e in formato report.

  • Non-intrusive- Apache Ivy non impone alcuna restrizione per essere parte della distribuzione. Anche i file di build non dipendono da Apache Ivy.

  • Highly Flexible - Apache Ivy fornisce molte configurazioni predefinite e può essere configurato in base ai requisiti molto facilmente.

  • Extendible- Apache Ivy può essere esteso facilmente. È possibile definire il proprio repository, risolutori di conflitti e la strategia più recente.

  • Performance- Apache Ivy è progettato per le prestazioni. Mantiene una cache della libreria già scaricata. Cerca prima nei repository locali per risolvere le dipendenze che in altri repository.

  • Transitive Dependencies - Apache Ivy gestisce automaticamente le dipendenze transitive se un progetto o una libreria dipende da un'altra libreria che potrebbe richiedere un'altra libreria.

  • Maven Repository- Apache Ivy segue convenzioni simili alle convenzioni del repository Maven. Apache Ivy può risolvere le dipendenze utilizzando il repository globale Maven.

  • Maven 2 POMs- Apache Ivy può leggere i POM di Maven 2 come descrittori di moduli, può impostare ivy come descrittori di moduli. In questo modo è facile migrare i progetti esistenti in progetti gestiti da IVY.

  • Publishing - Apache Ivy fornisce supporti per pubblicare il tuo progetto e semplifica il processo di distribuzione dell'ambiente multi-progetto.

  • Free to Use - Apache Ivy è open source ed è gratuito.

  • Documentation - Apache Ivy ha una documentazione molto dettagliata e tutorial disponibili per imparare.

Apache Ivy richiede Java e ANT installati sulla tua macchina come unico requisito.

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

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

Installazione di Apache Ant

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

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

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

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

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

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

Verifica dell'installazione di Apache Ant

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

Dovresti vedere un output simile a -

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

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

Installazione di Apache Ivy

  • Scarica i binari da https://ant.apache.org/ivy

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

  • Copia ivy-2.5.0.jar in c:\apache-ant-1.9.14-bin/lib cartella.

Verifica dell'installazione di Apache Ivy

Per verificare la corretta installazione di Apache Ivy sul tuo computer, crea il seguente file di build in una cartella 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>

Dovresti vedere un output simile a -

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

Installazione di Eclipse

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

Per installare Eclipse -

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

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

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

Considera il seguente esempio ivy.xml per comprendere la 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>

Termini di Ivy

Di seguito sono riportati i termini importanti di Ivy Eco-System.

  • Organisation- Come suggerisce il nome, si riferisce al nome dell'azienda, del singolo sviluppatore o del nome del team che crea il progetto o la libreria. Ad esempio, com.tutorialspoint.

  • Module- Come suggerisce il nome, si riferisce all'unità o al modulo riutilizzabile. Un modulo generalmente ha una versione allegata ad esso. Ad esempio commons-lang o ivy-test ecc.

  • Module Descriptor- Il descrittore del modulo si riferisce al file ivy.xml che descrive un modulo. Un descrittore del modulo contiene l'identificatore (organizzazione, nome, ramo e versione), gli artefatti pubblicati, le configurazioni e le dipendenze.

  • Artifact- Artefatto si riferisce a un singolo file come deliverable. Ad esempio, un file jar. Gli artefatti possono essere di tipo: zip, gz ecc. Jar, Source Jar, Javadoc Jar sono vari artefatti di un modulo.

  • Type - Il tipo identifica la categoria di artefatto come jar, war, src, doc ecc.

  • Artifact file name extension - Estensione artefatto come .jar,, zip, .gz ecc.

  • Module Revision - Un numero di revisione univoco del modulo o il suo numero di versione.

  • Status of Revision- Lo stato di revisione indica la stabilità della revisione. Di seguito è riportato il valore importante dello stato:

    • integration - Rappresenta lo sviluppo continuo, la costruzione notturna ecc.

    • milestone - Rappresenta una distribuzione ma non finalizzata.

    • release - Rappresenta testato e completato, una versione principale.

  • Repository - Simile ai repository Maven, il repository rappresenta un sito di distribuzione in cui ivy può cercare una libreria, artefatti, moduli ecc. Un repository può essere pubblico, privato o condiviso.

  • Ivy Settings- Apache Ivy segue i principi di Maven e viene fornito con molte configurazioni predefinite. Le impostazioni predefinite possono essere sovrascritte definendo un file ivysettings.xml.

Apache Ivy segue i principi di Maven e viene fornito con molte configurazioni predefinite. Le impostazioni predefinite possono essere sovrascritte definendo un file 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>

Tag del file delle impostazioni di Ivy

Di seguito sono riportati i tag importanti del file Ivy Setting.

  • property- Per impostare una variabile edera. Cardinalità: 0..n

  • properties- Per impostare un ivy variabili utilizzando il file delle proprietà. Cardinalità: 0..n

  • settings- Per configurare Ivy con i valori predefiniti. Cardinalità: 0..1

  • include- Per includere un altro file di impostazioni. Cardinalità: 0..n

  • classpath- Per aggiungere una posizione nel percorso di classe utilizzato per caricare i plugin. Cardinalità: 0..n

  • typedef- Per definire nuovi tipi di edera. Cardinalità: 0..n

  • lock-strategies- Per definire strategie di blocco. Cardinalità: 0..1

  • caches- Per definire i gestori della cache del repository. Cardinalità: 0..1

  • latest-strategies- Definire le ultime strategie. Cardinalità: 0..1

  • parsers- Per definire i parser del descrittore del modulo. Cardinalità: 0..1

  • version-matchers- Per definire nuovi abbinamenti di versione. Cardinalità: 0..1

  • triggers- Per registrare trigger su eventi ivy. Cardinalità: 0..1

  • namespaces- Per definire nuovi spazi dei nomi. Cardinalità: 0..1

  • macrodef- Per definire un nuovo risolutore di macro. Cardinalità: 0..n

  • resolvers- Per definire risolutori di dipendenze. Cardinalità: 0..1

  • conflict-managers- Definire i gestori dei conflitti. Cardinalità: 0..1

  • modules- Definire regole tra moduli e risolutori di dipendenze. Cardinalità: 0..1

  • outputters- Per definire l'elenco dei generatori di rapporti disponibili. Cardinalità: 0..1

  • statuses- Per definire l'elenco degli stati disponibili. Cardinalità: 0..1

IvyDE è un plugin Eclipse fornito da Apache. Per installare IvyDE, avvia Eclipse e vai su Aiuto> Installa nuovo software. Visualizza la finestra Software disponibili. Entra nel sito di aggiornamento di IvyDE http://www.apache.org/dist/ant/ivyde/updatesite/e premere il tasto Invio. Visualizza i seguenti plugin.

Fare clic su Avanti e verrà visualizzata la schermata seguente.

Se si verificano errori durante l'installazione del plug-in, è sufficiente riavviare il processo. Dopo l'installazione con successo, vedrai il plugin in eclipe.

Ora puoi eseguire la gestione delle dipendenze utilizzando Eclipse e Ivy.

L'attività di risoluzione viene utilizzata per risolvere le dipendenze descritte in ivy.xml, scaricarle e inserirle in ivy cache.

Creiamo prima un file java Tester.java in E: > ivy > src > com > tutorialspoint cartella che fungerà da cartella di origine per il progetto 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 classe sopra sta usando la libreria lang di apache commons per usare la sua classe StringUtils. Ivy dovrebbe scaricare questa libreria e quindi dovrebbe essere definita nella sezione delle dipendenze in ivy.xml. Di seguito è riportato ivy.xml creato in E: > ivy cartella.

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>

Di seguito sono riportati i termini importanti.

  • ivy-module - Elemento radice per identificare la versione di Ivy, lo spazio dei nomi ecc.

  • info - elemento per identificare il progetto come entità unica.

    • organisation - nome dell'organizzazione

    • module - nome del modulo

    • status - stato come rilascio, integrazione o pietra miliare.

  • dependencies - elemento per contenere le dipendenze del progetto come tag di dipendenza che ha i seguenti attributi.

    • org - nome dell'organizzazione della dipendenza

    • name - nome della dipendenza.

    • rev - versione della dipendenza.

build.xml

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

Di seguito sono riportati i termini importanti.

  • project - Elemento radice per identificare il nome del progetto, lo spazio dei nomi dell'attività predefinito per Ivy ecc.

  • target- elemento target per creare una nuova attività e la sua descrizione. Questo contiene un'attività di risoluzione dell'edera. Quando formica costruisce il progetto, esegue l'attività di risoluzione ivy che poi risolve le dipendenze usando ivy.

Costruire il progetto

Poiché abbiamo tutti i file pronti. Vai alla console. Navigare versoE: > ivy cartella ed esegui il comando ant.

E:\ivy > ant

Ivy entrerà in azione, risolvendo le dipendenze, vedrai il seguente risultato.

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>

Risolvi output

Di seguito sono riportati i termini importanti.

  • conf - configurazione, nel nostro caso stiamo usando la configurazione predefinita.

  • modules - indica il numero totale di moduli, moduli scaricati ecc.

  • artifacts - indica il numero totale di artefatti, artefatti scaricati ecc.

Puoi verificare i file scaricati nella posizione predefinita di ivy cache in ${ivy.default.ivy.user.dir} > .ivy2 > cachecartella. E $ {ivy.default.ivy.user.dir} è per impostazione predefinita la home dell'utente: $ HOME.

L'attività di installazione viene utilizzata per installare un modulo e le sue dipendenze in un resolver. Viene utilizzato quando un artefatto pubblico deve essere scaricato e utilizzato in un repository privato. Per impostazione predefinita, un repository locale dell'utente è il suo repository privato ed è presente in $ {ivy.default.ivy.user.dir} / local.

Creiamo Tester.java, build.xml e ivy.xml come descritto nel capitolo IVY - Risolvi attività .

Aggiorna il file build.xml per utilizzare l'attività di installazione di 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>

Di seguito sono riportati i termini importanti.

  • organisation - nome dell'organizzazione.

  • module - nome del modulo del progetto.

  • revision - versione del progetto.

  • from - dal tipo di repository.

  • to - al tipo di repository.

Costruire il progetto

Poiché abbiamo tutti i file pronti. Vai alla console. Navigare versoE: > ivy cartella ed esegui il comando ant.

E:\ivy > ant install

Ivy entrerà in azione, risolvendo le dipendenze, vedrai il seguente risultato.

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

È possibile verificare i file scaricati nella posizione del repository locale predefinita di ivy cache ${ivy.default.ivy.user.dir} > .ivy2 > local directory.

l'attività di recupero viene utilizzata per risolvere le dipendenze in una posizione specificata nell'area di lavoro del progetto.

Creiamo Tester.java, build.xml e ivy.xml come descritto nel capitolo IVY - Risolvi attività .

Aggiorna il file build.xml per utilizzare l'attività di recupero dell'edera.

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>

Di seguito sono riportati i termini importanti.

  • sync - sync true assicura che la directory lib sia aggiornata e qualsiasi file aggiuntivo venga eliminato.

  • type- il tipo indica a edera di copiare solo il tipo specificato di artefatti come jar. Source jar, javadoc jar verranno ignorati. il tipo per il jar di origine è src o source e doc o bundle per il jar di javadoc.

recupera attività copia le dipendenze risolte nella directory lib del progetto per impostazione predefinita e può essere modificata utilizzando l'attributo pattern.

Costruire il progetto

Poiché abbiamo tutti i file pronti. Vai alla console. Navigare versoE: > ivy cartella ed esegui il comando ant.

E:\ivy > ant

Ivy entrerà in azione, risolvendo le dipendenze, vedrai il seguente risultato.

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

È possibile verificare i file scaricati nella directory lib del progetto.

L'attività cachepath viene utilizzata per creare un classpath ANT con artefatti risolti presenti nella cache. Poiché ANT ha bisogno che i jar siano classpath per compilare i file java, Ivy cachepath costruisce il classpath.

Creiamo Tester.java, build.xml e ivy.xml come descritto nel capitolo IVY - Risolvi attività .

Aggiorna il file build.xml per utilizzare l'attività di recupero dell'edera.

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>

Di seguito sono riportati i termini importanti.

  • pathid - id del classpath in cui sono presenti i jar memorizzati nella cache.

recupera attività copia le dipendenze risolte nella directory lib del progetto per impostazione predefinita e può essere modificata utilizzando l'attributo pattern.

Costruire il progetto

Poiché abbiamo tutti i file pronti. Vai alla console. Navigare versoE: > ivy cartella ed esegui il comando ant.

E:\ivy > ant compile

Ivy entrerà in azione, risolvendo le dipendenze, vedrai il seguente risultato.

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

È possibile verificare il file di classe compilato nella directory di compilazione del progetto.

L'attività di pubblicazione viene utilizzata per pubblicare gli artefatti correnti ei relativi file descrittori risolti nel repository menzionato.

Creiamo Tester.java, build.xml e ivy.xml come descritto nel capitolo IVY - Risolvi attività .

Aggiorna il file build.xml per utilizzare l'attività di pubblicazione di ivy. Per prima cosa creeremo un file jar e poi lo pubblicheremo.

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>

Di seguito sono riportati i termini importanti.

  • resolver - resolver da utilizzare per la pubblicazione.

  • pattern - modello per individuare l'artefatto.

Qui pubblica l'attività prima, crea il jar, quindi risolvi le dipendenze, imposta le informazioni e quindi pubblica l'artefatto nel repository locale.

Costruire il progetto

Poiché abbiamo tutti i file pronti. Vai alla console. Navigare versoE: > ivy cartella ed esegui il comando ant.

E:\ivy > ant publish

Ivy entrerà in azione, risolvendo le dipendenze, vedrai il seguente risultato.

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

È possibile verificare gli artefatti dell'edera di pubblicazione nel repository locale.

L'attività info viene utilizzata per impostare informazioni specifiche su edera in un file e può essere utilizzata senza alcuna risoluzione delle dipendenze.

Creiamo Tester.java, build.xml e ivy.xml come descritto nel capitolo IVY - Risolvi attività .

Aggiorna il file build.xml per utilizzare l'attività di pubblicazione di ivy. Per prima cosa creeremo un file jar e poi lo pubblicheremo. Prima di pubblicare l'attività, abbiamo impostato le informazioni di ivy richieste utilizzando l'attività info.

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>

Qui pubblica l'attività prima crea il vaso, quindi imposta le informazioni utilizzando ivy: attività info e quindi pubblica l'artefatto nel repository locale.

Costruire il progetto

Poiché abbiamo tutti i file pronti. Vai alla console. Navigare versoE: > ivy cartella ed esegui il comando ant.

E:\ivy > ant publish

Ivy entrerà in azione, risolvendo le dipendenze, vedrai il seguente risultato.

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 non inseriamo l'attività di informazioni, l'attività di pubblicazione non funzionerà. Utilizzare il build.xml modificato di seguito e visualizzare l'errore per l'attributo dell'organizzazione mancante e così via.

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>

Navigare verso E: > ivy cartella ed esegui il comando ant.

E:\ivy > ant publish

Ivy entrerà in azione, risolvendo le dipendenze, vedrai il seguente risultato.

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

I resolver vengono utilizzati per trovare le posizioni da cui scaricare una libreria. Un risolutore di dipendenze gestisce anche attività comuni. Ivy fornisce due tipi di resolver.

  • Composite - Un risolutore che utilizza altri risolutori per svolgere i propri compiti.

  • Standard - Un resolver esegue le attività richieste.

Resolver standard

La tabella seguente elenca i resolver standard e il loro utilizzo.

Sr.No. Nome (tipo) e descrizione
1

IvyRep (Standard)

Individua i file Ivy su ivyrep e gli artefatti su ibiblio.
2

IBiblio (Standard)

Individua artefatti su ibiblio.
3

BinTray (Standard)

Individua gli artefatti su bintray.
4

Packager (Standard)

Individua i file Ivy e le istruzioni di pacchettizzazione tramite URL, crea artefatti utilizzando le istruzioni.
5

FileSystem (Standard)

Individua i file e gli artefatti Ivy sul file system locale.
6

URL (Standard)

Individua i file e gli artefatti Ivy nei repository a cui è possibile accedere utilizzando gli URL.
7

MirroredURL (Standard)

Individua i file e gli artefatti Ivy sui repository a cui è possibile accedere utilizzando gli URL da un elenco mirror.
8

VFS (Standard)

Individua i file e gli artefatti Ivy nei repository a cui è possibile accedere utilizzando Apache Commons VFS.
9

SSH (Standard)

Individua i file e gli artefatti Ivy sui repository a cui è possibile accedere tramite SSH.
10

SFTP (Standard)

Individua i file e gli artefatti Ivy sui repository a cui è possibile accedere tramite SFTP.
11

Jar (Standard)

Individua i file e gli artefatti Ivy sui repository all'interno di un jar.
12

Chain (Composite)

Delega la ricerca a una catena di sub-risolutori.
13

Dual (Composite)

Delega la ricerca a un risolutore e gli artefatti a un altro.
14

OBR (Standard)

Risolvi i moduli come bundle OSGi elencati da un OSGi obr.xml.
15

Eclipse updatesite (Standard)

Risolvi i moduli come bundle OSGi che sono ospitati su un sito di aggiornamento di Eclipse.
16

OSGi-agg (Composite)

Delega la ricerca a una catena di sub-resolver che supportano i bundle OSGi.

Creiamo Tester.java, build.xml e ivy.xml in un nuovo progetto sotto E: > ivy2cartella simile a quella descritta nel capitolo IVY - Risolvi attività . Crea una cartella delle impostazioni inE: > ivy2. Crea ivysettings.xml nella cartella delle impostazioni.

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>

Qui abbiamo aggiunto due dipendenze, una della libreria commons-lang e un'altra come test che abbiamo pubblicato nel capitolo 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>

Qui abbiamo aggiunto creato un risolutore composito usando il risolutore a catena che ha due risolutori, una librerie con nome per individuare le librerie sul repository locale e una denominata ibiblio sul repository pubblico maven.

Costruire il progetto

Poiché abbiamo tutti i file pronti. Vai alla console. Navigare versoE: > ivy2 cartella ed esegui il comando ant.

E:\ivy > ant

Ivy entrerà in azione, risolvendo le dipendenze, vedrai il seguente risultato.

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

Nei log puoi verificare che abbiamo utilizzato risolutori di repository sia locali che pubblici.

Un repository locale è un repository privato di un utente. È molto utile nel caso in cui un utente stia utilizzando una libreria la cui versione è stata modificata in altri luoghi e presenta modifiche sostanziali. In caso di repository locale, ivy utilizzerà la libreria presente nel locale se trovata e non esaminerà repository pubblici o condivisi.

Posizione predefinita

Per impostazione predefinita, il repository locale è presente nella cartella $ {ivy.default.ivy.user.dir} / local. Se vuoi cambiarlo, usa la variabile ivy.local.default.root nel file ant.

build.xml

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

Altre proprietà come il modello di edera e il modello di artefatto possono anche essere personalizzate come segue:

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>

Ignorare i valori predefiniti di ivysettings

Per impostazione predefinita, ivy ha le sue configurazioni in ivysettings.xml presente 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>

Per sovrascrivere l'impostazione del repository locale, aggiornare il contenuto di 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>

Un repository condiviso è un repository condiviso a livello di team di un team. È molto comune essere sovrascritti nelle organizzazioni.

Posizione predefinita

Per impostazione predefinita, il repository condiviso è presente nella cartella $ {ivy.default.ivy.user.dir} / shared. Se vuoi cambiarlo, usa la variabile ivy.shared.default.root nel file ant.

build.xml

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

Altre proprietà come il modello di edera e il modello di artefatto possono anche essere personalizzate come segue:

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>

Ignorare i valori predefiniti di ivysettings

Per impostazione predefinita, ivy ha le sue configurazioni in ivysettings.xml presente 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>

Per sovrascrivere l'impostazione del repository condiviso, aggiornare il contenuto di 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 repository pubblico è un repository accessibile tramite Internet e dispone di moduli di terze parti. Per impostazione predefinita, ibiblio in modalità compatibile con m2 è il repository pubblico. Viene anche indicato come repository pubblico di maven 2.

Ignorare i valori predefiniti di ivysettings

Per impostazione predefinita, ivy ha le sue configurazioni in ivysettings.xml presente 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>

Per sovrascrivere l'impostazione del repository pubblico, aggiornare i contenuti di ivysettings-public.xml o creare ivysettings.xml nella cartella delle impostazioni del progetto.

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>

Aggiorna i contenuti ivysetting-public.xml predefiniti.

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