Wie kann ich Maven anweisen, die neueste Version einer Abhängigkeit zu verwenden?

In Maven werden Abhängigkeiten normalerweise folgendermaßen eingerichtet:

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

Wenn Sie jetzt mit Bibliotheken arbeiten, die häufig veröffentlicht werden, kann die ständige Aktualisierung des <version> -Tags etwas ärgerlich sein. Gibt es eine Möglichkeit, Maven anzuweisen, immer die neueste verfügbare Version (aus dem Repository) zu verwenden?

HINWEIS:

Diese Antwort gilt nur für Maven 2! Die erwähnten LATESTund RELEASEMetaversionen wurden vor über 6 Jahren in Maven 3 "aus Gründen reproduzierbarer Builds" gelöscht . Bitte beziehen Sie sich auf diese Maven 3-kompatible Lösung .

Wenn Sie immer die neueste Version verwenden möchten, verfügt Maven über zwei Schlüsselwörter, die Sie als Alternative zu Versionsbereichen verwenden können. Sie sollten diese Optionen mit Vorsicht verwenden, da Sie nicht mehr die Kontrolle über die von Ihnen verwendeten Plugins / Abhängigkeiten haben.

Wenn Sie von einem Plugin oder einer Abhängigkeit abhängig sind, können Sie den Versionswert LATEST oder RELEASE verwenden. LATEST bezieht sich auf die neueste veröffentlichte Version oder Snapshot-Version eines bestimmten Artefakts, das zuletzt in einem bestimmten Repository bereitgestellte Artefakt. RELEASE bezieht sich auf die letzte Nicht-Snapshot-Version im Repository. Im Allgemeinen ist es keine bewährte Methode, Software zu entwerfen, die von einer unspezifischen Version eines Artefakts abhängt. Wenn Sie Software entwickeln, möchten Sie möglicherweise RELEASE oder LATEST als Annehmlichkeit verwenden, damit Sie die Versionsnummern nicht aktualisieren müssen, wenn eine neue Version einer Bibliothek eines Drittanbieters veröffentlicht wird. Wenn Sie Software veröffentlichen, sollten Sie immer sicherstellen, dass Ihr Projekt von bestimmten Versionen abhängt, um die Wahrscheinlichkeit zu verringern, dass Ihr Build oder Ihr Projekt von einer Softwareversion betroffen ist, die nicht unter Ihrer Kontrolle steht.

Siehe die POM Syntax Abschnitt des Maven Buch für weitere Details. Oder lesen Sie dieses Dokument über Abhängigkeitsversionsbereiche , in denen:

• Eine eckige Klammer ( [& ]) bedeutet "geschlossen" (einschließlich).
• Eine Klammer ( (& )) bedeutet "offen" (exklusiv).

Hier ist ein Beispiel, das die verschiedenen Optionen veranschaulicht. Im Maven-Repository enthält com.foo:my-foo die folgenden Metadaten:

<?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>

Wenn eine Abhängigkeit von diesem Artefakt erforderlich ist, haben Sie folgende Möglichkeiten (andere Versionsbereiche können natürlich angegeben werden, wobei nur die relevanten hier angezeigt werden):

Deklarieren Sie eine genaue Version (wird immer auf 1.0.1 aufgelöst):

<version>[1.0.1]</version>

Deklarieren Sie eine explizite Version (wird immer auf 1.0.1 aufgelöst, es sei denn, es kommt zu einer Kollision, wenn Maven eine passende Version auswählt):

<version>1.0.1</version>

Deklarieren Sie einen Versionsbereich für alle 1.x (wird derzeit in 1.1.1 aufgelöst):

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

Deklarieren Sie einen offenen Versionsbereich (wird auf 2.0.0 aufgelöst):

<version>[1.0.0,)</version>

Deklarieren Sie die Version als NEUESTE (wird auf 2.0.0 aufgelöst) (aus maven 3.x entfernt)

<version>LATEST</version>

