Mastering Spring’s @ConfigurationProperties and @PropertySources for Clean Config Management

1. Introduction

In modern software development, configuration management is essential. Spring provides powerful annotations @ConfigurationProperties and @PropertySources to simplify handling of configuration data.

2. What are @ConfigurationProperties and @PropertySources

@ConfigurationProperties

binds external properties to a Java bean, typically used with @Configuration or @Component. Example:

@Configuration
@ConfigurationProperties(prefix = "myapp")
public class MyAppProperties {
    private String name;
    private String version;
    // getters and setters
}

@PropertySources

(plural) allows specifying multiple property sources in a Spring application. It works similarly to @PropertySource but can list several files.

@Configuration
@PropertySources({
    @PropertySource("classpath:application.properties"),
    @PropertySource("classpath:custom.properties")
})
public class AppConfig {
    // beans can use properties from both sources
}

3. Using @ConfigurationProperties

Steps: 1) Create a POJO with fields matching the properties. 2) Create a configuration class annotated with @Configuration and @EnableConfigurationProperties(MyAppProperties.class). 3) Add matching entries to application.properties or application.yml. 4) Inject the POJO into beans via @Autowired.

import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableConfigurationProperties(MyAppProperties.class)
public class AppConfig {
}

myapp.name=My Spring Boot App
myapp.version=1.0

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class MyService {
    private final MyAppProperties myAppProperties;

    @Autowired
    public MyService(MyAppProperties myAppProperties) {
        this.myAppProperties = myAppProperties;
    }

    public void doSomething() {
        System.out.println("App Name: " + myAppProperties.getName());
        System.out.println("App Version: " + myAppProperties.getVersion());
    }
}

4. Using @PropertySources

In standard Spring (or Spring Boot) you can declare multiple property files with @PropertySources and inject values with @Value.

import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.context.annotation.PropertySources;

@Configuration
@PropertySources({
    @PropertySource("classpath:default.properties"),
    @PropertySource("classpath:custom.properties")
})
public class AppConfig {
}

app.name=My Spring Boot App (Default)
app.version=1.0 (Default)

app.name=My Custom Spring Boot App

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

@Service
public class MyService {
    @Value("${app.name}")
    private String appName;

    @Value("${app.version}")
    private String appVersion;

    public String getAppInfo() {
        return "App Name: " + appName + ", App Version: " + appVersion;
    }
}

5. Differences between @PropertySources and @ConfigurationProperties

@PropertySources

defines multiple property files, enabling modular and environment‑specific configuration. @ConfigurationProperties binds those properties to a strongly‑typed Java bean. They can be used together: @PropertySources loads the files, while @ConfigurationProperties maps the values to beans.

@PropertySources specifies multiple sources, supports modular configuration and priority ordering.

@ConfigurationProperties binds external properties to POJOs, simplifying access throughout the application.