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

https://stackoverflow.com/questions/30571

09-06-2019
|

Pregunta

En Maven, las dependencias normalmente se configuran así:

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

Ahora bien, si trabaja con bibliotecas que tienen lanzamientos frecuentes, actualizar constantemente la etiqueta <version> puede resultar algo molesto.¿Hay alguna forma de decirle a Maven que utilice siempre la última versión disponible (del repositorio)?

Solución

NOTA:

¡Esta respuesta se aplica solo a Maven 2!el mencionado LATEST y RELEASE metaversiones se han eliminado en Maven 3 "en aras de compilaciones reproducibles", hace más de 6 años.Por favor consulte esto Solución compatible con Maven 3.

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

Cuando depende de un complemento o una dependencia, puede usar el valor de versión ÚLTIMA 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 una 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 su comodidad, de modo 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 vea afectado por una versión de software que no está bajo su control.Utilice ÚLTIMO y LIBERAR 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 dependencia, dónde:

Un corchete ( [ & ] ) significa "cerrado" (inclusive).
Un paréntesis ( ( & ) ) significa "abierto" (exclusivo).

A continuación se muestra un ejemplo que ilustra las distintas 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 gamas de versiones se pueden 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 versiones para todas las versiones 1.x (actualmente se resolverá en 1.1.1):

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

Declare un rango de versiones abierto (se resolverá en 2.0.0):

<version>[1.0.0,)</version>

Declare la versión como ÚLTIMA (se resolverá en 2.0.0) (eliminada de maven 3.x)

<version>LATEST</version>

Declare la versión como RELEASE (se resolverá en 1.1.1) (eliminada de maven 3.x):

<version>RELEASE</version>

Tenga en cuenta que, de forma predeterminada, sus propias implementaciones actualizarán la entrada "más reciente" en los metadatos de Maven, pero para actualizar la entrada "lanzamiento", debe activar el "perfil de lanzamiento" desde el Maven súper POM.Puedes hacer esto con "-Prelease-profile" o "-DperformRelease=true"

Vale la pena enfatizar que cualquier enfoque que permita a Maven elegir las versiones de dependencia (ÚLTIMAS, VERSIONES y rangos de versiones) puede dejarlo expuesto a problemas de tiempo de compilación, ya que las versiones posteriores pueden tener un comportamiento diferente (por ejemplo, el complemento de dependencia ha cambiado previamente un valor predeterminado). valor de verdadero a falso, con resultados confusos).

Por lo tanto, generalmente es una buena idea definir versiones exactas en las versiones.Como la respuesta de tim señala, el complemento-versiones-maven es una herramienta útil para actualizar las versiones de dependencia, particularmente la versiones: usar-últimas-versiones y versiones: usar-últimas-versiones objetivos.

Otros consejos

Ahora sé que este tema es antiguo, pero al leer la pregunta y la respuesta proporcionada por el 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 útiles:

versiones: usar-últimas-versiones Busca en el POM todas las versiones que han sido una versión más reciente y los reemplaza con los últimos Versión.
versiones: usar-últimas-versiones busca en el pom todos los elementos que no sean SNAPSHOT versiones que han sido más recientes y los reemplaza con el atributo última versión.
versiones: propiedades de actualización 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 todos deben estar bloqueados en una versión.

También se proporcionan los siguientes otros objetivos:

versiones: pantalla-actualizaciones-de-dependencia escanea las dependencias de un proyecto y elabora un informe de los dependencias que tienen más Versiones disponibles.
versiones: display-plugin-actualizaciones escanea los plugins de un proyecto y Produce un informe de esos complementos que tienen versiones más nuevas disponibles.
versiones: actualización-padre actualiza la sección principal de un proyecto para que que hace referencia a la versión más reciente versión disponible.Por ejemplo, si utiliza un POM raíz corporativo, este puede ser útil si lo necesita Asegúrese de que está utilizando la versión más reciente versión del POM raíz corporativo.
versiones: actualización-módulos-secundarios actualiza la sección principal de la sección módulos secundarios de un proyecto, por lo que el método versión coincide con la versión de la proyecto actual.Por ejemplo, si tener un POM agregador que también sea el padre de los proyectos que agregados y los hijos y Las versiones principales no están sincronizadas, esto mojo puede ayudar a arreglar las versiones de la función módulos secundarios.(Tenga en cuenta que es posible que deba invoque Maven con la opción -N en para ejecutar este objetivo si su proyecto está tan roto que no se puede compilar debido a la versión desajuste).
versiones: instantáneas de bloqueo busca en el pom todos los -SNAPSHOT versiones y las reemplaza con el atributo versión actual de la marca de tiempo de ese -INSTANTÁNEA, p. ej.-20090327.172306-4
versiones: desbloquear-instantáneas Busca en el POM todas las marcas de tiempo Versiones de instantáneas bloqueadas y reemplazas con -SNAPSHOT.
versiones: rangos de resolución Busca dependencias mediante intervalos de versiones y resuelve el rango a la función específica versión que se está utilizando.
versiones: uso-lanzamientos Busca en el pom todas las versiones de -SNAPSHOT que han sido liberados y reemplazan con la liberación correspondiente Versión.
versiones: usar-próximas-versiones busca en el pom todos los elementos que no sean SNAPSHOT versiones que han sido más recientes y los reemplaza con el atributo Próxima versión de lanzamiento.
versiones: usar-siguientes-versiones Busca en el POM todas las versiones que han sido una versión más reciente y los reemplaza con la siguiente versión.
versiones: comprometerse elimina los archivos pom.xml.versionsBackup.Formas la mitad de la obra incorporada "Poor Man's SCM".
versiones: revertir Restaura los archivos POM.xml desde el archivo pom.xml.versionsArchivos de copia de seguridad.Formas la mitad de la obra incorporada "Poor Man's SCM".

Sólo pensé en incluirlo para cualquier referencia futura.

Por favor echa un vistazo a esta página (sección "Rangos de versión de dependencia").Lo que quizás quieras hacer es algo como

<version>[1.2.3,)</version>

Estos rangos de versiones se implementan en Maven2.

A diferencia de otros, creo que hay muchas razones por las que podrías siempre quiero lo último versión.Especialmente si realiza una implementación continua (a veces tenemos como 5 lanzamientos en un día) y no desea realizar un proyecto de varios módulos.

Lo que hago es hacer que Hudson/Jenkins haga lo siguiente para cada compilación:

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

Es decir, uso el complemento de versiones y el complemento scm para actualizar las dependencias y luego registrarlas en el control de fuente.Sí, dejo que mi CI realice comprobaciones de SCM (que debes hacer de todos modos para el complemento de lanzamiento de Maven).

Querrá configurar el complemento de versiones para actualizar solo lo que desee:

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

Utilizo el complemento de lanzamiento para realizar el lanzamiento que se encarga de -SNAPSHOT y valida que exista una versión de lanzamiento de -SNAPSHOT (lo cual es importante).

Si hace lo que yo hago, obtendrá la última versión para todas las compilaciones de instantáneas y la última versión para las compilaciones de lanzamiento.Tus compilaciones también serán reproducibles.

Actualizar

Noté algunos comentarios que preguntaban sobre algunos detalles de este flujo de trabajo.Diré que ya no usamos este método y la gran razón es que el complemento de versiones de Maven tiene errores y, en general, es inherentemente defectuoso.

Es defectuoso porque para ejecutar el complemento de versiones para ajustar las versiones, todas las versiones existentes deben existir para que pom se ejecute correctamente.Es decir, el complemento de versiones no puede actualizar a la última versión de nada si no puede encontrar la versión a la que se hace referencia en el pom.En realidad, esto es bastante molesto ya que a menudo limpiamos versiones antiguas por razones de espacio en disco.

Realmente necesitas una herramienta separada de maven para ajustar las versiones (para que no dependas del archivo pom para ejecutarse correctamente).He escrito dicha herramienta en el lenguaje humilde que es Bash.El script actualizará las versiones como el complemento de versión y verificará el pom nuevamente en el control de fuente.También se ejecuta 100 veces más rápido que el complemento de versiones mvn.Desafortunadamente, no está escrito para uso público, pero si la gente está interesada, podría hacerlo así y ponerlo en un gist o github.

Volviendo al flujo de trabajo, algunos comentarios preguntaron acerca de que esto es lo que hacemos:

Tenemos aproximadamente 20 proyectos en sus propios repositorios con sus propios trabajos de jenkins.
Cuando lanzamos, se utiliza el complemento de lanzamiento de Maven.El flujo de trabajo está cubierto en la documentación del complemento.El complemento de lanzamiento de Maven apesta (y estoy siendo amable) pero funciona.Algún día planeamos reemplazar este método por algo más óptimo.
Cuando se lanza uno de los proyectos, Jenkins ejecuta un trabajo especial, llamaremos al trabajo de actualización de todas las versiones (cómo sabe Jenkins que es un lanzamiento es una manera complicada en parte porque el complemento de lanzamiento de Maven Jenkins también es bastante malo).
El trabajo de actualización de todas las versiones conoce los 20 proyectos.En realidad, es un pom agregador para ser específico con todos los proyectos en la sección de módulos en orden de dependencia.Jenkins ejecuta nuestro magic groovy/bash foo que activará todos los proyectos, actualizará las versiones a la última y luego registrará los poms (nuevamente hecho en orden de dependencia según la sección de módulos).
Para cada proyecto, si el pom ha cambiado (debido a un cambio de versión en alguna dependencia), se registra y luego inmediatamente hacemos ping a jenkins para ejecutar el trabajo correspondiente para ese proyecto (esto es para preservar el orden de dependencia de compilación, de lo contrario, estás a merced del programador de encuestas SCM).

