¿Cómo le digo a Maven que use la última versión de una dependencia?

14 minutos de lectura

¿Como le digo a Maven que use la ultima version
Anders Sandvig

En Maven, las dependencias generalmente se configuran así:

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

Ahora, si está trabajando con bibliotecas que tienen lanzamientos frecuentes, actualizar constantemente la etiqueta puede ser algo molesto. ¿Hay alguna forma de decirle a Maven que use siempre la última versión disponible (del repositorio)?

  • @Martin Conozco la convención xyz-SNAPSHOT, pero estaba pensando en bibliotecas que se lanzan en versiones finales al repositorio (es decir, pasar de dream-library-1.2.3.jar a dream-library-1.2.4.jar , y así).

    –Anders Sandvig

    27 de agosto de 2008 a las 16:50

  • Realmente no recomiendo esta práctica (ni el uso de rangos de versión) en aras de la reproducibilidad de la compilación. Una compilación que comienza a fallar repentinamente por una razón desconocida es mucho más molesta que actualizar manualmente un número de versión.

    – Pascal Thivent

    17 de septiembre de 2009 a las 22:52

  • @PascalThivent Actualizar manualmente un número de versión en un pom es una molestia si está realizando versiones continuas. Utilizo el complemento de versiones combinado con el complemento scm para superar esto (ver mi respuesta).

    – Adam Gent

    9 de enero de 2012 a las 21:24

  • @PascalThivent Ambos son molestos, pero de una manera diferente. Me gustaría elegir entre ambos dependiendo de mi situación y no verme obligado a usar uno porque alguien más decidió que este sería mejor.

    – juegos de pies

    2 de febrero de 2018 a las 20:07

  • La biblioteca de guayaba es un buen ejemplo de la versión más nueva que tiene clases eliminadas de versiones anteriores, lo que luego rompe la compilación. La mentalidad de Maven es que cualquier versión más nueva puede reemplazar a cualquier anterior, lo que no se cumple en la práctica.

    – Thorbjorn Ravn Andersen

    25 de noviembre de 2020 a las 9:19

¿Como le digo a Maven que use la ultima version
Vendedor rico

NOTA:

el mencionado LATEST y RELEASE metaversiones se han caído para dependencias de complementos en Maven 3 “en aras de compilaciones reproducibles”, hace más de 6 años. (Todavía funcionan perfectamente bien para dependencias regulares). Para dependencias de complementos, consulte esto Solución compatible con Maven 3.


Si siempre desea usar la versión más reciente, Maven tiene dos palabras clave que puede usar como alternativa a los rangos de versión. Debe usar estas opciones con cuidado ya que ya no tiene el control de los complementos/dependencias que está usando.

Cuando depende de un complemento o una dependencia, puede usar un valor de versión de LATEST o RELEASE. ÚLTIMO se refiere a la última versión publicada o instantánea de un artefacto en particular, el artefacto implementado más recientemente en un repositorio en particular. RELEASE se refiere a la última versión que no es instantánea en el repositorio. En general, no es una buena práctica diseñar software que dependa de una versión no específica de un artefacto. Si está desarrollando software, es posible que desee utilizar RELEASE o LATEST para que no tenga que actualizar los números de versión cuando se publique una nueva versión de una biblioteca de terceros. Cuando lanza software, siempre debe asegurarse de que su proyecto dependa de versiones específicas para reducir las posibilidades de que su compilación o su proyecto se vean afectados por una versión de software que no está bajo su control. Use ÚLTIMO y RELEASE con precaución, en todo caso.

Ver el Sección de sintaxis POM del libro Maven para más detalles. O vea este documento en Rangos de versión de dependenciadonde:

  • Un corchete ( [ & ] ) significa “cerrado” (inclusive).
  • un paréntesis ( ( & ) ) significa “abierto” (exclusivo).

He aquí un ejemplo que ilustra las diversas opciones. En el repositorio de Maven, com.foo:my-foo tiene los siguientes metadatos:

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

Si se requiere una dependencia de ese artefacto, tiene las siguientes opciones (otras rangos de versión se puede especificar, por supuesto, solo mostrando los relevantes aquí):

Declare una versión exacta (siempre se resolverá en 1.0.1):

<version>[1.0.1]</version>

Declare una versión explícita (siempre se resolverá en 1.0.1 a menos que ocurra una colisión, cuando Maven seleccionará una versión coincidente):

