Parlez du cycle de vie du haricot de printemps (1)

Présentation

Cet article parle principalement du cycle de vie des haricots dans le conteneur Spring IOC

Cycle de vie du haricot de printemps

Le cycle de déclaration du bean au printemps peut être divisé en quatre étapes:

1. Phase d'instanciation - L'instanciation appelle le constructeur
2. Phase d'attribution d'attribut: Populate configure l'injection de dépendance
3. Initialisation --- Méthode d'initialisation de l'appel d'initialisation
4. Destruction-Destruction appelle la méthode Destory

Interfaces et méthodes à différentes étapes

Chaque étape est une interface et une méthode spécifiques. Selon le type de méthode et d'interface, nous pouvons être répartis dans les catégories suivantes:

1. L'interface et la méthode du bean lui-même méthode init, méthode destroy
2. Interface du cycle de vie du bean BeanNameAware, ApplicationContextAware, BeanFactoryAware, InitializingBean, DisposableBean
3. L'interface du cycle de vie au niveau du conteneur comprend principalement BeanPostProcessor, InstantiationAwareBeanPostProcessor
4. Interface de traitement au niveau de l'usine BeanFactoryPostProcessor

Processus d'exécution

Vous venez de mentionner l'ordre d'exécution de nombreuses interfaces et méthodes ci-dessus?
Le code BeanLifecycle est le suivant

/**
 * @ClassName BeanLifecycle
 * @Auther burgxun
 * @Description: Spring bean 的生命周期
 * @Date 2020/4/21 12:45
 **/
public class BeanLifecycle implements BeanNameAware, ApplicationContextAware, BeanFactoryAware,InitializingBean,
        DisposableBean {

    public BeanLifecycle() {
        System.out.println("========>【Bean】【BeanLifecycle】执行 构造函数");
    }

    @Override
    public void setBeanName(String s) {
        System.out.println("========>【Bean】【BeanNameAware】 执行方法 setBeanName -------》实例化bean后 " +
                "为bean 注入BeanName-" + s);
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("========>【Bean】【ApplicationContextAware】 执行方法 " +
                "setApplicationContext-------》实例化bean后 为bean注入ApplicationContext");
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("========>【Bean】【BeanFactoryAware】 执行方法 setBeanFactory -------》实例化bean后 ");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("========>【Bean】【InitializingBean】执行方法 afterPropertiesSet -------》bean" +
                " 实例化完成后  初始化之前调用");
    }

    public void beanInit() {
        System.out.println("========>【Bean】【BeanLifecycle】 执行方法 Init-Method " +
                "-------》xml中配置bean实例化完成后 初始化方法");
    }

    public void beanDestroy() {
        System.out.println("========>【Bean】【BeanLifecycle】 执行方法 Destroy-Method " +
                "-------》xml中配置销毁bean之前 回调方法" +
                " ");
    }

    public void sayHello() {
        System.out.println("========>【Bean】【BeanLifecycle】执行方法  bean中方法 -------》 sayHello");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("========>【Bean】【DisposableBean】 执行方法 destroy -------》 销毁 Bean 的回调方法");
    }
}

La méthode ContainerLifecycle est la suivante:

**
 * @ClassName ContainerLifecycle
 * @Auther burgxun
 * @Description: Spring 容器 生命周期
 * @Date 2020/4/21 14:44
 **/
@Component
public class ContainerLifecycle extends InstantiationAwareBeanPostProcessorAdapter {
    public ContainerLifecycle() {
        System.out.println("========>【Container】【ContainerLifecycle】 执行 构造函数");
    }

    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        System.out.println("========>【Container】【InstantiationAwareBeanPostProcessor】执行 " +
                "postProcessBeforeInstantiation" +
                "-------》Bean实例化之前调用 beanName:" + beanName);
        return null;
    }

    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        System.out.println("========>【Container】【InstantiationAwareBeanPostProcessor】执行 " +
                "postProcessAfterInstantiation " +
                "-------》Bean实例化之后调用 beanName:" + beanName);
        return super.postProcessAfterInstantiation(bean, beanName);
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("========>【Container】【BeanPostProcessor】 执行" +
                "postProcessBeforeInitialization " +
                "-------》Bean初始化之前调用 beanName:" + beanName);
        return super.postProcessBeforeInitialization(bean, beanName);
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("========>【Container】【BeanPostProcessor】执行 " +
                "postProcessAfterInitialization " +
                "-------》Bean初始化之后调用 beanName:" + beanName);
        return super.postProcessAfterInitialization(bean, beanName);
    }

    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        System.out.println("========>【Container】【InstantiationAwareBeanPostProcessor】 执行 postProcessProperties " +
                "Bean 属性赋值的时候 beanName:" + beanName);
        return null;
    }
}

Le code FactoryLifecycle est le suivant

