printemps: entier-ressort-vif-cycle de l'enregistrement à la destruction avec des exemples d'échantillon

Ce guide fournit une procédure pas à pas complète du cycle de vie des haricots de printemps, démontrant chaque étape avec des exemples pratiques. Nous explorerons séquentiellement les méthodes de cycle de vie de Spring, en établissant une compréhension solide de la façon dont le printemps gère ses haricots de l'enregistrement à la destruction.

Étape 1: Enregistrement de définition du bean (registerBeanDefinition())

Nous commençons par examiner comment le printemps enregistre les définitions de bean avant Instanciation, tirant parti de BeanDefinitionRegistry.

Que se passe-t-il: Charges à ressort et enregistre les définitions de bean à partir de diverses sources: @ComponentScan, @Bean Méthodes dans les classes @Configuration et la configuration XML (si utilisée). Surtout, Aucun haricot n'est instancié à ce stade . Spring stocke simplement les métadonnées autour de chaque haricot.

Exemple pratique: Enregistrant manuellement un haricot en utilisant un BeanDefinitionRegistryPostProcessor.

@Configuration
public class CustomBeanRegistrar implements BeanDefinitionRegistryPostProcessor {

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
        beanDefinition.setBeanClass(MyDynamicBean.class);
        registry.registerBeanDefinition("myDynamicBean", beanDefinition);
        System.out.println("Custom bean definition registered: MyDynamicBean");
    }

    // ... (rest of the code remains the same)
}

Prise des clés: L'enregistrement dynamique du bean (par exemple, basé sur des conditions ou des configurations externes) est obtenue par le biais de cette méthode. Les haricots sont essentiellement des plans à ce stade. Utilisez cette méthode avec parcimonie, uniquement lorsque l'enregistrement dynamique est vraiment nécessaire.

Étape 2: Avant l'instanciation (postProcessBeforeInstantiation())

Ensuite, nous explorons InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation().

ce qui se passe: Cette méthode exécute avant l'instanciation d'un bean. Il permet la modification ou le remplacement de l'instance de bean avant Création, ou même la prévention de l'instanciation standard en renvoyant un proxy ou un objet personnalisé.

Exemple pratique: Intercepter l'instanciation des bean à des fins de journalisation.

@Component
class CustomInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        System.out.println("Before instantiating bean: " + beanName);
        return null; // Allows normal instantiation
    }
}

Observation des clés: Cette méthode s'exécute avant le constructeur est appelé. Il est précieux pour les scénarios AOP (créant des proxys).

Étape 3: Sensibilisation au nom de bean (setBeanName())

Après l'instanciation, Spring appelle BeanNameAware#setBeanName().

Ce qui se passe: Le bean prend conscience de son propre nom dans le contexte de l'application. Cela se produit avant injection de dépendance.

Exemple pratique: un haricot reconnaissant son propre nom.

class MyDynamicBean implements BeanNameAware {
    private String beanName;

    // ... (constructor and other methods)

    @Override
    public void setBeanName(String name) {
        this.beanName = name;
        System.out.println("Bean name set: " + name);
    }
}

Observation clé: Cette méthode est appelée immédiatement après l'instance. Le haricot peut stocker son nom pour une utilisation ultérieure (par exemple, journalisation ou manipulation interne).

Étapes 4-12: Méthodes de cycle de vie supplémentaires

Les méthodes de cycle de vie restantes (BeanClassLoaderAware, BeanFactoryAware, EnvironmentAware, EmbeddedValueResolverAware, ResourceLoaderAware, ApplicationEventPublisherAware, MessageSourceAware, et ApplicationContextAware) Suivent un modèle similaire: le printemps appelle un spécifique Méthode de setter, offrant au bean un accès à un composant à ressort crucial. Ceux-ci sont détaillés dans le document d'origine et suivent la même structure de «What Happens», «Exemple pratique» et «Observation clé». Ils permettent l'accès au chargeur de classe, à l'usine de bean, aux propriétés environnementales, au résolveur de valeur intégré, au chargeur de ressources, à l'éditeur d'événements, à la source de message et au contexte d'application respectivement.

Étape 13: Avant l'initialisation (postProcessBeforeInitialization())

BeanPostProcessor#postProcessBeforeInitialization() est appelé avant Les rappels d'initialisation (@PostConstruct, InitializingBean#afterPropertiesSet()).

Ce qui se passe: permet de modifier les propriétés du bean ou l'application des aspects (proxyage, validation, journalisation) avant que le bean ne soit complètement initialisé.

Exemple pratique: Modification d'un bean avant initialisation.

@Configuration
public class CustomBeanRegistrar implements BeanDefinitionRegistryPostProcessor {

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
        beanDefinition.setBeanClass(MyDynamicBean.class);
        registry.registerBeanDefinition("myDynamicBean", beanDefinition);
        System.out.println("Custom bean definition registered: MyDynamicBean");
    }

    // ... (rest of the code remains the same)
}

Observation des clés: Cette méthode s'exécute avant les rappels d'initialisation.

Étape 14: Rappels d'initialisation (@PostConstruct, afterPropertiesSet())

Spring invoque les rappels d'initialisation après postProcessBeforeInitialization().

ce qui se passe: @PostConstruct (basé sur l'annotation) et InitializingBean#afterPropertiesSet() (basés sur l'interface) pour la validation, la configuration des ressources ou toute initialisation d'injection post-dépendance.

Exemple pratique: en utilisant à la fois @PostConstruct et afterPropertiesSet().

@Component
class CustomInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        System.out.println("Before instantiating bean: " + beanName);
        return null; // Allows normal instantiation
    }
}

Observation des clés: @PostConstruct s'exécute avant afterPropertiesSet(). Favoriser @PostConstruct sur la mise en œuvre InitializingBean sauf si strictement nécessaire.

Étape 15: Après initialisation (postProcessAfterInitialization())

BeanPostProcessor#postProcessAfterInitialization() exécute après Les rappels d'initialisation.

Ce qui se passe: permet d'appliquer des proxys ou d'effectuer des modifications finales après l'initialisation complète du bean.

Exemple pratique: appliquer des modifications post-initialisation.

class MyDynamicBean implements BeanNameAware {
    private String beanName;

    // ... (constructor and other methods)

    @Override
    public void setBeanName(String name) {
        this.beanName = name;
        System.out.println("Bean name set: " + name);
    }
}

Observation clé: Cette méthode est appelée après les rappels d'initialisation.

Étape 16: Rappels de destruction (@PreDestroy, destroy())

Enfin, les rappels de destruction sont invoqués avant l'arrêt de l'application.

ce qui se passe: @PreDestroy (basé sur l'annotation) et DisposableBean#destroy() (basé sur l'interface) Assurez un nettoyage approprié des ressources.

Exemple pratique: nettoyer les ressources.

@Configuration
public class CustomBeanRegistrar implements BeanDefinitionRegistryPostProcessor {

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
        beanDefinition.setBeanClass(MyDynamicBean.class);
        registry.registerBeanDefinition("myDynamicBean", beanDefinition);
        System.out.println("Custom bean definition registered: MyDynamicBean");
    }

    // ... (rest of the code remains the same)
}

Observation des clés: @PreDestroy s'exécute avant destroy(). Préférez @PreDestroy à moins d'avoir besoin de la fonctionnalité de DisposableBean.

Cet aperçu complet détaille le cycle de vie de Spring Bean, permettant aux développeurs d'utiliser efficacement les fonctionnalités de gestion du cycle de vie de Spring pour des applications robustes et bien gérées.

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!