How does Spring Boot auto-configuration work internally?

Spring Boot auto-configuration is a powerful feature that automatically configures your Spring application based on the dependencies present on your classpath. It aims to simplify development by reducing boilerplate configuration, intelligently guessing what you need and setting it up for you. Internally, it relies on a sophisticated mechanism involving meta-annotations, conditional logic, and the SpringFactoriesLoader to achieve this seamless integration.

The Core Mechanism: `@EnableAutoConfiguration`

The entry point for Spring Boot's auto-configuration is typically the @EnableAutoConfiguration annotation. This annotation is itself a meta-annotation, commonly found as part of @SpringBootApplication. Its primary role is to trigger the auto-configuration process, which then attempts to configure beans based on the classpath and other factors.

SpringFactoriesLoader

When @EnableAutoConfiguration is active, Spring Boot uses SpringFactoriesLoader to discover all META-INF/spring.factories files on the classpath. This loader is a generic mechanism that finds factories and components listed in these files.

Specifically for auto-configuration, SpringFactoriesLoader looks for keys named org.springframework.boot.autoconfigure.EnableAutoConfiguration within these spring.factories files. The values associated with this key are a comma-separated list of auto-configuration candidate classes.

• Common examples found: DataSourceAutoConfiguration, WebMvcAutoConfiguration, SecurityAutoConfiguration, JacksonAutoConfiguration.
• Each of these classes is a potential source of configuration for a specific part of the application.

Auto-configuration Classes

Each auto-configuration class (e.g., WebMvcAutoConfiguration) is a standard Spring @Configuration class. These classes define beans that would normally be configured manually. However, they are designed to be applied conditionally.

The real power comes from Spring's @Conditional annotations, which are extensively used within these auto-configuration classes to decide whether a particular configuration should be applied or not. This ensures that only relevant configurations are activated.

Conditional Configuration

Spring Boot auto-configuration heavily relies on various @Conditional annotations to make intelligent decisions. These conditions check for the presence or absence of classes, beans, properties, and other environmental factors before applying a configuration. This prevents unwanted configurations and potential conflicts.

• @ConditionalOnClass: The configuration is applied only if the specified class is on the classpath.
• @ConditionalOnMissingClass: The configuration is applied only if the specified class is *not* on the classpath.
• @ConditionalOnBean: The configuration is applied only if a specific bean is already defined in the application context.
• @ConditionalOnMissingBean: The configuration is applied only if a specific bean is *not* defined in the application context.
• @ConditionalOnProperty: The configuration is applied only if a specific Spring environment property exists and optionally has a specific value.
• @ConditionalOnWebApplication: The configuration is applied only if the application is a web application (Servlet or Reactive).
• @ConditionalOnResource: The configuration is applied only if a specific resource exists.

@Configuration
@ConditionalOnClass({ DataSource.class, JdbcTemplate.class })
@ConditionalOnMissingBean(DataSource.class)
public class DataSourceAutoConfiguration {

    @Bean
    public DataSource myCustomDataSource() {
        // ... configure and return a DataSource
        return new EmbeddedDatabaseBuilder().build();
    }
}

Order of Auto-configuration

The order in which auto-configuration classes are applied can be crucial, especially when one configuration depends on or overrides another. Spring Boot provides annotations to control this order, ensuring configurations are processed in a predictable sequence.

• @AutoConfigureBefore: Ensures this configuration runs before another specified auto-configuration.
• @AutoConfigureAfter: Ensures this configuration runs after another specified auto-configuration.
• @AutoConfigureOrder: Specifies a direct order value for the configuration, similar to @Order.

How it all comes together (Example Flow)

When a Spring Boot application starts, the following simplified flow illustrates the auto-configuration process:

• The application's main class annotated with @SpringBootApplication starts.
• The @EnableAutoConfiguration meta-annotation triggers the auto-configuration phase.
• The SpringFactoriesLoader scans the classpath for all META-INF/spring.factories files.
• It collects all auto-configuration class names listed under the EnableAutoConfiguration key.
• For each discovered auto-configuration class, Spring Boot evaluates its @Conditional annotations.
• If all conditions for an auto-configuration class are met, that configuration class is activated, and its @Bean methods are processed, leading to the creation and registration of beans in the Spring ApplicationContext.

# META-INF/spring.factories example
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.example.app.MyCustomAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration