简单认识Spring bean的生命周期

 

本文仅对bean生命周期做简单、整体的认识

一、整体流程认识

BeanFactoryPostProcessor — postProcessBeanFactory() — 允许读取配置信息并且能够在容器实例化任何其他bean之前改变配置信息

.

.

BeanNameAware — setBeanName() — 感知自己在BeanFactory 中注册的名称

BeanFactoryAware — setBeanFactory() — 感知自己所属的 BeanFactory

BeanPostProcessor — postProcessBeforeInitialization()

InitializingBean — afterPropertiesSet()

Init-method — 自定义初始化的方法

BeanPostProcessor — postProcessAfterInitialization()

.

.

容器销毁

DisposableBean — destory()

Destory-method — 自定义销毁方法

二、按照作用范围分类

分类类型	所包含方法
Bean自身的方法	配置文件中的init-method和destroy-method配置的方法、Bean对象自己调用的方法
Bean级生命周期接口方法	BeanNameAware、BeanFactoryAware、InitializingBean、DiposableBean等接口中的方法
容器级生命周期接口方法	InstantiationAwareBeanPostProcessor、BeanPostProcessor等后置处理器实现类中重写的方法

三、测试代码

package com.legolas;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

public class MyBean implements BeanNameAware, BeanFactoryAware, InitializingBean, DisposableBean {

    public void selfInit() {
        System.out.println("自定义初始化方法 。。");
    }

    public void selfDestroy() {
        System.out.println("自定义初始化方法 。。");
    }

    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("BeanFactoryAware 类的 setBeanFactory 方法 。。");
    }

    public void setBeanName(String name) {
        System.out.println("BeanNameAware 类的 setBeanName 方法 。。");
    }

    public void destroy() throws Exception {
        System.out.println("DisposableBean 类的 destroy 方法 。。");
    }

    public void afterPropertiesSet() throws Exception {
        System.out.println("InitializingBean 类的 afterPropertiesSet 方法 。。");
    }
}

@Component
class MyBeanPostProcesser implements BeanPostProcessor {

    public Object postProcessBeforeInitialization(Object o, String s) throws BeansException {
        System.out.println("BeanPostProcessor 类的 postProcessBeforeInitialization 方法 。。" + s);
        return o;
    }

    public Object postProcessAfterInitialization(Object o, String s) throws BeansException {
        System.out.println("BeanPostProcessor 类的 postProcessAfterInitialization 方法 。。" + s);
        return o;
    }
}

@Component
class MyBeanFactoryPostProcesser implements BeanFactoryPostProcessor {

    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory)
            throws BeansException {
        System.out.println("BeanFactoryPostProcessor 类的 postProcessBeanFactory 方法 。。");
        //        System.out.println("====BeanFactoryPostProcesser=====");
        //        String[] beanDefinitionNames = configurableListableBeanFactory.getBeanDefinitionNames();
        //        Arrays.asList(beanDefinitionNames).stream().forEach(System.out::println);
        //        System.out.println("====BeanFactoryPostProcesser=====");
    }

}

@Configuration
@ComponentScan
class MyConfiguration {
    @Bean(name = "myBean", initMethod = "selfInit",destroyMethod = "selfDestroy")
    MyBean get() {
        return new MyBean();
    }
}

class MainTest {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext =
                new AnnotationConfigApplicationContext(MyConfiguration.class);
        applicationContext.registerShutdownHook();
    }
}

执行结果：