Bootstrapping Sequence

The Spring Boot Bootstrapping Sequence describes how a Spring Boot application starts—from calling main() to launching the embedded server and initializing all beans.

It explains the complete lifecycle Spring Boot executes before the application becomes ready to handle requests.

In short: Bootstrapping Sequence = How Spring Boot starts and prepares your application before it becomes ready to handle requests.

What is the Spring Boot Bootstrapping Sequence?

The Spring Boot Bootstrapping Sequence refers to the complete internal startup process that Spring Boot performs from the moment you run SpringApplication.run() until your application is fully initialized and ready to serve requests.

It includes:

• Creating the Spring application,
• Preparing the environment,
• Loading configurations,
• Building and refreshing the ApplicationContext,
• Auto-configuring beans,
• Starting the embedded server,
• And finally firing "application ready" events.

This sequence is the heart of Spring Boot’s startup mechanism and explains how Spring Boot:

• Loads properties
• Applies auto-configuration
• Creates beans
• Starts Tomcat/Jetty/Undertow
• Prepares your application to handle requests

Spring Boot Bootstrapping Sequence

Spring Boot Bootstrapping Sequence describes how Spring Boot prepares the environment, loads configs, initializes the ApplicationContext, creates beans, and starts the embedded server.

1. JVM Starts & Executes main() Method

The JVM runs your main class (with @SpringBootApplication) and calls:

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

This single line triggers the entire Spring Boot startup lifecycle.

2. SpringApplication Object is Created

Spring Boot prepares the runtime environment:

• Application type (Servlet / Reactive / Non-Web)
• Loads initializers & listeners
• Reads auto-configuration metadata

Example

SpringApplication app = new SpringApplication(MyApplication.class);
app.run(args);

What happens?

• Determines web environment
• Loads ApplicationContextInitializers
• Loads ApplicationListeners
• Reads spring.factories

3. Load ApplicationListeners

Spring Boot registers built-in listeners such as:

• ApplicationStartingEvent
• ApplicationEnvironmentPreparedEvent
• ApplicationPreparedEvent
• ApplicationReadyEvent
• ApplicationFailedEvent

These listeners respond to lifecycle events during startup.

Example

Create your own listener:

@Component
public class MyListener implements ApplicationListener<ApplicationStartingEvent> {
    @Override
    public void onApplicationEvent(ApplicationStartingEvent event) {
        System.out.println("Application is starting...");
    }
}

4. Prepare the Environment

Spring Boot builds a ConfigurableEnvironment.

Loads settings from:

• application.properties / application.yml
• System properties
• OS environment variables
• Command-line arguments
• Profile-specific properties (application-dev.yml)
• Random values, default configs

All property sources are merged into one unified Environment.

Example

application.properties:

app.mode=production
server.port=9090

Output (startup logs):

Loaded property: server.port=9090
Loaded property: app.mode=production

5. Print Banner

The Spring Boot banner is displayed:

• Default ASCII banner
• Or custom banner from banner.txt

Default banner example

  .   ____          _            __ _ _
 /\\\\ / ___'_ __ _ _(_)_ __  __ _ \\ \\ \\ \\
