Back to Guides
Edit this Page

Mapping Configuration to Objects

With config mappings it is possible to group multiple configuration properties in a single interface that share the same prefix.

1. @ConfigMapping

A config mapping requires a public interface with minimal metadata configuration and annotated with the @io.smallrye.config.ConfigMapping annotation.

@ConfigMapping(prefix = "server")
public interface Server {
    String host();

    int port();
}

The Server interface is able to map configuration properties with the name server.host into the Server.host() method and server.port into Server.port() method. The configuration property name to look up is built from the prefix, and the method name with . (dot) as the separator.

If a mapping fails to match a configuration property a NoSuchElementException is thrown, unless the mapped element is an Optional.

1.1. Mapping Rules

A config mapping interface must obey the following rules:

  • A mapping method cannot accept parameters

  • A mapping method return type cannot be void

  • A mapping cannot use self-reference types

  • default methods are allowed

1.2. Registration

When a Quarkus application starts, a config mapping can be registered twice. One time for STATIC INIT and a second time for RUNTIME INIT:

1.2.1. STATIC INIT

Quarkus starts some of its services during static initialization, and Config is usually one of the first things that is created. In certain situations it may not be possible to correctly initialize a config mapping. For instance, if the mapping requires values from a custom ConfigSource. For this reason, any config mapping requires the annotation @io.quarkus.runtime.configuration.StaticInitSafe to mark the mapping as safe to be used at this stage. Learn more about registration of a custom ConfigSource.

1.2.1.1. Example
@StaticInitSafe
@ConfigMapping(prefix = "server")
public interface Server {
    String host();

    int port();
}

1.2.2. RUNTIME INIT

The RUNTIME INIT stage happens after STATIC INIT. There are no restrictions at this stage, and any config mapping is added to the Config instance as expected.

1.3. Retrieval

A config mapping interface can be injected into any CDI aware bean:

class BusinessBean {
    @Inject
    Server server;

    public void businessMethod() {
        String host = server.host();
    }
}

In non-CDI contexts, use the API io.smallrye.config.SmallRyeConfig#getConfigMapping to retrieve the config mapping instance:

SmallRyeConfig config = ConfigProvider.getConfig().unwrap(SmallRyeConfig.class);
Server server = config.getConfigMapping(Server.class);

1.4. Hierarchy

A config mapping can extend another mapping and inherit all its super members:

public interface Parent {
    String name();
}

@ConfigMapping(prefix = "child")
public interface Child extends Parent {

}

Members can also be overridden:

public interface Parent {
    String name();
}

@ConfigMapping(prefix = "child")
public interface Child extends Parent {
    @WithName("child-name")
    String name();
}

1.5. Nested groups

A nested mapping provides a way to subgroup other config properties:

@ConfigMapping(prefix = "server")
public interface Server {
    String host();

    int port();

    Log log();

    interface Log {
        boolean enabled();

        String suffix();

        boolean rotate();
    }
}
application.properties
server.host=localhost
server.port=8080
server.log.enabled=true
server.log.suffix=.log
server.log.rotate=false

The method name of a mapping group acts as sub-namespace to the configurations properties.

1.6. Overriding property names

1.6.1. @WithName

If a method name, or a property name do not match with each other, the @WithName annotation can override the method name mapping and use the name supplied in the annotation:

@ConfigMapping(prefix = "server")
public interface Server {
    @WithName("name")
    String host();

    int port();
}
application.properties
server.name=localhost
server.port=8080

1.6.2. @WithParentName

The @WithParentName annotation allows the configuration mapping property to inherit its container name, simplifying the configuration property name required to match the mapping:

@ConfigMapping(prefix = "server")
interface Server {
    @WithParentName
    ServerHostAndPort hostAndPort();

    @WithParentName
    ServerInfo info();
}

interface ServerHostAndPort {
    String host();

    int port();
}

interface ServerInfo {
    String name();
}
application.properties
server.host=localhost
server.port=8080
server.name=konoha

Without the @WithParentName the method name() requires the configuration property server.info.name. Because we use @WithParentName, the info() mapping will inherit the parent name from Server and name() maps to server.name instead.

1.6.3. namingStrategy

Method names in camelCase map to kebab-case property names:

@ConfigMapping(prefix = "server")
public interface Server {
    String theHost();

    int thePort();
}
application.properties
server.the-host=localhost
server.the-port=8080

The mapping strategy can be adjusted by setting namingStrategy value in the @ConfigMapping annotation:

