Clean • Professional
Spring Boot’s biggest strength is auto-configuration — the ability to automatically configure your application based on the classpath, environment, and existing beans.
Behind this simplicity lies a powerful internal engine called the Auto-Configuration Import Process.
This guide explains how Spring Boot discovers, filters, orders, and imports auto-configuration classes, step by step.
Auto-configuration means Spring Boot automatically creates and configures beans without manual configuration.
Examples:
spring-boot-starter-web → Embedded Tomcat + DispatcherServlet configuredspring-boot-starter-data-jpa → DataSource + JPA setup applied
This behavior is driven entirely by the Auto-Configuration Import Process.
Understanding this process helps you:
It forms the core engine of Spring Boot startup.
@SpringBootApplicationEvery Spring Boot application starts with:
@SpringBootApplication
publicclassMyApplication {
publicstaticvoidmain(String[] args) {
SpringApplication.run(MyApplication.class, args);
}
}
Internally, this annotation is a shortcut for:
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan
👉 @EnableAutoConfiguration is the key player
@EnableAutoConfiguration@EnableAutoConfiguration tells Spring Boot:
“Automatically configure beans based on the classpath, environment, and existing beans.”
Internally, it uses:
@Import(AutoConfigurationImportSelector.class)
➡️ This delegates the entire auto-configuration decision process to AutoConfigurationImportSelector.
AutoConfigurationImportSelector is responsible for:
It implements:
DeferredImportSelector
👉 This ensures auto-configurations are applied after user configurations, allowing overrides.
Core Method:
selectImports(AnnotationMetadata metadata)
Returns a list of auto-configuration class names to import.
Spring Boot reads auto-configuration class names from metadata files.
Spring Boot ≤ 2.x
META-INF/spring.factories
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\\
org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration,\\
org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration
Spring Boot 3.x+
META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
Spring Boot removes auto-configurations explicitly excluded.
Exclusion Sources:
Spring Boot supports three official ways to exclude auto-configuration classes.
1. Annotation - The most common and recommended approach.
@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
public class MyApplication {
public static void main(String[] args) {
SpringApplication.run(MyApplication.class, args);
}
}
2. Properties - Exclusions can also be defined in application.properties or application.yml.
spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration3. Programmatic exclusions - Exclusions can be applied programmatically using the SpringApplication API.
SpringApplication application = new SpringApplication(MyApplication.class);
application.setExcludeConfiguration(DataSourceAutoConfiguration.class);
application.run(args);
Each auto-configuration class is guarded by conditions such as:
@ConditionalOnClass@ConditionalOnMissingBean@ConditionalOnProperty@ConditionalOnWebApplication@ConditionalOnExpressionExample:
@ConditionalOnClass(DataSource.class)
@ConditionalOnMissingBean(DataSource.class)
publicclassDataSourceAutoConfiguration {
}
Evaluation Rules:
📌 Class-level conditions run first
📌 Bean-level conditions run later
Spring Boot records every decision made during auto-configuration.
Enable it with:
debug=true
Sample Output:
DataSourceAutoConfiguration:
Did not match:
- @ConditionalOnProperty (spring.datasource.url) not found
This report explains exactly why something loaded or didn’t.
Spring Boot ensures correct startup order using:
@AutoConfigureBefore@AutoConfigureAfter@AutoConfigureOrderExamples:
➡️ Ordering is resolved before import.
After filtering and ordering:
@Configuration classes@Bean methods are registeredThis happens during:
refreshContext()
└── invokeBeanFactoryPostProcessors()
Inside auto-configurations:
@Bean
@ConditionalOnMissingBean
public ObjectMapperobjectMapper() {
returnnewObjectMapper();
}
Bean-level conditions are evaluated after:
@Configuration classes👉 This enables Spring Boot’s golden rule:
Auto-configuration backs off if you define your own bean
@SpringBootApplication
└── @EnableAutoConfiguration
└── AutoConfigurationImportSelector
├── Load candidates (factories / imports)
├── Remove exclusions
├── Apply class-level conditions
├── Sort auto-configurations
└── Import into ApplicationContext
├── Evaluate bean-level conditions
└── Instantiate beans
Auto-configuration runs during:
refreshContext()
├── Load bean definitions
├── Evaluate conditions
├── Import auto-configurations
└── Instantiate beans
Ensuring:
The Auto-Configuration Import Process is the engine behind Spring Boot’s “just works” philosophy.
It intelligently:
Mastering this process moves you from Spring Boot user → Spring Boot internals expert.