<version>1.0.1</version>

Declare un rango de versión para todo 1.x (actualmente se resolverá en 1.1.1):

[1.0.0,2.0.0)</version>

Declare an open-ended version range (will resolve to 2.0.0):

<version>[1.0.0,)</version>

Declare the version as LATEST (will resolve to 2.0.0) (removed from maven 3.x)

<version>LATEST</version>

Declare the version as RELEASE (will resolve to 1.1.1) (removed from maven 3.x):

<version>RELEASE</version>

Note that by default your own deployments will update the “latest” entry in the Maven metadata, but to update the “release” entry, you need to activate the “release-profile” from the Maven super POM. You can do this with either “-Prelease-profile” or “-DperformRelease=true”


It’s worth emphasising that any approach that allows Maven to pick the dependency versions (LATEST, RELEASE, and version ranges) can leave you open to build time issues, as later versions can have different behaviour (for example the dependency plugin has previously switched a default value from true to false, with confusing results).

It is therefore generally a good idea to define exact versions in releases. As Tim’s answer points out, the maven-versions-plugin is a handy tool for updating dependency versions, particularly the versions:use-latest-versions and versions:use-latest-releases goals.

  • I think that LATEST/RELEASE is very important for plugins which provide deploy functionality. For example we use plugin which deploy new version of artifacts to the our servers. If servers will change we release new version of plugin and all projects that use this plugin must by manually updated to use new version of deploy plugin.

    – ATom

    Aug 17, 2012 at 14:09

  • @RichSeller hey Rich; I spent a bit of time on this before I figured out this is not available in Maven 3.0 anymore 😉 Would you consider editing the answer so it starts with an update stating the Maven 3.0 depreaction? Thanks a bunch!

    – Miquel

    Nov 29, 2013 at 15:48

  • I believe a good balance would be to lock the major version but get the latest minor (or patch) version (whichever is used for bug-fixes only in the artifcat you are depending on). With the current syntax this appears to be only possible with a range like (note: starts with brackets and ends with parens): [1.1,2.0)

    – Amr Mostafa

    Aug 4, 2014 at 22:15


  • FWIW… updated link to Maven3 Compatibility Notes: cwiki.apache.org/confluence/display/MAVEN/…

    – dyodji

    May 4, 2015 at 21:17

  • Worth to note that [1.0.0, 2.0.0] el rango no incluye 1.0-SNAPSHOT pero sí incluye 2.0-SNAPSHOT.

    – salpicadura

    26 de enero de 2017 a las 22:53

1646959091 231 ¿Como le digo a Maven que use la ultima version
Tim

Ahora sé que este tema es antiguo, pero al leer la pregunta y la respuesta proporcionada por OP, parece que Complemento de versiones de Maven en realidad podría haber sido una mejor respuesta a su pregunta:

En particular, los siguientes objetivos podrían ser de utilidad:

  • versiones: usar-últimas-versiones busca en el pom todas las versiones que han sido una versión más nueva y las reemplaza con la última versión.
  • versiones: usar-últimos-lanzamientos busca en el pom todas las versiones que no son SNAPSHOT que han sido una versión más reciente y las reemplaza con la última versión de lanzamiento.
  • versiones:actualizar-propiedades actualiza las propiedades definidas en un proyecto para que correspondan a la última versión disponible de dependencias específicas. Esto puede ser útil si un conjunto de dependencias debe estar todas bloqueadas en una versión.

También se proporcionan los siguientes otros objetivos:

  • versiones: mostrar-dependencia-actualizaciones escanea las dependencias de un proyecto y produce un informe de aquellas dependencias que tienen versiones más nuevas disponibles.
  • versiones: mostrar-complemento-actualizaciones escanea los complementos de un proyecto y produce un informe de esos complementos que tienen versiones más nuevas disponibles.
  • versiones:actualizar-padre actualiza la sección principal de un proyecto para que haga referencia a la versión disponible más reciente. Por ejemplo, si usa un POM raíz corporativo, este objetivo puede ser útil si necesita asegurarse de que está usando la versión más reciente del POM raíz corporativo.
  • versiones:actualizar-módulos-secundarios actualiza la sección principal de los módulos secundarios de un proyecto para que la versión coincida con la versión del proyecto actual. Por ejemplo, si tiene un agregador pom que también es el principal de los proyectos que agrega y las versiones secundarias y principales no están sincronizadas, este mojo puede ayudar a corregir las versiones de los módulos secundarios. (Tenga en cuenta que es posible que deba invocar a Maven con la opción -N para ejecutar este objetivo si su proyecto está tan dañado que no puede compilarse debido a que la versión no coincide).
  • Versiones: bloqueo-instantáneas busca en el pom todas las versiones de -SNAPSHOT y las reemplaza con la versión de marca de tiempo actual de esa -SNAPSHOT, por ejemplo, -20090327.172306-4
  • Versiones: desbloquear-instantáneas busca en el pom todas las versiones de instantáneas bloqueadas con marca de tiempo y las reemplaza con -SNAPSHOT.
  • Versiones: rangos de resolución encuentra dependencias usando rangos de versión y resuelve el rango a la versión específica que se está usando.
  • Versiones: uso-lanzamientos busca en el pom todas las versiones -SNAPSHOT que se han lanzado y las reemplaza con la versión de lanzamiento correspondiente.
  • Versiones: use-next-releases busca en el pom todas las versiones que no sean SNAPSHOT que han sido una versión más reciente y las reemplaza con la próxima versión de lanzamiento.
  • versiones: usar-próximas-versiones busca en el pom todas las versiones que han sido una versión más nueva y las reemplaza con la siguiente versión.
  • Versiones: confirmar elimina los archivos pom.xml.versionsBackup. Forma la mitad del “SCM de Poor Man” incorporado.
  • Versiones: revertir restaura los archivos pom.xml de los archivos pom.xml.versionsBackup. Forma la mitad del “SCM de Poor Man” incorporado.

