Recupera la versione da maven pom.xml nel codice

Qual è il modo più semplice per recuperare il numero di versione dal codice pom.xml di maven nel codice, cioè programmaticamente?

Supponendo che tu stia utilizzando Java, puoi farlo

1. Crea un .propertiesfile nella (più comunemente) src/main/resourcesdirectory (ma al passaggio 4 potresti dirlo di cercare altrove).

2. Imposta il valore di alcune proprietà nel tuo .propertiesfile usando la proprietà Maven standard per la versione del progetto: foo.bar=${project.version}

3. Nel tuo codice Java, carica il valore dal file delle proprietà come risorsa dal percorso di classe (google per copiosi esempi di come eseguire questa operazione, ma ecco un esempio per cominciare ).

4. In Maven, abilita il filtro delle risorse - questo farà sì che Maven copi quel file nelle tue classi di output e traduca la risorsa durante quella copia, interpretando la proprietà. Puoi trovare alcune informazioni qui, ma per lo più fai questo nel tuo pom:

    <Costruzione>
      <risorse>
        <Risorsa>
          <Directory> src / main / risorse </ directory>
          <Filtraggio> true </ filtraggio>
        </ Risorsa>
      </ Risorse>   
    </ Build>

Puoi anche ottenere altre proprietà standard come project.name, project.descriptiono anche proprietà arbitrarie che hai inserito nel tuo pom <properties>, ecc. Il filtro delle risorse, combinato con i profili Maven, può darti un comportamento di compilazione variabile al momento della compilazione. Quando si specifica un profilo in fase di runtime con -PmyProfile, ciò può abilitare le proprietà che possono quindi essere visualizzate nella build.

La risposta accettata può essere il modo migliore e più stabile per ottenere staticamente un numero di versione in un'applicazione , ma in realtà non risponde alla domanda originale: come recuperare il numero di versione del manufatto da pom.xml? Quindi, voglio offrire un'alternativa che mostra come farlo dinamicamente durante il runtime:

Puoi usare Maven stesso. Per essere più precisi, puoi usare una libreria Maven.

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

E poi fai qualcosa del genere in 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());
    }
}

Il registro della console è il seguente:

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

Aggiornamento 2017-10-31: per rispondere alla domanda di follow-up di Simon Sobisch ho modificato l'esempio in questo modo:

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.stackoverflow/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());
  }
}

Gli artefatti confezionati contengono un META-INF/maven/${groupId}/${artifactId}/pom.propertiesfile il cui contenuto è simile:

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

Molte applicazioni utilizzano questo file per leggere la versione dell'applicazione / jar in fase di esecuzione, non è richiesta alcuna installazione.

L'unico problema con l'approccio sopra è che questo file è (attualmente) generato durante la packagefase e quindi non sarà presente durante i test, ecc. (C'è un problema con Jira per cambiarlo, vedere MJAR-76 ). Se questo è un problema per te, l'approccio descritto da Alex è la strada da percorrere.

Esiste anche il metodo descritto in Modo semplice per visualizzare il numero di versione delle app tramite Maven :

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

Quindi usa questo:

App.class.getPackage().getImplementationVersion()

Ho trovato questo metodo più semplice.

Se usi imballaggi mvn come jar o war, usa:

getClass().getPackage().getImplementationVersion()

Legge una proprietà "Versione di implementazione" del META-INF / MANIFEST.MF generato (che è impostato sulla versione di pom.xml) nell'archivio.

A complemento di ciò che ha pubblicato @kieste, che penso sia il modo migliore per avere Maven a costruire informazioni disponibili nel tuo codice se stai usando Spring-boot: la documentazione su http://docs.spring.io/spring-boot/ docs / current / reference / htmlsingle / # production-ready-application-info è molto utile.

Devi solo attivare gli attuatori e aggiungere le proprietà di cui hai bisogno nel tuo application.propertiesoapplication.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
info.build.artifact=@project.artifactId@
info.build.name=@project.name@
info.build.description=@project.description@
info.build.version=@project.version@

Utilizzare questa libreria per semplificare una soluzione semplice. Aggiungi al manifest tutto ciò di cui hai bisogno e poi esegui una query per stringa.

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

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

A volte la riga di comando di Maven è sufficiente quando si esegue lo scripting di qualcosa correlato alla versione del progetto, ad esempio per il recupero di artefatti tramite URL da un repository:

mvn help:evaluate -Dexpression=project.version -q -DforceStdout

Esempio di utilizzo:

VERSION=$( mvn help:evaluate -Dexpression=project.version -q -DforceStdout )
ARTIFACT_ID=$( mvn help:evaluate -Dexpression=project.artifactId -q -DforceStdout )
GROUP_ID_URL=$( mvn help:evaluate -Dexpression=project.groupId -q -DforceStdout | sed -e 's#\.#/#g' )
curl -f -S -O http://REPO-URL/mvn-repos/${GROUP_ID_URL}/${ARTIFACT_ID}/${VERSION}/${ARTIFACT_ID}-${VERSION}.jar

    <build>
            <finalName>${project.artifactId}-${project.version}</finalName>
            <pluginManagement>
                <plugins>
                    <plugin>
                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-war-plugin</artifactId>
                        <version>3.2.2</version>
                        <configuration>
                            <failOnMissingWebXml>false</failOnMissingWebXml>
                            <archive>
                                <manifest>
                                    <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
                                    <addDefaultSpecificationEntries>true</addDefaultSpecificationEntries>
                                </manifest>
                            </archive>
                        </configuration>
                    </plugin>
                 </plugins>
            </pluginManagement>
</build>

Ottieni la versione utilizzando this.getClass().getPackage().getImplementationVersion()

PS Non dimenticare di aggiungere:

<manifest>
    <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
    <addDefaultSpecificationEntries>true</addDefaultSpecificationEntries>
</manifest>

Con riferimento alla risposta di Ketankk :

Sfortunatamente, l'aggiunta di questo ha incasinato il modo in cui la mia applicazione ha gestito le risorse:

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

Ma usare questo tag <manifest> all'interno di maven-assemble-plugin ha funzionato:

<addDefaultImplementationEntries>true</addDefaultImplementationEntries>
<addDefaultSpecificationEntries>true</addDefaultSpecificationEntries>

Quindi sono stato in grado di ottenere la versione utilizzando

String version = getClass().getPackage().getImplementationVersion();