Spring中Bean的生命周期（五步）（七步）（十步）

五步：

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

    public User(){
        System.out.println("第一步：无参数构造方法执行。");
    }

    public void setName(String name) {
        System.out.println("第二步：给对象的属性赋值。");
        this.name = name;
    }

    //这个方法需要自己写，自己配，方法名随意
    public void initBean(){
        System.out.println("第三步：初始化Bean");
    }

    //这个方法需要自己写，自己配，方法名随意
    public void destroyBean(){
        System.out.println("第五步：销毁Bean");
    }
}

<!--需要手动指定初始化方法，和销毁方法。-->
    <bean id="user" class="com.powernode.spring6.bean.User"
          init-method="initBean" destroy-method="destroyBean">
        <property name="name" value="张三"/>
    </bean>

public class BeanLifecycleTest {
    @Test
    public void testBeanLifecycleFive(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        User user = applicationContext.getBean("user", User.class);
        System.out.println("第四步：使用Bean:"+user);

        //必须手动关闭spring容器，这样spring容器才会销毁Bean。
        ClassPathXmlApplicationContext context = (ClassPathXmlApplicationContext) applicationContext;
        context.close();
    }
}

七步：

在五步的基础上：

/*
Bean的生命周期七步：比五步添加的那两步在哪里? 在初始化Bean的前和后。    
    第一步：实例化Bean
    第二部：Bean属性赋值
    第三步：执行“Bean后处理器”的before方法
    第四步：初始化Bean
    第五步：执行“Bean后处理器”的after方法
    第六步：使用Bean
    第七步：销毁Bean
*/

public class LogBeanPostProcessor implements BeanPostProcessor {

    //以下两个方法中有两个参数，
    //第一个参数：刚创建的bean对象；
    //第二个参数：bean的名字
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("执行Bean后处理器的before方法。");
        return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("执行Bean后处理器的after方法");
        return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
    }
}

    <!--配置Bean后处理器-->
    <!--注意：这个Bean后处理器将作用于整个配置文件中的所有bean。-->
    <bean class="com.powernode.spring6.bean.LogBeanPostProcessor"/>

    <!--需要手动指定初始化方法，和销毁方法。-->
    <bean id="user" class="com.powernode.spring6.bean.User"
          init-method="initBean" destroy-method="destroyBean">
        <property name="name" value="张三"/>
    </bean>

十步：

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

    public User(){
        System.out.println("第一步：无参数构造方法执行。");
    }

    public void setName(String name) {
        System.out.println("第二步：给对象的属性赋值。");
        this.name = name;
    }

    //这个方法需要自己写，自己配，方法名随意
    public void initBean(){
        System.out.println("第三步：初始化Bean");
    }

    //这个方法需要自己写，自己配，方法名随意
    public void destroyBean(){
        System.out.println("第五步：销毁Bean");
    }

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

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("生产这个Bean的工厂对象是："+beanFactory);
    }

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

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("InitializingBean 中的 afterPropertiesSet方法执行。");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("DisposableBean 中的 destroy方法执行。");
    }
}

Bean的生命周期五步：
第一步：实例化Bean
第二部：Bean属性赋值
第三步：初始化Bean
第四步：使用Bean
第五步：销毁Bean

Bean的生命周期七步：比五步添加的那两步在哪里? 在初始化Bean的前和后。
第一步：实例化Bean
第二部：Bean属性赋值
第三步：执行“Bean后处理器”的before方法
第四步：初始化Bean
第五步：执行“Bean后处理器”的after方法
第六步：使用Bean
第七步：销毁Bean

Bean的生命周期十步：比七步添加的那三步在哪里?
点位1：在“Bean后处理器”的before方法前
干了什么事儿？
检查Bean是否实现了Aware相关接口，如果实现了接口则调用这些接口中的方法。
然后调用这些方法的目的是为了给你传递一些数据，让你更加方便使用。

点位2：在“Bean后处理器”的before方法后
干了什么事儿？
检查Bean是否实现了InitializingBean相关接口，如果实现了接口则调用接口中的方法。

点位3：使用Bean后 或者 销毁Bean前
干了什么事儿？
检查Bean是否实现了DisposableBean相关接口，如果实现了接口则调用接口中的方法。

添加的这三个点位的特点:都是在检查你这个Bean是否实现了某些特定的接口，如果实现了这些接口，则Spring容器会调用这个接口中的方法。

十步输出结果如下：

第一步：无参数构造方法执行。
第二步：给对象的属性赋值。
第三步：
这个Bean的名字是：张三
Bean这个类的加载器：jdk.internal.loader.ClassLoaders$AppClassLoader@63947c6b
生产这个Bean的工厂对象是：org.springframework.beans.factory.support.DefaultListableBeanFactory@1e730495: defining beans [com.powernode.spring6.bean.LogBeanPostProcessor#0,user]; root of factory hierarchy
第四步：执行Bean后处理器的before方法。
第五步：InitializingBean 中的 afterPropertiesSet方法执行。
第六步：初始化Bean
第七步：执行Bean后处理器的after方法
第八步：使用Bean:com.powernode.spring6.bean.User@41d477ed
第九步：DisposableBean 中的 destroy方法执行。
第十步：销毁Bean

注意 ：

Spring 根据Bean的作用域来选择管理方式。

• 对于singleton作用域的Bean，Spring 能够精确地知道该Bean何时被创建，何时初始化完成，以及何时被销毁；

• 而对于 prototype 作用域的 Bean，Spring 只负责创建，当容器创建了 Bean 的实例后，Bean 的实例就交给客户端代码管理，Spring容器将不再跟踪其生命周期。

• 通过测试一目了然。只执行了前8步，第9和10都没有执行。