Spring Boot Auto Configuration, Startup Lifecycle, and Core Internals

Auto Configuration

@SpringBootApplication includes @EnableAutoConfiguration, which imports AutoConfigurationImportSelector.

Auto Configuration Loading Flow

flowchart TD
A["@SpringBootApplication"] --> B["@EnableAutoConfiguration"]
B --> C["AutoConfigurationImportSelector"]
C --> D["META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports"]
D --> E["Evaluate @Conditional... annotations"]
E --> F["Load matching AutoConfiguration classes"]

Internal Process

1. @SpringBootApplication
2. Contains @EnableAutoConfiguration
3. Imports AutoConfigurationImportSelector
4. Reads:

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

(Older Spring Boot versions used spring.factories.)

Example entries:

org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration
org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration
org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration

Auto-configuration classes are loaded only when their conditions match.

Example:

If HikariCP and a JDBC driver are on the classpath, DataSourceAutoConfiguration is applied automatically.

Auto Configuration Depends On

• Classpath
• Existing beans
• Configuration properties
• Environment

---

Condition Evaluation Report

The Condition Evaluation Report shows which auto-configurations were applied or skipped and why.

Enable it with:

debug=true

or

--debug

Example output:

Positive matches:
-----------------
DataSourceAutoConfiguration matched

Negative matches:
-----------------
MongoAutoConfiguration did not match (MongoDB classes not found)

Benefits

• Diagnose missing auto-configuration
• Identify missing dependencies
• Verify property-based configuration

---

Conditional Annotations

@ConditionalOnClass

Loads configuration only when a class exists on the classpath.

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

@ConditionalOnMissingBean

Creates a bean only if the application has not already defined one.

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

This enables user-defined beans to override Boot defaults.

@ConditionalOnProperty

Loads configuration based on a property value.

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

feature.cache.enabled=true

Annotation	Usage
@ConditionalOnProperty	Enable beans using configuration values
@ConditionalOnClass	Enable beans only when classes exist on the classpath

---

Spring Boot Startup Lifecycle

Calling:

SpringApplication.run(Application.class, args);

triggers the following sequence.

flowchart TD
A["SpringApplication.run()"] --> B["Create SpringApplication"]
B --> C["Prepare Environment"]
C --> D["Print Banner"]
D --> E["Create ApplicationContext"]
E --> F["Run ApplicationContextInitializers"]
F --> G["Component Scan & Bean Registration"]
G --> H["Auto Configuration"]
H --> I["Start Embedded Server"]
I --> J["Publish Lifecycle Events"]

This expands on the shorter Application Startup overview with the full 9-step sequence.

Detailed Steps

1. Create SpringApplication

   • Determine application type (MVC, Reactive, Non-Web)
   • Identify the main class

2. Prepare the Environment

   • Load application.properties
   • Load application.yml
   • Read environment variables
   • Read JVM system properties
   • Create ConfigurableEnvironment

3. Print the Spring Boot banner.

4. Create the appropriate ApplicationContext.

Application Type	Context
Spring MVC	AnnotationConfigServletWebServerApplicationContext
Reactive	AnnotationConfigReactiveWebServerApplicationContext
Non-Web	AnnotationConfigApplicationContext

5. Execute ApplicationContextInitializer.

6. Perform component scanning and bean registration.

7. Apply auto-configuration through AutoConfigurationImportSelector.

8. Start the embedded server (Tomcat by default; Jetty and Undertow are supported alternatives).

9. Publish lifecycle events, then execute any CommandLineRunner and ApplicationRunner beans.

---

Role of SpringApplication.run()

Responsibilities:

• Create SpringApplication
• Prepare the Environment
• Create the ApplicationContext
• Load beans
• Apply auto-configuration
• Start the embedded server
• Publish application events

Returns:

ConfigurableApplicationContext

---

ApplicationContextInitializer

Allows customization of the ApplicationContext before it is refreshed.

public class MyInitializer
        implements ApplicationContextInitializer<ConfigurableApplicationContext> {

    @Override
    public void initialize(ConfigurableApplicationContext context) {
        System.out.println("Context initializing");
    }
}

Register using:

• SpringApplication.addInitializers()
• spring.factories (legacy registration approach)

Common Use Cases

• Add property sources
• Modify the environment
• Programmatically register beans

---

Environment Abstraction

Spring Boot exposes configuration through the Environment abstraction.

Interfaces:

Environment
ConfigurableEnvironment

Property Source Precedence

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

Example:

server.port=8081

Access values:

@Value("${server.port}")

or

environment.getProperty("server.port");

---

Spring Boot Application Events

Event	Description
ApplicationStartingEvent	Application startup begins
ApplicationEnvironmentPreparedEvent	Environment prepared
ApplicationContextInitializedEvent	Context initialized
ApplicationPreparedEvent	Context prepared but not refreshed
ApplicationStartedEvent	Context refreshed
ApplicationReadyEvent	Ready to serve requests
ApplicationFailedEvent	Startup failed

Example listener:

@Component
public class MyListener {

    @EventListener
    public void onReady(ApplicationReadyEvent event) {
        System.out.println("Application is ready");
    }
}

---

Spring Boot CLI

Spring Boot CLI is a command-line tool for rapidly developing Spring applications using Groovy.

Run:

spring run app.groovy

Example:

@RestController
class HelloController {

    @RequestMapping("/")
    String home() {
        "Hello Spring Boot"
    }
}

Execute:

spring run app.groovy

Typical Uses

• Rapid prototyping
• Learning
• Small APIs
• Quick experiments

It is rarely used in production systems.

---

Custom Spring Boot Starters

A starter bundles dependencies and auto-configuration.

Examples:

spring-boot-starter-web
spring-boot-starter-data-jpa

Creating a Custom Starter

Step 1: Create an Auto-Configuration Module

@Configuration
@ConditionalOnClass(Logger.class)
public class LoggingAutoConfiguration {

    @Bean
    public Logger logger() {
        return new Logger();
    }
}

Step 2: Register Auto-Configuration

File:

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

Contents:

com.example.LoggingAutoConfiguration

Step 3: Create the Starter Module

Dependencies:

logging-autoconfigure
logging-library

Step 4: Use the Starter

logging-spring-boot-starter

The auto-configuration is applied automatically.

Key Takeaways

• Auto-configuration is driven by AutoConfigurationImportSelector, conditional annotations, and metadata in AutoConfiguration.imports.
• Conditional annotations activate configuration based on the classpath, existing beans, or properties.
• SpringApplication.run() orchestrates the complete application bootstrap process.
• The Environment abstraction unifies configuration from multiple property sources with well-defined precedence.
• Lifecycle events and ApplicationContextInitializer provide extension points during application startup.
• Custom starters package reusable dependencies and auto-configuration for simplified application setup.