spring bean的生命周期

1.什么是bean

bean是被IOC容器管理（实例化，注入和管理）的对象

2.bean的生命周期

2.1简单来说，大致分为四个阶段，实例化、属性赋值、初始化、销毁。

这里用一个user实体类做简单介绍

public class User implements InitializingBean {

    private String address;

    public void setAddress(String address) {
        this.address = address;
        System.out.println("-------属性赋值");
    }

    public User() {
        System.out.println("----对象创建，实例化");
    }

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

    //系统初始化方法
    public void afterPropertiesSet() throws Exception {
        System.out.println("--------系统初始化方法");
    }

    //销毁了
    public void destory(){
        System.out.println("---------销毁了");
    }
}

spring的主配置文件

<bean class="com.apesource.pojo.User" id="user" init-method="doinit" destroy-method="destory">
    <property name="address" value="xx市"></property>
</bean>

测试，启动程序，创建容器，拿对象

public class Test01 {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        Object user = classPathXmlApplicationContext.getBean("user");
        System.out.println(user);
        //自己手动将容器关闭，为了演示bean对象销毁时，会执行销毁方法
        classPathXmlApplicationContext.close();
    }
}

 运行结果

2.2 一些可扩展接口

         在IOC容器管理bean时，为了方便操作，也提供了一些接口供操作者使用，可以在bean的实例化、初始化阶段完成一些自己的操作

bean后工厂处理器(BeanFactoryPostProcessor)

        在将所有的BeanDefinition信息对象保存至BeanDefinitionMap之后，Bean对象的实例化之前执行；

        BeanFactoryPostProcessor 接口 的 postProcessBeanFactory 方法

//自己定义一个类实现BeanFactoryPostProcessor接口
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        System.out.println("BeanFactoryPostProcessor 的 postProcessBeanFactory 方法");
    }
}

        BeanDefinitionRegistryPostProcessor 接口 继承了 BeanFactoryPostProcessor 接口，里面有两个方法 postProcessBeanDefinitionRegistry 方法 和 postProcessBeanFactory 方法

//自己定义一个类实现BeanDefinitionRegistryPostProcessor接口
public class MyBeanFactoryPostProcessor2 implements BeanDefinitionRegistryPostProcessor{
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
        System.out.println("MyBeanFactoryPostProcessor2 的 postProcessBeanDefinitionRegistry 方法");
    }

    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        System.out.println("MyBeanFactoryPostProcessor2 的 postProcessBeanFactory 方法");
    }
}

bean后处理器(BeanPostProcessor)

        Bean被实例化后，到最终被缓存到singletonObjects单例池之前，中间会经过Bean的初始化过程；

        BeanPostProcessor 接口 的 postProcessBeforeInitialization 方法

        BeanPostProcessor 接口 的 postProcessAfterInitialization 方法

//自己定义一个类实现BeanPostProcessor 接口
public class MyBeanPostProcessor implements BeanPostProcessor {

    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("MyBeanPostProcessor 的 postProcessBeforeInitialization 方法");
        return bean;
    }

    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("MyBeanPostProcessor 的 postProcessAfterInitialization 方法");
        return bean;
    }
}

Aware接口

        处理器的作用，为Bean生命周期各个阶段提供扩展

BeanNameAware 接口 的 setBeanName(String s) 注入当前bean对象在容器中的beanName

BeanFactoryAware 接口 的 setBeanFactory(BeanFactory beanFactory)  注入beanFactory对象

ApplicationContextAware 接口 的 setApplicationContext(ApplicationContext applicationContext) 注入applicationContext对象

ServletContextAware setServletContext(ServletContext servlet) 注入ServletContex对象，只有在web环境下才生效

这里只演示了三种。

public class User implements BeanNameAware, ApplicationContextAware,BeanFactoryAware{


    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println(beanFactory);
    }

    public void setBeanName(String s) {
        System.out.println(s);
    }

    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println(applicationContext);
    }
}

 这些实现类都是需要注入spring容器后才会有效果，加入这些接口之后又有了新的变化

        这些就是spring容器在创建bean的过程中给提供的一些接口，供操作者使用，自己根据需求实现

接下来总结一下，Spring Bean的生命周期大体上分为这几个阶段

1.bean的实例化阶段

beanDefinitionReader  读取配置文件中的bean信息，将bean标签的信息保存在BeanDefinition对象中，然后将BeanDefinition对象存放在BeanDefinitionMap的Map集合中，然后执行Bean工厂后处理器（BeanDefinitionRegistryPostProcessor）

2.bean的初始化阶段

属性填充，aware接口，bean后处理器（BeanPostProcessor）的postProcessBeforeInitialization方法，系统初始化方法，自定义初始化方法，bean后处理器（BeanPostProcessor）的postProcessAfterInitialization方法

3.bean的存储阶段

将实例化和初始化之后的bean对象存储在singletonObjects中等待调用

4.销毁

        这种销毁方式只会去销毁所有的单例Bean

当然这些过程还是取决于自己实现了那些接口，上面的举例，是将这些接口全部实现

注意：

以上这些spring bean 生命周期 只是针对 singleton bean