@ConfigMapping(prefix = "server", namingStrategy = ConfigMapping.NamingStrategy.VERBATIM)
public interface ServerVerbatimNamingStrategy {
    String theHost();

    int thePort();
}
application.properties
server.theHost=localhost
server.thePort=8080

The @ConfigMapping annotation support the following naming strategies with the following enum values:

  • KEBAB_CASE (default) - The method name is derived by replacing case changes with a dash to map the configuration property, i.e. theHost maps to the-host.

  • VERBATIM - The method name is used as is to map the configuration property, i.e. theHost maps to theHost.

  • SNAKE_CASE - The method name is derived by replacing case changes with an underscore to map the configuration property, i.e. theHost maps to the_host.

1.6.4. beanStyleGetters

The beanStyleGetters attribute (default false) enables matching bean-style getter names (get/is prefixed) to their property name equivalent. For example, getHost() and isEnabled() map to the properties host and enabled respectively:

@ConfigMapping(prefix = "server", beanStyleGetters = true)
public interface Server {
    String getHost();

    int getPort();

    boolean isEnabled();
}
application.properties
server.host=localhost
server.port=8080
server.enabled=true
Bean-style getter matching allows multiple method names to match the same configuration name. For instance, getFoo and isFoo both match foo, which may not be intended. Prefer simple method names that match one-to-one with their configuration names.

1.7. Conversions

A config mapping class support automatic conversions of all types available for conversion in Config:

@ConfigMapping
public interface SomeTypes {
    @WithName("int")
    int intPrimitive();

    @WithName("int")
    Integer intWrapper();

    @WithName("long")
    long longPrimitive();

    @WithName("long")
    Long longWrapper();

    @WithName("float")
    float floatPrimitive();

    @WithName("float")
    Float floatWrapper();

    @WithName("double")
    double doublePrimitive();

    @WithName("double")
    Double doubleWrapper();

    @WithName("char")
    char charPrimitive();

    @WithName("char")
    Character charWrapper();

    @WithName("boolean")
    boolean booleanPrimitive();

    @WithName("boolean")
    Boolean booleanWrapper();
}
application.properties
int=9
long=9999999999
float=99.9
double=99.99
char=c
boolean=true

This is also valid for Optional and friends:

@ConfigMapping
public interface Optionals {
    Optional<Server> server();

    Optional<String> optional();

    @WithName("optional.int")
    OptionalInt optionalInt();

    interface Server {
        String host();

        int port();
    }
}

In this case, the mapping won’t fail if there is no configuration property to match the mapping.

1.7.1. @WithConverter

The @WithConverter annotation provides a way to set a Converter to use in a specific mapping:

@ConfigMapping
public interface Converters {
    @WithConverter(FooBarConverter.class)
    String foo();
}

public static class FooBarConverter implements Converter<String> {
    @Override
    public String convert(final String value) {
        return "bar";
    }
}
application.properties
foo=foo

A call to Converters.foo() results in the value bar.

1.7.2. Optionals

A mapping can wrap any complex type with an Optional. Optional mappings do not require the configuration path and value to be present, so no NoSuchElementException is thrown when the configuration property is missing.

1.7.3. Collections

A config mapping is also able to map collections types List and Set:

@ConfigMapping(prefix = "server")
public interface ServerCollections {
    Set<Environment> environments();

    interface Environment {
        String name();

        List<App> apps();

        interface App {
            String name();

            List<String> services();

            Optional<List<String>> databases();
        }
    }
}
application.properties
server.environments[0].name=dev
server.environments[0].apps[0].name=rest
server.environments[0].apps[0].services=bookstore,registration
server.environments[0].apps[0].databases=pg,h2
server.environments[0].apps[1].name=batch
server.environments[0].apps[1].services=stock,warehouse

The List or Set mappings can use indexed properties to map configuration values in mapping groups. For collection with simple element types like String, their configuration value is a comma separated string.

A List mapping is backed by an ArrayList, and a Set mapping is backed by a HashSet. Only the List mapping can maintain element order.

1.7.4. Maps

A config mapping is also able to map a Map:

@ConfigMapping(prefix = "server")
public interface Server {
    String host();

    int port();

    Map<String, String> form();

    Map<String, List<Alias>> aliases();

