java - artefact - Recuperar la versión de maven pom.xml en el código

pom maven

Question

¿Cuál es la forma más sencilla de recuperar el número de versión del pom.xml de maven en código, es decir, programáticamente?

Answer 1

Asumiendo que estás usando Java, puedes

1. Cree un archivo .properties en (más comúnmente) su directorio src/main/resources (pero en el paso 4 podría indicarle que busque en otro lado).

2. Establezca el valor de alguna propiedad en su archivo .properties utilizando la propiedad estándar de Maven para la versión del proyecto: foo.bar=${project.version}

3. En su código Java, cargue el valor del archivo de propiedades como un recurso del classpath (google para ejemplos copiosos de cómo hacer esto, pero aquí hay un ejemplo para los principiantes ).

4. En Maven, habilite el filtrado de recursos: esto hará que Maven copie ese archivo en sus clases de salida y traduzca el recurso durante esa copia, interpretando la propiedad. Puedes encontrar algo de información here pero la mayoría solo haces esto en tu pom:

<build> <resources> <resource> <directory>src/main/resources</directory> <filtering>true</filtering> </resource> </resources> </build>

También puede acceder a otras propiedades estándar como project.name , project.description , o incluso propiedades arbitrarias que coloca en su pom <properties> , etc. El filtrado de recursos, combinado con los perfiles de Maven, puede darle un comportamiento de compilación variable en el momento de la compilación. Cuando especifica un perfil en tiempo de ejecución con -PmyProfile , eso puede habilitar propiedades que luego pueden aparecer en su compilación.

Answer 2

En proyectos de arranque de primavera puedes hacerlo así:

PropertiesConfigurationFactory<Map<String, Object>> factory = 
   new PropertiesConfigurationFactory<Map<String, Object>>(
      new LinkedHashMap<String, Object>());
factory.setTargetName("info");
factory.setPropertySources(environment.getPropertySources());
Map<String, Object> infoMap = factory.getObject();

infoMap contiene un mapa con información de compilación, incluida la versión del POM.

Lo encontré en la clase EndpointAutoConfiguration del proyecto Spring-boot.

@see https://github.com/spring-projects/spring-boot/blob/master/spring-boot-actuator/src/main/java/org/springframework/boot/actuate/autoconfigure/EndpointAutoConfiguration.java

Answer 3

La respuesta aceptada puede ser la mejor y la más estable para obtener un número de versión en una aplicación estáticamente , pero en realidad no responde la pregunta original: ¿Cómo recuperar el número de versión del artefacto de pom.xml? Por lo tanto, quiero ofrecer una alternativa que muestre cómo hacerlo dinámicamente durante el tiempo de ejecución:

Puedes usar Maven mismo. Para ser más exactos, puedes usar una biblioteca Maven.

<dependency>
  <groupId>org.apache.maven</groupId>
  <artifactId>maven-model</artifactId>
  <version>3.3.9</version>
</dependency>

Y luego haz algo como esto en Java:

package de.scrum_master.app;

import org.apache.maven.model.Model;
import org.apache.maven.model.io.xpp3.MavenXpp3Reader;
import org.codehaus.plexus.util.xml.pull.XmlPullParserException;

import java.io.FileReader;
import java.io.IOException;

public class Application {
    public static void main(String[] args) throws IOException, XmlPullParserException {
        MavenXpp3Reader reader = new MavenXpp3Reader();
        Model model = reader.read(new FileReader("pom.xml"));
        System.out.println(model.getId());
        System.out.println(model.getGroupId());
        System.out.println(model.getArtifactId());
        System.out.println(model.getVersion());
    }
}

El registro de la consola es el siguiente:

de.scrum-master.:my-artifact:jar:1.0-SNAPSHOT
de.scrum-master.
my-artifact
1.0-SNAPSHOT

Actualización 2017-10-31: para responder a la pregunta de seguimiento de Simon Sobisch modifiqué el ejemplo de esta manera:

package de.scrum_master.app;

import org.apache.maven.model.Model;
import org.apache.maven.model.io.xpp3.MavenXpp3Reader;
import org.codehaus.plexus.util.xml.pull.XmlPullParserException;

import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Application {
  public static void main(String[] args) throws IOException, XmlPullParserException {
    MavenXpp3Reader reader = new MavenXpp3Reader();
    Model model;
    if ((new File("pom.xml")).exists())
      model = reader.read(new FileReader("pom.xml"));
    else
      model = reader.read(
        new InputStreamReader(
          Application.class.getResourceAsStream(
            "/META-INF/maven/de.scrum-master./aspectj-introduce-method/pom.xml"
          )
        )
      );
    System.out.println(model.getId());
    System.out.println(model.getGroupId());
    System.out.println(model.getArtifactId());
    System.out.println(model.getVersion());
  }
}

Answer 4

Los artefactos empaquetados contienen un archivo META-INF/maven/${groupId}/${artifactId}/pom.properties cuyo contenido es el siguiente:

#Generated by Maven
#Sun Feb 21 23:38:24 GMT 2010
version=2.5
groupId=commons-lang
artifactId=commons-lang

Muchas aplicaciones usan este archivo para leer la aplicación / versión de jar en tiempo de ejecución, no se requiere configuración.

El único problema con el enfoque anterior es que este archivo se genera (actualmente) durante la fase del package y, por lo tanto, no estará presente durante las pruebas, etc. (hay un problema de Jira para cambiar esto, consulte MJAR-76 ). Si esto es un problema para usted, entonces el enfoque descrito por Alex es el camino a seguir.

Answer 5

Para complementar lo que @kieste ha publicado, que creo que es la mejor manera de tener información de compilación Maven disponible en tu código si estás utilizando Spring-boot: la documentación en http://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#production-ready-application-info es muy útil.

Solo necesita activar actuadores y agregar las propiedades que necesita en su application.properties o application.yml

Automatic property expansion using Maven

You can automatically expand info properties from the Maven project using resource filtering. If you use the spring-boot-starter-parent you can then refer to your Maven ‘project properties’ via @..@ placeholders, e.g.

project.artifactId=myproject
project.name=Demo
project.version=X.X.X.X
project.description=Demo project for info endpoint
[email protected]@
[email protected]@
[email protected]@
[email protected]@

Answer 6

Si usa un paquete de mvn como jar o war, use:

getClass().getPackage().getImplementationVersion()

Se lee una propiedad "Implementation-Version" del META-INF / MANIFEST.MF generado (que se establece en la versión de pom.xml) en el archivo.

Answer 7

También está el método descrito en la forma fácil de mostrar el número de versión de su aplicación usando Maven :

Agrega esto a pom.xml

<build>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-jar-plugin</artifactId>
      <configuration>
        <archive>
          <manifest>
            <mainClass>test.App</mainClass>
            <addDefaultImplementationEntries>
              true
            </addDefaultImplementationEntries>
          </manifest>
        </archive>
      </configuration>
    </plugin>
  </plugins>
</build>

Luego usa esto:

App.class.getPackage().getImplementationVersion()

He encontrado que este método es más simple.

Answer 8

Use esta biblioteca para la facilidad de una solución simple. Agregue al manifiesto lo que necesite y luego consulte por cadena.

 System.out.println("JAR was created by " + Manifests.read("Created-By"));

http://manifests.jcabi.com/index.html