spring-boot lifecycle

The Spring Boot lifecycle involves a sequence of steps that Spring Boot applications follow from initialization to shutdown. This lifecycle is highly automated, and Spring Boot manages many tasks behind the scenes to simplify application startup, configuration, and shutdown. Here’s a breakdown of the key stages and components in the Spring Boot lifecycle:

1. Application Start-Up

When a Spring Boot application starts, it typically goes through the following steps:

a) main() Method

The lifecycle begins when you call the main() method in a Spring Boot application, which usually looks like this:

The SpringApplication.run() method initializes the application context and manages all subsequent steps.

b) SpringApplication Initialization

SpringApplication is responsible for bootstrapping the application. Key actions here include:

• Setting up the environment by determining configuration properties, profiles, and default settings.
• Creating an ApplicationContext based on the application type (e.g., web, reactive).
• Loading beans by scanning for components, configuration classes, and beans.
• Setting up listeners and application events (such as ApplicationStartedEvent, ApplicationReadyEvent, etc.).

c) Customization with SpringApplication (Optional)

You can customize the behavior of SpringApplication by:

• Setting properties (e.g., disabling banner).
• Adding or removing listeners.
• Configuring profiles and sources.

Example:

2. Application Context Creation

The ApplicationContext is the core of the Spring framework, responsible for managing the beans and dependency injection.

• BeanFactory Creation: The BeanFactory manages bean instantiation and wiring.
• ApplicationContext Refresh: Loads bean definitions, processes bean factories, and instantiates singletons.
• Dependency Injection and Autowiring: Beans are injected into other beans, according to their @Autowired annotations or constructor arguments.

This stage also involves invoking @PostConstruct and InitializingBean methods to set up beans before they are ready for use.

3. Application Listeners and Events

Spring Boot supports several events that allow you to hook into the lifecycle at various stages. You can listen to these events to execute custom code or configure the application as it boots up.

Some important lifecycle events:

• ApplicationStartingEvent: Triggered at the very start of a run.
• ApplicationEnvironmentPreparedEvent: The environment is prepared, and properties are available, but the context is not yet created.
• ApplicationContextInitializedEvent: After the ApplicationContext is initialized but before any bean definitions are loaded.
• ApplicationPreparedEvent: The context is fully prepared but not refreshed.
• ApplicationStartedEvent: The application context has been refreshed and started.
• ApplicationReadyEvent: The application is fully started and ready to serve requests.
• ApplicationFailedEvent: If there’s an exception during startup.

To create a listener, you can implement the ApplicationListener interface or use the @EventListener annotation:

4. CommandLineRunner and ApplicationRunner

CommandLineRunner and ApplicationRunner are two callback interfaces in Spring Boot that allow you to execute code after the application has started.

• CommandLineRunner: Runs immediately after the context is loaded, allowing you to execute code with arguments passed from the command line.

  @Component public class MyCommandLineRunner implements CommandLineRunner { @Override public void run(String... args) { log.info("Running after application startup."); } }

  1 2 3 4 5 6 7

  @Component public class MyCommandLineRunner implements CommandLineRunner {     @Override     public void run(String... args) {         log.info("Running after application startup.");     } }

• ApplicationRunner: Similar to CommandLineRunner but provides access to ApplicationArguments for richer argument handling.

  @Component public class MyApplicationRunner implements ApplicationRunner { @Override public void run(ApplicationArguments args) { log.info("ApplicationRunner executed."); } }

  1 2 3 4 5 6 7

  @Component public class MyApplicationRunner implements ApplicationRunner {     @Override     public void run(ApplicationArguments args) {         log.info("ApplicationRunner executed.");     } }

5. Service Availability

After all beans are initialized and the ApplicationContext is fully prepared, the application is ready to serve requests. This phase is especially relevant in web applications, where the web server (such as Tomcat or Jetty) starts listening for incoming HTTP requests.

6. Application Shutdown

When the application is stopping, either because the JVM shuts down or due to an explicit call to context.close(), Spring Boot triggers shutdown procedures to ensure a graceful shutdown.

Key Steps in Shutdown:

• Shutdown Hooks: Spring Boot registers a shutdown hook to the JVM, which ensures that all beans are correctly destroyed and resources are released when the application exits.
• PreDestroy and DisposableBean: Methods annotated with @PreDestroy or implementing DisposableBean are invoked before the shutdown to clean up resources.

Application Events on Shutdown:

• ApplicationStoppingEvent: Fired just before the application is stopping.
• ApplicationFailedEvent: Triggered if the application fails during startup or shutdown.

Example of @PreDestroy:

Summary: Complete Spring Boot Lifecycle Steps

1. main() method starts the Spring Boot application.
2. SpringApplication sets up the environment, listeners, and initializes the ApplicationContext.
3. ApplicationContext creation and refresh, with bean loading, dependency injection, and initialization.
4. Listeners and Events for specific lifecycle stages, like ApplicationReadyEvent and ApplicationStartedEvent.
5. CommandLineRunner/ApplicationRunner to execute code after startup.
6. Application running and serving requests.
7. Shutdown with hooks, event listeners, and resource cleanup (e.g., @PreDestroy).

Spring Boot’s lifecycle is designed to simplify the process of starting, running, and shutting down applications in a way that’s easy to manage and extend. By tapping into these various stages, developers can add custom behavior at key points, making it adaptable for complex applications.