En este punto, soy de la opinión de que es bueno tener el lanzamiento y la versión automática como herramientas separadas de la compilación general.

Ahora podrías pensar que Maven apesta debido a los problemas enumerados anteriormente, pero esto en realidad sería bastante difícil con una herramienta de compilación que no tiene un declarativo fácil de analizar. extensible sintaxis (también conocida como XML).

De hecho, agregamos atributos XML personalizados a través de espacios de nombres para ayudar a insinuar scripts bash/groovy (p. ej.no actualice esta versión).

La sintaxis de dependencias se encuentra en la Especificación de requisitos de versión de dependencia documentación.Aquí está para que esté completo:

Dependencias version El elemento define los requisitos de versión y se utiliza para calcular la versión de dependencia efectiva.Los requisitos de versión tienen la siguiente sintaxis:

1.0:Requisito "suave" en 1.0 (solo una recomendación, si coincide con todos los demás rangos de la dependencia)

[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 o x >= 1,2;varios conjuntos están separados por comas

(,1.1),(1.1,):Esto excluye 1.1 (por ejemplo, si se sabe que no trabajo en combinación con esta biblioteca)

En tu caso, podrías hacer algo como <version>[1.2.3,)</version>

¿Es posible que dependa de versiones de desarrollo que obviamente cambian mucho durante el desarrollo?

En lugar de incrementar la versión de las versiones de desarrollo, podría simplemente usar una versión instantánea que sobrescriba cuando sea necesario, lo que significa que no tendría que cambiar la etiqueta de versión en cada cambio menor.Algo así como 1.0-INSTANTÁNEA...

Pero tal vez estés intentando lograr algo más ;)

Quien esté usando LATEST, asegúrese de tener -U, de lo contrario no se extraerá la última instantánea.

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

En el momento en que se planteó esta pregunta, había algunos problemas con los rangos de versiones en maven, pero se resolvieron en versiones más nuevas de maven.Este artículo captura muy bien cómo funcionan los rangos de versiones y las mejores prácticas para comprender mejor cómo entiende Maven las versiones: https://docs.oracle.com/middleware/1212/core/MAVEN/maven_version.htm#MAVEN8855

La verdad es que incluso en 3.x todavía funciona, sorprendentemente los proyectos se construyen y despliegan.Pero la palabra clave ÚLTIMA/RELEASE causa problemas en m2e y eclipse por todas partes, TAMBIÉN los proyectos dependen de la dependencia que se implementó a través de ÚLTIMA/RELEASE no reconoce la versión.

También causará problemas si intenta definir la versión como propiedad y hacer referencia a ella en otro lugar.

Entonces la conclusión es usar el versiones-maven-plugin si puedes.

A veces no desea utilizar rangos de versiones, porque parece que son "lentos" para resolver sus dependencias, especialmente cuando existe una entrega continua y hay toneladas de versiones, principalmente durante un desarrollo intenso.

Una solución sería utilizar el versiones-maven-plugin.Por ejemplo, puedes declarar una propiedad:

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

y agregue el complemento version-maven a su archivo 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>

Luego, para actualizar la dependencia, debes ejecutar los objetivos:

mvn versions:update-properties validate

Si hay una versión posterior a la 1.1.1, te dirá:

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

Si desea que Maven use la última versión de una dependencia, entonces puede usar Versiones del complemento Maven y cómo usar este complemento, Tim ya ha dado una buena respuesta, sigue su respuesta.

Pero como desarrollador, no recomendaré este tipo de prácticas.¿POR QUÉ?

La respuesta al por qué ya está dada por Pascal Thivent en el comentario de la pregunta

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

Recomendaré este tipo de práctica:

<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 fácil de mantener y fácil de depurar.Puede actualizar su POM en poco tiempo.

MI solución en maven 3.5.4, uso nexus, en eclipse:

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

luego en eclipse: atl + F5, y elige el force update of snapshots/release

esto funciona para mi.

Licenciado bajo: CC-BY-SA con atribución

No afiliado a StackOverflow