( ( )\\___ | '_ | '_| | '_ \\/ _` | \\ \\ \\ \\
 \\\\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\\__, | / / / /
 =========|_|==============|___/=/_/_/_/

Custom banner:

spring.banner.location=banner.txt

6. Create ApplicationContext

Spring Boot chooses the correct context based on application type:

• Servlet: AnnotationConfigServletWebServerApplicationContext
• Reactive: ReactiveWebServerApplicationContext
• Non-Web: AnnotationConfigApplicationContext

This context manages:

• Bean creation
• Injection
• AOP
• Lifecycle
• Event publishing

Example: For a normal Spring Boot REST API → servlet context is created.

7. Load Bean Definitions

Spring scans for components:

• @Component, @Service, @Repository, @Controller
• @Configuration & @Bean
• Auto-configuration classes (spring-boot-autoconfigure.jar)
• XML configs (if present)

Example:

@Service
public class OrderService {}

Spring creates a BeanDefinition like:

• Bean class: OrderService
• Scope: singleton
• Dependencies: none yet

➡ Still no objects created—only metadata loaded.

8. Apply Environment Post-Processors

Spring Boot modifies configuration before creating beans:

• Activates auto-configurations
• Customizes profiles
• Adjusts PropertySources

Example

Your application.properties:

spring.datasource.url=jdbc:h2:mem:test

Environment processors read these properties and configure DataSource.

Example Post Processor:

public class MyEnvProcessor implements EnvironmentPostProcessor {
    public void postProcessEnvironment(ConfigurableEnvironment env, SpringApplication app) {
        System.out.println("Active Profiles: " + env.getActiveProfiles().length);
    }
}

9. Refresh the ApplicationContext

This is where all DI magic happens.

What happens inside Refresh?

Create all non-lazy beans

If lazy is false, Spring creates beans immediately.

Perform dependency injection

Constructor, Setter, Field injection:

@Autowired
private UserRepository repo;

Apply BeanPostProcessors

• Autowired resolver
• AOP proxy creator
• Validation handler

Create AOP proxies

Example:

@Transactional
public class PaymentService {}

Spring wraps it in a CGLIB proxy like:

PaymentService$$EnhancerBySpringCGLIB

Run lifecycle callbacks

• @PostConstruct
• afterPropertiesSet()

➡ This is the phase where the application structure becomes fully functional.

10. Start Embedded Web Server (Web Apps Only)

Spring Boot automatically starts:

• Tomcat (default)
• Jetty
• Undertow

It creates and registers:

• ServletWebServerFactory
• DispatcherServlet
• HandlerMappings
• HandlerAdapters

Example output:

Tomcat started on port 8080

➡ At this moment, your HTTP endpoints become active.

11. Execute Application Runners

Runs after all beans are ready.

Examples:

CommandLineRunner

@Bean
CommandLineRunner runner() {
    return args -> System.out.println("App started!");
}

ApplicationRunner

@Bean
ApplicationRunner appRunner() {
    return args -> System.out.println("Runner executed!");
}

➡ Used for seeding data, preloading cache, checking connections, etc.

12. Application Ready Event

Spring publishes ApplicationReadyEvent.

You can listen:

@Component
public class ReadyListener implements ApplicationListener<ApplicationReadyEvent> {
    public void onApplicationEvent(ApplicationReadyEvent e) {
        System.out.println("Application is READY!");
    }
}

➡ The app is 100% ready to serve requests.

13. Register Shutdown Hook

Spring adds a JVM shutdown hook:

• Calls @PreDestroy
• Executes DisposableBean.destroy()
• Closes ApplicationContext
• Stops the embedded web server

Example:

@PreDestroy
public void cleanUp() {
    System.out.println("Releasing resources...");
}

➡ Ensures graceful and safe shutdown.

Spring Boot Bootstrapping Sequence – Flowchart

                ┌──────────────────────────┐
                │   JVM Starts Application  │
                │    Calls main() Method    │
                └─────────────┬────────────┘
                              │
                              ▼
                ┌──────────────────────────┐
                │  SpringApplication Created│
                │ Loads Initializers &      │
                │ Lifecycle Listeners       │
                └─────────────┬────────────┘
                              │
                              ▼
                ┌──────────────────────────┐
                │   Load Application        │
                │       Listeners           │
                └─────────────┬────────────┘
                              │
                              ▼
                ┌──────────────────────────┐
                │ Prepare Environment       │
                │ (properties, YAML, env,   │
                │ system vars, CLI args)    │
                └─────────────┬────────────┘
                              │
                              ▼
                ┌──────────────────────────┐
                │     Print Banner          │
                └─────────────┬────────────┘
                              │
                              ▼
                ┌──────────────────────────┐
                │Create ApplicationContext  │
                │(Servlet/Reactive/Non-Web) │
                └─────────────┬────────────┘
                              │
                              ▼
                ┌──────────────────────────┐
                │   Load Bean Definitions   │
                │ (@ComponentScan, @Bean,   │
                │ Auto-Configuration)       │
                └─────────────┬────────────┘
                              │
                              ▼
                ┌──────────────────────────┐
                │ Apply Env Post-Processors │
                │ (Profiles, properties)    │
                └─────────────┬────────────┘
                              │
                              ▼
                ┌──────────────────────────┐
                │ Refresh ApplicationContext│
                │ Create Beans, DI, AOP,    │
                │ PostConstruct callbacks   │
                └─────────────┬────────────┘
                              │
                              ▼
                ┌──────────────────────────┐
                │ Start Embedded Server     │
                │ (Tomcat/Jetty/Undertow)   │
                │ Register DispatcherServlet │
                └─────────────┬────────────┘
                              │
                              ▼
                ┌──────────────────────────┐
                │ Run Startup Runners       │
                │ (CommandLineRunner,       │
                │  ApplicationRunner)       │
                └─────────────┬────────────┘
                              │
                              ▼
                ┌──────────────────────────┐
                │ Application Ready Event   │
                │   (App Fully Started)     │
                └─────────────┬────────────┘
                              │
                              ▼
                ┌──────────────────────────┐
                │ Register Shutdown Hook    │
                │ Graceful Shutdown on Stop │
                └──────────────────────────┘

Conclusion

These examples show exactly what happens internally from:

• main() →
• Auto-configuration →
• Bean creation →
• Server startup →
• AppReady →
• Shutdown

This is the complete internal working of a Spring Boot application.