What happens during Spring Boot startup?

Spring Boot startup is the process of building the application context, creating beans, wiring dependencies, applying auto-configuration, and starting the embedded server.

From the application developer's perspective, startup may appear as simple as:

SpringApplication.run(App.class, args);

But internally, Spring Boot performs a large amount of orchestration before the application becomes ready.

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

This is the entry point. Spring Boot creates a SpringApplication object and begins the startup lifecycle.

One important thing happens immediately:

@SpringBootApplication

This annotation combines:

@Configuration
@ComponentScan
@EnableAutoConfiguration

That single annotation is one reason Spring Boot feels so compact.

The ApplicationContext is the central container that manages Spring beans and dependency injection.

During startup, Spring Boot creates the ApplicationContext and begins discovering components.

Spring scans packages looking for annotations like:

@Component
@Service
@Repository
@Controller
@RestController

These classes become Spring-managed beans.

Spring registers metadata about these classes so it can later create and inject them.

Spring now creates bean instances and wires dependencies together.

@Service
public class OrderService {

    private final PaymentService paymentService;

    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }
}

Spring sees that OrderService depends on PaymentService and injects the dependency automatically.

This is where Spring Boot becomes different from traditional Spring.

Spring Boot looks at:

• dependencies on the classpath
• application.properties / YAML
• existing beans
• environment settings

Then it automatically configures common infrastructure.

This is why adding one starter dependency can suddenly enable large amounts of framework behavior.

Some beans perform initialization work during startup.

@PostConstruct
public void init() {
    System.out.println("Bean initialized");
}

Spring also supports startup hooks like:

CommandLineRunner
ApplicationRunner

These run after the context is fully initialized.

If this is a web application, Spring Boot starts the embedded server.

One reason Spring Boot became so popular is that applications became self-contained:

java -jar app.jar

No external application server installation required.

Large Spring applications sometimes have slow startup times because:

• many beans are created
• classpath scanning is expensive
• reflection is used heavily
• database connections initialize
• caches warm up
• large dependency graphs exist