Spring Boot Auto-Configuration

Spring Boot Auto-Configuration is one of the most powerful features of Spring Boot. It helps developers build applications quickly by automatically configuring beans based on the dependencies present in the classpath.

What is Auto-Configuration in Spring Boot?

Auto-configuration automatically configures your Spring application based on the libraries (dependencies) available in the classpath.

In simple words:
"Add a dependency, and Spring Boot configures it for you."

Example:

• Add spring-boot-starter-web
• Spring Boot automatically configures:
  • Embedded Tomcat
  • DispatcherServlet
  • Spring MVC beans
  • Jackson for JSON processing

No XML configuration and minimal manual setup is required.

Why Do We Need Auto-Configuration?

Without auto-configuration:

• You must define many beans manually
• More boilerplate code
• Slower development

With auto-configuration:

• Faster application setup
• Sensible default configurations
• Easy customization and overrides

How Does Auto-Configuration Work?

Spring Boot auto-configuration works using the following components:

1. @SpringBootApplication
2. @EnableAutoConfiguration
3. Auto-configuration classes
4. Conditional annotations

@SpringBootApplication – The Entry Point

Every Spring Boot application starts with the @SpringBootApplication annotation.

@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}
    

Internally, this annotation is a combination of:

@Configuration
@ComponentScan
@EnableAutoConfiguration
    

@EnableAutoConfiguration is the key annotation responsible for auto-configuration.

@EnableAutoConfiguration

This annotation tells Spring Boot to:

Look at the classpath and automatically configure beans if certain conditions are met.

Spring Boot loads auto-configuration classes from:

• Spring Boot 2.x: META-INF/spring.factories
• Spring Boot 3.x: META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports

Auto-Configuration Classes

Spring Boot provides many built-in auto-configuration classes such as:

• DataSourceAutoConfiguration
• HibernateJpaAutoConfiguration
• WebMvcAutoConfiguration
• SecurityAutoConfiguration

These classes:

• Create required beans
• Apply default configurations
• Run only when conditions are satisfied

Conditional Annotations (Very Important)

Conditional annotations decide whether a configuration should be applied or not.

Example:

@Configuration
@ConditionalOnClass(DataSource.class)
public class DataSourceAutoConfiguration {

    @Bean
    @ConditionalOnMissingBean
    public DataSource dataSource() {
        return new HikariDataSource();
    }
}
    

This means:

• If DataSource class is present
• And no DataSource bean is defined
• Spring Boot creates a default DataSource

Overriding Auto-Configuration

1. Define Your Own Bean

@Bean
public DataSource dataSource() {
    return new CustomDataSource();
}
    

Spring Boot automatically backs off when it finds a user-defined bean.

2. Disable Specific Auto-Configuration

@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
public class MyApplication {
}
    

Or using properties:

spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration
    

Starter vs Auto-Configuration

How to Check Applied Auto-Configurations?

Enable debug mode in application.properties:

debug=true
    

Or run the application with:

java -jar app.jar --debug
    

This shows:

• Applied auto-configurations
• Skipped configurations with reasons

Real-Life Example

Adding the dependency:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
    

Spring Boot automatically configures:

• Embedded Tomcat server
• DispatcherServlet
• RequestMappingHandlerMapping
• HTTP message converters

Interview One-Liner

Spring Boot Auto-Configuration automatically configures application components based on classpath dependencies, properties, and predefined conditions, reducing boilerplate code and speeding up development.