Junior Level

Auto-configuration - Spring Boot configures beans itself, looking at what is in the classpath.

Simple analogy: A smart home. You enter a room - the light turns on by itself. You do not need to press a switch.

// Without Spring Boot:
@Bean
public DataSource dataSource() {
    // Manual configuration...
}

// With Spring Boot:
// Just add the dependency to pom.xml:
// <dependency>spring-boot-starter-data-jpa</dependency>
// -> DataSource will be created automatically!

How to disable:

@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})

---

Middle Level

How It Works

@SpringBootApplication
  -> @EnableAutoConfiguration
    -> AutoConfigurationImportSelector
      -> Reads spring.factories (Boot 2.x)
      -> or .imports (Boot 3.x)
        -> Loads auto-configurations

@Conditional Annotations

@ConditionalOnClass(DataSource.class)  // If class exists
@ConditionalOnMissingBean              // If no such bean exists
@ConditionalOnProperty("app.enabled")  // If property is true
@ConditionalOnWebApplication           // If web application

Auto-Configuration Example

@Configuration
@ConditionalOnClass(ObjectMapper.class)  // If Jackson exists
@ConditionalOnMissingBean(ObjectMapper.class)  // If you did not create your own
public class JacksonAutoConfiguration {

    @Bean
    @Primary
    public ObjectMapper objectMapper() {
        return new ObjectMapper();  // Creates a default one
    }
}

Debugging

# Run with report:
java -jar app.jar --debug

# Output: Condition Evaluation Report
# -> Shows why each bean was created or not

---

Senior Level

Spring Boot 2.x vs 3.x

Boot 2.x:
  -> META-INF/spring.factories
  -> Key: EnableAutoConfiguration
  -> These files contain a list of auto-configuration classes (fully qualified class names), one per line. Spring Boot reads them at startup and registers the specified beans.

Boot 3.x:
  -> META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
  -> Just a list of classes
  -> Faster, GraalVM Native support

Load Order

@AutoConfigureAfter(DataSourceAutoConfiguration.class)
@AutoConfigureBefore(HibernateJpaAutoConfiguration.class)
public class MyAutoConfiguration { }

-> Critical for dependencies between configurations!

Creating Your Own Auto-Configuration

// In a separate module: mylib-autoconfigure
@AutoConfiguration
@ConditionalOnClass(MyService.class)
public class MyLibAutoConfiguration {

    @Bean
    @ConditionalOnMissingBean
    public MyService myService() {
        return new MyService();
    }
}

// In META-INF/spring/...AutoConfiguration.imports:
com.example.MyLibAutoConfiguration

Production Experience

Real scenario: slow startup

Large number of auto-configurations increases startup time.
Excluding unnecessary ones via exclude and limiting package scanning can reduce startup by 20-40%.

Best Practices

1. @ConditionalOnMissingBean -> allow overriding
2. @AutoConfiguration (Spring Boot 2.7+: replacement for @Configuration for auto-configuration. For Boot 3.x use .imports file, for Boot 2.x - spring.factories).
3. exclude -> disable unnecessary ones
4. –debug -> configuration debugging
5. Order -> After/Before annotations
6. Boot 3.x -> new .imports format

Summary for Senior

• Auto-configuration = Convention over Configuration
• @Conditional -> condition checking
• Boot 3.x -> .imports instead of spring.factories
• Order -> critical for dependencies
• Own auto-configuration -> separate module
• –debug -> Condition Evaluation Report

---

Interview Cheat Sheet

Must know:

• Auto-configuration = Convention over Configuration: Spring Boot configures beans by classpath
• @SpringBootApplication -> @EnableAutoConfiguration -> AutoConfigurationImportSelector
• Boot 2.x reads META-INF/spring.factories, Boot 3.x -> META-INF/spring/…AutoConfiguration.imports
• @ConditionalOnClass, @ConditionalOnMissingBean, @ConditionalOnProperty - key conditional annotations
• @ConditionalOnMissingBean allows overriding a bean with your own configuration
• Order: @AutoConfigureAfter / @AutoConfigureBefore for dependencies between configurations
• Disable: @SpringBootApplication(exclude = {…})
• Debugging: –debug -> Condition Evaluation Report
• Own auto-configuration - separate module with .imports file

Common follow-up questions:

• How does Spring Boot know what to configure? -> Scans classpath, reads .imports/spring.factories, checks @Conditional
• How does Boot 3.x differ from 2.x? -> .imports file instead of spring.factories, faster, GraalVM Native support
• How to override auto-configuration? -> Create your own @Bean of the same type - @ConditionalOnMissingBean will not create the default
• How to find out why a bean was NOT created? -> Run with –debug, look at Condition Evaluation Report

Red flags (DO NOT say):

• “Auto-configuration creates all beans always” - only if @Conditional conditions are met
• “spring.factories is used in Boot 3.x” - replaced by .imports
• “@ConditionalOnMissingBean checks classpath” - checks for bean in context
• “Auto-configuration slows down the application at runtime” - affects only startup, not runtime

Related topics:

• [[11. What scopes exist in Spring]]
• [[14. When does Spring create a proxy]]
• [[17. What does the Transactional annotation do]]