web-dev-qa-db-fra.com

Utiliser maven pour sortir le numéro de version dans un fichier texte

Je veux générer un fichier Zip qui mettra à jour une application avec maven. Le zip sera hébergé sur un serveur et j'utilise le plugin Assembly pour générer le zip. Cependant, je voudrais que maven génère automatiquement un fichier texte qui stocke le numéro de version actuel en dehors du fichier Zip. Est-ce possible?

EDIT: Je l’ai fait avec succès en utilisant maven Assembly Plugin et deux descripteurs pour créer deux assemblys personnalisés. L'un d'eux a un objectif de répertoire unique et crée simplement un dossier avec le fichier version.txt mis à jour basé sur le filtrage. Ensuite, un autre avec un seul objectif empaquete réellement le fichier Zip. Cela semble être très inélégant et je suppose que cela ne mettra pas correctement à jour le dépôt avec tout le dossier mis à jour. S'il y a une meilleure façon de le faire, s'il vous plaît faites le moi savoir.

javamaven-2maven-assembly-plugin
46
sanz

Sûr. Créez un fichier texte quelque part dans src/main/resources, appelez-le version.txt (ou autre)

Contenu du fichier:

${project.version}

maintenant dans votre pom.xml, dans l'élément de construction, mettez ce bloc:

<build>
  <resources>
    <resource>
      <directory>src/main/resources</directory>
      <filtering>true</filtering>
      <includes>
        <include>**/version.txt</include>
      </includes>
    </resource>
    <resource>
      <directory>src/main/resources</directory>
      <filtering>false</filtering>
      <excludes>
        <exclude>**/version.txt</exclude>
      </excludes>
    </resource>
    ...
  </resources>
</build>

après chaque construction, le fichier (que vous pouvez trouver dans target/classes) contiendra la version actuelle.

Maintenant, si vous voulez déplacer automatiquement le fichier ailleurs, vous allez probablement avoir besoin d'exécuter une tâche ant via le maven-antrun-plugin .

Quelque chose comme ça:

  <build>
    ...
    <plugins>
      <plugin>
        <artifactId>maven-antrun-plugin</artifactId>
         <version>1.4</version>
         <executions>
          <execution>
            <phase>process-resources</phase>
            <configuration>
               <tasks>
                 <copy file="${project.build.outputDirectory}/version.txt"
                   toFile="..." overwrite="true" />
              </tasks>
            </configuration>
            <goals>
              <goal>run</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
   </plugins>
 </build>
85
Sean Patrick Floyd

Utiliser la norme META-INF\MANIFEST.MF (vous pouvez ensuite utiliser le code Java getClass().getPackage().getImplementationVersion() pour obtenir la version)

Pour .war, utilisez cette configuration:

<plugin>
    <artifactId>maven-war-plugin</artifactId>
    <version>2.1</version>
    <configuration>
        <archive>                   
            <manifest>
                <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
                <addDefaultSpecificationEntries>true</addDefaultSpecificationEntries>
            </manifest>
        </archive>
    </configuration>
</plugin>

Cela va ajouter manifeste lors de la construction, ou vous pouvez appeler mvn war:manifest

Voir aussi Comment obtenir la version du paquet lors de l'exécution de Tomcat?

14
Paul Verest

Ce à quoi vous faites référence s'appelle filtrage

Vous devez activer le filtrage sur une ressource particulière, puis utiliser ${project.version} qui sera substitué dans le cadre de votre construction.

11
Jon Freedman

Vous pouvez également utiliser un script Groovy pour générer un fichier d'informations sur la version. J'aime davantage cette méthode parce qu'il n'est pas nécessaire d'exclure des éléments du descripteur du plugin Assembly. Vous pouvez également utiliser cette méthode pour inclure éventuellement des éléments disponibles uniquement si vous construisez à partir de Jenkins/Hudson (par exemple, vérifiez oug BUILD_ID, etc.).

