Spring boot / spring number of the embedded version of the web application

Question

What are the strategies for embedding a unique version number in a Spring application?

I have an application using Spring Boot and Spring Web.

It is mature enough that I want to update it and see how it is displayed on the screen at runtime.

Answer 1

I believe that what you are looking for generates this version number during build (usually using build tools like Ant, Maven or Gradle) as part of the build task chain.

I believe that a fairly common approach is to either put the version number in Manifest.mf from a prepared JAR and then read it or create a file that is part of the created JAR that can be read by your application.

Another solution would be to use Spring Boot banner settings described here: http://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-spring-application.html#boot-features-banner However, this will only allow you to change the spring-boot banner.

I also believe that Spring Boot provides the product version installed in Manifest.MF of your application. To do this, you need to make sure that the Implementation-Version attribute of the manifest is set.

Custom solution for access anywhere in the code

Suppose you would like to have a version.properties file in src/main/resources that contains information about your version. It will contain placeholders instead of actual values ​​so that these placeholders can be expanded during build time.

 version=${prodVersion} build=${prodBuild} timestamp=${buildTimestamp} 

Now that you have such a file, you need to fill it with actual data. I use Gradle, so I have to make sure that the processResources task, which starts automatically for assembly, extends resources. Something like this should do the trick in the build.gradle file for Git-restricted code:

 import org.codehaus.groovy.runtime.* import org.eclipse.jgit.api.* def getGitBranchCommit() { try { def git = Git.open(project.file(project.getRootProject().getProjectDir())); def repo = git.getRepository(); def id = repo.resolve(repo.getFullBranch()); return id.abbreviate(7).name() } catch (IOException ex) { return "UNKNOWN" } } processResources { filesMatching("**/version.properties") { expand ( "prodVersion": version, "prodBuild": getGitBranchCommit(), "buildTimestamp": DateGroovyMethods.format(new Date(), 'yyyy-MM-dd HH:mm') ) } } processResources.outputs.upToDateWhen{ false } 

The following happens in the code:

• We have defined a function that can accept a build number from VCS (in this case Git). The commit hash is limited to 7 characters.
• We set up the processResources task to handle version.properties and populate it with our variables. prodVersion is taken from the version of the Gradle project. Usually it is installed as version in the gradle.properties file (part of the general assembly is customized).
• As a last step, we guarantee that it is always updated (Gradle has some mechanics to determine if files should be processed

Given that you are on SVN, you will need to use the getSvnBranchCommit() method. For example, you can use SVNKit or similar for this.

The last thing that is missing right now is reading the file for use in your application.

This can be achieved by simply reading the pathpath resource and parsing it in java.util.Properties . You can do this one more step and, for example, create access methods for each field, for example getVersion() , getBuild() , etc.

Hope this helps a bit (even if it cannot be 100% inapplicable)

Answer 2

I'm sure you probably understood something, because this is an old question, but here's what I did, and it looks good. (To get into the banner, you need to duplicate a lot).

I would recommend switching to git (this is a great SVN client), and then using this in the build.gradle file:

 // https://github.com/n0mer/gradle-git-properties plugins { id "com.gorylenko.gradle-git-properties" version "1.4.17" } // http://docs.spring.io/spring-boot/docs/current/reference/html/deployment-install.html springBoot { buildInfo() // create META-INF/build-info.properties } bootRun.dependsOn = [assemble] 

And this is in your SpringBoot application:

 @Resource GitProperties props; @Resource BuildProperties props2; 

Or this way to expose these properties to a standard spring environment:

 @SpringBootApplication @PropertySources({ @PropertySource("classpath:git.properties"), @PropertySource("classpath:META-INF/build-info.properties") }) public class MySpringBootApplication { 

and then, if necessary, referring to individual properties.

 @Value("${git.branch}") String gitBranch; @Value("${build.time}") String buildTime; 

Answer 3

Maven can be used to track version number , for example:

 <!-- pom.xml --> <version>2.0.3</version> 

Spring Boot can reference the version and expose it through REST using Actuator :

 # application.properties endpoints.info.enabled=true info.app.version=@project.version@ 

Then use Ajax to render the version in the browser, for example using Polymer iron-ajax :

 <!-- about-page.html --> <iron-ajax auto url="/info" last-response="{{info}}"></iron-ajax> Application version is: [[info.app.version]] 

This will be displayed in the browser as:

 Application version is: 2.0.3