Externalized Configuration with Spring Boot

For externalized configurations, Spring Boot supports file formats such as YAML and the .properties file.

While properties file works with @PropertySource annotation, YAML does not. While we can configure more than one Spring profiles per properties file, we can have any with YAML files.

 

@ConfigurationProperties

The annotation @ConfigurationProperties can turn your application properties into type safe POJOs, and then Spring can do the binding and injection part. You will need to annotate a class with @ConfigurationProperties and define the properties along with setters and getters. Maps and collections can be extended with only a getter, whereas arrays will require a setter. You can either annotate this class with @Component or add this class to the configuration using @EnableConfigurationProperties. Now you can autowire the config class in other components using @Inject annotation.

You can validate your configuration properties using JSR 303 annotations such as @NotNull, @Pattern, @Max, @Min, @Digits etc. @ConfigurationProperties can be used to configure your beans as well as third party beans.

 

Configuration Metadata

Spring Boot jars are shipped with meta-data files that provide details of all supported configuration properties. The files are designed to allow IDE developers to offer contextual help and “code completion” as users are working with application.properties or application.yml files.

You can generate your own configuration meta-data file from items annotated with @ConfigurationProperties by using the spring-boot-configuration-processor jar. Read more here.

Spring boot uses relaxed names for configuration properties. For instance, feature-enabled or FEATURE_ENABLED will be matched to featureEnabled.

 

Order of resolution of configuration options

Spring Boot provides cascading resolution of configuration.

Order of resolution is as follows:

  1. command line arguments (prefix any property with a double dash),  

  2. embedded JSON in SPRING_APPLICATION_JSON environment variable,

  3. StandardServletEnvironment,

    1. StandardServletEnvironment implementation is a hierarchy within itself and looks in following in order:

      1. ServletConfig init parameters,

      2. ServletContext init parameters,

      3. JNDI attributes,

      4. System.getProperties(),

      5. OS environment variables.

  4. RandomValuePropertySource,

  5. application.properties/application.yml (variants),  

    1. In case of application.properties/application.yml variants, first profile specific files (e.g. application-{profile}.properties) and then the generic application.properties/application.yml.

  6. @PropertySource,

  7. Default Properties.

    1. The default properties can be set in the main class using SpringApplication.setDefaultProperties().

References and notes: 

YAML is a human friendly data serialization standard, which is mainly made for configuration files. YAML stands for YAML Ain't Markup Language.

YAML supports Maps, lists and scalar types. YAML is hierarchical and may use consistent spaces to denote hierarchy. It will also support inline maps.

Properties file is mainly used with Java, supports only String types and is non-hierarchical.

In Properties file, we can have maps by denoting hierarchies as dots.

Search the Web

Custom Search

Searches whole web. Use the search in the right sidebar to search only within javajee.com!!!