Groovy / Maven

@Configuration and @ConfigurationBuilder

Learn how to use @Configuration and @ConfigurationBuilder annotations to configure declared properties.

Nirav Assar

On this guide

In this section

Getting Started

In this guide, we will create a Micronaut application written in Groovy.

In this guide, you will learn how to use the annotations @ConfigurationProperties, @ConfigurationBuilder, and @EachProperty to consume configured properties in a Micronaut application. These annotations allow declared values to be injected into a bean for use in the application.

What you will need

To complete this guide, you will need the following:

Some time on your hands
A decent text editor or IDE (e.g. IntelliJ IDEA)
JDK 21 or greater installed with JAVA_HOME configured appropriately

Solution

We recommend that you follow the instructions in the next sections and create the application step by step. However, you can go right to the completed example.

Download and unzip the source

Writing the Application

Create an application using the Micronaut Command Line Interface or with Micronaut Launch.

mn create-app example.micronaut.micronautguide \
    --features=serialization-jackson \
    --build=maven \
    --lang=groovy \
    --test=spock

Note	If you don’t specify the `--build` argument, Gradle with the Kotlin DSL is used as the build tool. If you don’t specify the `--lang` argument, Java is used as the language. If you don’t specify the `--test` argument, JUnit is used for Java and Kotlin, and Spock is used for Groovy.

The previous command creates a Micronaut application with the default package example.micronaut in a directory named micronautguide.

If you use Micronaut Launch, select Micronaut Application as application type and add serialization-jackson features.

Note	If you have an existing Micronaut application and want to add the functionality described here, you can view the dependency and configuration changes from the specified features, and apply those changes to your application.

Diff

Setup IntelliJ IDEA to develop Micronaut Applications.

Team Configuration with @ConfigurationProperties

Imagine a feature where you can configure a sports team in a declarative manner. The team has a few attributes like team name, color, and players.

src/main/resources/application.properties

team.name=Steelers
team.color=Black
team.player-names[0]=Mason Rudolph
team.player-names[1]=James Connor

With Micronaut Framework, you can use the @ConfigurationProperties annotation to bind the configuration into a bean. Each property that matches the configuration in application.properties will call the setter in the bean. The bean will then be available for injection in the application.

Note	Empty tag `gettersandsetters` in `groovy/src/main/groovy/example/micronaut/TeamConfiguration.groovy`.

Test @ConfigurationProperties

Let’s validate that the bean is available in the application context and is created with the values declared in the application.properties.

groovy/src/test/groovy/example/micronaut/TeamConfigurationSpec.groovy

void "test team configuration"() {
    given:
    ApplicationContext ctx = ApplicationContext.run(ApplicationContext, [ // 
            "team.name": 'evolution',
            "team.color": 'green',
            "team.player-names": ['Nirav Assar', 'Lionel Messi']
    ])

    when:
    TeamConfiguration teamConfiguration = ctx.getBean(TeamConfiguration)

    then:
    teamConfiguration.name == "evolution"
    teamConfiguration.color == "green"
    teamConfiguration.playerNames[0] == "Nirav Assar"
    teamConfiguration.playerNames[1] == "Lionel Messi"

    cleanup:
    ctx.close()
}

1	Set up configuration properties for the test to use

Team Admin Builder with @ConfigurationBuilder

The Builder pattern is a great way to build configuration objects incrementally. Read about the Builder pattern in this DZone article to learn more. Micronaut Framework supports the Builder pattern with @ConfigurationBuilder.

Suppose you want to add team administrators to a team. The team administration is composed by using a builder pattern object. You can add a coach, manager, and president to the team.

src/main/resources/application.properties

team.name=Steelers
team.color=Black
team.player-names[0]=Mason Rudolph
team.player-names[1]=James Connor
team.team-admin.manager=Nirav Assar 
team.team-admin.coach=Mike Tomlin
team.team-admin.president=Dan Rooney

1	The `manager` property is an example of an element that will be built.

The TeamAdmin object abides by the Builder pattern.

groovy/src/main/groovy/example/micronaut/TeamAdmin.groovy

package example.micronaut

import groovy.transform.CompileStatic

@CompileStatic
class TeamAdmin { // 

    String manager
    String coach
    String president

    // should use the builder pattern to create the object
    private TeamAdmin() {
    }

    static Builder builder() {
        return new Builder()
    }

    static class Builder { // 
        String manager
        String coach
        String president

        // 
        Builder withManager(String manager) {
            this.manager = manager
            this
        }

        Builder withCoach(String coach) {
            this.coach = coach
            this
        }

