To support the ability for a builder style class to be populated with configuration values, the annotation can be used. ConfigurationBuilder can be added to a field or method in a class annotated with .

Since there is no consistent way to define builders in the Java world, one or more method prefixes can be specified in the annotation to support builder methods like or setXxx. If the builder methods have no prefix, assign an empty string to the parameter.

For example:

import io.micronaut.context.annotation.ConfigurationBuilder
import io.micronaut.context.annotation.ConfigurationProperties
@ConfigurationProperties('my.engine') (1)
class EngineConfig {
    @ConfigurationBuilder(prefixes = "with") (2)
    EngineImpl.Builder builder = EngineImpl.builder()
    @ConfigurationBuilder(prefixes = "with", configurationPrefix = "crank-shaft") (3)
    CrankShaft.Builder crankShaft = CrankShaft.builder()
    SparkPlug.Builder sparkPlug = SparkPlug.builder()
    @ConfigurationBuilder(prefixes = "with", configurationPrefix = "spark-plug") (4)
    void setSparkPlug(SparkPlug.Builder sparkPlug) {
        this.sparkPlug = sparkPlug
    }
}

import io.micronaut.context.annotation.ConfigurationBuilder
import io.micronaut.context.annotation.ConfigurationProperties
@ConfigurationProperties("my.engine") (1)
internal class EngineConfig {
    @ConfigurationBuilder(prefixes = ["with"])  (2)
    val builder = EngineImpl.builder()
    @set:ConfigurationBuilder(prefixes = ["with"], configurationPrefix = "spark-plug") (4)
    var sparkPlug = SparkPlug.builder()
}

Just like in the previous example, we can construct an EngineImpl. Since we are using a builder, a factory class can be used to build the engine from the builder.

import io.micronaut.context.annotation.Factory
import javax.inject.Singleton
@Factory
class EngineFactory {
    @Singleton
    EngineImpl buildEngine(EngineConfig engineConfig) {
        engineConfig.builder.build(engineConfig.crankShaft, engineConfig.sparkPlug)
    }
}

import io.micronaut.context.annotation.Factory
import javax.inject.Singleton
@Factory
internal class EngineFactory {
    @Singleton
    fun buildEngine(engineConfig: EngineConfig): EngineImpl {
        return engineConfig.builder.build(engineConfig.crankShaft, engineConfig.sparkPlug)

Configuration values can be supplied from one of the PropertySource instances. For example:

        ApplicationContext applicationContext = ApplicationContext.run(
                ['my.engine.cylinders'             : '4',
                 'my.engine.manufacturer'          : 'Subaru',
                 'my.engine.crank-shaft.rod-length': 4,
                 'my.engine.spark-plug.name'       : '6619 LFR6AIX',
                 'my.engine.spark-plug.type'       : 'Iridium',
                 'my.engine.spark-plug.companyName': 'NGK'
                ],
                "test"
        )
        Vehicle vehicle = applicationContext
                .getBean(Vehicle)
        println(vehicle.start())

        val applicationContext = ApplicationContext.run(
                mapOf(
                        "my.engine.cylinders" to "4",
                        "my.engine.manufacturer" to "Subaru",
                        "my.engine.crank-shaft.rod-length" to 4,
                        "my.engine.spark-plug.name" to "6619 LFR6AIX",
                        "my.engine.spark-plug.type" to "Iridium",
                        "my.engine.spark-plug.company" to "NGK"
                ),
                "test"
        )
        val vehicle = applicationContext.getBean(Vehicle::class.java)

The above example prints: