17

I come from ANT where you can invoke a .java file to obtain the version number through executing some method. I would like to do something similar in my new pom.xml to automatically obtain the correct version number. I need the app to know about its own version and at the same time Maven to know about the version got make the right builds. Holding the version infomormation doubled is no option.

Or can Maven create a new .java file during/before building?

I can image quite a few ways to achive this, but is there a best practise way to do this in Maven project?

Franz Kafka
  • 10,623
  • 20
  • 93
  • 149
  • You can specify the version in the configuration file for maven - `pom.xml` – donnior Jan 12 '12 at 01:52
  • 1
    Yes I know that, but I need the app to also know about the version number, therefore the pom.xml should read the version number fro a java file or the pom.xml should trigger the creation of a java file with the version number. – Franz Kafka Jan 12 '12 at 02:01
  • Maven has a "filter resource" feature, it can replace some content in your code file with maven variables during build, what you need to do is add markup like `${project.version}` into your files. You can get it at http://maven.apache.org/plugins/maven-resources-plugin/examples/filter.html – donnior Jan 12 '12 at 02:09

5 Answers5

29

When building a JAR, Maven writes the pom.xml and a pom.properties file into META-INF/maven/[group ID]/[artifact ID] directory. You can then read the version out of one of these in your application.

Alternatively, you can explicitly write a new version.properties file by using resource filtering.

If you put the following in your POM:

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

and then put a version.properties template into the src/main/resources directory that looks like:

version = ${project.version}

Maven will substitute in the version read out of the POM, and your application then just needs to read the version.properties resource and query the version key.

CodeButcher
  • 564
  • 5
  • 16
prunge
  • 22,460
  • 3
  • 73
  • 80
  • This approach sounds nice, but one thing I can't figure out: If I'm developing in Ecplise and start the project directly with the run button, Maven won't have substituted the value yet. Or must I always start the project through Maven? – Franz Kafka Jan 18 '12 at 12:39
  • 1
    @Franz True, Maven needs to have run and rewritten the file for Eclipse to pick it up. You could add the target/build/classes directory as a source folder so Eclipse picks up the rewritten file, or you could explicitly make the resources plugin run and generate its output files to a different directory, and include that as a source folder in Eclipse. Also, I don't know how sophisticated the latest M2Eclipse is, but maybe it can handle filtered resources. (see http://stackoverflow.com/questions/2773474/m2eclipse-resource-filtering) – prunge Jan 19 '12 at 06:05
1

I will refer you to this thread on SO: How to read an external properties file in Maven. In particular, check out the answer from Dougnukem that describes how to read an external property file into Maven. You can use this as a shared source for controlling the version number in both your Maven build script and your Java application.

Community
  • 1
  • 1
Perception
  • 79,279
  • 19
  • 185
  • 195
1

Perhaps if you elaborate a bit more on this requirement we can help more to provide a more elegant mavenish solution to your problem. Nmely, what is this second application, is it launched from Maven, if so during what phase of the build process is it launched ? What is the interaction this application and Maven have ?

there are many ways this can be accomplished but choosing the right one depends largely on your particular situation, there is not enough information in your question to dig deeper in a more comprehensive solution. That said, the following come to mind :

  • External properties : you can create a property file either externally or directly from the Maven build process. you can then read this property file from your other application.

  • Filtering : As others have mentioned it is possible to have Maven filter a resource file. this file can be a java file to which you insert the current version number and call this file from your other application.

  • Call your application from the Maven build and pass arguments : you can use the exec plugin and call your application as a sub-process of Maven passing the current version number ${project.version}.

  • Integrate your old Ant build in Maven : you can call directly some Ant snippets or complete ant build from Maven. This would yield you a hybrid build system which is probably not the best but still would allow you some leeway in your migration process and manage older Ant scripts slowly migrating slices of functionality over to Maven. Not that it's not necessarily bad per say to have a mix of the two, just that Maven provides a lot of hard wired or quasi hard wired configuration convention that the Ant script could interfere with. In this regards it can be hard to have both play nice with each-other.

  • Drive your Maven build from ant : you can also do the opposite, that is drive the Maven build process from ant thus keeping control on how you call your other system. By integrating the right things (such as properties or filter) you can ensure Maven generates the necessary artifact from a specific project that you can use at later time within your Ant script. Note that the docs for this task is not very elaborate, you may have to fiddle around a bit to get it to work but at least you would be in a familiar environment.

