Comment dire à Maven d'utiliser la dernière version d'une dépendance?

maintenant je sais que ce sujet est vieux, mais la lecture de la question et de la réponse OP fourni il semble que le Maven Versions Plugin aurait pu être en fait une meilleure réponse à sa question:

En particulier les objectifs suivants pourraient être utilisés:

• versions:utilisez-les dernières versions recherche dans le pom de toutes les versions qui ont été une version plus récente et remplace avec la dernière version.
• versions: use-latest-releases recherche le pom pour tous les non-SNAPSHOT les versions qui ont été une nouvelle la libération et les remplace par le dernière version.
• versions:mise à jour-propriétés mises à jour des propriétés définies dans un projet pour qu'ils correspondent à la dernière version disponible de dépendances spécifiques. Cela peut être utile si une suite de dépendances tout doit être verrouillé sur une seule version.

les autres objectifs suivants sont également fournis:

• versions: display-dependency-updates scanne les dépendances d'un projet et produit un rapport de ces dépendances plus récentes versions disponibles.
• versions:display-plugin-updates scanne les plugins d'un projet et produit un rapport de ces plugins qui ont de nouvelles versions disponibles.
• versions: mise à jour-parent met à jour la section parent d'un projet afin qu'il fait référence à la plus récente version disponible. Par exemple, si vous utilisez un soft POM d'entreprise, ceci l'objectif peut être utile si vous avez besoin de assurez-vous d'utiliser la dernière la version de l'entreprise racine POM.
• versions: update-child-modules met à jour la section parent de la enfant les modules d'un projet de sorte que le version correspond à la la version de la projet en cours. Par exemple, si vous ont un agrégateur pom qui est également le parent pour les projets qu'il les agrégats et les enfants et les versions parentes ne sont pas synchronisées, ceci mojo peut aider à corriger les versions modules pour enfants. (Veuillez noter que vous devez invoquer Maven avec l'option-N dans afin d'exécuter ce but si votre le projet est cassé si mal que ça ne peut pas construire à cause de la version mis-match).
• versions: lock-snapshots recherche le pom pour tout-SNAPSHOT les versions et les remplace par le la version actuelle de cette horodatage - Instantané, p.ex.-20090327.172306-4
• versions: unlock-snapshots recherche le pom pour tous les horodateurs verrouiller les versions de snapshot et les remplacer avec -INSTANTANÉ.
• versions: resolve-ranges trouve des dépendances en utilisant des gammes de version et résout la gamme spécifique la version utilisée.
• versions: use-releases recherche le pom pour toutes les versions SNAPSHOT qui ont été libérés et remplace avec la version correspondante version.
• versions: use-next-releases recherche le pom pour tous les non-SNAPSHOT les versions qui ont été une nouvelle la libération et les remplace par le la prochaine version.
• versions:utilisez-la prochaine versions recherches le pom pour toutes les versions qui ont été une version plus récente et remplace avec la prochaine version.
• versions:s'engager supprime le pom.XML.versionsBackup files. Forme la moitié de l'intégré dans le "Pauvre Homme SMC."
• versions: revert restaure the pom.les fichiers xml de la POM.XML.versionsBackup files. Forme la moitié de l'intégré dans le "Pauvre Homme SMC."

Juste pensé Je l'inclurais pour toute référence future.

regardez cette page (section"gammes de versions de dépendances"). Ce que vous pourriez vouloir faire est quelque chose comme

<version>[1.2.3,)</version>

ces gammes de versions sont implémentées dans Maven2.

contrairement à d'autres je pense qu'il ya beaucoup de raisons pour lesquelles vous pourriez toujours vouloir la dernière version. Particulièrement si vous faites un déploiement continu (nous avons parfois comme 5 versions par jour) et que vous ne voulez pas faire un projet multi-modules.

Ce que je fais, c'est de faire Hudson/Jenkins, effectuez les opérations suivantes pour chaque génération:

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

