【Spring 从0开始】IOC容器的Bean管理

bean 的生命周期是指，从对象创建到对象销毁的过程。

过程如下：

1. 通过构造器创建 bean 实例（比如，无参数构造）。
2. 为 bean 的属性设置值和对其他 bean 的引用（比如，调用set方法）。
3. 调用 bean 的初始化方法（需要进行配置初始化的方法）。
4. bean 可以使用了（比如，对象被获取到了）。
5. 当容器关闭，调用 bean 的销毁的方法（需要进行配置销毁的方法）。

一、生命周期过程示例

新建一个类 Orders，并且在配置文件中写好 bean 标签。然后根据上面的步骤，依次写好打印输出。

package com.pingguo.spring5.bean;

public class Orders {
    public Orders() {
        System.out.println("第一步：执行无参构造方法创建 bean 的实例");
    }

    private String orderName;

    public void setOrderName(String orderName) {
        this.orderName = orderName;
        System.out.println("第二步：调用 set 方法设置属性值");
    }

    // 创建执行的初始化方法，需要在配置文件中配置调用
    public void initMethod() {
        System.out.println("第三步：执行初始化方法");
    }

    // 创建 bean 销毁方法，需要在配置文件中配置调用
    public void destroyMethod() {
        System.out.println("第五步：执行销毁的方法");
    }
}

注意：

• 第四步，是在测试方法里调用时候走到的。
• 初始化方法和销毁方法，需要在配置文件中进行配置，使用 init-method和destroy-method。

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

    <!--配置初始化方法、销毁方法-->
    <bean id="orders" class="com.pingguo.spring5.bean.Orders"
          init-method="initMethod"
          destroy-method="destroyMethod">
        <property name="orderName" value="苹果"></property>
    </bean>
</beans>

现在添加一个测试函数来执行一下：

    @Test
    public void test4() {
        ClassPathXmlApplicationContext context =
                new ClassPathXmlApplicationContext("bean4.xml");
        Orders orders = context.getBean("orders", Orders.class);
        System.out.println("第四步：获取创建的 bean 实例对象");
        System.out.println(orders);

        // 手动让 bean 实例销毁
        context.close();
    }

注意这里是用的 ClassPathXmlApplicationContext ，因为close()方法在这个类下面。而 ClassPathXmlApplicationContext是ApplicationContext的实现类。

ok，执行测试方法 test4():

第一步：执行无参构造方法创建 bean 的实例
第二步：调用 set 方法设置属性值
第三步：执行初始化方法
第四步：获取创建的 bean 实例对象
com.pingguo.spring5.bean.Orders@43738a82
第五步：执行销毁的方法

Process finished with exit code 0

二、更完整的过程

其实更完整的过程，还有 2 个步骤，这个2个过程叫做 bean 的后置处理器。

分别会在 上述 5 步骤中的第 3 步的前后调用，所以 7 个步骤现在应该是这样的：

1. 通过构造器创建 bean 实例（比如，无参数构造）。
2. 为 bean 的属性设置值和对其他 bean 的引用（比如，调用set方法）。
3. 把 bean 实例传递给后置处理器的一个方法。
4. 调用 bean 的初始化方法（需要进行配置初始化的方法）。
5. 把 bean 实例传递给后置处理器的另一个方法。
6. bean 可以使用了（比如，对象被获取到了）。
7. 当容器关闭，调用 bean 的销毁的方法（需要进行配置销毁的方法）。

现在看下添加后置处理器的效果：

1. 创建后置处理器

创建类，实现接口 BeanPostProcessor 来创建后置处理器。

package com.pingguo.spring5.bean;

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

public class MyBeanPost implements BeanPostProcessor {

}

点进去 BeanPostProcessor 会看到有2个方法，这就是后置处理器过程中先后调用到的方法：

• postProcessBeforeInitialization：初始化之前调用
• postProcessAfterInitialization：初始化之后调用

现在手动在类中实现这2个方法：

package com.pingguo.spring5.bean;

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

public class MyBeanPost implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("执行初始化之前的方法");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("执行初始化之后的方法");
        return bean;
    }
}

还没结束，现在还需要在配置文件中配置后置处理器：

    <!--配置后置处理器-->
    <bean id="myBeanPost" class="com.pingguo.spring5.bean.MyBeanPost"></bean>

配置好后，当前配置文件里的所有 bean 都会走这个后置处理器。

执行测试函数：

这个就是完整的生命周期。