    interface Alias {
        String name();
    }
}
application.properties
server.host=localhost
server.port=8080
server.form.index=index.html
server.form.login.page=login.html
server.form.error.page=error.html
server.aliases.localhost[0].name=prod
server.aliases.localhost[1].name=127.0.0.1
server.aliases."io.quarkus"[0].name=quarkus

The configuration property needs to specify an additional segment to act as the map key. In this case the form() Map will contain three elements with the keys index, login.page and error.page.

Quotes are required around a Map key only when the key contains a dot (e.g. "io.quarkus"), because a dot would otherwise be interpreted as a path separator. For single-segment keys (no dots), quotes are optional.

Do not mix quoted and unquoted forms for the same Map key. For a key that spans a single segment, both server.aliases.localhost.name and server.aliases."localhost".name refer to the same key localhost, making it ambiguous. When SmallRye Config finds both forms it resolves the entry using the quoted form and logs a warning.

When both quoted and unquoted forms are found, only the quoted form is then used to look up values and; property names written in the unquoted form are left unmapped and the mapping may fail validation or yield unexpected values. If members of a nested group are split between the two forms, the unquoted members are not found and the mapping may fail validation or yield unexpected values.

Pick one form and use it consistently for a given key across all configuration sources.

It also works for groups:

@ConfigMapping(prefix = "server")
public interface Servers {
    @WithParentName
    Map<String, Server> allServers();
}

public interface Server {
    String host();

    int port();

    String login();

    String error();

    String landing();
}
application.properties
server."my-server".host=localhost
server."my-server".port=8080
server."my-server".login=login.html
server."my-server".error=error.html
server."my-server".landing=index.html

In this case the allServers() Map will contain one Server element with the key my-server.

1.7.5. @WithUnnamedKey

The @WithUnnamedKey annotation allows omitting a single map key in the configuration path:

@ConfigMapping(prefix = "server")
public interface Server {
    @WithUnnamedKey("localhost")
    Map<String, Alias> aliases();

    interface Alias {
        String name();
    }
}
application.properties
server.aliases.name=localhost
server.aliases.prod.name=prod

The server.aliases.name property is unnamed because it does not contain the map key segment. Due to @WithUnnamedKey("localhost"), the key localhost is used automatically when the map key is absent.

Server server = config.getConfigMapping(Server.class);
Alias localhost = server.aliases().get("localhost");
Alias prod = server.aliases().get("prod");

If the unnamed key is also explicitly set in a property name (e.g. server.aliases.localhost.name=explicit), the explicit value takes precedence over the unnamed entry.

The eager attribute (default true) controls whether the unnamed key entry is included when its values come only from defaults. When eager = false, the entry is excluded from the Map unless at least one value is explicitly set in a configuration source.

1.7.6. @WithKeys

The @WithKeys annotation defines which Map keys must be loaded by the configuration, instead of discovering keys from Config#getPropertyNames. This is useful when the ConfigSource does not enumerate its properties:

@ConfigMapping(prefix = "server")
public interface Server {
    @WithKeys(KeysProvider.class)
    Map<String, Alias> aliases();

    interface Alias {
        String name();
    }

    class KeysProvider implements Supplier<Iterable<String>> {
        @Override
        public Iterable<String> get() {
            return List.of("dev", "test", "prod");
        }
    }
}

Each key must exist in the final configuration relative to the Map path segment, or the mapping will fail with a ConfigValidationException.

1.7.7. @WithDefaults

The @WithDefaults marker annotation on a Map returns the default value for the value element on any key lookup:

@ConfigMapping(prefix = "server")
public interface Server {
    @WithDefaults
    Map<String, Alias> aliases();

    interface Alias {
        @WithDefault("localhost")
        String name();
    }
}
application.properties
server.aliases.prod.name=prod

A lookup with the key localhost, any, or any other key returns an Alias instance populated from @WithDefault values. A lookup with prod returns an Alias instance with name=prod because the property is defined in the configuration. The Map can only iterate and size explicitly defined keys — in this case only prod.

Server server = config.getConfigMapping(Server.class);
Alias localhost = server.aliases().get("localhost");    (1)
Alias any = server.aliases().get("any");                (2)
Alias prod = server.aliases().get("prod");              (3)
1 Calling localhost.name() returns localhost
2 Calling any.name() also returns localhost, since it is the default
3 Calling prod.name() return prod, since it is the value defined in the configuration file

1.8. Defaults

The @WithDefault annotation allows to set a default property into a mapping (and prevent and error if the configuration value is not available in any ConfigSource):

public interface Defaults {
    @WithDefault("foo")
    String foo();

    @WithDefault("bar")
    String bar();
}

No configuration properties required. The Defaults.foo() will return the value foo and Defaults.bar() will return the value bar.

1.9. Secrets

A mapping can mark a member as a secret with Secret<T>:

@ConfigMapping(prefix = "credentials")
public interface Credentials {
    String username();

    Secret<String> password();
}

A Secret value modifies the behavior of the Config system by:

  • Omitting the name of the secret from Config#getPropertyNames()

  • Omitting the name and value of the secret from the mapping toString output

  • Throwing a SecurityException when trying to retrieve the value via the Config programmatic API

A Secret can be of any type that can be converted by a registered org.eclipse.microprofile.config.spi.Converter of the same type.

1.10. toString, equals, hashCode

If the config mapping contains a toString method declaration, the config mapping instance will include a proper implementation of the toString method. The equals and hashCode methods are included automatically.

Do not include a toString declaration in a config mapping with sensitive information.

1.11. Validation

A config mapping may combine annotations from Bean Validation to validate configuration values:

@ConfigMapping(prefix = "server")
public interface Server {
    @Size(min = 2, max = 20)
    String host();

    @Max(10000)
    int port();
}

The application startup fails with a io.smallrye.config.ConfigValidationException if the configuration property values do not follow the constraints defined in Server.

For validation to work, the quarkus-hibernate-validator extension is required, and it is performed automatically.

1.12. Mocking

A mapping interface implementation is not a proxy, so it cannot be mocked directly with @InjectMock like other CDI beans. One trick is to make it proxyable with a producer method:

public class ServerMockProducer {
    @Inject
    Config config;

    @Produces
    @ApplicationScoped
    @io.quarkus.test.Mock
    Server server() {
        return config.unwrap(SmallRyeConfig.class).getConfigMapping(Server.class);
    }
}

The Server can be injected as a mock into a Quarkus test class with @InjectMock:

@QuarkusTest
class ServerMockTest {
    @InjectMock
    Server server;

    @Test
    void localhost() {
        Mockito.when(server.host()).thenReturn("localhost");
        assertEquals("localhost", server.host());
    }
}
The mock is just an empty shell without any actual configuration values.

If the goal is to only mock certain configuration values and retain the original configuration, the mocking instance requires a spy:

@ConfigMapping(prefix = "app")
@Unremovable
public interface AppConfig {
    @WithDefault("app")
    String name();

    Info info();

    interface Info {
        @WithDefault("alias")
        String alias();
        @WithDefault("10")
        Integer count();
    }
}

public static class AppConfigProducer {
    @Inject
    Config config;

    @Produces
    @ApplicationScoped
    @io.quarkus.test.Mock
    AppConfig appConfig() {
        AppConfig appConfig = config.unwrap(SmallRyeConfig.class).getConfigMapping(AppConfig.class);
        AppConfig appConfigSpy = Mockito.spy(appConfig);
        AppConfig.Info infoSpy = Mockito.spy(appConfig.info());
        Mockito.when(appConfigSpy.info()).thenReturn(infoSpy);
        return appConfigSpy;
    }
}

The AppConfig can be injected as a mock into a Quarkus test class with @Inject:

@QuarkusTest
class AppConfigTest {
    @Inject
    AppConfig appConfig;

    @Test
    void localhost() {
        Mockito.when(appConfig.name()).thenReturn("mocked-app");
        assertEquals("mocked-app", server.host());

        Mockito.when(appConfig.info().alias()).thenReturn("mocked-alias");
        assertEquals("mocked-alias", server.info().alias());
    }
}
Nested elements need to be spied individually by Mockito.

2. ConfigInstanceBuilder

With the io.smallrye.config.ConfigInstanceBuilder API, it is possible to create instances of a config mapping interface programmatically, without requiring a SmallRyeConfig instance or any configuration source. This is particularly useful for testing, providing default configurations, or any scenario where configuration values are known ahead of time.

The configuration interface does not need the @ConfigMapping annotation to work with the builder. Any valid configuration interface is accepted.

2.1. Usage

A configuration interface instance is created with ConfigInstanceBuilder.forInterface():

interface Server {
    String host();

    int port();
}

Server server = ConfigInstanceBuilder.forInterface(Server.class)
        .with(Server::host, "localhost")
        .with(Server::port, 8080)
        .build();

The builder uses method references to identify which property to set, providing compile-time type safety without string-based property names.

2.2. Primitive Types

