java - plugin - Usando maven para dar salida al número de versión a un archivo de texto

maven-jar-plugin

Question

Quiero generar un archivo zip que actualice una aplicación con maven. El zip se alojará en un servidor y estoy usando el plugin de ensamblaje para generar el zip. Sin embargo, me gustaría que maven genere automáticamente un archivo de texto que almacene el número de versión actual fuera del zip. es posible?

EDITAR: Lo hice con éxito usando el Ensamblador Maven y dos descriptores para crear dos conjuntos personalizados. Uno tiene un objetivo de directorio único y simplemente crea una carpeta con el archivo version.txt actualizado basado en el filtrado. Luego, otro con un solo objetivo realmente empaqueta el archivo zip. Esto parece ser muy poco elegante y supongo que no actualizará adecuadamente el repositorio maven con toda la carpeta actualizada. Si hay una mejor manera de hacerlo, por favor avíseme.

Answer 1

A lo que te refieres se lo llama filtering

Necesita habilitar el filtrado en un recurso en particular, y luego usar ${project.version} que será sustituido como parte de su compilación.

Answer 2

Acabo de hacer esto con una tarea de hormiga.

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

Answer 3

Para agregar a la respuesta de Sean, puede mover el archivo de versión a una ubicación de carpeta dentro del contenedor utilizando el parámetro targetpath dentro del recurso. El siguiente código crea una carpeta llamada ''resources'' dentro del jar y el archivo de texto (version.number) se encuentra en esa carpeta.

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

Answer 4

También puede usar una secuencia de comandos Groovy para producir un archivo de información de versión. Me gusta más este método porque no tiene que excluir cosas en el descriptor del plugin de ensamblaje. También puede utilizar este método para incluir opcionalmente cosas solo disponibles si está compilando desde Jenkins / Hudson (por ejemplo, verifique BUILD_ID, etc.).

Entonces, tendrías un script groovy para generar archivos en pom.xml como este:

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

Y luego su plugin de ensamblaje plugin en pom.xml que se vería así:

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

Y, finalmente, su descriptor de ensamblaje dist-all.xml se vería así:

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

Answer 5

Una posibilidad es almacenar todas las propiedades del proyecto en .jar usando maven-properties-plugin .
Luego puede leer estas propiedades usando la API de propiedades Java estándar (aunque no demasiado práctica).

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

Tenga cuidado con este enfoque, ya que puede filtrar propiedades que no se supone que terminen publicadas, también desde settings.xml .

Answer 6

Use el estándar META-INF/MANIFEST.MF (Luego puede usar el código Java getClass().getPackage().getImplementationVersion() para obtener la versión)

Para .war use esta configuración:

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

Eso agregará manifiesto durante la construcción, o puede llamar a mvn war:manifest

Consulte también ¿Cómo obtener la versión del paquete al ejecutar Tomcat?

Answer 7

en Maven 3, use la respuesta de Sean para crear su archivo version.txt , (el mío se muestra aquí, junto con la fecha de compilación y el perfil activo):

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

agregar propiedad profileID a cada uno de los perfiles, por ejemplo:

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

Utilice los recursos de copia de Maven para copiar el archivo a un directorio de más fácil acceso, como ${basedir} o ${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>

salida se ve así:

1.2.3-profileName
yymmdd_hhmm

Answer 8

Por supuesto. Crea un archivo de texto en src / main / resources, llámalo version.txt (o lo que sea)

Contenido del archivo:

${project.version}

ahora en tu pom.xml, dentro del elemento de compilación, coloca este bloque:

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

después de cada compilación, el archivo (que puede encontrar en el target / clases) contendrá la versión actual.

Ahora, si desea mover el archivo a otro lugar automáticamente, probablemente necesite ejecutar una tarea ant a través del maven-antrun-plugin .

Algo como esto:

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