        Builder withPresident(String president) {
            this.president = president
            this
        }

        TeamAdmin build() { // 
            TeamAdmin teamAdmin = new TeamAdmin()
            teamAdmin.manager = this.manager
            teamAdmin.coach = this.coach
            teamAdmin.president = this.president
            teamAdmin
        }
    }
}

1	`TeamAdmin` is the configuration object that consumes the declared properties.
2	The builder object is used to incrementally construct the object.
3	An example of a builder method, where an attribute is set and then the builder itself is returned.
4	The final `build()` method creates the `TeamAdmin` object.

At the bottom of TeamConfiguration, add the inner class TeamAdmin.Builder and annotate it with @ConfigurationBuilder. This tells Micronaut Framework that configuration can be read and an object can be constructed using the Builder pattern.

Note	The builder is used only here, so call `builder.build()` later to get the `TeamAdmin` object. In this guide, the JUnit test calls `builder.build()`.

groovy/src/main/groovy/example/micronaut/TeamConfiguration.groovy

package example.micronaut

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;

import io.micronaut.context.annotation.ConfigurationBuilder
import io.micronaut.context.annotation.ConfigurationProperties
import io.micronaut.serde.annotation.Serdeable

@Serdeable // 
@JsonIgnoreProperties("builder") // 
@ConfigurationProperties("team")
class TeamConfiguration {
    String name
    String color
    List<String> playerNames

    @ConfigurationBuilder(prefixes = "with", configurationPrefix = "team-admin") // 
    TeamAdmin.Builder builder = TeamAdmin.builder() // 
}

1	Declare the `@Serdeable` annotation at the type level in your source code to allow the type to be serialized or deserialized.
2	Mark the builder as being ignored during serialization.
3	`prefixes` tells Micronaut Framework to find methods that are prefixed by `with`; `configurationPrefix` allows the developer to customize the `application.properties` element.
4	Instantiate the builder object so it can be populated with configuration values.

Test @ConfigurationBuilder

Validate that @ConfigurationBuilder is applied properly with the following JUnit test. The test format is similar to previous tests.

groovy/src/test/groovy/example/micronaut/TeamConfigurationSpec.groovy

void "test team configuration admin configuration builder "() {
    given:
    ApplicationContext ctx = ApplicationContext.run(ApplicationContext, [
            "team.name": 'evolution',
            "team.color": 'green',
            "team.player-names": ['Nirav Assar', 'Lionel Messi'],
            "team.team-admin.manager": "Jerry Jones", // 
            "team.team-admin.coach": "Tommy O'Neill",
            "team.team-admin.president": "Mark Scanell"
    ])

    when:
    TeamConfiguration teamConfiguration = ctx.getBean(TeamConfiguration)
    TeamAdmin teamAdmin = teamConfiguration.builder.build() // 

    then:
    teamConfiguration.name == "evolution"
    teamConfiguration.color == "green"
    teamConfiguration.playerNames[0] == "Nirav Assar"
    teamConfiguration.playerNames[1] == "Lionel Messi"

    // check the builder has values set
    teamConfiguration.builder.manager == "Jerry Jones"
    teamConfiguration.builder.coach == "Tommy O'Neill"
    teamConfiguration.builder.president == "Mark Scanell"

    // check the object can be built
    teamAdmin.manager == "Jerry Jones" // 
    teamAdmin.coach == "Tommy O'Neill"
    teamAdmin.president == "Mark Scanell"

    cleanup:
    ctx.close()
}

1	Properties that will invoke the builder methods on `TeamAdmin.Builder`.
2	The builder object is now configured, so run `build()` on it to create the `TeamAdmin` object.
3	Verify the object is created with the `application.properties` properties.

Stadiums with @EachProperty

Micronaut Framework is also able to read a list of related configurations. Imagine you would like to declare stadiums and their attributes.

src/main/resources/application.properties

stadium.coors.city=Denver 
stadium.coors.size=50000
stadium.pnc.city=Pittsburgh
stadium.pnc.size=35000

1	This element will be the name of the bean. It must be lower kebab-case.

You can use @EachProperty to cycle through the configuration and read each nested clause as a bean. The higher-level property will be parameterized as the name.

groovy/src/main/groovy/example/micronaut/StadiumConfiguration.groovy

package example.micronaut

import io.micronaut.context.annotation.EachProperty
import io.micronaut.context.annotation.Parameter
import io.micronaut.serde.annotation.Serdeable

@Serdeable // 
@EachProperty("stadium") // 
class StadiumConfiguration {
    String name // 
    String city
    Integer size