Deklarieren Sie die Version als RELEASE (wird in 1.1.1 aufgelöst) (aus maven 3.x entfernt):

<version>RELEASE</version>

Beachten Sie, dass Ihre eigenen Bereitstellungen standardmäßig den "neuesten" Eintrag in den Maven-Metadaten aktualisieren. Um den "Release" -Eintrag zu aktualisieren, müssen Sie jedoch das "Release-Profil" aus dem Maven-Super-POM aktivieren . Sie können dies entweder mit "-Prelease-Profil" oder "-DperformRelease = true" tun.

Hervorzuheben ist, dass jeder Ansatz, mit dem Maven die Abhängigkeitsversionen (LATEST, RELEASE und Versionsbereiche) auswählen kann, Sie für Zeitprobleme offen lässt, da spätere Versionen ein anderes Verhalten aufweisen können (z. B. hat das Abhängigkeits-Plugin zuvor einen Standard geändert Wert von wahr nach falsch, mit verwirrenden Ergebnissen).

Es ist daher im Allgemeinen eine gute Idee, genaue Versionen in Releases zu definieren. Wie Tims Antwort zeigt, ist das Maven-Versions-Plugin ein praktisches Tool zum Aktualisieren von Abhängigkeitsversionen, insbesondere der Versionen: Use-Recent-Versionen und Versionen: Use-Recent-Releases- Ziele.

Jetzt weiß ich, dass dieses Thema alt ist, aber beim Lesen der Frage und der vom OP bereitgestellten Antwort scheint das Maven Versions Plugin tatsächlich eine bessere Antwort auf seine Frage gewesen zu sein:

Insbesondere könnten folgende Ziele von Nutzen sein:

• Versionen: Use-Recent-Versionen durchsucht den POM nach allen Versionen, die eine neuere Version waren, und ersetzt sie durch die neueste Version.
• Versionen: Use- Recent -Releases durchsucht den POM nach allen Nicht-SNAPSHOT-Versionen, die eine neuere Version waren, und ersetzt sie durch die neueste Release-Version.
• Versionen: Update-Eigenschaften Aktualisiert die in einem Projekt definierten Eigenschaften so, dass sie der neuesten verfügbaren Version bestimmter Abhängigkeiten entsprechen. Dies kann nützlich sein, wenn eine Reihe von Abhängigkeiten an eine Version gebunden sein muss.

Die folgenden anderen Ziele werden ebenfalls bereitgestellt:

• Versionen: display-dependency-updates scannt die Abhängigkeiten eines Projekts und erstellt einen Bericht über die Abhängigkeiten, für die neuere Versionen verfügbar sind.
• Versionen: Display-Plugin-Updates scannen die Plugins eines Projekts und erstellen einen Bericht über die Plugins, für die neuere Versionen verfügbar sind.
• Versionen: update-parent aktualisiert den übergeordneten Abschnitt eines Projekts so, dass er auf die neueste verfügbare Version verweist. Wenn Sie beispielsweise ein Unternehmens-Root-POM verwenden, kann dieses Ziel hilfreich sein, wenn Sie sicherstellen müssen, dass Sie die neueste Version des Unternehmens-Root-POM verwenden.
• Versionen: update-child-modules aktualisiert den übergeordneten Abschnitt der untergeordneten Module eines Projekts, sodass die Version mit der Version des aktuellen Projekts übereinstimmt. Wenn Sie beispielsweise einen Aggregator-POM haben, der auch das übergeordnete Element für die Projekte ist, die aggregiert werden, und die untergeordneten und übergeordneten Versionen nicht mehr synchron sind, kann dieses Mojo dabei helfen, die Versionen der untergeordneten Module zu reparieren. (Beachten Sie, dass Sie Maven möglicherweise mit der Option -N aufrufen müssen, um dieses Ziel auszuführen, wenn Ihr Projekt so stark beschädigt ist, dass es aufgrund der Versionsfehlanpassung nicht erstellt werden kann.)
• Versionen: Lock-Snapshots durchsucht den POM nach allen -SNAPSHOT-Versionen und ersetzt sie durch die aktuelle Zeitstempelversion dieses -SNAPSHOT, z. B. -20090327.172306-4
• Versionen: Unlock-Snapshots durchsucht den POM nach allen mit Zeitstempel gesperrten Snapshot-Versionen und ersetzt sie durch -SNAPSHOT.
• Versionen: Auflösungsbereiche findet Abhängigkeiten mithilfe von Versionsbereichen und löst den Bereich in die verwendete Version auf.
• Versionen: use- release durchsucht den pom nach allen freigegebenen -SNAPSHOT-Versionen und ersetzt sie durch die entsprechende Release-Version.
• Versionen: Use-Next-Releases durchsucht den POM nach allen Nicht-SNAPSHOT-Versionen, die eine neuere Version waren, und ersetzt sie durch die nächste Release-Version.
• Versionen: use-next-Versionen durchsucht den POM nach allen Versionen, die eine neuere Version waren, und ersetzt sie durch die nächste Version.
• Versionen: Commit entfernt die Dateien pom.xml.versionsBackup. Bildet die Hälfte des eingebauten "Poor Man's SCM".
• version : revert stellt die pom.xml-Dateien aus den pom.xml.versionsBackup-Dateien wieder her. Bildet die Hälfte des eingebauten "Poor Man's SCM".

Ich dachte nur, ich würde es für zukünftige Referenzzwecke hinzufügen.

Bitte werfen Sie einen Blick auf diese Seite (Abschnitt "Abhängigkeitsversionsbereiche"). Was Sie vielleicht tun möchten, ist so etwas wie

<version>[1.2.3,)</version>

Diese Versionsbereiche sind in Maven2 implementiert.

Im Gegensatz zu anderen gibt es meiner Meinung nach viele Gründe, warum Sie immer die neueste Version wünschen . Insbesondere, wenn Sie eine kontinuierliche Bereitstellung durchführen (wir haben manchmal 5 Releases pro Tag) und kein Projekt mit mehreren Modulen durchführen möchten.

Ich lasse Hudson / Jenkins für jeden Build Folgendes tun:

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

Das heißt, ich verwende das Versions-Plugin und das SCM-Plugin, um die Abhängigkeiten zu aktualisieren und sie dann in die Quellcodeverwaltung einzuchecken. Ja, ich lasse mein CI SCM-Checkins durchführen (was Sie für das Maven Release Plugin sowieso tun müssen).

Sie möchten das Versions-Plugin so einrichten, dass nur das aktualisiert wird, was Sie möchten:

<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>

Ich benutze das Release-Plugin, um das Release zu machen, das sich um -SNAPSHOT kümmert und überprüft, ob es eine Release-Version von -SNAPSHOT gibt (was wichtig ist).

Wenn Sie das tun, was ich tue, erhalten Sie die neueste Version für alle Snapshot-Builds und die neueste Release-Version für Release-Builds. Ihre Builds sind auch reproduzierbar.

Aktualisieren

Ich habe einige Kommentare bemerkt, in denen nach Einzelheiten zu diesem Workflow gefragt wurde. Ich werde sagen, dass wir diese Methode nicht mehr verwenden und der Hauptgrund dafür, dass das Plugin für die Maven-Versionen fehlerhaft und im Allgemeinen fehlerhaft ist.

Es ist fehlerhaft, da zum Ausführen des Versions-Plugins zum Anpassen der Versionen alle vorhandenen Versionen vorhanden sein müssen, damit der POM ordnungsgemäß ausgeführt werden kann. Das heißt, das Versions-Plugin kann nicht auf die neueste Version von irgendetwas aktualisiert werden, wenn es die im POM referenzierte Version nicht findet. Dies ist eigentlich ziemlich ärgerlich, da wir alte Versionen häufig aus Gründen des Speicherplatzes bereinigen.

Sie benötigen wirklich ein separates Tool von maven, um die Versionen anzupassen (damit Sie nicht von der POM-Datei abhängig sind, um korrekt ausgeführt zu werden). Ich habe ein solches Werkzeug in der niederen Sprache Bash geschrieben. Das Skript aktualisiert die Versionen wie das Versions-Plugin und überprüft den POM wieder in der Quellcodeverwaltung. Es läuft auch 100x schneller als das Plugin für MVN-Versionen. Leider ist es nicht für den öffentlichen Gebrauch geschrieben, aber wenn die Leute interessiert sind, könnte ich es so machen und es in einen Kern oder Github stecken.

Zurück zum Workflow, als einige Kommentare dazu fragten, was wir tun:

1. Wir haben ungefähr 20 Projekte in ihren eigenen Repositories mit eigenen Jenkins-Jobs
2. Wenn wir das Maven Release Plugin veröffentlichen, wird es verwendet. Der Workflow dafür wird in der Dokumentation des Plugins behandelt. Das Maven Release Plugin ist irgendwie beschissen (und ich bin nett), aber es funktioniert. Eines Tages planen wir, diese Methode durch etwas Optimaleres zu ersetzen.
3. Wenn eines der Projekte veröffentlicht wird, führt Jenkins den Job "Alle Versionen aktualisieren" aus (wie Jenkins weiß, dass es sich um eine Veröffentlichung handelt, ist teilweise deshalb kompliziert, weil das Maven Jenkins-Release-Plugin auch ziemlich beschissen ist).
4. Der Job zum Aktualisieren aller Versionen kennt alle 20 Projekte. Es ist eigentlich ein Aggregator-POM, um mit allen Projekten im Modulabschnitt in Abhängigkeitsreihenfolge spezifisch zu sein. Jenkins führt unser magisches Groovy / Bash-Foo aus, das alle Projekte aufruft, die Versionen auf den neuesten Stand bringt und dann die Poms eincheckt (erneut in Abhängigkeitsreihenfolge basierend auf dem Modulabschnitt).
5. Wenn sich der POM für jedes Projekt geändert hat (aufgrund einer Versionsänderung in einer Abhängigkeit), wird er eingecheckt, und dann pingen wir sofort Jenkins an, um den entsprechenden Job für dieses Projekt auszuführen (dies dient dazu, die Reihenfolge der Build-Abhängigkeiten beizubehalten, da Sie sonst der Gnade ausgeliefert sind des SCM Poll Scheduler).

An diesem Punkt bin ich der Meinung, dass es eine gute Sache ist, die Release- und Auto-Version sowieso von Ihrem allgemeinen Build zu trennen.

Jetzt könnte man denken, dass Maven aufgrund der oben aufgeführten Probleme irgendwie scheiße ist, aber dies wäre tatsächlich ziemlich schwierig mit einem Build-Tool, das keine deklarative, einfach zu analysierende erweiterbare Syntax (auch bekannt als XML) hat.

Tatsächlich fügen wir benutzerdefinierte XML-Attribute über Namespaces hinzu, um Hinweise auf Bash / Groovy-Skripte zu erhalten (z. B. aktualisieren Sie diese Version nicht).

Die Abhängigkeitssyntax befindet sich in der Dokumentation zur Anforderungsspezifikation für die Abhängigkeitsversion . Hier ist es der Vollständigkeit halber:

Das versionElement " Abhängigkeiten" definiert Versionsanforderungen, die zur Berechnung der effektiven Abhängigkeitsversion verwendet werden. Versionsanforderungen haben die folgende Syntax:

• 1.0: "Soft" -Anforderung für 1.0 (nur eine Empfehlung, wenn sie mit allen anderen Bereichen für die Abhängigkeit übereinstimmt)
• [1.0]: "Harte" Anforderung an 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 oder x> = 1,2; Mehrere Sätze sind durch Kommas getrennt
• (,1.1),(1.1,): Dies schließt 1.1 aus (zum Beispiel, wenn bekannt ist, dass es nicht in Kombination mit dieser Bibliothek funktioniert).

