Spring中Bean的生命周期

Bean的生命周期

1. 通过构造器创建Bean对象。

2. 为Bean对象中的属性赋值。

3. 如果Bean对象实现了BeanNameAware接口，会执行setBeanName(String beanName)方法，可以获取到Bean的ID。

4. 如果Bean对象实现了BeanFactoryAware接口，会执行setBeanFactory(BeanFactory beanFactory)方法，可以获取到BeanFactory对象。

5. 如果Bean对象实现了ApplicationContextAware接口，会执行setApplicationContext(ApplicationContext applicationContext)方法，可以获取到ApplicationContext对象。

6. 如果装配了Bean后置处理器，会执行Bean后置处理器中的PostProcessBeforeInitialization方法()

7. 如果Bean对象实现了InitializingBean接口，会执行afterPropertySet()方法。

8. 如果为Bean对象指定了初始化方法，会执行自定义的初始化方法。

9. 如果装配了Bean后置处理器，会执行Bean后置处理器中的postProcessAfterInitialization方法。

10. Bean可以使用了。

11. 在容器对象销毁时，如果Bean对象实现了DisposableBean接口，会执行Destroy()方法。

12. 在容器对象销毁时，如果为Bean对象指定了销毁方法，会执行自定义的销毁方法。

示例代码

实体类：

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

public class MyBean implements InitializingBean, DisposableBean, BeanNameAware, BeanFactoryAware, ApplicationContextAware {

    private String name;

    public void setName(String name) {
        System.out.println("2、调用set方法为属性赋值");
        this.name = name;
    }

    public MyBean(){
        System.out.println("1、调用无参构造器");
    }

    // 指定Bean的初始化方法
    public void initMethod(){
        System.out.println("8、执行初始化方法");
    }

    @Override
    public void setBeanName(String s) {
        System.out.println("3、执行BeanNameAware接口的setBeanName方法，可以获取Bean的名称，当前Bean的名称为：" + s);
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("4、执行BeanFactoryAware接口的setBeanFactory方法，可以获取BeanFactory对象");
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("5、执行ApplicationContextAware接口的setApplicationContext方法，可以获取ApplicationContext对象");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("7、执行InitializingBean接口的afterPropertySet方法");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("11、执行DisposableBean接口的destroy方法");
    }

    // 指定Bean的销毁方法
    public void destroyMethod(){
        System.out.println("12、执行销毁方法");
    }

}

Bean后置处理器：

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

public class MyBeanProcessor implements BeanPostProcessor {

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

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

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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 装配Bean后置处理器 -->
    <bean class="com.flydog.xml.life_cycle_scope.bean_processor.MyBeanProcessor"/>

    <!--
        通过init-method属性来指定初始化方法，destroy-method属性来指定销毁方法
    -->
    <bean id="myBean" class="com.flydog.xml.life_cycle_scope.MyBean" init-method="initMethod" destroy-method="destroyMethod">
        <property name="name" value="测试"/>
    </bean>

</beans>

测试代码及执行结果：

@Test
public void test01(){
    // 1、创建容器对象
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext_bean_life_cycle.xml");
    // 2、关闭容器，ApplicationContext接口中没有提供关闭容器的方法，它的子接口ConfigurableApplicationContext中提供了关闭和刷新容器对象的方法，将applicationContext的类型转换为ConfigurableApplicationContext
    ConfigurableApplicationContext configurableApplicationContext = (ConfigurableApplicationContext) applicationContext;
     System.out.println("10、Bean可以使用了");
     // 关闭容器
     configurableApplicationContext.close();
}

1、调用无参构造器
2、调用set方法为属性赋值
3、执行BeanNameAware接口的setBeanName方法，可以获取Bean的名称，当前Bean的名称为：myBean
4、执行BeanFactoryAware接口的setBeanFactory方法，可以获取BeanFactory对象
5、执行ApplicationContextAware接口的setApplicationContext方法，可以获取ApplicationContext对象
6、执行Bean后置处理器的postProcessBeforeInitialization方法
7、执行InitializingBean接口的afterPropertySet方法
8、执行初始化方法
9、执行Bean后置处理器的postProcessAfterInitialization方法
10、Bean可以使用了
11、执行DisposableBean接口的destroy方法
12、执行销毁方法