Come posso dire a Maven di utilizzare la versione più recente di una dipendenza?

https://stackoverflow.com/questions/30571

09-06-2019
|

Domanda

In Maven, le dipendenze sono solitamente impostate in questo modo:

<dependency>
  <groupId>wonderful-inc</groupId>
  <artifactId>dream-library</artifactId>
  <version>1.2.3</version>
</dependency>

Ora, se lavori con librerie che hanno rilasci frequenti, aggiornare costantemente il tag <version> può essere alquanto fastidioso.Esiste un modo per dire a Maven di utilizzare sempre l'ultima versione disponibile (dal repository)?

Soluzione

NOTA:

Questa risposta si applica solo a Maven 2!Il citato LATEST E RELEASE metaversioni sono stati eliminati in Maven 3 "per motivi di build riproducibili", oltre 6 anni fa.Si prega di fare riferimento a questo Soluzione compatibile con Maven 3.

Se desideri utilizzare sempre la versione più recente, Maven ha due parole chiave che puoi utilizzare in alternativa agli intervalli di versioni.Dovresti utilizzare queste opzioni con cautela poiché non hai più il controllo dei plugin/dipendenze che stai utilizzando.

Quando dipendi da un plugin o da una dipendenza, puoi utilizzare il valore di versione di LATEST o RELEASE.LATEST si riferisce all'ultima versione rilasciata o snapshot di un particolare artefatto, l'artefatto distribuito più recentemente in un particolare repository.RELEASE si riferisce all'ultima versione non snapshot nel repository.In generale, non è una buona pratica progettare software che dipenda da una versione non specifica di un artefatto.Se stai sviluppando software, potresti voler utilizzare RELEASE o LATEST per comodità in modo da non dover aggiornare i numeri di versione quando viene rilasciata una nuova versione di una libreria di terze parti.Quando rilasci software, dovresti sempre assicurarti che il tuo progetto dipenda da versioni specifiche per ridurre le possibilità che la tua build o il tuo progetto siano influenzati da una versione software non sotto il tuo controllo.Utilizzare LATEST e RELEASE con cautela, se non del tutto.

Vedi il Sezione Sintassi POM del libro Maven per ulteriori dettagli.Oppure consulta questo documento Intervalli di versioni di dipendenza, Dove:

Una parentesi quadra ( [ & ] ) significa "chiuso" (compreso).
Una parentesi ( ( & ) ) significa "aperto" (esclusivo).

Ecco un esempio che illustra le varie opzioni.Nel repository Maven, com.foo:my-foo ha i seguenti metadati:

<?xml version="1.0" encoding="UTF-8"?><metadata>
  <groupId>com.foo</groupId>
  <artifactId>my-foo</artifactId>
  <version>2.0.0</version>
  <versioning>
    <release>1.1.1</release>
    <versions>
      <version>1.0</version>
      <version>1.0.1</version>
      <version>1.1</version>
      <version>1.1.1</version>
      <version>2.0.0</version>
    </versions>
    <lastUpdated>20090722140000</lastUpdated>
  </versioning>
</metadata>

Se è richiesta una dipendenza da quell'artefatto, sono disponibili le seguenti opzioni (other gamme di versioni possono essere specificati ovviamente, semplicemente mostrando quelli rilevanti qui):

Dichiara una versione esatta (si risolverà sempre in 1.0.1):

<version>[1.0.1]</version>

Dichiara una versione esplicita (si risolverà sempre in 1.0.1 a meno che non si verifichi una collisione, quando Maven selezionerà una versione corrispondente):

<version>1.0.1</version>

Dichiara un intervallo di versioni per tutte le versioni 1.x (attualmente verrà risolto in 1.1.1):

<version>[1.0.0,2.0.0)</version>

Dichiarare un intervallo di versioni a tempo indeterminato (si risolverà in 2.0.0):

<version>[1.0.0,)</version>

Dichiara la versione come ULTIMA (si risolverà in 2.0.0) (rimossa da Maven 3.x)

<version>LATEST</version>

Dichiara la versione come RELEASE (si risolverà in 1.1.1) (rimosso da Maven 3.x):

<version>RELEASE</version>

Tieni presente che per impostazione predefinita le tue distribuzioni aggiorneranno la voce "latest" nei metadati Maven, ma per aggiornare la voce "release", devi attivare il "release-profile" dal Maven super POM.Puoi farlo con "-Prelease-profile" o "-DperformRelease=true"

Vale la pena sottolineare che qualsiasi approccio che consenta a Maven di scegliere le versioni delle dipendenze (LATEST, RELEASE e intervalli di versioni) può lasciarti aperto a problemi relativi al tempo di creazione, poiché le versioni successive possono avere comportamenti diversi (ad esempio il plug-in di dipendenza ha precedentemente cambiato un valore predefinito valore da vero a falso, con risultati confusi).