C'est-à-dire que j'utilise les versions plugin et scm plugin pour mettre à jour les dépendances et puis vérifiez le contrôle source. Oui, j'ai laissé mon CI faire SCM checkins (ce que vous devez faire de toute façon pour le plugin Maven release).

vous voudrez configurer les versions plugin pour mettre à jour seulement ce que vous voulez:

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

j'utilise le plugin release pour faire la version qui prend soin de-SNAPSHOT et valide qu'il y a une version release de-SNAPSHOT (ce qui est important).

Si vous faites ce que je fais, vous obtiendrez la dernière version pour tous les clichés de construit et la dernière version de release. Vos constructions seront également reproductibles.

mise à Jour

j'ai remarqué des commentaires demandant des détails sur ce workflow. Je dirai que nous n'utilisons plus cette méthode et que la grande raison pour laquelle le plugin maven versions est bogué et en général imparfait.

il est défectueux parce que d'exécuter les versions plugin pour ajuster versions toutes les versions existantes doivent exister pour que le pom fonctionne correctement. C'est-à-dire que le plugin versions ne peut pas mettre à jour à la dernière version de quoi que ce soit s'il ne peut pas trouver la version référencée dans le pom. C'est en fait plutôt ennuyeux car nous nettoyons souvent les anciennes versions pour des raisons d'espace disque.

vous avez vraiment besoin d'un outil séparé de maven pour ajuster les versions (de sorte que vous ne dépendez pas du fichier pom pour exécuter correctement). J'ai écrit un tel outil dans le les plus humbles de la langue C'est Bash. Le script mettra à jour les versions comme le plugin de version et vérifiera le pom de nouveau dans le contrôle source. Il tourne aussi comme 100x plus vite que le plugin mvn versions. Malheureusement, il n'est pas écrit d'une manière pour l'usage public, mais si les gens sont intéressés je pourrais le faire et le mettre dans un gist ou github.

retour à workflow comme certains commentaires demandés sur ce que c'est ce que nous faisons:

1. nous avons une vingtaine de projets dans leur propres dépôts avec leur propre jenkins emplois
2. lorsque nous sortons le plugin maven release est utilisé. Le workflow de cela est couvert dans la documentation du plugin. La version plugin maven sorte de suce (et je suis gentil) mais il fonctionne. Un jour, nous prévoyons de remplacer cette méthode par quelque chose de plus optimal.
3. quand l'un des projets est libéré jenkins puis exécute un travail spécial, nous appellerons la mise à jour toutes les versions travail (comment jenkins sait son la publication est une manière compliquée en partie parce que le plugin de publication de Maven jenkins est assez merdique aussi bien).
4. la mise à jour toutes les versions job connaît tous les 20 projets. Il s'agit en fait d'un agrégateur pom à être spécifique avec tous les projets dans la section modules en ordre de dépendance. Jenkins exécute notre foo Magic groovy / bash qui va tirer tous les projets mettre à jour les versions au plus tard et ensuite vérifier les poms (encore fait dans l'ordre de dépendance basé sur les modules section.)
5. pour chaque projet si le pom a changé (à cause d'un changement de version dans une dépendance), il est enregistré et nous envoyons immédiatement un ping à jenkins pour exécuter la tâche correspondante pour ce projet (ceci afin de préserver l'ordre de dépendance de construction sinon vous êtes à la merci du Planificateur de sondage SCM).

à ce point je suis de l'avis que c'est une bonne chose d'avoir la version de libération et auto un outil séparé de votre général construire de toute façon.

Maintenant, vous pourriez penser maven sorte de sucks en raison des problèmes énumérés ci-dessus, mais ce serait en fait assez difficile avec un outil de construction qui n'a pas une déclaration facile à analyser extensible syntaxe (aka XML).

en fait, nous ajoutons des attributs XML personnalisés par le biais d'espaces de noms pour aider les scripts d'indication bash/groovy (par exemple, ne mettez pas à jour cette version).

la syntaxe des dépendances est située dans la documentation Dependency Version Requirement Specification . Ici, il est pour l'exhaustivité:

Dépendances " version élément de définir les exigences de version, utilisée pour calculer efficace de la dépendance version. Les exigences de Version ont la syntaxe suivante:

• 1.0 : "l'exigence" souple " de la version 1.0 (juste une recommandation, si elle correspond à toutes les autres gammes de la dépendance)
• [1.0] : prescription "dure" sur 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 ou x > = 1.2; plusieurs ensembles sont séparés par des virgules
• (,1.1),(1.1,) : ce exclut 1.1 (par exemple s'il est connu pour ne pas travailler en combinaison avec cette bibliothèque)

Dans votre cas, vous pourriez faire quelque chose comme <version>[1.2.3,)</version>

êtes-vous peut-être dépendant des versions de développement qui évidemment changent beaucoup pendant le développement?

au lieu d'incrémenter la version des versions de développement, vous pouvez simplement utiliser une version de snapshot que vous écrasez si nécessaire, ce qui signifie que vous n'auriez pas à changer la balise de version à chaque changement mineur. Quelque chose comme 1.0-SNAPSHOT...

Mais peut-être que vous essayez d'atteindre quelque chose d'autre ;)

qui utilise la dernière version, s'il vous plaît assurez-vous que vous avez-U sinon le dernier snapshot ne sera pas tiré.

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

au moment où cette question a été posée, il y avait quelques problèmes avec les gammes de version dans maven, mais ceux-ci ont été résolus dans les nouvelles versions de maven. Cet article décrit très bien comment fonctionnent les gammes de versions et les meilleures pratiques pour mieux comprendre comment maven comprend les versions: https://docs.oracle.com/middleware/1212/core/MAVEN/maven_version.htm#MAVEN8855

la vérité est même en 3.x il fonctionne toujours, étonnamment les projets construit et déploie. Mais le dernier mot-clé / RELEASE causant des problèmes dans m2e et eclipse partout, les projets dépendent aussi de la dépendance qui s'est déployée à travers le dernier/RELEASE ne parviennent pas à reconnaître la version.

Il permettra également de poser problème si vous essayez de définir la version la propriété, et le référencer ailleurs.

donc la conclusion est d'utiliser le versions-maven-plugin si vous le pouvez.

parfois vous ne voulez pas utiliser de gammes de versions, parce qu'il semble qu'elles soient "lentes" à résoudre vos dépendances, surtout quand il y a Livraison continue en place et qu'il y a des tonnes de versions - principalement pendant le développement lourd.

une solution serait d'utiliser les versions-maven-plugin . Par exemple, vous pouvez déclarer une propriété:

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

et ajouter les versions-maven-plugin à votre fichier 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>

ensuite, pour mettre à jour la dépendance, vous devez exécuter les objectifs:

mvn versions:update-properties validate

S'il y a une version plus récente que 1.1.1, elle vous dira:

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

MA solution dans maven 3.5.4 ,utilisez nexus, dans eclipse:

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

puis dans eclipse: atl + F5 , et choisissez le force update of snapshots/release

ça me va.

si vous voulez Maven devrait utiliser la dernière version d'une dépendance, alors vous pouvez utiliser Versions Maven Plugin et comment utiliser ce plugin, Tim a déjà donné une bonne réponse, suivre sa réponse .

mais en tant que développeur, Je ne recommanderai pas ce type de pratiques. Pourquoi?

réponse à pourquoi est déjà donnée par Pascal Thivent dans le commentaire de la question

Je ne recommande vraiment pas cette pratique (ni l'utilisation de gammes de version) pour le souci de construire la reproductibilité. Une construction qui commence à soudainement échouer pour une raison inconnue est bien plus ennuyeux que la mise à jour manuelle un numéro de version.

je recommanderai ce type de pratique:

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

il est facile à entretenir et facile à déboguer. Vous pouvez mettre à jour votre POM en un rien de temps.