In Ihrem Fall könnten Sie so etwas tun <version>[1.2.3,)</version>

Sind Sie möglicherweise auf Entwicklungsversionen angewiesen, die sich während der Entwicklung offensichtlich stark ändern?

Anstatt die Version von Entwicklungsversionen zu erhöhen, können Sie auch eine Snapshot-Version verwenden, die Sie bei Bedarf überschreiben. Dies bedeutet, dass Sie das Versions-Tag nicht bei jeder geringfügigen Änderung ändern müssen. So etwas wie 1.0-SNAPSHOT ...

Aber vielleicht versuchst du etwas anderes zu erreichen;)

Wenn Sie LATEST verwenden, stellen Sie bitte sicher, dass Sie -U haben, da sonst der neueste Schnappschuss nicht abgerufen wird.

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

Zu dem Zeitpunkt, als diese Frage gestellt wurde, gab es einige Knicke mit Versionsbereichen in Maven, aber diese wurden in neueren Versionen von Maven behoben. Dieser Artikel beschreibt sehr gut, wie Versionsbereiche funktionieren, und bewährte Methoden, um besser zu verstehen, wie Maven Versionen versteht: https://docs.oracle.com/middleware/1212/core/MAVEN/maven_version.htm#MAVEN8855

Die Wahrheit ist sogar in 3.x, dass es immer noch funktioniert, überraschenderweise werden die Projekte erstellt und bereitgestellt. Aber das Schlüsselwort LATEST / RELEASE, das überall Probleme in m2e und Eclipse verursacht. AUCH Projekte hängen von der Abhängigkeit ab, die durch LATEST / RELEASE bereitgestellt wird und die Version nicht erkennt.

Dies führt auch zu Problemen, wenn Sie versuchen, die Version als Eigenschaft zu definieren und an anderer Stelle darauf zu verweisen.

Die Schlussfolgerung ist also, dass Sie das Versions-Maven-Plugin verwenden, wenn Sie können.

Manchmal möchten Sie keine Versionsbereiche verwenden, da diese Ihre Abhängigkeiten anscheinend "langsam" auflösen, insbesondere wenn eine kontinuierliche Bereitstellung vorhanden ist und es Unmengen von Versionen gibt - hauptsächlich während einer intensiven Entwicklung.

Eine Problemumgehung wäre die Verwendung des Versions-Maven-Plugins . Sie können beispielsweise eine Eigenschaft deklarieren:

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

und füge das version-maven-plugin deiner pom datei hinzu:

<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>

Um die Abhängigkeit zu aktualisieren, müssen Sie die folgenden Ziele ausführen:

mvn versions:update-properties validate

Wenn es eine neuere Version als 1.1.1 gibt, wird Folgendes angezeigt:

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

Wenn Sie möchten, dass Maven die neueste Version einer Abhängigkeit verwendet, können Sie das Versions Maven-Plugin verwenden. Wie Sie dieses Plugin verwenden, hat Tim bereits eine gute Antwort gegeben. Folgen Sie seiner Antwort .

Aber als Entwickler werde ich diese Art von Praktiken nicht empfehlen. WARUM?

Die Antwort auf das Warum gibt Pascal Thivent bereits im Kommentar zur Frage

Ich empfehle diese Vorgehensweise wirklich nicht (und verwende auch keine Versionsbereiche), um die Reproduzierbarkeit des Builds zu gewährleisten. Ein Build, der aus einem unbekannten Grund plötzlich fehlschlägt, ist weitaus ärgerlicher als das manuelle Aktualisieren einer Versionsnummer.

Ich werde diese Art der Übung empfehlen:

<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>

Es ist leicht zu warten und leicht zu debuggen. Sie können Ihr POM in kürzester Zeit aktualisieren.

MEINE Lösung in Maven 3.5.4, benutze Nexus, in Eclipse:

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

dann in Eclipse: atl + F5und wählen Sie dieforce update of snapshots/release

Für mich geht das.