The builder provides dedicated with() overloads for int, long, double, and boolean. Other primitive types (byte, short, float, char) use the generic with() method with their boxed types:

@ConfigMapping
interface Primitives {
    int intValue();

    boolean booleanValue();

    byte byteValue();
}

Primitives primitives = ConfigInstanceBuilder.forInterface(Primitives.class)
        .with(Primitives::intValue, 42)
        .with(Primitives::booleanValue, true)
        .with(Primitives::byteValue, Byte.valueOf((byte) 1))
        .build();

2.3. Optional Properties

The withOptional() method sets Optional properties. If an optional property is not set, it defaults to empty:

interface AppConfig {
    Optional<String> name();

    OptionalInt timeout();
}

AppConfig config = ConfigInstanceBuilder.forInterface(AppConfig.class)
        .withOptional(AppConfig::name, "MyApp")
        .withOptional(AppConfig::timeout, 30)
        .build();

The withOptional method wraps the value in Optional.of(), OptionalInt.of(), OptionalLong.of(), or OptionalDouble.of() depending on the property type.

2.4. Defaults

Properties annotated with @WithDefault are automatically applied when no value is explicitly set in the builder:

interface ServerDefaults {
    @WithDefault("localhost")
    String host();

    @WithDefault("8080")
    int port();
}

ServerDefaults server = ConfigInstanceBuilder.forInterface(ServerDefaults.class).build(); (1)
1 Both host() and port() return their @WithDefault values

Explicitly set values override the @WithDefault annotation:

ServerDefaults server = ConfigInstanceBuilder.forInterface(ServerDefaults.class)
        .with(ServerDefaults::host, "0.0.0.0")
        .build(); (1)
1 Now, host() returns 0.0.0.0 and, port() returns 8080 from @WithDefault

2.5. Nested Groups

Nested configuration groups are built separately and composed into the parent builder:

interface AppConfig {
    String name();

    DatabaseConfig database();
}

interface DatabaseConfig {
    String url();

    int poolSize();
}

AppConfig config = ConfigInstanceBuilder.forInterface(AppConfig.class)
        .with(AppConfig::name, "MyApp")
        .with(AppConfig::database, ConfigInstanceBuilder.forInterface(DatabaseConfig.class)
                .with(DatabaseConfig::url, "jdbc:h2:mem:test")
                .with(DatabaseConfig::poolSize, 10)
                .build())
        .build();
If a nested group has @WithDefault values for all its members, the nested group instance is automatically built with those defaults when not explicitly set in the parent builder.

2.6. Collections and Maps

List, Set, and Map types are set directly with their values:

interface AppConfig {
    List<String> hosts();

    Map<String, String> labels();
}

AppConfig config = ConfigInstanceBuilder.forInterface(AppConfig.class)
        .with(AppConfig::hosts, List.of("host1", "host2"))
        .with(AppConfig::labels, Map.of("env", "prod", "region", "us-east"))
        .build();

2.7. Required Properties

Properties without a @WithDefault are considered required. Calling build() throws a NoSuchElementException if any required property is not set:

interface Server {
    String host();

    @WithDefault("8080")
    int port();
}

Server fails = ConfigInstanceBuilder.forInterface(Server.class)
        .build(); (1)

Server works = ConfigInstanceBuilder.forInterface(Server.class)
        .with(Server::host, "localhost")
        .build(); (2)
1 - Throws a NoSuchElementException, the host is required but not set
2 - Works as expected since the host value is now provided

2.8. Builder Reuse

A builder instance can be used to produce multiple independent instances. Each build() call creates a new object:

ConfigInstanceBuilder<Server> builder = ConfigInstanceBuilder.forInterface(Server.class)
        .with(Server::host, "localhost")
        .with(Server::port, 8080);

Server first = builder.build();
Server second = builder.build();
boolean equals = first.equals(second); (1)
1 first and second are equal but not the same object

Quarkus is open. All dependencies of this project are available under the Apache Software License 2.0 or compatible license. CC by 3.0

This website was built with Roq on Quarkus, is hosted on GitHub Pages and is completely open source. If you want to make it better, fork the website and show us what you’ve got.

Navigation
Follow Us
Get Help
Languages
Quarkus is made of community projects
Copyright © Quarkus. All rights reserved. For details on our trademarks, please visit our Trademark Policy and Trademark List. Trademarks of third parties are owned by their respective holders and their mention here does not suggest any endorsement or association.