    StadiumConfiguration(@Parameter String name) { // 
        this.name = name
    }

}

1	Declare the `@Serdeable` annotation at the type level in your source code to allow the type to be serialized or deserialized.
2	Establish the top layer of configuration.
3	`name` is read from the property key and sent as a parameter to the bean.

Test @EachProperty

Validate the configuration with a test. Notice multiple beans are created from the configuration. In a controller, you can inject a particular StadiumConfiguration instance bean by using the @Named parameter with a qualifier name.

groovy/src/test/groovy/example/micronaut/StadiumConfigurationSpec.groovy

package example.micronaut

import example.micronaut.StadiumConfiguration
import io.micronaut.context.ApplicationContext
import io.micronaut.inject.qualifiers.Qualifiers
import spock.lang.Specification

class StadiumConfigurationSpec extends Specification {

    void "test stadium configuration"() {
        given:
        ApplicationContext ctx = ApplicationContext.run(ApplicationContext, [
                "stadium.fenway.city": 'Boston', // 
                "stadium.fenway.size": 60000,
                "stadium.wrigley.city": 'Chicago',
                "stadium.wrigley.size": 45000
        ])

        when:
        // 
        StadiumConfiguration fenwayConfiguration = ctx.getBean(StadiumConfiguration, Qualifiers.byName("fenway"))
        StadiumConfiguration wrigleyConfiguration = ctx.getBean(StadiumConfiguration, Qualifiers.byName("wrigley"))

        then:
        fenwayConfiguration.name == "fenway"
        fenwayConfiguration.size == 60000
        wrigleyConfiguration.name == "wrigley"
        wrigleyConfiguration.size == 45000

        cleanup:
        ctx.close()
    }
}

1	Multiple configurations can be declared for the same class.
2	Since there are multiple beans, a `Qualifier` must be sent to retrieve a bean.

Running the Application

To run the application, use the ./mvnw mn:run command, which starts the application on port 8080.

Controller

Configuration beans can be injected into the application just like any other beans. As a demonstration, create a controller where the beans are constructor injected. The StadiumConfiguration class has two instances, so for injection you need to use the @Named annotation with a qualifier name to specify the bean.

groovy/src/main/groovy/example/micronaut/MyController.groovy

package example.micronaut

import groovy.transform.CompileStatic
import io.micronaut.http.annotation.Controller
import io.micronaut.http.annotation.Get

import jakarta.inject.Named

@CompileStatic
@Controller("/my")
class MyController {

    TeamConfiguration teamConfiguration
    StadiumConfiguration stadiumConfiguration

    MyController(TeamConfiguration teamConfiguration,
                 @Named("pnc") StadiumConfiguration stadiumConfiguration) { // 
        this.teamConfiguration = teamConfiguration
        this.stadiumConfiguration = stadiumConfiguration
    }

    @Get("/team")
    TeamConfiguration team() {
        this.teamConfiguration
    }

    @Get("/stadium")
    StadiumConfiguration stadium() {
        this.stadiumConfiguration
    }
}

1	Injection of configuration beans; `@Named` annotation is needed to choose which `StadiumConfiguration` instance is retrieved.

Note	In the browser go to http://localhost:8080/my/team and http://localhost:8080/my/stadium.

Add test:

groovy/src/test/groovy/example/micronaut/MyControllerSpec.groovy

package example.micronaut

import io.micronaut.http.HttpRequest
import io.micronaut.http.client.HttpClient
import io.micronaut.http.client.annotation.Client
import io.micronaut.test.extensions.spock.annotation.MicronautTest
import spock.lang.Specification

import jakarta.inject.Inject

@MicronautTest
class MyControllerSpec extends Specification {

    @Inject
    @Client("/")
    HttpClient client

    void 'test my team'() {
        when:
        TeamConfiguration teamConfiguration = client.toBlocking().retrieve(HttpRequest.GET("/my/team"), TeamConfiguration)

        then:
        teamConfiguration.name == 'Steelers'
        teamConfiguration.color == 'Black'

        and:
        teamConfiguration.playerNames.size() == 2
        teamConfiguration.playerNames == ['Mason Rudolph', 'James Connor']
    }
}

Next Steps

Visit Micronaut Application Configuration to learn more.

Help with the Micronaut Framework

The Micronaut Foundation sponsored the creation of this Guide. A variety of consulting and support services are available.

License

Note	All guides are released with an Apache License 2.0 for the code and a Creative Commons Attribution 4.0 license for the writing and media (images).