Donc, vous auriez un script groovy générant des fichiers dans pom.xml comme ceci:

  <plugin>
    <groupId>org.codehaus.mojo.groovy</groupId>
    <artifactId>groovy-maven-plugin</artifactId>
    <version>1.0-beta-3</version>
    <executions>
      <execution>
        <phase>test</phase>
        <goals>
          <goal>execute</goal>
        </goals>
        <configuration>
          <source>
        <![CDATA[
        println("==== Creating version.txt ====");
        File mainDir = new File("src/main");
        if(mainDir.exists() && !mainDir.isDirectory()) {
            println("Main dir does not exist, wont create version.txt!");
            return;
        }
        File confDir = new File("src/main/conf");
        if(confDir.exists() && !confDir.isDirectory()) {
            println("Conf dir is not a directory, wont create version.txt!");
            return;
        }
        if(!confDir.exists()) {
            confDir.mkdir();
        }
        File versionFile = new File("src/main/conf/version.txt");
        if(versionFile.exists() && versionFile.isDirectory()) {
            println("Version file exists and is directory! Wont overwrite");
            return;
        }
        if(versionFile.exists() && !versionFile.isDirectory()) {
            println("Version file already exists, overwriting!");
        }
        println("Creating Version File");
        BufferedWriter writer = new BufferedWriter(new FileWriter(versionFile));

        writer.write("groupId = ${project.groupId}");
        writer.newLine();
        writer.write("artifactId = ${project.artifactId}");
        writer.newLine();
        writer.write("version = ${project.version}");
        writer.newLine();
        writer.write("timestamp = ${maven.build.timestamp}");

        String buildTag = "";
        String buildNumber = "";
        String buildId = "";
        try {
            buildTag = "${BUILD_TAG}";
            buildNumber = "${BUILD_NUMBER}";
            buildId = "${BUILD_ID}";

            writer.write("BUILD_TAG = " + buildTag + "\n");
            writer.write("BUILD_NUMBER = " + buildNumber + "\n");
            writer.write("BUILD_ID = " + buildId + "\n");

        } catch (Exception e) {
            println("============= Could not find BUILD_TAG probably this is not a Jenkins/Hudson build ===========");
        }

        writer.close();
        ]]>
          </source>
        </configuration>
      </execution>
    </executions>
  </plugin>

Et ensuite votre plugin Assembly dans pom.xml qui ressemblerait à ceci:

  <plugin>
    <artifactId>maven-Assembly-plugin</artifactId>
    <version>2.2.1</version>
    <!-- Produce the all-dependencies-included jar for Java classloaders -->
    <executions>
      <execution>
        <id>all</id>
        <phase>package</phase>
        <goals>
          <goal>single</goal>
        </goals>
        <configuration>
          <finalName>${project.artifactId}</finalName>
          <descriptors>
            <descriptor>dist-all.xml</descriptor>
          </descriptors>
        </configuration>
      </execution>
    </executions>
  </plugin>

Et enfin, votre descripteur d'assembly dist-all.xml ressemblerait à ceci:

<?xml version="1.0" encoding="UTF-8"?>
<Assembly>
  <id>all</id>
  <formats>
    <format>dir</format>
    <format>Zip</format>
  </formats>
  <includeBaseDirectory>false</includeBaseDirectory>
  <fileSets>
    <fileSet>
      <directory>target</directory>
      <outputDirectory></outputDirectory>
      <includes>
        <include>*.jar</include>
      </includes>
    </fileSet>
    <fileSet>
      <directory>src/main/conf</directory>
      <outputDirectory></outputDirectory>
      <includes>
        <include>**</include>
      </includes>
    </fileSet>
  </fileSets>
</Assembly>
6
DeusAquilus

dans Maven 3, utilisez La réponse de Sean pour créer votre fichier version.txt (le mien apparaît ici, avec la date de construction et le profil actif):

${project.version}-${profileID}
${buildDate}

ajout de la propriété profileID à chacun des profils, par exemple:

<properties>
    <profileID>profileName</profileID>
</properties>

Utilisez Maven copy-resources pour copier le fichier dans un répertoire plus facile à atteindre, tel que ${basedir} ou ${basedir}/target:

<plugin>
    <groupId>org.Apache.maven.plugins</groupId>
    <artifactId>maven-resources-plugin</artifactId>
    <version>3.0.2</version>
    <executions>
        <execution>
            <id>copy-resources</id>
            <phase>validate</phase>
            <goals>
                <goal>copy-resources</goal>
            </goals>
            <configuration>
                <outputDirectory>${basedir}</outputDirectory>
                <resources>
                    <resource>
                        <directory>${basedir}/target/.../[version.txt dir]/version.txt</directory>
                        <includes>
                            <include>version.txt</include>
                        </includes>
                        <filtering>true</filtering>
                    </resource>
                </resources>
            </configuration>
        </execution>
    </executions>
</plugin>

la sortie ressemble à ceci:

1.2.3-profileName
yymmdd_hhmm
6
ekangas

Je viens de faire cela avec une tâche de fourmi.

<echo file="version.txt">${project.version}</echo>
2
Dr.Octoboz

Pour une application Spring Boot, suivez la réponse acceptée ci-dessus, mais en remplaçant par

${project.version}

avec

@project.version@

Voici le lien vers la documentation https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-1.3-Release-Notes#maven-resources-filtering

1
Vuong Ly

Pour ajouter à la réponse de Sean, vous pouvez déplacer le fichier de version dans un dossier du jar en utilisant le paramètre targetpath dans la ressource. Le code suivant crée un dossier appelé «ressources» dans le fichier jar et le fichier texte (version.number) se trouve dans ce dossier. 

<resource>
    <directory>resources</directory>
    <targetPath>resources</targetPath>
    <filtering>true</filtering>
    <includes>
        <include>version.number</include>
    </includes>
</resource>
<resource>
    <directory>resources</directory>
    <filtering>false</filtering>
    <excludes>
        <exclude>version.number</exclude>
    </excludes>
</resource>
0
learmo

Une possibilité consiste à stocker toutes les propriétés du projet dans le .jar construit à l'aide de maven-properties-plugin.
Ensuite, vous pouvez lire ces propriétés en utilisant standard (bien que pas trop pratique) API de propriétés Java .

        <!-- Build properties to a file -->
        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>properties-maven-plugin</artifactId>
            <version>1.0.0</version>
            <executions>
                <execution>
                    <phase>generate-resources</phase>
                    <goals> <goal>write-project-properties</goal> </goals>
                    <configuration>
                        <outputFile> ${project.build.outputDirectory}/build.properties </outputFile>
                    </configuration>
                </execution>
            </executions>
        </plugin>

Soyez prudent avec cette approche car elle risque de laisser fuir des propriétés qui ne sont pas censées être publiées, également à partir de settings.xml.

0
Ondra Žižka

Je préfère le write-properties-file-maven-plugin , parce que je ne veux pas que toutes les propriétés de maven-project-propriétés dans un seul fichier

  <plugin>
    <groupId>com.internetitem</groupId>
    <artifactId>write-properties-file-maven-plugin</artifactId>
    <version>1.0.1</version>
    <executions>
      <execution>
        <id>one</id>
        <phase>compile</phase>
        <goals>
            <goal>write-properties-file</goal>
        </goals>
        <configuration>
          <filename>test.properties</filename>
          <properties>
            <property>
              <name>one</name>
              <value>1</value>
            </property>
            <property>
              <name>artifactId</name>
              <value>My Artifact ID is ${project.artifactId}</value>
            </property>
          </properties>
        </configuration>
      </execution>
    </executions>
  </plugin>
0
Gambotic

Si vous voulez écrire un fichier texte en utilisant les propriétés disponibles de maven, vous pouvez faire ce que Dr.Octoboz (merci) a suggéré. C'est vrai que tout le fichier est écrasé. Peut-être que ceci est un meilleur indice (utilisez le bloc CDATA) pour les futurs lecteurs.

<echo file="C:/var/install/myapp/${thisProfile}/${maven.build.timestamp}/myapp_install.txt"><![CDATA[
# Profile ${thisProfile}
bmix api https://api.eu-de.bluemix.net
bmix  login -u [email protected] -p "********"
bmix target --cf
bmix cf Push myapp1-${service} -p C:\var\install\myapp\${thisProfile}\${maven.build.timestamp}\myapp1.war
bmix cf Push myapp2-${service} -p C:\var\install\myapp\${thisProfile}\${maven.build.timestamp}\myapp1.war
]]></echo>
0
Marcos