Solo pensé en incluirlo para cualquier referencia futura.

  • En este contexto, ¿cuál es la diferencia entre “lanzamiento” y “versión”.

    – Ben Noland

    23 de diciembre de 2012 a las 15:39

  • @BenNoland, creo que la diferencia en este caso es que es posible que la próxima versión no necesite ser un artefacto de lanzamiento. Por ejemplo, dado un artefacto con la versión 1.0.0-SNAPSHOT, 1.0.0 y 1.0.1-SNAPSHOT, y una referencia pom a 1.0.0-SNAPSHOT, versions:next-versions y versions:next-releases se resolverán en 1.0.0 , mientras que versions:latest-versions y versions:latest-releases se resolverán en 1.0.1-SNAPSHOT y 1.0.0 respectivamente.

    –Ryan Beesley

    17 de junio de 2014 a las 19:14

  • Imprimir todos los objetivos posibles y no relacionados no es útil.

    – MariuszS

    25 de agosto de 2015 a las 9:53

  • Lo que estoy buscando es algo que haga lo contrario de versions:resolve-ranges. Tengo un pom que se resolvió y quiero volver a abrirlo a versiones más nuevas (es decir, pasar de 1.2.3-4 a [1.2,)</version>.

    – fmpdmb

    Feb 25, 2016 at 20:23

  • I would think versions:use-latest-versions solves most of the OP’s problems.

    – Alex R

    May 31, 2018 at 0:07

1646959092 563 ¿Como le digo a Maven que use la ultima version
Martin Klinke

Please take a look at this page (section “Dependency Version Ranges”). What you might want to do is something like

<version>[1.2.3,)</version>

These version ranges are implemented in Maven2.

  • You may want to have a closer look at how Maven compare version numbers – if you do not conform to a strict pattern Maven compares as strings and not numbers.

    – Thorbjørn Ravn Andersen

    Feb 25, 2013 at 13:19

  • That page is on Codehaus, and describes itself as things “that have not yet been implemented for Maven 2.0″… The Maven documentation itself doesn’t say anything about version ranges. Am I missing something? When were version ranges introduced? Where are they described in the official documentation?

    – Shannon

    Aug 1, 2014 at 21:37

  • You are wrong, version range means that all versions are OK from 1.2.3 to higher. This is not the latest version at all.

    – MariuszS

    Aug 24, 2015 at 7:43

1646959092 768 ¿Como le digo a Maven que use la ultima version
Adam Gent

Unlike others I think there are many reasons why you might always want the latest version. Particularly if you are doing continuous deployment (we sometimes have like 5 releases in a day) and don’t want to do a multi-module project.

What I do is make Hudson/Jenkins do the following for every build:

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

That is I use the versions plugin and scm plugin to update the dependencies and then check it in to source control. Yes I let my CI do SCM checkins (which you have to do anyway for the maven release plugin).

You’ll want to setup the versions plugin to only update what you want:

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

I use the release plugin to do the release which takes care of -SNAPSHOT and validates that there is a release version of -SNAPSHOT (which is important).

If you do what I do you will get the latest version for all snapshot builds and the latest release version for release builds. Your builds will also be reproducible.

Update

I noticed some comments asking some specifics of this workflow. I will say we don’t use this method anymore and the big reason why is the maven versions plugin is buggy and in general is inherently flawed.

It is flawed because to run the versions plugin to adjust versions all the existing versions need to exist for the pom to run correctly. That is the versions plugin cannot update to the latest version of anything if it can’t find the version referenced in the pom. This is actually rather annoying as we often cleanup old versions for disk space reasons.

Really you need a separate tool from maven to adjust the versions (so you don’t depend on the pom file to run correctly). I have written such a tool in the the lowly language that is Bash. The script will update the versions like the version plugin and check the pom back into source control. It also runs like 100x faster than the mvn versions plugin. Unfortunately it isn’t written in a manner for public usage but if people are interested I could make it so and put it in a gist or github.

Going back to workflow as some comments asked about that this is what we do:

  1. We have 20 or so projects in their own repositories with their own jenkins jobs
  2. When we release the maven release plugin is used. The workflow of that is covered in the plugin’s documentation. The maven release plugin sort of sucks (and I’m being kind) but it does work. One day we plan on replacing this method with something more optimal.
  3. When one of the projects gets released jenkins then runs a special job we will call the update all versions job (how jenkins knows its a release is a complicated manner in part because the maven jenkins release plugin is pretty crappy as well).
  4. The update all versions job knows about all the 20 projects. It is actually an aggregator pom to be specific with all the projects in the modules section in dependency order. Jenkins runs our magic groovy/bash foo that will pull all the projects update the versions to the latest and then checkin the poms (again done in dependency order based on the modules section).
  5. For each project if the pom has changed (because of a version change in some dependency) it is checked in and then we immediately ping jenkins to run the corresponding job for that project (this is to preserve build dependency order otherwise you are at the mercy of the SCM Poll scheduler).

At this point I’m of the opinion it is a good thing to have the release and auto version a separate tool from your general build anyway.

Now you might think maven sort of sucks because of the problems listed above but this actually would be fairly difficult with a build tool that does not have a declarative easy to parse extendable syntax (aka XML).

In fact we add custom XML attributes through namespaces to help hint bash/groovy scripts (e.g. don’t update this version).

The dependencies syntax is located at the Dependency Version Requirement Specification documentation. Here it is is for completeness:

Dependencies’ version element define version requirements, used to compute effective dependency version. Version requirements have the following syntax:

  • 1.0: “Soft” requirement on 1.0 (just a recommendation, if it matches all other ranges for the dependency)
  • [1.0]: Requisito “duro” en 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 or x >= 1.2; multiple sets are comma-separated
  • (,1.1),(1.1,): this excludes 1.1 (for example if it is known not to
    work in combination with this library)

In your case, you could do something like <version>[1.2.3,)</version>

1646959092 563 ¿Como le digo a Maven que use la ultima version
Martin Klinke

Are you possibly depending on development versions that obviously change a lot during development?

Instead of incrementing the version of development releases, you could just use a snapshot version that you overwrite when necessary, which means you wouldn’t have to change the version tag on every minor change. Something like 1.0-SNAPSHOT…

But maybe you are trying to achieve something else 😉

1646959093 918 ¿Como le digo a Maven que use la ultima version
trung

Who ever is using LATEST, please make sure you have -U otherwise the latest snapshot won’t be pulled.

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

  • This does not pulls latest snapshot from local m2 repo

    – c.sankhala

    Feb 12, 2021 at 9:42

¿Ha sido útil esta solución?

Esta web utiliza cookies propias y de terceros para su correcto funcionamiento y para fines analíticos y para mostrarte publicidad relacionada con sus preferencias en base a un perfil elaborado a partir de tus hábitos de navegación. Al hacer clic en el botón Aceptar, acepta el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Configurar y más información
Privacidad