Spring-: printemps-boot-application-barian-lifecycle-compréhension-Exécution-Order-with lis-mods

Ce document détaille l'ordre d'exécution complet du cycle de vie du bean d'application Spring Boot, englobant les méthodes connexes à chaque étape.

Phase 1: bootstrap (JVM & Spring Boot Initialisation)

1. JVM Initialisation: La machine virtuelle Java (JVM) démarre et charge la classe d'application principale (contenant public static void main(String[] args)).
2. Exécution de SpringApplication: SpringApplication.run() initie la création de contexte d'application. (Méthode associée: SpringApplication.run())
3. Configuration de l'environnement: L'application charge les paramètres des propriétés du système, les variables d'environnement, les fichiers application.properties / yml et les arguments en ligne de commande. Les profils actifs et par défaut sont déterminés. (Méthodes associées: ConfigurableEnvironment#setActiveProfiles(), PropertySourcesPropertyResolver#getProperty())
4. Détermination du type d'application: Spring identifie le type d'application (Web ou non Web). Cela détermine le contexte d'application approprié: AnnotationConfigServletWebServerApplicationContext (web) ou AnnotationConfigApplicationContext (non Web). (Méthode associée: SpringApplication#determineWebApplicationType())
5. Auto-configuration et SpringFactoriesloader: Spring enregistre automatiquement les dépendances trouvées sur le chemin de classe (via META-INF/spring.factories). (Méthode associée: SpringFactoriesLoader#loadFactoryNames())
6. Application Run Indiners: SpringApplicationRunListeners Sont déclenchés, tirant des événements comme ApplicationStartingEvent et ApplicationEnvironmentPreparedEvent. (Méthodes associées: SpringApplicationRunListeners#starting(), SpringApplicationRunListeners#environmentPrepared())

Phase 2: Initialisation du contexte et cycle de vie des bean

1. Création d'applicationContext: Le ApplicationContext est créé, et les beans sont analysés à l'aide d'annotations comme @ComponentScan et @Configuration. (Méthode associée: AnnotationConfigApplicationContext#register())
2. Chargement de définition du bean: Spring traite les définitions de bean à partir de classes de configuration, de fichiers XML ou de numérisation des composants. Remarque: les instances de bean sont pas encore créées. (Méthode associée: BeanDefinitionRegistry#registerBeanDefinition())
3. Instanciation Bean: Les haricots sont instanciés à l'aide de méthodes d'injection de constructeur ou d'usine. (Méthode associée: InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation())
4. Traitement des bean conscients du cycle de vie: Les haricots implémentant les interfaces de cycle de vie (par exemple, BeanNameAware, BeanFactoryAware, EnvironmentAware) sont traités. (Méthodes associées: BeanNameAware#setBeanName(), BeanClassLoaderAware#setBeanClassLoader(), BeanFactoryAware#setBeanFactory(), EnvironmentAware#setEnvironment(), EmbeddedValueResolverAware#setEmbeddedValueResolver(), etc.)
5. Les haricots et profils conditionnels: Les haricots marqués avec @Conditional ou @Profile sont évalués et créés conditionnellement sur la base de conditions spécifiées ou de profils actifs. (Méthodes associées: Condition#matches(), ConfigurableEnvironment#getActiveProfiles())
6. Pré-initialisation post-traitement: BeanPostProcessor#postProcessBeforeInitialization() Les méthodes sont exécutées.
7. Initialisation personnalisée: La logique d'initialisation personnalisée est exécutée à l'aide de @PostConstruct, InitializingBean.afterPropertiesSet() ou de l'attribut init-method dans les annotations @Bean. (Méthodes associées: InitializingBean#afterPropertiesSet(), @PostConstruct)
8. post-initialisation post-traitement: BeanPostProcessor#postProcessAfterInitialization() Les méthodes sont exécutées.

Phase 3: Achèvement du démarrage de l'application

1. ApplicationContext Refresh: Le ApplicationContext est rafraîchi, terminant l'injection de dépendance. Le ContextRefreshedEvent est licencié. (Méthode associée: AbstractApplicationContext#refresh())
2. Démarrer le serveur Web intégré (le cas échéant): S'il s'agit d'une application Web, le serveur intégré (Tomcat, Jetty, Undertow) démarre et se lie à un port. ServletContextInitializer et WebApplicationInitializer sont exécutés (pour les applications basées sur le servlet). (Méthode associée: ConfigurableWebServerApplicationContext#start())
3. CommandLinerUnner & ApplicationRunner Exécution: Les beans implémentation CommandLineRunner ou ApplicationRunner sont exécutés, effectuant des tâches post-startup. (Méthodes associées: CommandLineRunner#run(), ApplicationRunner#run())
4. ApplicationReadyEvent: Le ApplicationReadyEvent est licencié, signalant que l'application est entièrement initialisée et prête à gérer les demandes. (Méthode associée: ApplicationListener#onApplicationEvent(ApplicationReadyEvent))

Phase 4: Destruction des haricots et arrêt des applications

1. Arrêt gracieux: Le processus d'arrêt commence, contrôlé par spring.lifecycle.timeout-per-shutdown-phase. (Méthode associée: SpringApplication#setRegisterShutdownHook(true))
2. Traitement de pré-destruction: DestructionAwareBeanPostProcessor#postProcessBeforeDestruction() Les méthodes sont exécutées.
3. nettoyage personnalisé: La logique de nettoyage personnalisée est effectuée à l'aide de méthodes DisposableBean.destroy(), @PreDestroy, ou l'attribut destroy-method dans les annotations @Bean. (Méthodes associées: DisposableBean#destroy(), @PreDestroy)
4. CLOSE CONCETTEUR D'APPLICATION: le ApplicationContext ferme, tirant le ContextClosedEvent. (Méthode associée: ConfigurableApplicationContext#close())
5. codes de sortie personnalisés: SpringApplication.exit() peuvent être utilisés pour définir les codes de sortie personnalisés (en utilisant ExitCodeGenerator). (Méthode associée: SpringApplication#exit())

Phase 5: Considérations avancées

• Initialisation paresseuse (@Lazy): Les haricots sont créés uniquement lorsqu'ils sont accessibles. (Méthode associée: DefaultListableBeanFactory#setAllowBeanDefinitionOverriding(false))
• Gestion de la dépendance circulaire: Utiliser @Lazy, l'injection de setter ou @DependsOn pour gérer les dépendances circulaires. (Méthode associée: AbstractAutowireCapableBeanFactory#doResolveDependency())
• Mécanisme d'usine: Permet la création dynamique des haricots. (Méthode associée: FactoryBean#getObject())
• ACTUATEUR DE BOOT SPRING (si activé): fournit des points de terminaison pour la surveillance et la gestion (/ actionneur / santé, / actionneur / arrêt, / actionneur / métriques). (Méthode associée: HealthIndicator#health())
• Optimisations de performances: Réduisez le temps de démarrage avec spring.main.lazy-initialization=true et réglez la collecte des ordures.
• Écouteurs d'applications personnalisés (ApplicationListener): Permet de s'accrocher aux événements de démarrage / arrêt. (Méthode associée: ApplicationListener#onApplicationEvent())

Résumé de l'ordre d'exécution:

1. Bootstrap: JVM → SpringApplication.run() → Auto-configuration → Création de contexte
2. Initialisation du contexte: Instanciation Bean → Cycy de vie → Injection de dépendance
3. Startup d'application: SERVICE Web Démarrer → Les coureurs exécutent → Application Ready
4. Phase d'arrêt: Rappels de pré-destruction → Nettoyage → Le contexte ferme

Cette ventilation détaillée fournit une compréhension complète du cycle de vie du bean de démarrage de Spring et de son ordre d'exécution. Comprendre cet ordre est crucial pour le débogage, l'optimisation et l'extension des applications de démarrage de ressort.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!