Custom configuration properties in Spring Boot - Performance & Optimization

Performance: Custom configuration properties

MEDIUM IMPACT

This affects application startup time and memory usage by how configuration properties are loaded and bound.

Defining and loading custom configuration properties in Spring Boot

Spring Boot

Using a single @ConfigurationProperties class to bind all related properties:

@ConfigurationProperties(prefix = "app")
public class AppProperties {
  private int timeout;
  private String url;
  // getters and setters
}

@Configuration
@EnableConfigurationProperties(AppProperties.class)
public class MyService {
  private final AppProperties props;
  public MyService(AppProperties props) {
    this.props = props;
  }
}

Binds all related properties once in a structured object, reducing repeated lookups and improving startup efficiency.

📈 Performance GainSingle binding operation reduces startup overhead and improves memory locality.

Defining and loading custom configuration properties in Spring Boot

Spring Boot

Using @Value annotations repeatedly for many properties scattered across classes:

@Component
public class MyService {
  @Value("${app.timeout}")
  private int timeout;
  @Value("${app.url}")
  private String url;
  // many more @Value injections
}

Repeated @Value injections cause multiple property lookups and scattered binding, increasing startup time and complexity.

📉 Performance CostTriggers multiple property resolution calls, increasing startup time by tens of milliseconds in large apps.

Performance Comparison

Pattern	Property Lookups	Startup Delay	Memory Usage	Verdict
Multiple @Value annotations	Many repeated lookups	Higher (tens of ms)	Higher due to scattered bindings	[X] Bad
Single @ConfigurationProperties class	Single batch lookup	Lower (few ms)	Lower due to structured binding	[OK] Good

Rendering Pipeline

Spring Boot loads configuration properties during application startup before the main application context is fully initialized.

→Property Binding

→Bean Initialization

⚠️ BottleneckMultiple scattered property lookups increase binding time and bean initialization delay.

Optimization Tips

1Use @ConfigurationProperties to group related config properties for efficient binding.

2Avoid scattering many @Value annotations across classes to reduce repeated lookups.

3Enable debug logging to monitor property binding performance during startup.

Performance Quiz - 3 Questions

What is a performance benefit of using @ConfigurationProperties over multiple @Value annotations?

A It caches properties in the browser for faster access.

B It delays property loading until first use to save memory.

C It batches property binding reducing repeated lookups and startup time.

D It automatically compresses property files to reduce size.

DevTools: Spring Boot Actuator / Logs

How to check: Enable debug logging for property binding by setting logging.level.org.springframework.boot.context.properties=DEBUG and observe startup logs.

What to look for: Look for repeated property resolution messages indicating multiple lookups versus single batch binding.