spring bean的生命周期

一、概述　
 我们知道一个spring容器中的bean生命周期包括一下及部分
1、实例化 实例化是为bean对象开辟空间会调用构造函数
2、初始化 初始化则是对属性的初始化为对象进行属性的注入
3、bean的使用 
4、销毁
实例化 -> 属性赋值 -> 初始化 -> 使用 -> 销毁
在Spring容器中的Bean对象都要遵从这一过程,同时Spring也提供了许多对外接口,允许开发者对三个过程(实例化、初始化、销毁)的前后做一些操作。 
二、相关用法及代码测试

bean生命周期的简要流程

下面我们进行生命周期的验证

public static void main(String[] args) {
        ClassPathXmlApplicationContext context =
                new ClassPathXmlApplicationContext("appcontext.xml");
        User user = (User) context.getBean("user");
        System.out.println("第十四步:创建bean完成=====" + user);
        context.close();
    }

User类

package springCloud.dto;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;

import javax.annotation.PostConstruct;

/**
 * @author LWH
 * @version 1.0.0
 * @description: TODO
 * @date 2021/1/11 17:48
 */

public class User implements BeanNameAware, BeanFactoryAware, InitializingBean, DisposableBean {
    private String name;
    private String age;
    private String sex;
    private static final int num = 1;

    public User(String name, String age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age='" + age + '\'' +
                ", sex='" + sex + '\'' +
                '}';
    }

    public User() {
        System.out.println("num =" + num);
        System.out.println("实例化对象之前" + "name =" + name + "age =" + age + "sex =" + sex);
        System.out.println("第三步：-----构造方法,实例化User对象------");
        System.out.println("实例化对象之后" + "name =" + name + "age =" + age + "sex =" + sex);
    }

    public void init() {
        System.out.println("第十一步：-------开始初始化init-method-----");
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("第七步:setBeanFactory(实现了BeanFactoryAware接口)");
    }

    @Override
    public void setBeanName(String s) {
        System.out.println("第六步:setBeanName(实现BeanNameAware接口) 属性注入后调用");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("第十步:afterPropertiesSet(实现InitializingBean接口) 在processBeforeInitialization之后调用,在init方法之前调用");
    }

    @Override
    public void destroy() {
        System.out.println("最后一步销毁：User bean");
    }
    // 自定义初始化方法
    @PostConstruct
    public void springPostConstruct(){
        System.out.println("@PostConstruct======初始化回调方法");
    }
}

BeanFactoryPostProcessor

package springCloud.config;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;

/**
 * @author LWH
 * @version 1.0.0
 * @description: TODO
 * @date 2021/2/26 10:08
 */

public class TestBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        System.out.println("第一步:BeanFactoryPostProcessor=====>postProcessBeanFactory 工厂后处理器, ApplicationContext容器初始化中refresh()中调用");
    }
}

InstantiationAwareBeanPostProcessor

package springCloud.config;

import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor;

/**
 * @author LWH
 * @version 1.0.0
 * @description: TODO
 * @date 2021/2/26 10:14
 */
public class InstanceBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
    @Override
    public Object postProcessBeforeInstantiation(Class<?> aClass, String s) throws BeansException {
        System.out.println("第二步:InstantiationAwareBeanPostProcessor======>postProcessBeforeInstantiation (该方法在实例化bean，调用构造方法前调用)" + aClass.getName());
        return null;
    }

    @Override
    public boolean postProcessAfterInstantiation(Object o, String s) throws BeansException {
        System.out.println("第四步:InstantiationAwareBeanPostProcessor======>postProcessAfterInstantiation实例化之后");
        return true;
    }

    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        System.out.println("第五步:InstantiationAwareBeanPostProcessor=====>postProcessProperties 注入bean的属性property=====" + "属性对象" + pvs + "bean的名称" + beanName);
        return pvs;
    }

    @Override
    public Object postProcessBeforeInitialization(Object o, String s) throws BeansException {
        System.out.println("第九步:InstantiationAwareBeanPostProcessor====>postProcessBeforeInitialization ");
        return o;
    }

    @Override
    public Object postProcessAfterInitialization(Object o, String s) throws BeansException {
        System.out.println("第十三步:InstantiationAwareBeanPostProcessor====>postProcessAfterInitialization");
        return o;
    }
}

BeanPostProcessor

package springCloud.config;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

/**
 * @author LWH
 * @version 1.0.0
 * @description: TODO
 * @date 2021/2/26 10:11
 */