Pertanto è generalmente una buona idea definire le versioni esatte nelle versioni.COME La risposta di Tim sottolinea, il plug-in-versioni-maven è uno strumento utile per aggiornare le versioni delle dipendenze, in particolare il file versioni: usa-le-ultime-versioni E versioni: usa-le-ultime-rilasci obiettivi.

Altri suggerimenti

Ora so che questo argomento è vecchio, ma leggendo la domanda e la risposta fornita dall'OP sembra che sia così Plugin per versioni Maven avrebbe potuto effettivamente essere una risposta migliore alla sua domanda:

In particolare potrebbero essere utili i seguenti obiettivi:

versioni: usa-le-ultime-versioni Cerca al POM per tutte le versioni che sono state una versione più recente e le sostituisce con l'ultima versione.
versioni: usa-le-ultime-rilasci Cerca al POM per tutte le versioni non snapshot che sono state una versione più recente e li sostituisce con l'ultima versione di rilascio.
versioni:proprietà-aggiornamento Aggiorna le proprietà definite in un progetto in modo che corrispondano all'ultima versione disponibile di dipendenze specifiche.Ciò può essere utile se una suite di dipendenze deve essere bloccata a una versione.

Sono inoltre previsti i seguenti altri obiettivi:

versioni: aggiornamenti-dipendenze-display Scansiona le dipendenze di un progetto e produce un rapporto di quelle dipendenze che dispongono di versioni più recenti.
versioni: aggiornamenti-plug-in-display Scansiona i plug -in di un progetto e produce un rapporto di quei plugin che dispongono di versioni più recenti.
versioni:aggiornamento-genitore Aggiorna la sezione genitore di un progetto in modo da fare riferimento alla versione disponibile più recente.Ad esempio, se si utilizza un POM di radice aziendale, questo obiettivo può essere utile se è necessario assicurarsi di utilizzare l'ultima versione del POM radice aziendale.
versioni:update-child-modules Aggiorna la sezione genitore dei moduli figlio di un progetto in modo che la versione corrisponda alla versione del progetto corrente.Ad esempio, se si dispone di un POM aggregatore che è anche il genitore dei progetti che aggrega e le versioni per bambini e genitore non riescono a sincronizzazione, questo mojo può aiutare a correggere le versioni dei moduli figlio.(Nota potrebbe essere necessario invocare Maven con l'opzione -N per eseguire questo obiettivo se il progetto è rotto così male che non può costruire a causa della versione errata della versione).
versioni: lock-snapshots Cerca il POM per tutte le versioni -snapshot e le sostituisce con l'attuale versione del timestamp di quel -snapshot, ad esempio-20090327.172306-4
versioni:istantanee di sblocco Cerca il POM per tutte le versioni di istantanea bloccate con timestamp e le sostituisce con -snapshot.
versioni:resolve-ranges Trova dipendenze utilizzando gli intervalli di versione e risolve l'intervallo alla versione specifica da utilizzare.
versioni: rilasci d'uso Cerca il POM per tutte le versioni di SNAPShot che sono state rilasciate e li sostituiscono con la versione di rilascio corrispondente.
versioni:usa-prossime-rilasci Ricerca il POM per tutte le versioni non snapshot che sono state una versione più recente e le sostituisce con la versione di versione successiva.
versioni:usa-versioni-successive Cerca al POM per tutte le versioni che sono state una versione più recente e le sostituisce con la prossima versione.
versioni:commit rimuove i file pom.xml.versionsBackup.Forma metà della "SCM povero" incorporata.
versioni:ripristina Ripristina i file pom.xml dai file pom.xml.versionsbackup.Forma metà della "SCM povero" incorporata.

Ho pensato di includerlo per qualsiasi riferimento futuro.

Per favore, dai un'occhiata questa pagina (sezione "Intervalli di versioni delle dipendenze").Quello che potresti voler fare è qualcosa del genere

<version>[1.2.3,)</version>

Questi intervalli di versioni sono implementati in Maven2.

A differenza di altri, penso che ci siano molte ragioni per cui potresti voglio sempre l'ultima novità versione.Soprattutto se stai eseguendo una distribuzione continua (a volte abbiamo circa 5 rilasci in un giorno) e non vuoi realizzare un progetto multi-modulo.

Quello che faccio è fare in modo che Hudson/Jenkins eseguano le seguenti operazioni per ogni build:

mvn clean versions:use-latest-versions scm:checkin deploy -Dmessage="update versions" -DperformRelease=true

Cioè utilizzo il plug-in delle versioni e il plug-in scm per aggiornare le dipendenze e quindi effettuarne il check-in nel controllo del codice sorgente.Sì, lascio che il mio CI esegua i check-in SCM (cosa che devi fare comunque per il plug-in di rilascio di Maven).

Ti consigliamo di configurare il plug-in delle versioni per aggiornare solo ciò che desideri:

        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>versions-maven-plugin</artifactId>
            <version>1.2</version>
            <configuration>
                <includesList>com.snaphop</includesList>
                <generateBackupPoms>false</generateBackupPoms>
                <allowSnapshots>true</allowSnapshots>
            </configuration>
        </plugin>

Utilizzo il plugin di rilascio per eseguire il rilascio che si occupa di -SNAPSHOT e verifica che esista una versione di rilascio di -SNAPSHOT (che è importante).

Se fai quello che faccio io, otterrai la versione più recente per tutte le build di istantanee e l'ultima versione di rilascio per le build di rilascio.Anche le tue build saranno riproducibili.

Aggiornamento

Ho notato alcuni commenti che chiedevano alcune specifiche di questo flusso di lavoro.Dirò che non utilizziamo più questo metodo e il motivo principale per cui il plug-in delle versioni Maven è difettoso e in generale è intrinsecamente difettoso.

È difettoso perché per eseguire il plug-in delle versioni per modificare le versioni, è necessario che esistano tutte le versioni esistenti affinché il pom funzioni correttamente.Cioè il plugin delle versioni non può aggiornarsi all'ultima versione di nulla se non riesce a trovare la versione a cui si fa riferimento nel pom.Questo in realtà è piuttosto fastidioso poiché spesso puliamo le vecchie versioni per motivi di spazio su disco.

In realtà hai bisogno di uno strumento separato da Maven per regolare le versioni (in modo da non dipendere dal file pom per funzionare correttamente).Ho scritto uno strumento del genere nel linguaggio umile che è Bash.Lo script aggiornerà le versioni come il plug-in della versione e ricontrollerà il pom nel controllo del codice sorgente.Funziona anche 100 volte più velocemente del plug-in delle versioni mvn.Sfortunatamente non è scritto in modo da essere utilizzato dal pubblico, ma se le persone sono interessate, potrei farlo così e inserirlo in un riepilogo o in GitHub.

Tornando al flusso di lavoro, poiché alcuni commenti hanno chiesto che questo è ciò che facciamo:

Abbiamo circa 20 progetti nei propri repository con i propri lavori Jenkins
Quando rilasciamo viene utilizzato il plug-in di rilascio Maven.Il flusso di lavoro è trattato nella documentazione del plugin.Il plug-in di rilascio di Maven fa schifo (e sono gentile) ma funziona.Un giorno pensiamo di sostituire questo metodo con qualcosa di più ottimale.
Quando uno dei progetti viene rilasciato, Jenkins esegue un lavoro speciale, chiameremo il lavoro di aggiornamento di tutte le versioni (il modo in cui Jenkins sa che si tratta di una versione è complicato, in parte perché anche il plug-in di rilascio di Maven Jenkins è piuttosto scadente).
Il lavoro di aggiornamento di tutte le versioni conosce tutti i 20 progetti.In realtà è un aggregatore pom per essere precisi con tutti i progetti nella sezione moduli in ordine di dipendenza.Jenkins esegue il nostro magico groovy/bash foo che farà sì che tutti i progetti aggiornino le versioni all'ultima e quindi effettui il check-in dei pom (sempre eseguito in ordine di dipendenza in base alla sezione dei moduli).
Per ogni progetto se il pom è cambiato (a causa di un cambio di versione in qualche dipendenza) viene archiviato e quindi eseguiamo immediatamente il ping di jenkins per eseguire il lavoro corrispondente per quel progetto (questo serve per preservare l'ordine di dipendenza della compilazione altrimenti sei in balia dello scheduler SCM Poll).

A questo punto sono dell'opinione che sia comunque una buona cosa avere il rilascio e la versione automatica come uno strumento separato dalla build generale.

Ora potresti pensare che Maven faccia schifo a causa dei problemi sopra elencati, ma in realtà sarebbe abbastanza difficile con uno strumento di creazione che non ha un dichiarativo facile da analizzare estensibile sintassi (nota anche come XML).

Infatti aggiungiamo attributi XML personalizzati attraverso gli spazi dei nomi per aiutare a suggerire script bash/groovy (ad es.non aggiornare questa versione).

La sintassi delle dipendenze si trova in Specifica dei requisiti della versione della dipendenza documentazione.Eccolo per completezza:

Dipendenze' version L'elemento definisce i requisiti della versione, utilizzato per calcolare la versione effettiva della dipendenza.I requisiti della versione hanno la seguente sintassi:

1.0:Requisito "soft" su 1.0 (solo una raccomandazione, se corrisponde a tutti gli altri intervalli per la dipendenza)

[1.0]:Requisito "difficile" su 1.0

(,1.0]:x <= 1,0

[1.2,1.3]:1,2 <= x <= 1,3

[1.0,2.0):1,0 <= x < 2,0

[1.5,):x >= 1,5

(,1.0],[1.2,):x <= 1,0 oppure x >= 1,2;più set sono separati da virgole

(,1.1),(1.1,):Ciò esclude 1.1 (ad esempio se non si sa che non funzioni in combinazione con questa libreria)

Nel tuo caso potresti fare qualcosa del genere <version>[1.2.3,)</version>

Dipendi forse da versioni di sviluppo che ovviamente cambiano molto durante lo sviluppo?

Invece di incrementare la versione delle versioni di sviluppo, potresti semplicemente utilizzare una versione snapshot da sovrascrivere quando necessario, il che significa che non dovresti modificare il tag della versione per ogni modifica minore.Qualcosa come 1.0-SNAPSHOT...

Ma forse stai cercando di ottenere qualcos'altro ;)

Chiunque utilizzi LATEST, assicurati di avere -U altrimenti l'ultima istantanea non verrà estratta.

mvn -U dependency:copy -Dartifact=com.foo:my-foo:LATEST
// pull the latest snapshot for my-foo from all repositories

Nel momento in cui è stata posta questa domanda c'erano alcuni problemi con gli intervalli di versione in Maven, ma questi sono stati risolti nelle versioni più recenti di Maven.Questo articolo illustra molto bene il funzionamento degli intervalli di versioni e le migliori pratiche per comprendere meglio il modo in cui Maven comprende le versioni: https://docs.oracle.com/middleware/1212/core/MAVEN/maven_version.htm#MAVEN8855

La verità è che anche nella versione 3.x funziona ancora, sorprendentemente i progetti vengono creati e distribuiti.Ma la parola chiave LATEST/RELEASE causa problemi in m2e ed eclissi ovunque, ANCHE i progetti dipendono dalla dipendenza che distribuita tramite LATEST/RELEASE non riesce a riconoscere la versione.

Causerà problemi anche se si tenta di definire la versione come proprietà e farvi riferimento altrove.

Quindi la conclusione è utilizzare il versioni-maven-plugin se potete.

A volte non vuoi utilizzare gli intervalli di versioni, perché sembra che siano "lenti" nel risolvere le tue dipendenze, specialmente quando è in atto una consegna continua e ci sono tonnellate di versioni, principalmente durante uno sviluppo intenso.

Una soluzione alternativa potrebbe essere quella di utilizzare il file versioni-maven-plugin.Ad esempio, puoi dichiarare una proprietà:

<properties>
    <myname.version>1.1.1</myname.version>
</properties>

e aggiungi il pluginversions-maven al tuo file pom:

<build>
    <plugins>
        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>versions-maven-plugin</artifactId>
            <version>2.3</version>
            <configuration>
                <properties>
                    <property>
                        <name>myname.version</name>
                        <dependencies>
                            <dependency>
                                <groupId>group-id</groupId>
                                <artifactId>artifact-id</artifactId>
                                <version>latest</version>
                            </dependency>
                        </dependencies>
                    </property>
                </properties>
            </configuration>
        </plugin>
    </plugins>
</build>

Quindi, per aggiornare la dipendenza, devi eseguire gli obiettivi:

mvn versions:update-properties validate

Se esiste una versione più recente della 1.1.1, ti dirà:

[INFO] Updated ${myname.version} from 1.1.1 to 1.3.2

Se vuoi che Maven utilizzi la versione più recente di una dipendenza, puoi utilizzare Versioni del plugin Maven e come utilizzare questo plugin, Tim ha già dato una buona risposta, segui la sua risposta.

Ma come sviluppatore, non consiglierò questo tipo di pratiche.PERCHÉ?

la risposta al perché è già data da Pasquale Thivent nel commento della domanda

Non raccomando davvero questa pratica (né usando gli intervalli di versione) per motivi di riproducibilità di build.Una build che inizia a fallire improvvisamente per una ragione sconosciuta è molto più fastidiosa che aggiornare manualmente un numero di versione.

Consiglierò questo tipo di pratica:

<properties>
    <spring.version>3.1.2.RELEASE</spring.version>
</properties>

<dependencies>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring.version}</version>
    </dependency>

</dependencies>

è facile da mantenere e facile da eseguire il debug.Puoi aggiornare il tuo POM in pochissimo tempo.

LA MIA soluzione in Maven 3.5.4, usa Nexus, in Eclipse:

<dependency>
    <groupId>yilin.sheng</groupId>
    <artifactId>webspherecore</artifactId>
    <version>LATEST</version> 
</dependency>

poi in eclissi: atl + F5, e scegli il force update of snapshots/release

per me funziona.

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow