Spring Boot Startup Flow

Introduction

When you run SpringApplication.run(), Spring Boot prepares the environment, loads auto-configuration, creates the application context, starts the embedded web server, and publishes lifecycle events. Knowing this sequence helps you debug slow startup, missing beans, and failures that happen before the first HTTP request.

Prerequisites

• Auto-Configuration Mechanism
• Create First Spring Boot Project

Entry Point

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

SpringApplication.run roughly:

1. Create SpringApplication instance
2. Run listeners (StartupApplicationListener)
3. Prepare Environment (properties, profiles, env vars)
4. Print banner (optional)
5. Create ApplicationContext
6. Refresh context (bean registration)
7. Call runners (ApplicationRunner / CommandLineRunner)
8. Return started context

Environment Preparation

Sources merged (later overrides earlier):

Active profiles:

spring:
  profiles:
    active: dev

Or --spring.profiles.active=prod.

Context Refresh (Core)

AbstractApplicationContext.refresh():

1. Parse configuration classes (@Configuration, @ComponentScan)
2. Invoke BeanFactoryPostProcessor
3. Register bean definitions
4. Instantiate singleton beans
5. Run BeanPostProcessor chain (AOP proxies, @Autowired injection)
6. Publish ContextRefreshedEvent

Auto-configuration classes participate during bean definition loading—conditions evaluated before creating expensive beans.

Embedded Web Server Start

For servlet apps (spring-boot-starter-web):

ServletWebServerFactory bean created (Tomcat)
        ↓
WebServer started on server.port
        ↓
DispatcherServlet registered
        ↓
Log: "Tomcat started on port(s): 8080"

Reactive (WebFlux) uses NettyReactiveWebServerFactory instead—different stack, same startup idea.

ApplicationRunner Hooks

Run code after context is up:

@Component
public class StartupValidator implements ApplicationRunner {
 
    @Override
    public void run(ApplicationArguments args) {
        // verify external dependency, warm cache
    }
}

CommandLineRunner similar—raw String[] args.

Order multiple runners with @Order(1).

Lifecycle Events

Listen for metrics or readiness checks:

@Component
public class ReadyListener {
 
    @EventListener
    public void onReady(ApplicationReadyEvent event) {
        // app fully started
    }
}

Startup Failure Debugging

Common log sections:

APPLICATION FAILED TO START
Description: ...
Action: ...

Steps:

1. Read root cause at bottom of stack trace
2. Run with --debug for condition report
3. Check missing property: Could not resolve placeholder
4. Check port bind: Port 8080 already in use
5. Check DB on startup if ddl-auto=validate fails

Disable fail-fast datasource (dev only):

spring:
  datasource:
    hikari:
      initialization-fail-timeout: -1

Not recommended for prod—fix connectivity instead.

Slow Startup Tips

Measure:

spring.main.log-startup-info=true

Boot 3 logs startup steps with timings when enabled.

Graceful Shutdown

server:
  shutdown: graceful
 
spring:
  lifecycle:
    timeout-per-shutdown-phase: 30s

In-flight requests finish before JVM exits—important for Kubernetes rolling updates.

FAQ

Started but 404 on endpoint?

Controller outside component scan package—move class or adjust scan.

Two ApplicationContext?

Parent/child rare in Boot apps—usually one context in simple apps.

Bean created too early?

Depends on injection graph—use @DependsOn sparingly.

Fail on missing optional service?

Use @ConditionalOnProperty for optional integrations.

main runs twice in IDE?

Debug "Spring Boot" + "Application" duplicate run configs—pick one.

Next topic?

Redis, Security, Actuator—scenario integration chapters follow.