public class InitBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object obj, String s) throws BeansException {
        System.out.println("第八步.BeanPostProcessor======>postProcessBeforeInitialization 注入属性完成准备初始化, bean = " + obj);
        return obj;
    }

    @Override
    public Object postProcessAfterInitialization(Object obj, String s) throws BeansException {
        System.out.println("第十二步.BeanPostProcessor======>postProcessAfterInitialization" + "=====在init-method之后调用=====" + "bean =" + obj);
        return obj;
    }
}

appcontext.xml

<?xml version="1.0" encoding="utf-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
                            ">

    <context:component-scan base-package="springCloud.*"/>
    <!--User信息配置-->
    <bean id="user" class="springCloud.dto.User" init-method="init" destroy-method="destroy">
        <property name="name" value="张三"/>
        <property name="age" value="23"/>
        <property name="sex" value="男"/>
    </bean>
    <!--配置工厂后置处理器..........-->
    <bean class="springCloud.config.InitBeanPostProcessor"/>
    <bean class="springCloud.config.InstanceBeanPostProcessor"/>
    <bean class="springCloud.config.TestBeanFactoryPostProcessor"/>
</beans>

打印结果

第一步:BeanFactoryPostProcessor=====>postProcessBeanFactory 工厂后处理器, ApplicationContext容器初始化中refresh()中调用
15:19:09.901 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'org.springframework.context.annotation.internalAutowiredAnnotationProcessor'
15:19:09.901 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'org.springframework.context.annotation.internalCommonAnnotationProcessor'
15:19:09.904 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'springCloud.config.InitBeanPostProcessor#0'
15:19:09.910 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'springCloud.config.InstanceBeanPostProcessor#0'
15:19:09.913 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'user'
第二步:InstantiationAwareBeanPostProcessor======>postProcessBeforeInstantiation (该方法在实例化bean，调用构造方法前调用)springCloud.dto.User
num = 1
实例化对象之前 name = null age = null sex = null
第三步：-----构造方法,实例化User对象------
实例化对象之后 name = null age = null sex = null
第四步:InstantiationAwareBeanPostProcessor======>postProcessAfterInstantiation实例化之后
第五步:InstantiationAwareBeanPostProcessor=====>postProcessProperties 注入bean的属性property=====属性对象PropertyValues: length=3; bean property 'name'; bean property 'age'; bean property 'sex'bean的名称user
第六步:setBeanName(实现BeanNameAware接口) 属性注入后调用
第七步:setBeanFactory(实现了BeanFactoryAware接口)
第八步.BeanPostProcessor======>postProcessBeforeInitialization(BeanPostProcessor)注入属性完成准备初始化, bean = User{name='张三', age='23', sex='男'}
第九步:InstantiationAwareBeanPostProcessor====>postProcessBeforeInitialization 
@PostConstruct======初始化回调方法
第十步:afterPropertiesSet(实现InitializingBean接口) 在processBeforeInitialization之后调用,在init方法之前调用
第十一步：-------开始初始化init-method-----
第十二步.BeanPostProcessor======>postProcessAfterInitialization=====在init-method之后调用=====bean =User{name='张三', age='23', sex='男'}
第十三步:InstantiationAwareBeanPostProcessor====>postProcessAfterInitialization
第十四步:创建bean完成=====User{name='张三', age='23', sex='男'}
15:19:09.954 [main] DEBUG org.springframework.context.support.ClassPathXmlApplicationContext - Closing org.springframework.context.support.ClassPathXmlApplicationContext@de0a01f, started on Fri Feb 26 15:19:09 GMT+08:00 2021
最后一步销毁：User bean

总结

Spring对bean进行实例化,默认bean是单例。

Spring对bean进行实例化---->属性注入----> 。

如果bean实现了BeanNameAware接口，Spring将bean的名称传给setBeanName()方法；

如果bean实现了BeanFactoryAware接口，Spring将调用setBeanFactory()方法，将BeanFactory实例传进来；

如果bean实现了BeanPostProcessor接口，它的postProcessBeforeInitialization()方法将被调用；

如果bean中有方法添加了@PostConstruct注解，那么该方法将被调用；

如果bean实现了InitializingBean接口，spring将调用它的afterPropertiesSet()接口方法，类似的如果bean使用了init-method属性声明了初始化方法，该方法也会被调用；

如果在xml文件中通过<bean>标签的init-method元素指定了初始化方法，那么该方法将被调用；

如果bean实现了BeanPostProcessor接口，它的postProcessAfterInitialization()接口方法将被调用；

此时bean已经准备就绪，可以被应用程序使用了，他们将一直驻留在应用上下文中，直到该应用上下文被销毁；

若bean实现了DisposableBean接口，spring将调用它的distroy()接口方法。同样的，如果bean使用了destroy-method属性声明了销毁方法，则该方法被调用；

接下来对 BeanDefinitionRegistryPostProcessor BeanFactoryPostProcessor 扩展