Auto-Configuration and @SpringBootApplication

#Introduction

Every Spring Boot application starts with:

@SpringBootApplication
public class Application {

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

Yet many developers can't explain what happens internally after pressing Run. Interviewers frequently ask: What does @SpringBootApplication do? What is auto-configuration? How does Spring Boot configure itself? What are @EnableAutoConfiguration, @ComponentScan and @Configuration? How does Boot know to configure a DataSource? What are conditional annotations? What is AutoConfiguration.imports? What happens inside SpringApplication.run()?

#Before Spring Boot

In traditional Spring applications, developers configured almost everything manually:

@Bean
public DataSource dataSource() {
}

@Bean
public EntityManagerFactory entityManagerFactory() {
}

@Bean
public DispatcherServlet dispatcherServlet() {
}

@Bean
public ViewResolver viewResolver() {
}

Lots of XML or Java configuration.

#With Spring Boot

Just add spring-boot-starter-web, put @SpringBootApplication on the main class, run it — and everything works. How? Auto-configuration.

#What is Auto-Configuration?

Instead of you declaring @Bean DispatcherServlet, @Bean ObjectMapper and @Bean Tomcat, Spring Boot creates them automatically.

Spring Boot Startup

#What is @SpringBootApplication?

Many developers think it's a single annotation. It's actually a combination of three:

One of the most common interview questions. (Precisely, it's meta-annotated with @SpringBootConfiguration, a specialization of @Configuration.)

@Configuration

Marks a class as a configuration class:

@Configuration
public class AppConfig {

    @Bean
    public UserService userService() {
        return new UserService();
    }
}

Spring processes this class and registers the beans.

@Bean

@Bean
public UserRepository repository() {
    return new UserRepository();
}

Spring registers a UserRepository bean inside the ApplicationContext.

@ComponentScan

Automatically scans packages for @Component, @Service, @Repository and @Controller classes and creates beans.

Component Scan Rules

If @SpringBootApplication is in com.company, Spring scans com.company and all sub-packages. It does not scan sibling or parent packages automatically. That's why the main class is usually placed in the root package.

#@EnableAutoConfiguration

The magic annotation. It tells Spring Boot: configure the application automatically based on the classpath and environment.

No manual configuration.

#How Does Spring Boot Know?

Interview favourite.

In modern Spring Boot, auto-configuration classes are listed in:

META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports

AutoConfiguration.imports

The file contains entries such as DataSourceAutoConfiguration, WebMvcAutoConfiguration, JacksonAutoConfiguration, JpaRepositoriesAutoConfiguration and SecurityAutoConfiguration. Spring Boot loads these configuration classes.

#Auto-Configuration Examples

DataSource

spring.datasource.url=jdbc:mysql://localhost:3306/app
spring.datasource.username=root
spring.datasource.password=secret

Embedded Tomcat

With spring-boot-starter-web, Spring Boot creates embedded Tomcat on port 8080 and the DispatcherServlet. If you use another server starter (Jetty or Undertow), Boot configures that server instead.

Jackson

With spring-boot-starter-web, Boot detects Jackson and creates an ObjectMapper — JSON works automatically.

#Conditional Annotations

Auto-configuration uses conditional annotations extensively:

@ConditionalOnClass
@ConditionalOnBean
@ConditionalOnMissingBean
@ConditionalOnProperty
@ConditionalOnWebApplication
@ConditionalOnExpression

@ConditionalOnClass

@ConditionalOnClass(DataSource.class)

@ConditionalOnMissingBean

Interview favourite.

If you create:

@Bean
PasswordEncoder encoder() {
    return new BCryptPasswordEncoder();
}

Spring Boot won't create another PasswordEncoder where its auto-configuration is guarded by @ConditionalOnMissingBean. This is how Boot backs off.

@ConditionalOnBean

@ConditionalOnBean(DataSource.class)

Creates the bean only if a DataSource bean exists. Useful for dependent configuration.

@ConditionalOnProperty

feature.email=true

@ConditionalOnProperty(name = "feature.email", havingValue = "true")

The bean is created only when the property matches.

Auto-Configuration Flow

#SpringApplication.run()

One of the most asked interview questions.

ApplicationContext Refresh

During refresh(), Spring runs the BeanFactory setup, BeanFactoryPostProcessors, registers BeanPostProcessors, instantiates beans, performs dependency injection and runs @PostConstruct — this connects directly to the Bean Lifecycle chapter. The embedded web server is also created and started as part of the refresh.

#External Configuration

Spring Boot reads configuration from multiple sources. Simplified order (highest precedence first):

1. Command-line arguments
2. Environment variables
3. application.properties / application.yml
4. Default values

This allows the same application to behave differently in different environments.

@ConfigurationProperties

Instead of @Value("${app.name}"), use:

@ConfigurationProperties(prefix = "app")
public class AppProperties {
    private String name;
    private Integer timeout;
}

app.name=Ticket Booking
app.timeout=30

Spring binds the properties into the Java object — the preferred approach for related configuration values (covered in its own chapter).

#Overriding Auto-Configuration

Spring Boot provides a default ObjectMapper. If you create your own:

@Bean
ObjectMapper objectMapper() {
    return new ObjectMapper();
}

…Boot's auto-configuration backs off because of @ConditionalOnMissingBean.

#Internal Spring Boot Components

Important classes: SpringApplication, AutoConfigurationImportSelector, ConfigurationClassParser, DefaultListableBeanFactory and ApplicationContext — interview favourites.

#Complete Startup Flow

#Enterprise Architecture

#Key Takeaways

• @SpringBootApplication = @Configuration + @EnableAutoConfiguration + @ComponentScan.
• Auto-configuration inspects the classpath, environment and existing beans.
• AutoConfigurationImportSelector discovers classes listed in AutoConfiguration.imports.
• Conditional annotations decide whether an auto-configuration creates a bean.
• @ConditionalOnMissingBean lets your own beans override Boot's defaults.
• SpringApplication.run() orchestrates the whole startup, from environment preparation to the embedded server.