Master Spring Boot Auto‑Configuration: 4 Layers Every Developer Should Know

Hello, I'm your friend Architect Jun, a coder‑poet architect.

Last week over skewers, a colleague was stumped by Spring Boot auto‑configuration interview questions. He memorized annotations like @EnableAutoConfiguration and @ComponentScan but couldn't explain conditional annotations or configuration loading order. This article demystifies auto‑configuration in four logical layers.

Layer 1: Annotation combo – @SpringBootApplication is a wrapper

The @SpringBootApplication annotation is just a container that combines three annotations:

@SpringBootConfiguration : declares the class as a configuration (essentially @Configuration).

@ComponentScan : scans the current package for @Component, @Service, etc.

@EnableAutoConfiguration : the core switch for auto‑configuration (focus on this).

Common pitfall: placing the main class in the wrong package prevents component scanning.

Layer 2: Configuration loading engine – What @EnableAutoConfiguration does

This annotation imports AutoConfigurationImportSelector, which scans all META-INF/spring.factories files in the classpath and collects the listed auto‑configuration classes.

Example: adding spring-boot-starter-data-redis brings in RedisAutoConfiguration via its spring.factories, so Spring Boot knows to configure Redis.

File: META-INF/spring.factories – declares auto‑configuration classes (e.g., RedisAutoConfiguration).

File: xxxAutoConfiguration – contains the specific component's configuration logic.

Pitfall: a typo in spring.factories class name causes a ClassNotFoundException at startup.

Layer 3: Conditional assembly – @ConditionalOnXXX annotations

Each auto‑configuration class is guarded by conditional annotations such as @ConditionalOnClass, @ConditionalOnProperty, @ConditionalOnMissingBean.

@Configuration
@ConditionalOnClass(RedisTemplate.class) // activates only if RedisTemplate is on the classpath
@EnableConfigurationProperties(RedisProperties.class) // binds properties
public class RedisAutoConfiguration {
    @Bean
    @ConditionalOnMissingBean // provides default bean only if user hasn't defined one
    public RedisTemplate<String, Object> redisTemplate() { ... }
}

Key conditional annotations: @ConditionalOnClass: activates when the specified class is present. @ConditionalOnProperty: activates when a configuration property is true. @ConditionalOnMissingBean: provides a bean only if the user hasn't defined one.

Pitfall: forgetting a conditional annotation can cause unwanted configuration loading and startup errors.

Layer 4: Property binding – xxxProperties classes

Properties classes bind external configuration (e.g., application.yml) to POJOs.

Example with RedisProperties:

@ConfigurationProperties(prefix = "spring.redis")
public class RedisProperties {
    private String host;
    private int port;
    // getters and setters...
}

RedisAutoConfiguration injects these properties into RedisTemplate, illustrating “convention over configuration”.

Pitfall: using an incorrect prefix (e.g., "redis" instead of "spring.redis") prevents property binding.

Summary: Four layers to ace the interview

Startup layer : @SpringBootApplication (focus on @EnableAutoConfiguration).

Loading layer : AutoConfigurationImportSelector scans spring.factories.

Filtering layer : @ConditionalOnXXX controls bean registration.

Property layer : @ConfigurationProperties binds external settings.

Understanding these layers turns Spring Boot auto‑configuration from a mystery into a clear, interview‑ready explanation.

Image illustrating the concept: