{"id":20966,"date":"2014-01-23T19:00:27","date_gmt":"2014-01-23T17:00:27","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/?p=20966"},"modified":"2014-01-23T07:59:11","modified_gmt":"2014-01-23T05:59:11","slug":"specifying-gradle-build-properties","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2014\/01\/specifying-gradle-build-properties.html","title":{"rendered":"Specifying Gradle Build Properties"},"content":{"rendered":"

Properties<\/a> are a valuable tool for easily customizing Gradle<\/a> builds and the Gradle environment<\/a>. I demonstrate some of these approaches for specifying properties used in a Gradle<\/a> build in this post.<\/p>\n

Gradle supports both project properties<\/em> and system properties<\/em>. The main difference between the two that is of interest in this post is how each is accessed. Project properties are more conducive to direct access by name while system properties are accessed via normal Java\/Groovy system properties access methods.<\/p>\n

Passing Project Properties from Command-Line with -P<\/h2>\n

One of the easiest approaches for passing properties to a Gradle build is to specify project properties with -P<\/a> from the command line. Properties passed into the build with -P<\/code> are readily accessible in the build as project properties and, if their naming structure allows, can be accessed directly like variables.<\/p>\n

Passing System Properties from Command-Line with -D<\/h2>\n

As is the case with other Java applications, one can pass system properties to Gradle builds with -D<\/a>. Although these system properties provided to the Gradle build via the -D<\/code> option are always available to the Gradle build via the normal Java mechanism for obtaining system properties<\/a>, Gradle makes it possible to specify Project Properties as system properties. This is done by placing the prefix org.gradle.project.<\/code> before the name of the property desired in the build. For example, if one wanted to specify a system property named name.first<\/code> with -D<\/code> that would be available to the Gradle build as if it was provided with -P<\/code>, the person could provide it to the Gradle build on the command line as org.gradle.project.name.first<\/b><\/code> and the Gradle build would see it as a project property named name.first<\/code>.<\/p>\n

Passing System Properties via Environmental Variable<\/h2>\n

Any Java or Groovy application (including a Gradle build) can access environmental variables via System.getenv(String)<\/a>. However, Gradle allows environment variables to be accessed within the build like other project properties if the environmental variable is prefixed with ORG_GRADLE_PROJECT_<\/code>. For example, if one wanted a project property in the Gradle build to be called name.last<\/code> and wanted to supply it to the build via environment variable, that person could declare the environment variable ORG_GRADLE_PROJECT_name.last<\/code> and its value would be available to the Gradle build as a project property with name name.last<\/code>.

<\/div> <\/div><\/p>\n

gradle.properties<\/h2>\n

Properties can also be provided to a Gradle build via a properties file named gradle.properties<\/code>. Any properties specified with systemProp.<\/code> at the beginning of their property name are seen as system properties in the Gradle build and other properties (without their names beginning with “systemProp.”) are seen as Gradle project properties. For example, if my gradle.properties file had a property name.last=Marx<\/code> and a property systemPropr.name.first=Dustin<\/code>, the name.last<\/code> property would be seen and accessed in the Gradle build like any project property while the name.first<\/code> property would be seen and accessed in the Gradle build like any system property.<\/p>\n

Demonstration \/ Example<\/h2>\n

Each of these types of properties-specifying mechanisms can be demonstrated with a simple example. The Gradle build shown next attempts to print out various properties that are specified in different ways.<\/p>\n

build-properties.gradle<\/h4>\n
task displayProperties << {\r\n   displaySystemProperties()\r\n   displayGradleProjectProperties()\r\n}\r\n\r\ndef displaySystemProperties()\r\n{\r\n   println \"\\n=== System Properties ===\"\r\n   println \"Favorite Movie (1994): ${System.properties['movie.favorite.1994']}\"\r\n   println \"Favorite Movie (1996): ${System.properties['movie.favorite.1996']}\" \r\n   println \"Favorite Movie (1997): ${System.properties['movie.favorite.1997']}\"\r\n   println \"Favorite Movie (1981): ${System.properties['movie.favorite.1981']}\"\r\n   println \"Favorite Movie (2012): ${System.properties['movie.favorite.2012']}\"\r\n   println \"Favorite Movie (2013): ${System.properties['movie.favorite.2013']}\"\r\n}\r\n\r\ndef displayGradleProjectProperties()\r\n{\r\n   println \"\\n=== Gradle Project Properties ===\"\r\n   println \"Favorite Movie (1994): ${getProjectProperty('movie.favorite.1994')}\"\r\n   println \"Favorite Movie (1996): ${getProjectProperty('movie.favorite.1996')}\"\r\n   println \"Favorite Movie (1997): ${getProjectProperty('movie.favorite.1997')}\"\r\n   println \"Favorite Movie (1981): ${getProjectProperty('movie.favorite.1981')}\"\r\n   println \"Favorite Movie (2012): ${getProjectProperty('movie.favorite.2012')}\"\r\n   println \"Favorite Movie (2013): ${getProjectProperty('movie.favorite.2013')}\"\r\n}\r\n\r\ndef String getProjectProperty(String propertyName)\r\n{\r\n   String movieTitle = \"null\"\r\n   if (hasProperty(propertyName))\r\n   {\r\n      movieTitle = this.properties[propertyName]\r\n   }\r\n   return movieTitle\r\n}<\/pre>\n
Some of the properties to be passed to this script will be provided on the command-line with -P<\/code>, some will be provided on the command line with -D<\/code>, one will be provided via environment variable, and two will be provided via gradle.properties<\/code> file in the same directory as the build. That gradle.properties<\/code> file is shown next.<\/p>\n
gradle.properties<\/h4>\n
movie.favorite.2013=Star Trek into Darkness\r\nsystemProp.movie.favorite.2012=Skyfall<\/pre>\n
With the gradle.properties<\/code> file in place, the other two interesting parts of the example are the setting of the environment variable. The example here is in DOS, but the same thing could be done with slightly different syntax in Linux environments. The DOS\/Windows command is: set ORG_GRADLE_PROJECT.movie.favorite.1981=\"Raiders of the Lost Ark\"<\/code><\/p>\n
For this demonstration, I’ll run the Gradle build script with -D<\/code> and -P<\/code> parameters: gradle -b build-properties.gradle displayProperties -Pmovie.favorite.1996=\"Independence Day\" -Dmovie.favorite.1997=Gattaca -Dorg.gradle.project.movie.favorite.1994=\"Shawshank Redemption\" <\/code><\/p>\n
When running the above-listed Gradle build script with the indicated gradle.properties<\/code> file in place, with the indicated environment variable specified, and with the command just shown, the output looks that shown in the next screen snapshot.<\/p>\n
\"gradlePropertiesProjectSystemEnvironmentalVariable\"<\/a><\/p>\n
The screen snapshot indicates how properties are seen\/accessed in the Gradle build depending on their source and naming convention. In short, the output demonstrates the following “rules” of property availability in a Gradle build:<\/p>\n