Spring Boot Startup Lifecycle -Internal Workflow

Spring Boot applications may appear simple, often starting with just one line:

SpringApplication.run(MyApplication.class, args);

However, behind this single line, Spring Boot executes a well-structured, multi-step startup process. Understanding this internal workflow is crucial for:

• Debugging startup issues
• Optimizing application performance
• Mastering auto-configuration
• Answering advanced Spring Boot interview questions

This guide explains everything about SpringApplication, startup phases, bean lifecycle, embedded server initialization, and events—perfect for students, developers, and professionals.

What Is SpringApplication?

SpringApplication is the core bootstrap engine of Spring Boot. It is the orchestrator of the application startup process.

Responsibilities of SpringApplication

• Bootstrapping the Spring Boot application
• Preparing the Environment and configuration
• Creating the ApplicationContext (bean container)
• Loading and initializing beans
• Triggering auto-configuration
• Starting the embedded web server (Tomcat, Jetty, Netty)
• Notifying lifecycle listeners about startup events

Think of SpringApplication as the brain and conductor of the Spring Boot startup engine.

High-Level SpringApplication Startup Flow

Here’s the big picture of the Spring Boot startup process:

SpringApplication.run()
        ↓
SpringApplication initialization
        ↓
RunListeners.starting()
        ↓
prepareEnvironment()
        ↓
RunListeners.environmentPrepared()
        ↓
createApplicationContext()
        ↓
prepareContext()
        ↓
load() – Bean definition loading
        ↓
refresh() – Bean instantiation, wiring, auto-configuration
        ↓
RunListeners.started()
        ↓
RunListeners.running()

Each phase executes in a specific order with a well-defined responsibility.

1. Application Starts (main Method)

The JVM executes the main() method:

publicstaticvoidmain(String[] args) {
    SpringApplication.run(MyApplication.class, args);
}

What happens here:

• The application enters Spring Boot startup
• SpringApplication.run() triggers all internal phases
• At this point, no environment, context, or beans exist yet

2. SpringApplication Initialization Phase

Spring Boot performs initial setup:

• Determines application type:
  • Web (Servlet) – Spring MVC
  • Reactive (WebFlux)
  • Non-web
• Loads:
  • ApplicationContextInitializer
  • SpringApplicationRunListeners
• Prepares default configuration and startup metadata

At this phase:

• No ApplicationContext
• No Environment
• No beans

Only startup preparation occurs.

3. SpringApplication RunListeners – starting()

Spring Boot notifies listeners that the application is starting:

RunListeners.starting()

Purpose:

• Logging startup beginning
• Monitoring application startup
• Custom initialization hooks

At this moment:

• Environment and context are still not available
• No beans exist

4. prepareEnvironment() – Environment Setup

Spring Boot prepares the Environment, which holds properties, profiles, and configuration sources.

Key steps:

• Creates StandardEnvironment or StandardServletEnvironment (depending on application type)
• Loads application.properties / application.yml
• Activates profiles (e.g., dev, prod)
• Loads property sources in order:

Property Priority (High → Low):

1. Command-line arguments
2. System properties
3. OS environment variables
4. Application configuration files (application.yml, application.properties)
5. Default values

After this step, all configuration values are known and available for context preparation.

5. RunListeners – environmentPrepared()

Listeners are notified that the environment is ready:

RunListeners.environmentPrepared()

Purpose:

• Custom listeners can modify environment properties
• Useful for logging, monitoring, metrics, or early configuration

At this stage:

• ApplicationContext still does not exist
• No beans exist

6. createApplicationContext() – Context Creation

Spring Boot now creates the ApplicationContext, the container for all beans.

Application Type → Context Mapping:

Notes:

• Context exists but is empty
• Beans are not yet created
• Context type determines which embedded server will be started later

7. prepareContext() – Context Configuration

The ApplicationContext is prepared for bean registration:

• Sets Environment inside context
• Registers ApplicationListeners for startup, ready, or failure events
• Executes ApplicationContextInitializer hooks
• Loads primary application configuration class
• Adds property sources to the context

At this stage:

• Beans are still not instantiated
• Dependency injection has not started

8. postProcessApplicationContext() – Context Customization

Before bean instantiation, Spring Boot allows context customization:

• Apply BeanFactoryPostProcessor (e.g., ConfigurationPropertiesBindingPostProcessor)
• Handle auto-configuration exclusions
• Prepare ConditionEvaluationReport for @Conditional beans

This ensures only relevant beans are created during startup.

9. load() – Bean Definition Loading

Spring Boot scans for all bean definitions:

• @Component
• @Service
• @Repository
• @Controller
• @Configuration classes
• @Bean methods
• Auto-configuration classes

Important:

• Beans are registered but not instantiated
• This is metadata registration only

10. refresh() – Core Spring Engine

The heart of Spring Boot startup.

Steps inside refresh():

1. BeanFactory Initialization – Prepares bean container
2. BeanPostProcessor Registration – For lifecycle hooks
3. Singleton Bean Instantiation – Creates all non-lazy beans
4. Dependency Injection – @Autowired dependencies are resolved
5. @PostConstruct Execution – Initialization methods run
6. Auto-Configuration Execution – Conditional beans and defaults
7. Embedded Web Server Startup (if web app)
8. DispatcherServlet Initialization – For Spring MVC

Bean Lifecycle Simplified:

Create Bean
   ↓
Inject Dependencies
   ↓
@PostConstruct
   ↓
Readyto Use

After refresh(), the application is fully initialized.

11. RunListeners – started()

RunListeners.started()

• ApplicationContext is fully refreshed
• Embedded server is running
• Startup timing can be measured

12. RunListeners – running() (Application Ready)

RunListeners.running()

• Application is fully ready to accept requests
• APIs are available
• Background tasks can start
• Runners (CommandLineRunner / ApplicationRunner) are executed

13. Embedded Web Server Startup (Web Apps)

For web applications:

• Embedded server (Tomcat, Jetty, Netty) starts
• DispatcherServlet is registered
• Default error pages, servlet mappings, and request handling are configured

14. afterRefresh() – Running Application Runners

Spring Boot executes:

• CommandLineRunner beans
• ApplicationRunner beans

Purpose: Custom logic after context initialization.

15. SpringApplicationRunListeners – Lifecycle Events

Throughout startup, Spring Boot notifies listeners:

These events allow custom logging, monitoring, and extensions.

Complete Startup Execution Order

1. JVM starts
2. main() executes
3. SpringApplication.run()
4. RunListeners.starting()
5. prepareEnvironment()
6. RunListeners.environmentPrepared()
7. createApplicationContext()
8. prepareContext()
9. load() – bean definitions registered
10. postProcessApplicationContext() – customize context
11. refresh() – beans instantiated & injected, auto-config applied
12. RunListeners.started()
13. Embedded web server starts (if web app)
14. afterRefresh() – CommandLineRunner / ApplicationRunner executed
15. RunListeners.running() – application ready

👉 Notes

• Auto-configuration occurs during refresh()
• @Conditional annotations control which beans are instantiated
• Fast-fail mechanism: Spring Boot stops startup if critical beans fail
• Logging is initialized very early, before context creation
• Startup customization possible via:
  • ApplicationContextInitializer
  • CommandLineRunner / ApplicationRunner
  • SpringApplicationRunListener

Why Understanding This Lifecycle Matters

• Debug startup issues and misconfigurations
• Optimize startup performance
• Understand auto-configuration behavior
• Customize application startup flow
• Gain confidence in production-ready systems
• Ace advanced Spring Boot interviews

Key Takeaways

• SpringApplication is the brain of Spring Boot
• Startup is predictable and structured
• Environment is prepared before context
• Beans are created during refresh
• Auto-configuration runs automatically
• Application becomes ready only after all phases complete

Conclusion

Spring Boot may appear to start with a single line of code, but internally it runs a powerful, structured, and well-designed engine.

Understanding the SpringApplication internal workflow gives you:

• Better debugging skills
• Deeper framework knowledge
• Confidence in production environments
• Strong interview preparation

Mastering the Spring Boot startup lifecycle transforms you from a user to an expert in Spring Boot.