Output the Version Number to a Text File Using Maven

Image may be NSFW.
Clik here to view.

1. Overview

In Maven-based Java projects, outputting the project version number to a text file is often necessary. This is useful for version tracking, logging, and ensuring consistency across different builds and deployments.

Maven maintains the project version in the pom.xml file under the <version> tag. By leveraging Maven’s resource filtering capability and additional plugins, we can extract and store this version automatically during the build process.

This article covers two approaches to achieve this: the first using the Maven Resources Plugin and the second using the Maven Antrun Plugin.

2. Using the Maven Resources Plugin

The Maven Resources Plugin is commonly used for file filtering, allowing placeholders in resource files to be replaced with values defined in the pom.xml.

In the context of outputting the version number, this plugin can insert dynamic project properties (version, artifactId, groupId) directly into resource files during the build process.

2.1. Enabling Resource Filtering

To use the Maven Resources Plugin for filtering, we must first configure the <resources> section in the pom.xml file. This configuration tells Maven to enable filtering for the resource files in our project.

Let’s see how to update the pom.xml file to enable resource filtering:

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

This configuration tells Maven to process all files inside the src/main/resources directory and apply filtering to replace any placeholders with the corresponding values from the Maven project properties (such as ${project.version}).

The <filtering>true</filtering> line is the key part that enables this feature.

2.2. Creating a Version File

Next, we’ll create a resource file (for example, version.txt) in the src/main/resources directory. This file can contain placeholders like ${project.version}, which will be dynamically replaced during the build process with the actual version number defined in our pom.xml.

For instance, let’s create a version.txt file with the following content:

Version: ${project.version}

2.3. Building the Project

Once we set up our configuration, we can build our project by running the Maven command:

$ mvn clean package

After the project build, we’ll find the filtered version.txt file in the target/classes/ directory by default. The ${project.version} placeholder will be replaced with the version number specified in the pom.xml:

$ cat target/classes/version.txt
Version: 1.0-SNAPSHOT

Additionally, we can customize the file location in the Maven configuration by specifying a different directory in the <outputDirectory> tag within the <build> section. This approach simplifies filtering version information and other project properties into resources during the build.

3. Using the Maven Antrun Plugin

Another way to generate a version file during the Maven build process is by using the Maven Antrun Plugin. This plugin offers flexibility by dynamically creating or modifying files without the need to configure resource files or perform additional filtering manually.

3.1. Plugin Configuration

To use this plugin, we’ll need to add its configuration to our pom.xml file:

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-antrun-plugin</artifactId>
    <version>3.1.0</version>
    <executions>
        <execution>
            <id>generate-version-file</id>
            <phase>generate-resources</phase>
            <goals>
                <goal>run</goal>
            </goals>
            <configuration>
                <target>
                    <echo file="${project.build.directory}/output/version.txt">
                        Version: ${project.version}
                    </echo>;
                </target>
            </configuration>
        </execution>
    </executions>
</plugin>

The key parts of the configuration include:

• <phase>generate-resources</phase>: This specifies that the plugin will run during the generate-resources phase of the Maven build lifecycle.
• <goal>run</goal>: This goal runs the Ant tasks defined in the configuration. In this case, it writes the version to a file.
• <echo file=”${project.build.directory}/output/version.txt”>: This writes the project’s version to a version.txt file under the target/output directory. The ${project.build.directory} is a Maven property that resolves to target by default.

3.2. Building the Project

After adding the plugin configuration, we can build the project using the Maven command:

$ mvn package

Once the build is complete, a version.txt file will be created in the target/output/ directory. This file contains the version number of the project:

$ cat target/output/version.txt
Version: 1.0-SNAPSHOT

This approach automates the generation of the version file, eliminating the need to manually filter resource files. Furthermore, the file’s location can be easily customized by adjusting the <echo file=”…”> path in the plugin configuration.

4. Conclusion

Both the Maven Resources Plugin and the Maven Antrun Plugin are excellent tools for managing project version information and outputting it to a text file. The Maven Resources Plugin is simple and works well if we want to filter version details into our resources manually, while the Maven Antrun Plugin provides a more automated approach for dynamically generating version files.

By using these plugins, we can easily manage and output the version number of our Java project into a file, ensuring that the version is always accurate and up-to-date during our build process.

As always, the code discussed here is available over on GitHub.

Image may be NSFW.
Clik here to view.

Image may be NSFW.
Clik here to view. Image may be NSFW.
Clik here to view. Image may be NSFW.
Clik here to view. Image may be NSFW.
Clik here to view. Image may be NSFW.
Clik here to view. Image may be NSFW.
Clik here to view. Image may be NSFW.
Clik here to view.