A brief overview of the config system helps clarify its different parts and how they work together. Most applications will typically deal with more than one of these parts.

The system reads configuration from a config source, a physical location (such as a file, a URL, or a String) which holds config data. Each config source works with a config parser which translates a particular text format (for example, Java properties or YAML) into an in-memory tree which represents the configuration’s structure and values. An optional polling strategy detects and publishes changes to the underlying config source so the config source itself or your application can respond.

Your application uses the Config object which results from building that in-memory tree to retrieve config data. The app can navigate explicitly among the nodes in the tree and fetch a node’s value

int pageSize = config
                .get("web")
                .get("page-size")
                .asInt()
                .orElse(20);

or it can address a node in the tree using the config key’s dotted name

int pageSize = config
                .get("web.page-size")
                .asInt()
                .orElse(20);

As part of retrieving a value from a node, the config system applies config filters which can change what values are returned for selected keys.

The Config object lets your application retrieve config data as a typed ConfigValue.

ConfigValue<T> can be used to obtain: * an Optional<T> value from a single node, * the T value from a single node interpreted as a basic Java type (primitive or simple object) already known to the config system (such as a boolean or a Double), or * a complex Java type from a subtree of the config tree.

+ The config system automatically knows how to return List and Map complex types, and you can provide config mappers to convert a config subtree to whatever Java types your application needs.

An easy way to start with the Config API is to follow these four steps:

1. add config-related dependencies to your pom.xml
2. revise your module-info.java to refer to config (if you are using Java 9)
3. create a simple config properties file
4. retrieve and use the default Config from your app

Add Maven Dependency on Config

<dependencies>
    <dependency>
        <groupId>io.helidon.config</groupId>
        <artifactId>helidon-config</artifactId>
        <version>version-of-config-you-are-using</version>
    </dependency>
</dependencies>

Update module-info.java

module myModule {
    requires io.helidon.config;
}

Create simple Config Properties File

greeting = Hello

web.debug = true
web.page-size = 20
web.ratio = 1.3

bl.initial-id = 10000000000

origin = props
java.home=homeFromProps # will be ignored

Write Code using the Default Config

import io.helidon.config.Config; 
...
Config config = Config.create(); 
System.out.println(String.format(
        "greeting is %s\n"
                + "web.debug is %b\n"
                + "web.page-size is %d\n"
                + "web.ratio is %f\n"
                + "bl.initial-id is %d\n"
                + "origin is %s\n"
                + "java.home is %s",
        config.get("greeting").asString().orElse("Default greeting"),  
        config.get("web.debug").asBoolean().orElse(false),
        config.get("web.page-size").asInt().orElse(50),
        config.get("web.ratio").asDouble().orElse(2.0),
        config.get("bl.initial-id").asLong().orElse(1L),
        config.get("origin").asString().orElse("defaults"),
        config.get("java.home").asString().get())); 

greeting is Hello
web.debug is true
web.page-size is 20
web.ratio is 1.300000
bl.initial-id is 10000000000
origin is props
java.home is /Library/Java/JavaVirtualMachines/jdk-10.0.1.jdk/Contents/Home