Without more information on how these two systems interact and why you need this information it is hard to dig deeper for you.

Hope this helps

Community
  • 1
  • 1
Newtopian
  • 7,543
  • 4
  • 48
  • 71
0

I realize this was answered long ago, but I have come up with a new twist on the answer that some might find useful.

I have the replacer plugin change a string in a Java file on each MAVEN build. So, if the pom.xml ever updates the pom project version number, it is automatically reflected in a java source file.

TO TELL MAVEN ABOUT THE replace goal:

<build>
    ...
    <pluginManagement>
        <plugins>
            <!--This plugin's configuration is used to store Eclipse m2e settings only. It has no influence on the Maven build itself.-->
            <plugin>
                <groupId>org.eclipse.m2e</groupId>
                <artifactId>lifecycle-mapping</artifactId>
                <version>1.0.0</version>
                <configuration>
                    <lifecycleMappingMetadata>
                        <pluginExecutions>
                            <pluginExecution>
                                <pluginExecutionFilter>
                                    <groupId>
                                        com.google.code.maven-replacer-plugin
                                    </groupId>
                                    <artifactId>
                                        replacer
                                    </artifactId>
                                    <versionRange>
                                        [1.5.3,)
                                    </versionRange>
                                    <goals>
                                        <goal>replace</goal>
                                    </goals>
                                </pluginExecutionFilter>
                                <action>
                                    <execute />
                                    <runOnIncremental>true</runOnIncremental>
                                </action>
                            </pluginExecution>
                        </pluginExecutions>
                    </lifecycleMappingMetadata>
                </configuration>
            </plugin>
        </plugins>
    </pluginManagement>
    ...
</build>

TO TELL MAVEN TO FILL IN THE CURRENT NAME AND VERSION:

(If you prefer, put the full sub path in the basedir and remove the **/ from the included filename.)

<build>
    ...
    <plugins>
        <plugin>
            <groupId>com.google.code.maven-replacer-plugin</groupId>
            <artifactId>replacer</artifactId>
            <version>1.5.3</version>
            <executions>
                <execution>
                    <id>replace-version-number</id>
                    <phase>generate-sources</phase>
                    <goals>
                        <goal>replace</goal>
                    </goals>
                </execution>
            </executions>
            <configuration>
                <basedir>${project.basedir}/src/main/java</basedir>
                <includes>
                    <include>**/Constants.java</include>
                </includes>
                <preserveDir>true</preserveDir>
                <replacements>
                    <replacement>
                        <token>mavenProjectName = ".*"</token>
                        <value>mavenProjectName = "${project.name}"</value>
                    </replacement>
                    <replacement>
                        <token>mavenProjectVersion = ".*"</token>
                        <value>mavenProjectVersion = "${project.version}"</value>
                    </replacement>
                </replacements>
            </configuration>
        </plugin>
        ....
    </plugins>
    ...
</build>

IN Constants.java:

...
private static final String mavenProjectName = "";
private static final String mavenProjectVersion = "";
...

The values get filled with the POM's values in the generate_sources phase, before the compile phase.

The wildcard .* in the replacer's token means the value is updated even if you check an updated copy into source control.

Jesse Chisholm
  • 3,857
  • 1
  • 35
  • 29
0

Its not clear what version number you are referring to, and why would it be in a java file. However if you are trying to assign a version number to your project than follow the standard Maven convention. Here is an example:

<project xmlns="http://maven.apache.org/POM/4.0.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.myco.abc</groupId>
  <artifactId>myapp</artifactId>
  <packaging>war</packaging>
  <version>1.0.0-SNAPSHOT</version>

  <name>My App</name>
  <description>My application description.</description>
  <url>http://myapp.myco.com</url>
....
dbrin
  • 15,525
  • 4
  • 56
  • 83
  • I'm referring to 1.0.0-SNAPSHOT. The app needs the version number to work differently when communicating with older versions of the app because e.g. interfaces might have changed. – Franz Kafka Jan 12 '12 at 02:19