Spring Boot Property Loading – Logical Overview

Spring Boot provides a flexible property loading mechanism, allowing configuration from multiple sources. It follows a structured process where properties are loaded, merged, and overridden based on precedence rules. Understanding this process helps in debugging and controlling application behavior dynamically.

1. How Spring Boot Loads Properties

📌 Spring Boot follows a structured sequence to load and apply properties, ensuring that the most relevant configurations take precedence.

Step-by-Step Property Loading Process

1️⃣ Initialize Environment (StandardEnvironment)

• Spring Boot sets up ConfigurableEnvironment, which acts as a container for all configuration sources.
  


• This environment is created before beans, ensuring that properties are available throughout the application lifecycle.
  

2️⃣ Load Property Sources

• Reads System properties (System.getProperties()).
  


• Reads Environment variables (System.getenv()).
  


• Loads Config files (application.properties / .yml) via ConfigFileApplicationListener.
  


• Loads Config Server properties if using Spring Cloud Config.
  


• Reads Custom property sources, such as database-stored configurations or external APIs.
  

3️⃣ Merge & Apply Property Precedence

• Properties from different sources are merged, and higher-precedence sources override lower ones:
  
  
  
  
  • 
    Command-line arguments > System properties > Environment variables > Config files > Default values
    
  
  
  
  
  
  

🔗 This approach ensures that configuration can be dynamically adjusted at runtime without modifying the application code.

2. System Properties & Environment Variables in Spring Boot

🛠️ Using System.getProperties() (Java System Properties)

• These are set via JVM options when running the application:
  

  java -Dserver.port=9090 -jar myapp.jar

• Internally, Java stores these properties in a Properties object that can be accessed via:
  

  System.getProperties().getProperty("server.port");

• These properties are loaded early in Spring Boot’s startup sequence and override properties from files.

🛠️ Using System.getenv() (Environment Variables)

• These are set at the OS level:
  

  export SERVER_PORT=9090

• Retrieved in Java via:
  

  System.getenv("SERVER_PORT");

• Environment variables are global and can be accessed across multiple applications.

Difference Between System.getProperties() and System.getenv()

3. Spring Environment & Property Sources

📌 Spring Boot manages configuration through ConfigurableEnvironment, which organizes properties from multiple sources.

• 
  ConfigurableEnvironment acts as a wrapper around various property sources, ensuring that configurations can be:
  
  
  
  
  • 
    Overridden dynamically
    
  
  
  • 
    Loaded externally without code changes
    
  
  
  • 
    Used consistently across beans and services
    
  
  
  
  
  
  

Primary Property Sources

🔗 By using ConfigurableEnvironment, Spring Boot ensures that property resolution is handled in a structured and predictable manner.

4. PropertySource Hierarchy (Key Sources)

📌 Spring Boot uses PropertySource objects to encapsulate different property sources. These sources are loaded in a hierarchical order, allowing flexible configuration management.

What is a PropertySource?

• A PropertySource is an abstraction that wraps property values and makes them accessible in the application context.
  


• Each configuration source (e.g., system properties, config files) is represented as a separate PropertySource in ConfigurableEnvironment.
  

Common PropertySource Implementations

5. Inspecting Property Sources at Runtime

📌 Spring Boot allows developers to inspect loaded property sources using getPropertySources(), which is useful for debugging and runtime modifications.

• Example:
  

  @Autowired

  private Environment environment;



  public void printSources() {

      ((ConfigurableEnvironment) environment).getPropertySources()

          .forEach(source -> System.out.println(source.getName()));

  }

(This method only lists existing property sources; it does not load new ones.)

🔗 This method helps developers verify the source of a property and understand how configurations are resolved.

6. Property Source Precedence (Highest to Lowest)

📌 Spring Boot resolves properties based on a strict order of precedence, ensuring that the most specific settings override broader defaults.

1️⃣ Command-line arguments (--server.port=8081)


2️⃣ System properties (-Dserver.port=8082)


3️⃣ Environment variables (SERVER_PORT=8083)


4️⃣ Config files (application.properties / .yml)


5️⃣ Code defaults (@Value("${server.port:8084}"))

🔗 This hierarchy ensures that temporary configurations (e.g., CLI arguments) take precedence while allowing fallback to default values.

🔹 Key Takeaways

✅ Spring Boot merges all property sources before startup, ensuring flexible and externalized configuration.


✅ Higher precedence sources override lower ones, allowing dynamic runtime overrides.


✅ Command-line arguments always take priority, making them ideal for temporary configurations.


✅ Use Environment API (getProperty(), getPropertySources()) to inspect and debug loaded properties.

Happy Coding! 🚀