Fork me on GitHub

Basic usage

The approach used by OWNER APIs, is to define a Java interface associated to a properties file.

Suppose your properties file is defined as ServerConfig.properties:

port=80
hostname=foobar.com
maxThreads=100

To access this properties file you need to define a convenient Java interface ServerConfig.java in the same package:

import org.aeonbits.owner.Config;

public interface ServerConfig extends Config {
    int port();
    String hostname();
    @DefaultValue("42")
    int maxThreads();
}

Notice that the above interface extends from Config, that is a marker interface recognized by OWNER as valid to work with.

We'll call this interface the Properties Mapping Interface or just Mapping Interface since its goal is to map Properties into a an easy to use piece of code.

How does the mapping work?

Since the properties file does have the same name as the Java class, and they are located in the same package, the OWNER API will be able to automatically associate them.
For instance, if your mapping interface is called com.foo.bar.ServerConfig, OWNER will try to associate it to com.foo.bar.ServerConfig.properties, loading from the classpath.

The properties names defined in the properties file will be associated to the methods in the Java class having the same name.
For instance, the property port defined in the properties file will be associated to the method int port() in the Java class, the property hostname will be associated to the method String hostname() and the appropriate type conversion will apply automatically, so the method port() will return an int while the method hostname() will return a Java string, since the interface is defined in this way.

The mapping mechanism is fully customizable, as well the automatic type conversion we just introduced is flexible enough to cover most of the Java types as well as object types defined by the user.
You can see how in the next chapters.

Using the Config object

At this point, you can create the ServerConfig object and use it in your code:

ServerConfig cfg = ConfigFactory.create(ServerConfig.class);
System.out.println("Server " + cfg.hostname() + ":" + cfg.port() +
                   " will run " + cfg.maxThreads());

Using @DefaultValue and @Key annotations

Did you notice that in the above example it is specified @DefaultValue("42") annotation?

public interface ServerConfig extends Config {
    int port();
    String hostname();
    @DefaultValue("42")    // here!!!
    int maxThreads();
}

It is used in case the maxThread key is missing from the properties file.

This annotation gets automatically converted to int, since maxThreads() returns an int.

Using the annotations, you can also customize the property keys:

# Example of property file 'ServerConfig.properties'
server.http.port=80
server.host.name=foobar.com
server.max.threads=100

This time, as commonly happens in Java applications, the properties names are separated by dots. Instead of just "port" we have "server.http.port", so we need to map this property name to the associated method using the @Key annotation.

/*
 * Example of ServerConfig.java interface mapping the previous 
 * properties file.
 */
public interface ServerConfig extends Config {
    @Key("server.http.port")
    int port();

    @Key("server.host.name")
    String hostname();

    @Key("server.max.threads");
    @DefaultValue("42")
    int maxThreads();
}

The @DefaultValue and @Key annotations are the basics to start using the OWNER API.

You can leave the properties file away during development!

During the development you may decide to just use the `@DefaultValue` to provide a default configuration, without really adding the properties file. You can add the properties file later or leave this task to the end user.

Undefined properties

Suppose you have defined a method in your mapping interface that cannot be resolved to any property loaded from a properties file, and this method doesn't define a @DefaultValue what happens? Simple: it will return null, or a NullPointerException;

Suppose our ServerConfig class was looking like this:

public static interface ServerConfig extends Config {
    String hostname();
    int port();
    Boolean debugEnabled();
}

If we don't have any ServerConfig.properties associated to it, when we call the method String hostname() it will return null, as well as when we call the method Boolean debugEnabled() since the return types String and Boolean are java objects. But if we call the method int port() then a NullPointerException will be raised.

You don't want the NullPointerException?

If you don't want to get the NullPointerException, you can just define a default value. For instance, you can set @DefaultValue("0") for an int return type, or a @DefaultValue("false") for a boolean return type, and so on...

Conclusions

Now you know the minimum to get productive with the OWNER API. But this is just the beginning. OWNER is a rich API that allows you to add additional behaviors and have more interesting features, so that you should be able to use this library virtually in any other context where you where using the java.util.Properties class.