1. The Initial Setup and Auto-Configuration

Spring Boot is known for its auto-configuration capabilities, which significantly reduce the need for manual setup. When you start a Spring Boot application, the initial setup phase is crucial. Here's what happens:

1.1 The Entry Point: main Method

Every Spring Boot application begins with a main method, usually located in the @SpringBootApplication annotated class. This annotation is a combination of three other annotations: @EnableAutoConfiguration , @ComponentScan , and @Configuration.

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

1.2 SpringApplication Class: Bootstrapping the Application

The SpringApplication.run() method is the entry point for bootstrapping the Spring Boot application. This method sets up the default configuration, starts the Spring application context, and performs a component scan.

1.3 Auto-Configuration in Action

The @EnableAutoConfiguration annotation is where the magic happens. It tells Spring Boot to automatically configure your application based on the dependencies present in the classpath. For example, if you have spring-boot-starter-web in your dependencies, Spring Boot will automatically configure an embedded Tomcat server.

@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
}

2. Application Context: The Core of Spring Boot

Once the initial setup is complete, the application context is created. The application context is the core of any Spring application, and it manages the beans, dependency injection, and lifecycle of the application.

2.1 Bean Definition and Dependency Injection

During the creation of the application context, Spring scans the classpath for components (beans) and registers them. Beans are objects that form the backbone of your application and are managed by the Spring container.

@Configuration
public class AppConfig {
    @Bean
    public MyService myService() {
        return new MyServiceImpl();
    }
}

2.2 Profiles and Environment Setup

Spring Boot allows you to configure different environments using profiles. The active profiles are determined during the application context initialization and are used to load the appropriate configuration files.

@Profile("dev")
@Configuration
public class DevConfig {
    // Beans specific to the development environment
}

2.3 Event Handling

Spring Boot’s event handling mechanism allows the application to respond to certain lifecycle events. For example, the ApplicationStartedEvent is published when the application has started but before the CommandLineRunner and ApplicationRunner beans are executed.

@Component
public class ApplicationStartListener implements ApplicationListener<ApplicationStartedEvent> {
    @Override
    public void onApplicationEvent(ApplicationStartedEvent event) {
        System.out.println("Application has started");
    }
}

3. Embedded Server Startup

For web applications, Spring Boot usually starts an embedded server, such as Tomcat, Jetty, or Undertow, during the startup process. This server handles incoming HTTP requests and routes them to the appropriate controller methods.

3.1 Embedded Servlet Container Initialization

Spring Boot’s ServletWebServerApplicationContext is responsible for starting the embedded servlet container. The server is initialized with the necessary configuration, including port, context path, and SSL settings.

3.2 DispatcherServlet Registration

The DispatcherServlet is the front controller in Spring Web MVC. When the embedded server starts, the DispatcherServlet is registered and mapped to handle incoming requests.

@Bean
public DispatcherServlet dispatcherServlet() {
    return new DispatcherServlet();
}

3.3 Context Refresh and Final Preparations

After all the beans are initialized, and the embedded server is started, Spring Boot refreshes the application context. This phase is crucial for ensuring that all beans are ready to serve incoming requests.

4. Application Ready and Post-Startup Operations

Once the application context is fully initialized and the embedded server is running, the Spring Boot application is considered ready. However, there are still a few more operations that take place post-startup.

4.1 CommandLineRunner and ApplicationRunner Execution

If your application has beans that implement the CommandLineRunner or ApplicationRunner interfaces, their run methods are executed after the application context is initialized.

@Component
public class MyAppStartupRunner implements CommandLineRunner {
    @Override
    public void run(String... args) throws Exception {
        System.out.println("Application started with command-line arguments: " + Arrays.toString(args));
    }
}

4.2 Actuator Endpoints Initialization

If you have Spring Boot Actuator in your application, the various management endpoints (such as /actuator/health ) are initialized at this stage.

5. Conclusion

Understanding what happens internally when you start a Spring Boot application is crucial for effective troubleshooting and optimization. From the initial setup and auto-configuration to the application context and embedded server startup, every step is integral to the smooth operation of your Spring Boot application. If you have any questions or need further clarification on any of the steps, feel free to comment below!

Read posts more at : Understanding the internal processes when a Spring Boot application begins