This document details the comprehensive execution order of the Spring Boot application bean lifecycle, encompassing related methods at each stage.

Phase 1: Bootstrapping (JVM & Spring Boot Initialization)

1. JVM Initialization: The Java Virtual Machine (JVM) starts and loads the main application class (containing public static void main(String[] args)).
2. SpringApplication Execution: SpringApplication.run() initiates the application context creation. (Related Method: SpringApplication.run())
3. Environment Configuration: The application loads settings from system properties, environment variables, application.properties/yml files, and command-line arguments. Active and default profiles are determined. (Related Methods: ConfigurableEnvironment#setActiveProfiles(), PropertySourcesPropertyResolver#getProperty())
4. Application Type Determination: Spring identifies the application type (web or non-web). This determines the appropriate application context: AnnotationConfigServletWebServerApplicationContext (web) or AnnotationConfigApplicationContext (non-web). (Related Method: SpringApplication#determineWebApplicationType())
5. Auto-Configuration & SpringFactoriesLoader: Spring automatically registers dependencies found on the classpath (via META-INF/spring.factories). (Related Method: SpringFactoriesLoader#loadFactoryNames())
6. Application Run Listeners: SpringApplicationRunListeners are triggered, firing events like ApplicationStartingEvent and ApplicationEnvironmentPreparedEvent. (Related Methods: SpringApplicationRunListeners#starting(), SpringApplicationRunListeners#environmentPrepared())

Phase 2: Context Initialization & Bean Lifecycle

1. ApplicationContext Creation: The ApplicationContext is created, and beans are scanned using annotations like @ComponentScan and @Configuration. (Related Method: AnnotationConfigApplicationContext#register())
2. Bean Definition Loading: Spring processes bean definitions from configuration classes, XML files, or component scanning. Note: Bean instances are not created yet. (Related Method: BeanDefinitionRegistry#registerBeanDefinition())
3. Bean Instantiation: Beans are instantiated using constructor injection or factory methods. (Related Method: InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation())
4. Lifecycle Aware Bean Processing: Beans implementing lifecycle interfaces (e.g., BeanNameAware, BeanFactoryAware, EnvironmentAware) are processed. (Related Methods: BeanNameAware#setBeanName(), BeanClassLoaderAware#setBeanClassLoader(), BeanFactoryAware#setBeanFactory(), EnvironmentAware#setEnvironment(), EmbeddedValueResolverAware#setEmbeddedValueResolver(), etc.)
5. Conditional Beans & Profiles: Beans marked with @Conditional or @Profile are evaluated and conditionally created based on specified conditions or active profiles. (Related Methods: Condition#matches(), ConfigurableEnvironment#getActiveProfiles())
6. Pre-Initialization Post-Processing: BeanPostProcessor#postProcessBeforeInitialization() methods are executed.
7. Custom Initialization: Custom initialization logic is executed using @PostConstruct, InitializingBean.afterPropertiesSet(), or the init-method attribute in @Bean annotations. (Related Methods: InitializingBean#afterPropertiesSet(), @PostConstruct)
8. Post-Initialization Post-Processing: BeanPostProcessor#postProcessAfterInitialization() methods are executed.

Phase 3: Application Startup Completion

1. ApplicationContext Refresh: The ApplicationContext is refreshed, completing dependency injection. The ContextRefreshedEvent is fired. (Related Method: AbstractApplicationContext#refresh())
2. Embedded Web Server Start (if applicable): If it's a web application, the embedded server (Tomcat, Jetty, Undertow) starts and binds to a port. ServletContextInitializer and WebApplicationInitializer are executed (for servlet-based apps). (Related Method: ConfigurableWebServerApplicationContext#start())
3. CommandLineRunner & ApplicationRunner Execution: Beans implementing CommandLineRunner or ApplicationRunner are executed, performing post-startup tasks. (Related Methods: CommandLineRunner#run(), ApplicationRunner#run())
4. ApplicationReadyEvent: The ApplicationReadyEvent is fired, signaling that the application is fully initialized and ready to handle requests. (Related Method: ApplicationListener#onApplicationEvent(ApplicationReadyEvent))

Phase 4: Bean Destruction & Application Shutdown

1. Graceful Shutdown: The shutdown process begins, controlled by spring.lifecycle.timeout-per-shutdown-phase. (Related Method: SpringApplication#setRegisterShutdownHook(true))
2. Pre-Destruction Processing: DestructionAwareBeanPostProcessor#postProcessBeforeDestruction() methods are executed.
3. Custom Cleanup: Custom cleanup logic is performed using DisposableBean.destroy(), @PreDestroy methods, or the destroy-method attribute in @Bean annotations. (Related Methods: DisposableBean#destroy(), @PreDestroy)
4. ApplicationContext Closure: The ApplicationContext closes, firing the ContextClosedEvent. (Related Method: ConfigurableApplicationContext#close())
5. Custom Exit Codes: SpringApplication.exit() can be used to set custom exit codes (using ExitCodeGenerator). (Related Method: SpringApplication#exit())

Phase 5: Advanced Considerations

• Lazy Initialization (@Lazy): Beans are created only when accessed. (Related Method: DefaultListableBeanFactory#setAllowBeanDefinitionOverriding(false))
• Circular Dependency Handling: Use @Lazy, setter injection, or @DependsOn to manage circular dependencies. (Related Method: AbstractAutowireCapableBeanFactory#doResolveDependency())
• FactoryBean Mechanism: Allows for dynamic bean creation. (Related Method: FactoryBean#getObject())
• Spring Boot Actuator (if enabled): Provides endpoints for monitoring and management (/actuator/health, /actuator/shutdown, /actuator/metrics). (Related Method: HealthIndicator#health())
• Performance Optimizations: Reduce startup time with spring.main.lazy-initialization=true and tune garbage collection.
• Custom Application Listeners (ApplicationListener): Allows hooking into startup/shutdown events. (Related Method: ApplicationListener#onApplicationEvent())

Summary of Execution Order:

1. Bootstrapping: JVM → SpringApplication.run() → Auto-Configuration → Context Creation
2. Context Initialization: Bean Instantiation → Lifecycle Hooks → Dependency Injection
3. Application Startup: Web Server Starts → Runners Execute → Application Ready
4. Shutdown Phase: Pre-Destruction Callbacks → Cleanup → Context Closes

This detailed breakdown provides a comprehensive understanding of the Spring Boot bean lifecycle and its execution order. Understanding this order is crucial for debugging, optimizing, and extending Spring Boot applications.

The above is the detailed content of spring-: spring-boot-application-bean-lifecycle-comprehensive-execution-order-with-related-methods. For more information, please follow other related articles on the PHP Chinese website!