Kotlin and Spring Boot: Injecting Configuration Properties Using @Value

1. Overview

One common requirement in Spring Boot applications is to inject external configuration properties into Spring Beans. The @ConfigurationProperties annotation allows us to bind a set of configuration properties into a class. Alternatively, we can leverage the @Value annotation to inject arbitrary configuration properties into a Spring Bean.

In this quick tutorial, we’ll explore how to inject configuration properties using @Value.

2. Our YAML Configuration File

Let’s create a simple YAML file named application-inject-value.yml under src/main/resources as our application’s configuration:

my-app:
  magic-number: 42
  magic-string: "It's a magic string"
  magic-flag: true

  magic-string-with-default: "It's another magic string"

To make @PropertySource load our YAML configuration file, we create the YamlPropertySourceFactory class:

class YamlPropertySourceFactory : PropertySourceFactory {
    override fun createPropertySource(@Nullable name: String?, encodedResource: EncodedResource): PropertySource<*> =
      PropertiesPropertySource(encodedResource.resource.filename,
        YamlPropertiesFactoryBean().also { it.setResources(encodedResource.resource) }.getObject()
      )
}

Then, we can use the @PropertySource annotation to parse our YAML configuration:

@PropertySource(value = ["classpath:application-inject-value.yml"], factory = YamlPropertySourceFactory::class)
@SpringBootApplication(scanBasePackages = ["com.baeldung.theValueAnnotation"])
class KotlinValueInjectionApplication

Next, we’ll create a Spring component and inject configuration properties based on this YAML file.

3. Injecting Configuration Properties

When we work with @Value in Java, we can inject configuration property in this way: @Value(“${prop.name.from.config}”). 

In Kotlin, we adhere to a similar approach. However, due to Kotlin’s String template using ‘$‘ to reference variables or expressions, we must escape ‘$‘ within the @Value annotation. Now, let’s create a Spring component and inject several properties from our application-inject-value.yml:

@Component
class ValueBean(
  @Value("\${my-app.magic-number}")
  val magicNumber: Int,
  @Value("\${my-app.magic-string}")
  val magicString: String,
  @Value("\${my-app.magic-flag}")
  val magicFlag: Boolean,
)

As the ValueBean class shows, we applied the constructor injection approach to inject three configuration properties.

Next, we’ll verify whether these @Value annotations work as expected in a unit test. Let’s start with creating a test class:

@SpringBootTest
@TestConstructor(autowireMode = AutowireMode.ALL)
class TheValueAnnotationUnitTest(val valueBean: ValueBean) {
    ...
}

We used the @TestConstructor annotation to implement constructor injection for injecting the ValueBean Spring component within the test class. Subsequently, we can conduct verifications within a test function:

with(valueBean) {
    assertEquals(42, magicNumber)
    assertEquals("It's a magic string", magicString)
    assertTrue(magicFlag)
}

The test passes if we run it. That is, these three configuration properties have been injected into the ValueBean bean as expected.

4. @Value With Non-Null Default Values

Sometimes, we may wish to offer a default value for situations where a property might be absent in the configuration file. To accomplish this, we can adopt the @Value(“\${prop.name:defaultValue”) pattern.

Now, let’s extend our ValueBean component by injecting two new properties with default values:

@Component
class ValueBean(
  ... 
  // with default values
  @Value("\${my-app.not-defined-value:1024}")
  val magicNumberWithDefault: Int,
  @Value("\${my-app.magic-string-with-default:default Value}")
  val magicStringWithDefault: String,
}

In the code above, both @Value injections are with default values.

Looking at the configuration file, my-app.not-defined-value is absent, while my-app.magic-string-with-default is explicitly defined. As a result, the default value 1024 is applied to magicNumberWithDefault, and the specified value is injected into magicStringWithDefault:

with(valueBean) {
    assertEquals(1024, magicNumberWithDefault)
    assertEquals("It's another magic string", magicStringWithDefault)
}

5. @Value With null as the Default Value

We’ve learned how to set non-null values as defaults when using @Value injections. Occasionally, when a property is missing in configuration files, we might prefer to treat null as the default.

Let’s further extend ValueBean to cover this case:

@Component
class ValueBean(
  ...
  // with null as the default value
  @Value("\${my-app.not-defined-value:null}")
  val stringDefaultLiteralNull: String?,
  @Value("\${my-app.not-defined-value:#{null}}")
  val stringDefaultNull: String?
)

As Kotlin has nullable and non-nullable types, we must declare the fields nullable if we want their defaults to be null.

We can see that although both @Value attempt to inject non-existing properties and introduce defaults, one uses “prop.name:null”, and the other one employs “prop.name:#{null}“.

Next, let’s look at the outcome:

with(valueBean) {
    assertEquals("null", stringDefaultLiteralNull)
    assertNull(stringDefaultNull)
}

The test shows their difference clearly:

• prop.name:null – The literal String “null” is the default.
• prop.name:#{null} – The default value is null. Because #{null} is a Spring Expression (SpEL) that evaluates to null.

6. Conclusion

In this article, we explored using Spring’s @Value for injecting configuration properties in Kotlin, including how to introduce defaults for absent properties in the configuration file.

As always, the complete source code for the examples is available over on GitHub.