Is it possible to declare a variable in Gradle usable in Java?

java

gradle

buildconfig

system-properties

byNikita Barsukov·Sep 19, 2024

Yes, you can declare a variable in Gradle and use it in your Java code. You'll use gradle.properties to define your variable, and inject it into your Java code at build time.

Define your variable in gradle.properties:
```
myVariable=HelloWorld
```

Extend processResources task in build.gradle:

processResources {
    filesMatching('**/*.properties') {
        expand(project.properties)
    }
}
// In code we trust!

Create src/main/resources/config.properties file with a placeholder:
```
myVariable=${myVariable}
```

Use it in Java code:

// Not the droids you're looking for? Check your properties!
ResourceBundle rb = ResourceBundle.getBundle("config");
String myVariable = rb.getString("myVariable");
System.out.println(myVariable); // "HelloWorld"

This method allows you to reuse Gradle-defined variables in your Java application. Think of it as getting a backstage pass to the concert of your app!

Handing runtime and environment variables

System properties and environment variables might seem like some obscure wizards' stuff, but you can wield their magic to achieve dynamic settings for your app!

Runtime configuration via system properties

System properties help you pull a rabbit out of the hat by regulating dynamic values at runtime.

In build.gradle,

test {
    systemProperty 'testProperty', 'aValue'
}

And our Java magician says:

// Hey Presto!
String testProperty = System.getProperty("testProperty");

Environment variables: Masters of disguise

Environment variables can don many faces, adding flexibility to your variable values. No more misdirections!

// It's a bird... It's a plane... No, it's env_variable!
if (System.getenv("ENV_VARIABLE") != null) {
    buildConfigField "String", "ENV_VARIABLE", "\"${System.getenv('ENV_VARIABLE')}\""
}

But in the realm of Java, we do:

// Meet the variable with many faces!
String envVariable = BuildConfig.ENV_VARIABLE;

Securing the vault and keeping it clean

Every great magic show needs protection and tidiness. Let's see how we can secure sensitive information and endeavor cleanliness in our build setup.

The vault of secrets: `gradle.properties`

Lock away your API keys and other sensitive information like an ancient scroll of magic spell. Feed them to buildConfigField in build.gradle. Oh, and keep the vault off the Git stage!

// Handing over the ancient scroll to the guardian
buildConfigField "String", "API_KEY", "\"" + myApiKey + "\""

How to access it? Just whisper BuildConfig.API_KEY and voila! Magic! 🎩

The cleanliness charm: Code obfuscation

Use Proguard to keep your Java code clean and tidy in release builds. Like a broom sweeping away the mess, or a magic cloak that makes your code harder to see!

// Wish cleanliness? You shall have it!
android {
    buildTypes {
        release {
            minifyEnabled true
            // Proguard configurations
        }
    }
}

The magic mirror: Testing and logging

Use JUnit tests to ensure your magic spells (values) did not get lost in translation:

test {
    assertEquals("ExpectedValue", BuildConfig.MY_VARIABLE);
}

For consistent logging throughout your Java codebase, call upon our trusty friend, the static final Logger.

Brewing advanced potions

Buckle up! We're diving deep into advance integration techniques where you can conjure up variables depending on build variants or custom tasks.

Multiple build types

Control your magic spells (variables) according to your build types.

// brew for release and debug potions separately
android {
    buildTypes {
        release {
            buildConfigField "String", "ENDPOINT", "\"https://api.example.com\""
        }
        debug {
            buildConfigField "String", "ENDPOINT", "\"https://staging-api.example.com\""
        }
    }
}

In Java, retrieve whichever potion you brewed:

// Give me the potion!
String endpoint = BuildConfig.ENDPOINT;

Custom tasks: Your magic wand

Wave your magic wand (write a custom task) when faced with complex conditions for injecting variables.

// Swish and flick! 
task injectVars {
    doLast {
        // Logic to inject variables
    }
}

Conjure them up when the conditions are just right during the build sequence.

Concocting the ultimate potion

Let's stir the cauldron and brew the ultimate integration potion by combining all the magic spells we have conjured so far.

Creating potions of different tastes

The buildConfigField in Gradle can handle various flavors like boolean, int, and more. See it in action:

// A pinch of int
buildConfigField "int", "VERSION_CODE", "100"

Advanced resource management

To create Android resources using resValue, just say the magic words:

// Keep your friends close, but your resources closer.
android {
    defaultConfig {
        resValue "string", "welcome_message", "Hello World"
    }
}

And in your Android incantation:

// In the wise words of Gandalf, "Speak, friend, and enter!"
getString(R.string.welcome_message)

Provisions for the magical realm of CI/CD

Good news for wizarding schools depending on CI/CD pipelines! Easily swap variables using environment variables configured in the pipeline settings. This keeps the stages apart without altering the magic spells!

explain-codes / Java / Is it possible to declare a variable in Gradle usable in Java?

Linked

How can I get System variable value in Java?



Setting active profile and config location from command line in Spring Boot



How can I access environment variables in Python?



Java system properties and environment variables



Proper usage of Java -D command-line parameters