/**
 * @ClassName FactoryLifecycle
 * @Auther burgxun
 * @Description: Spring beanFactory 如下
 * @Date 2020/4/21 17:32
 **/
public class FactoryLifecycle implements BeanFactoryPostProcessor {

    public FactoryLifecycle() {
        System.out.println("========>【BeanFactory】【BeanFactoryPostProcessor】 执行 FactoryLifecycle " +
                "构造函数");
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        System.out.println("========>【BeanFactory】【BeanFactoryPostProcessor】 执行方法 " +
                "postProcessBeanFactory ");
    }
}

Test de haricot de printemps

public class SpringTest {

    @Test
    public void mySpringBeanTest() {

        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath" +
                ":Spring-life.xml");
        BeanLifecycle beanLifecycle = (BeanLifecycle) context.getBean("beanLifecycle");

        beanLifecycle.sayHello();
        context.close();
    }
}

Le résultat de l'exécution est:

【BeanFactory】【BeanFactoryPostProcessor】 执行 FactoryLifecycle 构造函数
【BeanFactory】【BeanFactoryPostProcessor】 执行方法 postProcessBeanFactory 
【Container】【ContainerLifecycle】 执行 构造函数
【Container】【InstantiationAwareBeanPostProcessor】执行 postProcessBeforeInstantiation-------》Bean实例化之前调用 beanName:beanLifecycle
【Bean】【BeanLifecycle】执行 构造函数
【Container】【InstantiationAwareBeanPostProcessor】执行 postProcessAfterInstantiation -------》Bean实例化之后调用 beanName:beanLifecycle
【Container】【InstantiationAwareBeanPostProcessor】 执行 postProcessProperties Bean 属性赋值的时候 beanName:beanLifecycle
【Bean】【BeanNameAware】 执行方法 setBeanName -------》实例化bean后 为bean 注入BeanName-beanLifecycle
【Bean】【BeanFactoryAware】 执行方法 setBeanFactory -------》实例化bean后 为bean注入BeanFactory
【Bean】【ApplicationContextAware】 执行方法 setApplicationContext-------》实例化bean后 为bean注入ApplicationContext
【Container】【BeanPostProcessor】 执行postProcessBeforeInitialization -------》Bean初始化之前调用 beanName:beanLifecycle
【Bean】【InitializingBean】执行方法 afterPropertiesSet -------》bean 实例化完成后  初始化之前调用
【Bean】【BeanLifecycle】 执行方法 Init-Method -------》xml中配置bean实例化完成后 初始化方法
【Container】【BeanPostProcessor】执行 postProcessAfterInitialization -------》Bean初始化之后调用 beanName:beanLifecycle
【Bean】【BeanLifecycle】执行方法  bean中方法 -------》 sayHello
【Bean】【DisposableBean】 执行方法 destroy -------》 销毁 Bean 的回调方法
【Bean】【BeanLifecycle】 执行方法 Destroy-Method -------》xml中配置销毁bean之前 回调方法 

Continuez ensuite à dessiner un organigramme

graph TB A [Bean] B [BeanFactory 构造] C [BeanFactoryPostProcessor-postProcessBeanFactory] D [Container 构造] E [InstantiationAwareBeanPostProcessor-postProcessBeforeInstantiation] F [InstantiationAwareBeanPostProcessor-postProcessAfterInstantiation] H [BeanProcessAssName ] K [BeanFactoryAware-setBeanFactory] L [ApplicationContextAware-setApplicationContext] M [BeanPostProcessor-postProcessBeforeInitialization] N [InitializingBean-afterPropertiesSet] X [Bean 中 Init-Method] Y [BeanPostProcessor-postProcessAfterInitialization] Z方法 BeanPostProcessor-postProcessAfterInitialization Z Z] ] V [Bean 中 Destroy-Method] A -> B Y -> Z subgraph BeanFactory B -> C end subgraph 实例 化 Instanciation C -> D D -> E E -> H H -> F sous-graphe 设置 属性 和 相关 依赖 Remplir F -> I I -> J J -> K K ->Sous-graphique d'extrémité L 初始化 Initialisation L -> M M -> N N -> X X -> Sous-graphique d'extrémité Y 销毁 Destruction Z -> U U -> Extrémité V

Le processus de la méthode a été réglé

Résumez à nouveau
les trois méthodes d'appel pour initialiser et détruire les beans au printemps

1. Terminé via l'interface InitializingBean / DisposableBean
2. Spécifiez la méthode à appeler en ajoutant init-method / destroy-method à la configuration de l'élément bean
3. Spécifiez la méthode d'appel via l'annotation @PostConstruct ou @PreDestroy

Quel est leur ordre d'exécution?
La réponse est la méthode d'annotation "interface method" configurée dans l'élément bean