Spring中bean的生命周期：五步+七步+十步详解

生命周期之五步

实例化-->属性赋值-->初始化-->使用-->销毁

写程序进行验证：
用户实体类：

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

/**
 * Bean的生命周期按照粗略的五步的话：
 *  第一步：实例化Bean（调用无参数构造方法）
 *  第二步：给属性赋值（调用set方法）
 *  第三步：初始化Bean（会调用Bean的init方法，这个方法需要自己写，自己配）
 *  第四步：使用Bean
 *  第五步：销毁Bean（会调用Bean的destory方法，也需要自己写，自己配）
 */
public class User{
    private String name;

    public void setName(String name) {
        System.out.println("step2: set attribute");
        this.name = name;
    }

    public User() {
        System.out.println("step1 : construct bean");
    }

    //  方法名随意
    public void initBean(){
        System.out.println("step3 init");
    }
    public void destory(){
        System.out.println("step5 destory");
    }
}

Spring配置文件：

<!--    需要指定初始化和销毁方法-->
    <bean id="userBean" class="spring.bean.User" init-method="initBean" destroy-method="destory">
        <property name="name" value="zhangsan"/>
    </bean>

测试方法：

    @Test
    public void testLifeCycleFive(){
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        User userBean = applicationContext.getBean("userBean", User.class);
        System.out.println("step4: using bean--" + userBean);
        ClassPathXmlApplicationContext context = applicationContext;
        context.close();
    }

运行结果为：

生命周期之七步

实例化--属性赋值--Bean后处理器的before方法--初始化--Bean后处理器的after方法--使用--销毁

实体类不需要改变，但是需要增加后处理器的实现类，并且在Spring配置文件中加上配置Bean后处理器的信息
后处理器实现类：

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

public class LogBeanPostProcessor implements BeanPostProcessor {

    // 两个参数，一个是刚创建出来的Bean，一个是Bean的名字
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("before step3:  BeanPostProcessor before running");
        return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("after step3:  BeanPostProcessor after running");
        return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
    }
}

配置文件中添加：

<bean class="spring.bean.LogBeanPostProcessor"/>

测试结果为：

生命周期之十步：

实例化-->属性赋值-->是否实现Aware相关接口，实现了就调用-->Bean后处理器的before方法-->是否实现InitializingBean相关接口，实现了就调用--	
	-->初始化-->Bean后处理器的after方法-->使用-->是否实现DisposableBean接口，实现了就调用-->销毁

记住相较于七步增加的三个点位：
	点位1：Bean后处理器的before方法 之前：
		是否实现Aware相关接口[BeanNameAware, BeanClassLoaderAware, BeanFactoryAware]，实现了就调用相关方法。
			会传过来一些参数，方便程序员使用。
			
	点位2：Bean后处理器的before方法 之后：
		是否实现InitializingBean接口，实现了就调用相关方法。
			
	点位3：销毁之前
		是否实现DisposableBean接口，实现了就调用

更改实体类，实现对应的接口：

public class User implements BeanNameAware, BeanClassLoaderAware, BeanFactoryAware, InitializingBean, DisposableBean {
    private String name;

    public void setName(String name) {
        System.out.println("step2: set attribute");
        this.name = name;
    }

    public User() {
        System.out.println("step1 : construct bean");
    }

    //  方法名随意
    public void initBean(){
        System.out.println("step3 init");
    }
    public void destory(){
        System.out.println("step5 destory");
    }

    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        System.out.println("这个Bean的类加载器是"+classLoader);
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("这个Bean的beanFactory是"+beanFactory);
    }

    @Override
    public void setBeanName(String name) {
        System.out.println("这个bean的名字是"+name);

    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("InitializingBean's method afterPropertiesSet running");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("销毁Bean之前的工作");
    }
}

测试结果为：